bomen-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bomen - vervolg\n",
    "\n",
    "In dit hoofdstuk behandelen we algemene (n-aire) bomen, zoals je die bijvoorbeeld tegenkomt in de Elm HTML en SVG-libraries.\n",
    "\n",
    "We laten bovendien het type van de node in het midden: we kunnen later een boom maken met getallen als knoop, of strings, of een ander type.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Html exposing (..)\n",
    "import Svg exposing (..)\n",
    "import Svg.Attributes exposing (..)\n",
    "import String exposing (..)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "type Tree a\n",
    "  = Node a (List (Tree a))\n",
    "  | Nil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div id=\"elm-div-3\"></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            var defineElm = function(cb) {\n",
       "                if (this.Elm) {\n",
       "                    this.oldElm = this.Elm;\n",
       "                }\n",
       "                var define = null;\n",
       "\n",
       "                (function(scope){\n",
       "'use strict';\n",
       "\n",
       "function F(arity, fun, wrapper) {\n",
       "  wrapper.a = arity;\n",
       "  wrapper.f = fun;\n",
       "  return wrapper;\n",
       "}\n",
       "\n",
       "function F2(fun) {\n",
       "  return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })\n",
       "}\n",
       "function F3(fun) {\n",
       "  return F(3, fun, function(a) {\n",
       "    return function(b) { return function(c) { return fun(a, b, c); }; };\n",
       "  });\n",
       "}\n",
       "function F4(fun) {\n",
       "  return F(4, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return fun(a, b, c, d); }; }; };\n",
       "  });\n",
       "}\n",
       "function F5(fun) {\n",
       "  return F(5, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F6(fun) {\n",
       "  return F(6, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return fun(a, b, c, d, e, f); }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F7(fun) {\n",
       "  return F(7, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F8(fun) {\n",
       "  return F(8, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return function(g) { return function(h) {\n",
       "    return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F9(fun) {\n",
       "  return F(9, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return function(g) { return function(h) { return function(i) {\n",
       "    return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "\n",
       "function A2(fun, a, b) {\n",
       "  return fun.a === 2 ? fun.f(a, b) : fun(a)(b);\n",
       "}\n",
       "function A3(fun, a, b, c) {\n",
       "  return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);\n",
       "}\n",
       "function A4(fun, a, b, c, d) {\n",
       "  return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);\n",
       "}\n",
       "function A5(fun, a, b, c, d, e) {\n",
       "  return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);\n",
       "}\n",
       "function A6(fun, a, b, c, d, e, f) {\n",
       "  return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);\n",
       "}\n",
       "function A7(fun, a, b, c, d, e, f, g) {\n",
       "  return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);\n",
       "}\n",
       "function A8(fun, a, b, c, d, e, f, g, h) {\n",
       "  return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);\n",
       "}\n",
       "function A9(fun, a, b, c, d, e, f, g, h, i) {\n",
       "  return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);\n",
       "}\n",
       "\n",
       "console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');\n",
       "\n",
       "\n",
       "// EQUALITY\n",
       "\n",
       "function _Utils_eq(x, y)\n",
       "{\n",
       "\tfor (\n",
       "\t\tvar pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);\n",
       "\t\tisEqual && (pair = stack.pop());\n",
       "\t\tisEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)\n",
       "\t\t)\n",
       "\t{}\n",
       "\n",
       "\treturn isEqual;\n",
       "}\n",
       "\n",
       "function _Utils_eqHelp(x, y, depth, stack)\n",
       "{\n",
       "\tif (x === y)\n",
       "\t{\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\n",
       "\tif (typeof x !== 'object' || x === null || y === null)\n",
       "\t{\n",
       "\t\ttypeof x === 'function' && _Debug_crash(5);\n",
       "\t\treturn false;\n",
       "\t}\n",
       "\n",
       "\tif (depth > 100)\n",
       "\t{\n",
       "\t\tstack.push(_Utils_Tuple2(x,y));\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\n",
       "\t/**/\n",
       "\tif (x.$ === 'Set_elm_builtin')\n",
       "\t{\n",
       "\t\tx = $elm$core$Set$toList(x);\n",
       "\t\ty = $elm$core$Set$toList(y);\n",
       "\t}\n",
       "\tif (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')\n",
       "\t{\n",
       "\t\tx = $elm$core$Dict$toList(x);\n",
       "\t\ty = $elm$core$Dict$toList(y);\n",
       "\t}\n",
       "\t//*/\n",
       "\n",
       "\t/**_UNUSED/\n",
       "\tif (x.$ < 0)\n",
       "\t{\n",
       "\t\tx = $elm$core$Dict$toList(x);\n",
       "\t\ty = $elm$core$Dict$toList(y);\n",
       "\t}\n",
       "\t//*/\n",
       "\n",
       "\tfor (var key in x)\n",
       "\t{\n",
       "\t\tif (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn true;\n",
       "}\n",
       "\n",
       "var _Utils_equal = F2(_Utils_eq);\n",
       "var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });\n",
       "\n",
       "\n",
       "\n",
       "// COMPARISONS\n",
       "\n",
       "// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on\n",
       "// the particular integer values assigned to LT, EQ, and GT.\n",
       "\n",
       "function _Utils_cmp(x, y, ord)\n",
       "{\n",
       "\tif (typeof x !== 'object')\n",
       "\t{\n",
       "\t\treturn x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;\n",
       "\t}\n",
       "\n",
       "\t/**/\n",
       "\tif (x instanceof String)\n",
       "\t{\n",
       "\t\tvar a = x.valueOf();\n",
       "\t\tvar b = y.valueOf();\n",
       "\t\treturn a === b ? 0 : a < b ? -1 : 1;\n",
       "\t}\n",
       "\t//*/\n",
       "\n",
       "\t/**_UNUSED/\n",
       "\tif (typeof x.$ === 'undefined')\n",
       "\t//*/\n",
       "\t/**/\n",
       "\tif (x.$[0] === '#')\n",
       "\t//*/\n",
       "\t{\n",
       "\t\treturn (ord = _Utils_cmp(x.a, y.a))\n",
       "\t\t\t? ord\n",
       "\t\t\t: (ord = _Utils_cmp(x.b, y.b))\n",
       "\t\t\t\t? ord\n",
       "\t\t\t\t: _Utils_cmp(x.c, y.c);\n",
       "\t}\n",
       "\n",
       "\t// traverse conses until end of a list or a mismatch\n",
       "\tfor (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES\n",
       "\treturn ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);\n",
       "}\n",
       "\n",
       "var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });\n",
       "var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });\n",
       "var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });\n",
       "var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });\n",
       "\n",
       "var _Utils_compare = F2(function(x, y)\n",
       "{\n",
       "\tvar n = _Utils_cmp(x, y);\n",
       "\treturn n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;\n",
       "});\n",
       "\n",
       "\n",
       "// COMMON VALUES\n",
       "\n",
       "var _Utils_Tuple0_UNUSED = 0;\n",
       "var _Utils_Tuple0 = { $: '#0' };\n",
       "\n",
       "function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }\n",
       "function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }\n",
       "\n",
       "function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }\n",
       "function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }\n",
       "\n",
       "function _Utils_chr_UNUSED(c) { return c; }\n",
       "function _Utils_chr(c) { return new String(c); }\n",
       "\n",
       "\n",
       "// RECORDS\n",
       "\n",
       "function _Utils_update(oldRecord, updatedFields)\n",
       "{\n",
       "\tvar newRecord = {};\n",
       "\n",
       "\tfor (var key in oldRecord)\n",
       "\t{\n",
       "\t\tnewRecord[key] = oldRecord[key];\n",
       "\t}\n",
       "\n",
       "\tfor (var key in updatedFields)\n",
       "\t{\n",
       "\t\tnewRecord[key] = updatedFields[key];\n",
       "\t}\n",
       "\n",
       "\treturn newRecord;\n",
       "}\n",
       "\n",
       "\n",
       "// APPEND\n",
       "\n",
       "var _Utils_append = F2(_Utils_ap);\n",
       "\n",
       "function _Utils_ap(xs, ys)\n",
       "{\n",
       "\t// append Strings\n",
       "\tif (typeof xs === 'string')\n",
       "\t{\n",
       "\t\treturn xs + ys;\n",
       "\t}\n",
       "\n",
       "\t// append Lists\n",
       "\tif (!xs.b)\n",
       "\t{\n",
       "\t\treturn ys;\n",
       "\t}\n",
       "\tvar root = _List_Cons(xs.a, ys);\n",
       "\txs = xs.b\n",
       "\tfor (var curr = root; xs.b; xs = xs.b) // WHILE_CONS\n",
       "\t{\n",
       "\t\tcurr = curr.b = _List_Cons(xs.a, ys);\n",
       "\t}\n",
       "\treturn root;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "var _List_Nil_UNUSED = { $: 0 };\n",
       "var _List_Nil = { $: '[]' };\n",
       "\n",
       "function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }\n",
       "function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }\n",
       "\n",
       "\n",
       "var _List_cons = F2(_List_Cons);\n",
       "\n",
       "function _List_fromArray(arr)\n",
       "{\n",
       "\tvar out = _List_Nil;\n",
       "\tfor (var i = arr.length; i--; )\n",
       "\t{\n",
       "\t\tout = _List_Cons(arr[i], out);\n",
       "\t}\n",
       "\treturn out;\n",
       "}\n",
       "\n",
       "function _List_toArray(xs)\n",
       "{\n",
       "\tfor (var out = []; xs.b; xs = xs.b) // WHILE_CONS\n",
       "\t{\n",
       "\t\tout.push(xs.a);\n",
       "\t}\n",
       "\treturn out;\n",
       "}\n",
       "\n",
       "var _List_map2 = F3(function(f, xs, ys)\n",
       "{\n",
       "\tfor (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A2(f, xs.a, ys.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_map3 = F4(function(f, xs, ys, zs)\n",
       "{\n",
       "\tfor (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A3(f, xs.a, ys.a, zs.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_map4 = F5(function(f, ws, xs, ys, zs)\n",
       "{\n",
       "\tfor (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A4(f, ws.a, xs.a, ys.a, zs.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)\n",
       "{\n",
       "\tfor (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_sortBy = F2(function(f, xs)\n",
       "{\n",
       "\treturn _List_fromArray(_List_toArray(xs).sort(function(a, b) {\n",
       "\t\treturn _Utils_cmp(f(a), f(b));\n",
       "\t}));\n",
       "});\n",
       "\n",
       "var _List_sortWith = F2(function(f, xs)\n",
       "{\n",
       "\treturn _List_fromArray(_List_toArray(xs).sort(function(a, b) {\n",
       "\t\tvar ord = A2(f, a, b);\n",
       "\t\treturn ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;\n",
       "\t}));\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "var _JsArray_empty = [];\n",
       "\n",
       "function _JsArray_singleton(value)\n",
       "{\n",
       "    return [value];\n",
       "}\n",
       "\n",
       "function _JsArray_length(array)\n",
       "{\n",
       "    return array.length;\n",
       "}\n",
       "\n",
       "var _JsArray_initialize = F3(function(size, offset, func)\n",
       "{\n",
       "    var result = new Array(size);\n",
       "\n",
       "    for (var i = 0; i < size; i++)\n",
       "    {\n",
       "        result[i] = func(offset + i);\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_initializeFromList = F2(function (max, ls)\n",
       "{\n",
       "    var result = new Array(max);\n",
       "\n",
       "    for (var i = 0; i < max && ls.b; i++)\n",
       "    {\n",
       "        result[i] = ls.a;\n",
       "        ls = ls.b;\n",
       "    }\n",
       "\n",
       "    result.length = i;\n",
       "    return _Utils_Tuple2(result, ls);\n",
       "});\n",
       "\n",
       "var _JsArray_unsafeGet = F2(function(index, array)\n",
       "{\n",
       "    return array[index];\n",
       "});\n",
       "\n",
       "var _JsArray_unsafeSet = F3(function(index, value, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = array[i];\n",
       "    }\n",
       "\n",
       "    result[index] = value;\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_push = F2(function(value, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length + 1);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = array[i];\n",
       "    }\n",
       "\n",
       "    result[length] = value;\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_foldl = F3(function(func, acc, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        acc = A2(func, array[i], acc);\n",
       "    }\n",
       "\n",
       "    return acc;\n",
       "});\n",
       "\n",
       "var _JsArray_foldr = F3(function(func, acc, array)\n",
       "{\n",
       "    for (var i = array.length - 1; i >= 0; i--)\n",
       "    {\n",
       "        acc = A2(func, array[i], acc);\n",
       "    }\n",
       "\n",
       "    return acc;\n",
       "});\n",
       "\n",
       "var _JsArray_map = F2(function(func, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = func(array[i]);\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_indexedMap = F3(function(func, offset, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = A2(func, offset + i, array[i]);\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_slice = F3(function(from, to, array)\n",
       "{\n",
       "    return array.slice(from, to);\n",
       "});\n",
       "\n",
       "var _JsArray_appendN = F3(function(n, dest, source)\n",
       "{\n",
       "    var destLen = dest.length;\n",
       "    var itemsToCopy = n - destLen;\n",
       "\n",
       "    if (itemsToCopy > source.length)\n",
       "    {\n",
       "        itemsToCopy = source.length;\n",
       "    }\n",
       "\n",
       "    var size = destLen + itemsToCopy;\n",
       "    var result = new Array(size);\n",
       "\n",
       "    for (var i = 0; i < destLen; i++)\n",
       "    {\n",
       "        result[i] = dest[i];\n",
       "    }\n",
       "\n",
       "    for (var i = 0; i < itemsToCopy; i++)\n",
       "    {\n",
       "        result[i + destLen] = source[i];\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// LOG\n",
       "\n",
       "var _Debug_log_UNUSED = F2(function(tag, value)\n",
       "{\n",
       "\treturn value;\n",
       "});\n",
       "\n",
       "var _Debug_log = F2(function(tag, value)\n",
       "{\n",
       "\tconsole.log(tag + ': ' + _Debug_toString(value));\n",
       "\treturn value;\n",
       "});\n",
       "\n",
       "\n",
       "// TODOS\n",
       "\n",
       "function _Debug_todo(moduleName, region)\n",
       "{\n",
       "\treturn function(message) {\n",
       "\t\t_Debug_crash(8, moduleName, region, message);\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Debug_todoCase(moduleName, region, value)\n",
       "{\n",
       "\treturn function(message) {\n",
       "\t\t_Debug_crash(9, moduleName, region, value, message);\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "// TO STRING\n",
       "\n",
       "function _Debug_toString_UNUSED(value)\n",
       "{\n",
       "\treturn '<internals>';\n",
       "}\n",
       "\n",
       "function _Debug_toString(value)\n",
       "{\n",
       "\treturn _Debug_toAnsiString(false, value);\n",
       "}\n",
       "\n",
       "function _Debug_toAnsiString(ansi, value)\n",
       "{\n",
       "\tif (typeof value === 'function')\n",
       "\t{\n",
       "\t\treturn _Debug_internalColor(ansi, '<function>');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'boolean')\n",
       "\t{\n",
       "\t\treturn _Debug_ctorColor(ansi, value ? 'True' : 'False');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'number')\n",
       "\t{\n",
       "\t\treturn _Debug_numberColor(ansi, value + '');\n",
       "\t}\n",
       "\n",
       "\tif (value instanceof String)\n",
       "\t{\n",
       "\t\treturn _Debug_charColor(ansi, \"'\" + _Debug_addSlashes(value, true) + \"'\");\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'string')\n",
       "\t{\n",
       "\t\treturn _Debug_stringColor(ansi, '\"' + _Debug_addSlashes(value, false) + '\"');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'object' && '$' in value)\n",
       "\t{\n",
       "\t\tvar tag = value.$;\n",
       "\n",
       "\t\tif (typeof tag === 'number')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_internalColor(ansi, '<internals>');\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag[0] === '#')\n",
       "\t\t{\n",
       "\t\t\tvar output = [];\n",
       "\t\t\tfor (var k in value)\n",
       "\t\t\t{\n",
       "\t\t\t\tif (k === '$') continue;\n",
       "\t\t\t\toutput.push(_Debug_toAnsiString(ansi, value[k]));\n",
       "\t\t\t}\n",
       "\t\t\treturn '(' + output.join(',') + ')';\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === 'Set_elm_builtin')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_ctorColor(ansi, 'Set')\n",
       "\t\t\t\t+ _Debug_fadeColor(ansi, '.fromList') + ' '\n",
       "\t\t\t\t+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_ctorColor(ansi, 'Dict')\n",
       "\t\t\t\t+ _Debug_fadeColor(ansi, '.fromList') + ' '\n",
       "\t\t\t\t+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === 'Array_elm_builtin')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_ctorColor(ansi, 'Array')\n",
       "\t\t\t\t+ _Debug_fadeColor(ansi, '.fromList') + ' '\n",
       "\t\t\t\t+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === '::' || tag === '[]')\n",
       "\t\t{\n",
       "\t\t\tvar output = '[';\n",
       "\n",
       "\t\t\tvalue.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)\n",
       "\n",
       "\t\t\tfor (; value.b; value = value.b) // WHILE_CONS\n",
       "\t\t\t{\n",
       "\t\t\t\toutput += ',' + _Debug_toAnsiString(ansi, value.a);\n",
       "\t\t\t}\n",
       "\t\t\treturn output + ']';\n",
       "\t\t}\n",
       "\n",
       "\t\tvar output = '';\n",
       "\t\tfor (var i in value)\n",
       "\t\t{\n",
       "\t\t\tif (i === '$') continue;\n",
       "\t\t\tvar str = _Debug_toAnsiString(ansi, value[i]);\n",
       "\t\t\tvar c0 = str[0];\n",
       "\t\t\tvar parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '\"' || str.indexOf(' ') < 0;\n",
       "\t\t\toutput += ' ' + (parenless ? str : '(' + str + ')');\n",
       "\t\t}\n",
       "\t\treturn _Debug_ctorColor(ansi, tag) + output;\n",
       "\t}\n",
       "\n",
       "\tif (typeof DataView === 'function' && value instanceof DataView)\n",
       "\t{\n",
       "\t\treturn _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');\n",
       "\t}\n",
       "\n",
       "\tif (typeof File !== 'undefined' && value instanceof File)\n",
       "\t{\n",
       "\t\treturn _Debug_internalColor(ansi, '<' + value.name + '>');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'object')\n",
       "\t{\n",
       "\t\tvar output = [];\n",
       "\t\tfor (var key in value)\n",
       "\t\t{\n",
       "\t\t\tvar field = key[0] === '_' ? key.slice(1) : key;\n",
       "\t\t\toutput.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));\n",
       "\t\t}\n",
       "\t\tif (output.length === 0)\n",
       "\t\t{\n",
       "\t\t\treturn '{}';\n",
       "\t\t}\n",
       "\t\treturn '{ ' + output.join(', ') + ' }';\n",
       "\t}\n",
       "\n",
       "\treturn _Debug_internalColor(ansi, '<internals>');\n",
       "}\n",
       "\n",
       "function _Debug_addSlashes(str, isChar)\n",
       "{\n",
       "\tvar s = str\n",
       "\t\t.replace(/\\\\/g, '\\\\\\\\')\n",
       "\t\t.replace(/\\n/g, '\\\\n')\n",
       "\t\t.replace(/\\t/g, '\\\\t')\n",
       "\t\t.replace(/\\r/g, '\\\\r')\n",
       "\t\t.replace(/\\v/g, '\\\\v')\n",
       "\t\t.replace(/\\0/g, '\\\\0');\n",
       "\n",
       "\tif (isChar)\n",
       "\t{\n",
       "\t\treturn s.replace(/\\'/g, '\\\\\\'');\n",
       "\t}\n",
       "\telse\n",
       "\t{\n",
       "\t\treturn s.replace(/\\\"/g, '\\\\\"');\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Debug_ctorColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[96m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_numberColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[95m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_stringColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[93m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_charColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[92m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_fadeColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[37m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_internalColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[36m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_toHexDigit(n)\n",
       "{\n",
       "\treturn String.fromCharCode(n < 10 ? 48 + n : 55 + n);\n",
       "}\n",
       "\n",
       "\n",
       "// CRASH\n",
       "\n",
       "\n",
       "function _Debug_crash_UNUSED(identifier)\n",
       "{\n",
       "\tthrow new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');\n",
       "}\n",
       "\n",
       "\n",
       "function _Debug_crash(identifier, fact1, fact2, fact3, fact4)\n",
       "{\n",
       "\tswitch(identifier)\n",
       "\t{\n",
       "\t\tcase 0:\n",
       "\t\t\tthrow new Error('What node should I take over? In JavaScript I need something like:\\n\\n    Elm.Main.init({\\n        node: document.getElementById(\"elm-node\")\\n    })\\n\\nYou need to do this with any Browser.sandbox or Browser.element program.');\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\tthrow new Error('Browser.application programs cannot handle URLs like this:\\n\\n    ' + document.location.href + '\\n\\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\tvar jsonErrorString = fact1;\n",
       "\t\t\tthrow new Error('Problem with the flags given to your Elm program on initialization.\\n\\n' + jsonErrorString);\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tvar portName = fact1;\n",
       "\t\t\tthrow new Error('There can only be one port named `' + portName + '`, but your program has multiple.');\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\tvar portName = fact1;\n",
       "\t\t\tvar problem = fact2;\n",
       "\t\t\tthrow new Error('Trying to send an unexpected type of value through port `' + portName + '`:\\n' + problem);\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\tthrow new Error('Trying to use `(==)` on functions.\\nThere is no way to know if functions are \"the same\" in the Elm sense.\\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\tvar moduleName = fact1;\n",
       "\t\t\tthrow new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');\n",
       "\n",
       "\t\tcase 8:\n",
       "\t\t\tvar moduleName = fact1;\n",
       "\t\t\tvar region = fact2;\n",
       "\t\t\tvar message = fact3;\n",
       "\t\t\tthrow new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\\n\\n' + message);\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\tvar moduleName = fact1;\n",
       "\t\t\tvar region = fact2;\n",
       "\t\t\tvar value = fact3;\n",
       "\t\t\tvar message = fact4;\n",
       "\t\t\tthrow new Error(\n",
       "\t\t\t\t'TODO in module `' + moduleName + '` from the `case` expression '\n",
       "\t\t\t\t+ _Debug_regionToString(region) + '\\n\\nIt received the following value:\\n\\n    '\n",
       "\t\t\t\t+ _Debug_toString(value).replace('\\n', '\\n    ')\n",
       "\t\t\t\t+ '\\n\\nBut the branch that handles it says:\\n\\n    ' + message.replace('\\n', '\\n    ')\n",
       "\t\t\t);\n",
       "\n",
       "\t\tcase 10:\n",
       "\t\t\tthrow new Error('Bug in https://github.com/elm/virtual-dom/issues');\n",
       "\n",
       "\t\tcase 11:\n",
       "\t\t\tthrow new Error('Cannot perform mod 0. Division by zero error.');\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Debug_regionToString(region)\n",
       "{\n",
       "\tif (region.start.line === region.end.line)\n",
       "\t{\n",
       "\t\treturn 'on line ' + region.start.line;\n",
       "\t}\n",
       "\treturn 'on lines ' + region.start.line + ' through ' + region.end.line;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// MATH\n",
       "\n",
       "var _Basics_add = F2(function(a, b) { return a + b; });\n",
       "var _Basics_sub = F2(function(a, b) { return a - b; });\n",
       "var _Basics_mul = F2(function(a, b) { return a * b; });\n",
       "var _Basics_fdiv = F2(function(a, b) { return a / b; });\n",
       "var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });\n",
       "var _Basics_pow = F2(Math.pow);\n",
       "\n",
       "var _Basics_remainderBy = F2(function(b, a) { return a % b; });\n",
       "\n",
       "// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf\n",
       "var _Basics_modBy = F2(function(modulus, x)\n",
       "{\n",
       "\tvar answer = x % modulus;\n",
       "\treturn modulus === 0\n",
       "\t\t? _Debug_crash(11)\n",
       "\t\t:\n",
       "\t((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))\n",
       "\t\t? answer + modulus\n",
       "\t\t: answer;\n",
       "});\n",
       "\n",
       "\n",
       "// TRIGONOMETRY\n",
       "\n",
       "var _Basics_pi = Math.PI;\n",
       "var _Basics_e = Math.E;\n",
       "var _Basics_cos = Math.cos;\n",
       "var _Basics_sin = Math.sin;\n",
       "var _Basics_tan = Math.tan;\n",
       "var _Basics_acos = Math.acos;\n",
       "var _Basics_asin = Math.asin;\n",
       "var _Basics_atan = Math.atan;\n",
       "var _Basics_atan2 = F2(Math.atan2);\n",
       "\n",
       "\n",
       "// MORE MATH\n",
       "\n",
       "function _Basics_toFloat(x) { return x; }\n",
       "function _Basics_truncate(n) { return n | 0; }\n",
       "function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }\n",
       "\n",
       "var _Basics_ceiling = Math.ceil;\n",
       "var _Basics_floor = Math.floor;\n",
       "var _Basics_round = Math.round;\n",
       "var _Basics_sqrt = Math.sqrt;\n",
       "var _Basics_log = Math.log;\n",
       "var _Basics_isNaN = isNaN;\n",
       "\n",
       "\n",
       "// BOOLEANS\n",
       "\n",
       "function _Basics_not(bool) { return !bool; }\n",
       "var _Basics_and = F2(function(a, b) { return a && b; });\n",
       "var _Basics_or  = F2(function(a, b) { return a || b; });\n",
       "var _Basics_xor = F2(function(a, b) { return a !== b; });\n",
       "\n",
       "\n",
       "\n",
       "var _String_cons = F2(function(chr, str)\n",
       "{\n",
       "\treturn chr + str;\n",
       "});\n",
       "\n",
       "function _String_uncons(string)\n",
       "{\n",
       "\tvar word = string.charCodeAt(0);\n",
       "\treturn !isNaN(word)\n",
       "\t\t? $elm$core$Maybe$Just(\n",
       "\t\t\t0xD800 <= word && word <= 0xDBFF\n",
       "\t\t\t\t? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))\n",
       "\t\t\t\t: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))\n",
       "\t\t)\n",
       "\t\t: $elm$core$Maybe$Nothing;\n",
       "}\n",
       "\n",
       "var _String_append = F2(function(a, b)\n",
       "{\n",
       "\treturn a + b;\n",
       "});\n",
       "\n",
       "function _String_length(str)\n",
       "{\n",
       "\treturn str.length;\n",
       "}\n",
       "\n",
       "var _String_map = F2(function(func, string)\n",
       "{\n",
       "\tvar len = string.length;\n",
       "\tvar array = new Array(len);\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tarray[i] = func(_Utils_chr(string[i] + string[i+1]));\n",
       "\t\t\ti += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\t\tarray[i] = func(_Utils_chr(string[i]));\n",
       "\t\ti++;\n",
       "\t}\n",
       "\treturn array.join('');\n",
       "});\n",
       "\n",
       "var _String_filter = F2(function(isGood, str)\n",
       "{\n",
       "\tvar arr = [];\n",
       "\tvar len = str.length;\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar char = str[i];\n",
       "\t\tvar word = str.charCodeAt(i);\n",
       "\t\ti++;\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tchar += str[i];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\n",
       "\t\tif (isGood(_Utils_chr(char)))\n",
       "\t\t{\n",
       "\t\t\tarr.push(char);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn arr.join('');\n",
       "});\n",
       "\n",
       "function _String_reverse(str)\n",
       "{\n",
       "\tvar len = str.length;\n",
       "\tvar arr = new Array(len);\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar word = str.charCodeAt(i);\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tarr[len - i] = str[i + 1];\n",
       "\t\t\ti++;\n",
       "\t\t\tarr[len - i] = str[i - 1];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\t\telse\n",
       "\t\t{\n",
       "\t\t\tarr[len - i] = str[i];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn arr.join('');\n",
       "}\n",
       "\n",
       "var _String_foldl = F3(function(func, state, string)\n",
       "{\n",
       "\tvar len = string.length;\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\ti++;\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tchar += string[i];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\t\tstate = A2(func, _Utils_chr(char), state);\n",
       "\t}\n",
       "\treturn state;\n",
       "});\n",
       "\n",
       "var _String_foldr = F3(function(func, state, string)\n",
       "{\n",
       "\tvar i = string.length;\n",
       "\twhile (i--)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xDC00 <= word && word <= 0xDFFF)\n",
       "\t\t{\n",
       "\t\t\ti--;\n",
       "\t\t\tchar = string[i] + char;\n",
       "\t\t}\n",
       "\t\tstate = A2(func, _Utils_chr(char), state);\n",
       "\t}\n",
       "\treturn state;\n",
       "});\n",
       "\n",
       "var _String_split = F2(function(sep, str)\n",
       "{\n",
       "\treturn str.split(sep);\n",
       "});\n",
       "\n",
       "var _String_join = F2(function(sep, strs)\n",
       "{\n",
       "\treturn strs.join(sep);\n",
       "});\n",
       "\n",
       "var _String_slice = F3(function(start, end, str) {\n",
       "\treturn str.slice(start, end);\n",
       "});\n",
       "\n",
       "function _String_trim(str)\n",
       "{\n",
       "\treturn str.trim();\n",
       "}\n",
       "\n",
       "function _String_trimLeft(str)\n",
       "{\n",
       "\treturn str.replace(/^\\s+/, '');\n",
       "}\n",
       "\n",
       "function _String_trimRight(str)\n",
       "{\n",
       "\treturn str.replace(/\\s+$/, '');\n",
       "}\n",
       "\n",
       "function _String_words(str)\n",
       "{\n",
       "\treturn _List_fromArray(str.trim().split(/\\s+/g));\n",
       "}\n",
       "\n",
       "function _String_lines(str)\n",
       "{\n",
       "\treturn _List_fromArray(str.split(/\\r\\n|\\r|\\n/g));\n",
       "}\n",
       "\n",
       "function _String_toUpper(str)\n",
       "{\n",
       "\treturn str.toUpperCase();\n",
       "}\n",
       "\n",
       "function _String_toLower(str)\n",
       "{\n",
       "\treturn str.toLowerCase();\n",
       "}\n",
       "\n",
       "var _String_any = F2(function(isGood, string)\n",
       "{\n",
       "\tvar i = string.length;\n",
       "\twhile (i--)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xDC00 <= word && word <= 0xDFFF)\n",
       "\t\t{\n",
       "\t\t\ti--;\n",
       "\t\t\tchar = string[i] + char;\n",
       "\t\t}\n",
       "\t\tif (isGood(_Utils_chr(char)))\n",
       "\t\t{\n",
       "\t\t\treturn true;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn false;\n",
       "});\n",
       "\n",
       "var _String_all = F2(function(isGood, string)\n",
       "{\n",
       "\tvar i = string.length;\n",
       "\twhile (i--)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xDC00 <= word && word <= 0xDFFF)\n",
       "\t\t{\n",
       "\t\t\ti--;\n",
       "\t\t\tchar = string[i] + char;\n",
       "\t\t}\n",
       "\t\tif (!isGood(_Utils_chr(char)))\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn true;\n",
       "});\n",
       "\n",
       "var _String_contains = F2(function(sub, str)\n",
       "{\n",
       "\treturn str.indexOf(sub) > -1;\n",
       "});\n",
       "\n",
       "var _String_startsWith = F2(function(sub, str)\n",
       "{\n",
       "\treturn str.indexOf(sub) === 0;\n",
       "});\n",
       "\n",
       "var _String_endsWith = F2(function(sub, str)\n",
       "{\n",
       "\treturn str.length >= sub.length &&\n",
       "\t\tstr.lastIndexOf(sub) === str.length - sub.length;\n",
       "});\n",
       "\n",
       "var _String_indexes = F2(function(sub, str)\n",
       "{\n",
       "\tvar subLen = sub.length;\n",
       "\n",
       "\tif (subLen < 1)\n",
       "\t{\n",
       "\t\treturn _List_Nil;\n",
       "\t}\n",
       "\n",
       "\tvar i = 0;\n",
       "\tvar is = [];\n",
       "\n",
       "\twhile ((i = str.indexOf(sub, i)) > -1)\n",
       "\t{\n",
       "\t\tis.push(i);\n",
       "\t\ti = i + subLen;\n",
       "\t}\n",
       "\n",
       "\treturn _List_fromArray(is);\n",
       "});\n",
       "\n",
       "\n",
       "// TO STRING\n",
       "\n",
       "function _String_fromNumber(number)\n",
       "{\n",
       "\treturn number + '';\n",
       "}\n",
       "\n",
       "\n",
       "// INT CONVERSIONS\n",
       "\n",
       "function _String_toInt(str)\n",
       "{\n",
       "\tvar total = 0;\n",
       "\tvar code0 = str.charCodeAt(0);\n",
       "\tvar start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;\n",
       "\n",
       "\tfor (var i = start; i < str.length; ++i)\n",
       "\t{\n",
       "\t\tvar code = str.charCodeAt(i);\n",
       "\t\tif (code < 0x30 || 0x39 < code)\n",
       "\t\t{\n",
       "\t\t\treturn $elm$core$Maybe$Nothing;\n",
       "\t\t}\n",
       "\t\ttotal = 10 * total + code - 0x30;\n",
       "\t}\n",
       "\n",
       "\treturn i == start\n",
       "\t\t? $elm$core$Maybe$Nothing\n",
       "\t\t: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);\n",
       "}\n",
       "\n",
       "\n",
       "// FLOAT CONVERSIONS\n",
       "\n",
       "function _String_toFloat(s)\n",
       "{\n",
       "\t// check if it is a hex, octal, or binary number\n",
       "\tif (s.length === 0 || /[\\sxbo]/.test(s))\n",
       "\t{\n",
       "\t\treturn $elm$core$Maybe$Nothing;\n",
       "\t}\n",
       "\tvar n = +s;\n",
       "\t// faster isNaN check\n",
       "\treturn n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;\n",
       "}\n",
       "\n",
       "function _String_fromList(chars)\n",
       "{\n",
       "\treturn _List_toArray(chars).join('');\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "function _Char_toCode(char)\n",
       "{\n",
       "\tvar code = char.charCodeAt(0);\n",
       "\tif (0xD800 <= code && code <= 0xDBFF)\n",
       "\t{\n",
       "\t\treturn (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000\n",
       "\t}\n",
       "\treturn code;\n",
       "}\n",
       "\n",
       "function _Char_fromCode(code)\n",
       "{\n",
       "\treturn _Utils_chr(\n",
       "\t\t(code < 0 || 0x10FFFF < code)\n",
       "\t\t\t? '\\uFFFD'\n",
       "\t\t\t:\n",
       "\t\t(code <= 0xFFFF)\n",
       "\t\t\t? String.fromCharCode(code)\n",
       "\t\t\t:\n",
       "\t\t(code -= 0x10000,\n",
       "\t\t\tString.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)\n",
       "\t\t)\n",
       "\t);\n",
       "}\n",
       "\n",
       "function _Char_toUpper(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toUpperCase());\n",
       "}\n",
       "\n",
       "function _Char_toLower(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toLowerCase());\n",
       "}\n",
       "\n",
       "function _Char_toLocaleUpper(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toLocaleUpperCase());\n",
       "}\n",
       "\n",
       "function _Char_toLocaleLower(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toLocaleLowerCase());\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/**/\n",
       "function _Json_errorToString(error)\n",
       "{\n",
       "\treturn $elm$json$Json$Decode$errorToString(error);\n",
       "}\n",
       "//*/\n",
       "\n",
       "\n",
       "// CORE DECODERS\n",
       "\n",
       "function _Json_succeed(msg)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 0,\n",
       "\t\ta: msg\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Json_fail(msg)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 1,\n",
       "\t\ta: msg\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Json_decodePrim(decoder)\n",
       "{\n",
       "\treturn { $: 2, b: decoder };\n",
       "}\n",
       "\n",
       "var _Json_decodeInt = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value !== 'number')\n",
       "\t\t? _Json_expecting('an INT', value)\n",
       "\t\t:\n",
       "\t(-2147483647 < value && value < 2147483647 && (value | 0) === value)\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t:\n",
       "\t(isFinite(value) && !(value % 1))\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: _Json_expecting('an INT', value);\n",
       "});\n",
       "\n",
       "var _Json_decodeBool = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value === 'boolean')\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: _Json_expecting('a BOOL', value);\n",
       "});\n",
       "\n",
       "var _Json_decodeFloat = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value === 'number')\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: _Json_expecting('a FLOAT', value);\n",
       "});\n",
       "\n",
       "var _Json_decodeValue = _Json_decodePrim(function(value) {\n",
       "\treturn $elm$core$Result$Ok(_Json_wrap(value));\n",
       "});\n",
       "\n",
       "var _Json_decodeString = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value === 'string')\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: (value instanceof String)\n",
       "\t\t\t? $elm$core$Result$Ok(value + '')\n",
       "\t\t\t: _Json_expecting('a STRING', value);\n",
       "});\n",
       "\n",
       "function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }\n",
       "function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }\n",
       "\n",
       "function _Json_decodeNull(value) { return { $: 5, c: value }; }\n",
       "\n",
       "var _Json_decodeField = F2(function(field, decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 6,\n",
       "\t\td: field,\n",
       "\t\tb: decoder\n",
       "\t};\n",
       "});\n",
       "\n",
       "var _Json_decodeIndex = F2(function(index, decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 7,\n",
       "\t\te: index,\n",
       "\t\tb: decoder\n",
       "\t};\n",
       "});\n",
       "\n",
       "function _Json_decodeKeyValuePairs(decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 8,\n",
       "\t\tb: decoder\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Json_mapMany(f, decoders)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 9,\n",
       "\t\tf: f,\n",
       "\t\tg: decoders\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _Json_andThen = F2(function(callback, decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 10,\n",
       "\t\tb: decoder,\n",
       "\t\th: callback\n",
       "\t};\n",
       "});\n",
       "\n",
       "function _Json_oneOf(decoders)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 11,\n",
       "\t\tg: decoders\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "// DECODING OBJECTS\n",
       "\n",
       "var _Json_map1 = F2(function(f, d1)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1]);\n",
       "});\n",
       "\n",
       "var _Json_map2 = F3(function(f, d1, d2)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2]);\n",
       "});\n",
       "\n",
       "var _Json_map3 = F4(function(f, d1, d2, d3)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3]);\n",
       "});\n",
       "\n",
       "var _Json_map4 = F5(function(f, d1, d2, d3, d4)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4]);\n",
       "});\n",
       "\n",
       "var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5]);\n",
       "});\n",
       "\n",
       "var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);\n",
       "});\n",
       "\n",
       "var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);\n",
       "});\n",
       "\n",
       "var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);\n",
       "});\n",
       "\n",
       "\n",
       "// DECODE\n",
       "\n",
       "var _Json_runOnString = F2(function(decoder, string)\n",
       "{\n",
       "\ttry\n",
       "\t{\n",
       "\t\tvar value = JSON.parse(string);\n",
       "\t\treturn _Json_runHelp(decoder, value);\n",
       "\t}\n",
       "\tcatch (e)\n",
       "\t{\n",
       "\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));\n",
       "\t}\n",
       "});\n",
       "\n",
       "var _Json_run = F2(function(decoder, value)\n",
       "{\n",
       "\treturn _Json_runHelp(decoder, _Json_unwrap(value));\n",
       "});\n",
       "\n",
       "function _Json_runHelp(decoder, value)\n",
       "{\n",
       "\tswitch (decoder.$)\n",
       "\t{\n",
       "\t\tcase 2:\n",
       "\t\t\treturn decoder.b(value);\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\treturn (value === null)\n",
       "\t\t\t\t? $elm$core$Result$Ok(decoder.c)\n",
       "\t\t\t\t: _Json_expecting('null', value);\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tif (!_Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('a LIST', value);\n",
       "\t\t\t}\n",
       "\t\t\treturn _Json_runArrayDecoder(decoder.b, value, _List_fromArray);\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\tif (!_Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an ARRAY', value);\n",
       "\t\t\t}\n",
       "\t\t\treturn _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\tvar field = decoder.d;\n",
       "\t\t\tif (typeof value !== 'object' || value === null || !(field in value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an OBJECT with a field named `' + field + '`', value);\n",
       "\t\t\t}\n",
       "\t\t\tvar result = _Json_runHelp(decoder.b, value[field]);\n",
       "\t\t\treturn ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));\n",
       "\n",
       "\t\tcase 7:\n",
       "\t\t\tvar index = decoder.e;\n",
       "\t\t\tif (!_Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an ARRAY', value);\n",
       "\t\t\t}\n",
       "\t\t\tif (index >= value.length)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);\n",
       "\t\t\t}\n",
       "\t\t\tvar result = _Json_runHelp(decoder.b, value[index]);\n",
       "\t\t\treturn ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));\n",
       "\n",
       "\t\tcase 8:\n",
       "\t\t\tif (typeof value !== 'object' || value === null || _Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an OBJECT', value);\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\tvar keyValuePairs = _List_Nil;\n",
       "\t\t\t// TODO test perf of Object.keys and switch when support is good enough\n",
       "\t\t\tfor (var key in value)\n",
       "\t\t\t{\n",
       "\t\t\t\tif (value.hasOwnProperty(key))\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\tvar result = _Json_runHelp(decoder.b, value[key]);\n",
       "\t\t\t\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t\t\t\t{\n",
       "\t\t\t\t\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t\tkeyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t\treturn $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\tvar answer = decoder.f;\n",
       "\t\t\tvar decoders = decoder.g;\n",
       "\t\t\tfor (var i = 0; i < decoders.length; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tvar result = _Json_runHelp(decoders[i], value);\n",
       "\t\t\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\treturn result;\n",
       "\t\t\t\t}\n",
       "\t\t\t\tanswer = answer(result.a);\n",
       "\t\t\t}\n",
       "\t\t\treturn $elm$core$Result$Ok(answer);\n",
       "\n",
       "\t\tcase 10:\n",
       "\t\t\tvar result = _Json_runHelp(decoder.b, value);\n",
       "\t\t\treturn (!$elm$core$Result$isOk(result))\n",
       "\t\t\t\t? result\n",
       "\t\t\t\t: _Json_runHelp(decoder.h(result.a), value);\n",
       "\n",
       "\t\tcase 11:\n",
       "\t\t\tvar errors = _List_Nil;\n",
       "\t\t\tfor (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS\n",
       "\t\t\t{\n",
       "\t\t\t\tvar result = _Json_runHelp(temp.a, value);\n",
       "\t\t\t\tif ($elm$core$Result$isOk(result))\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\treturn result;\n",
       "\t\t\t\t}\n",
       "\t\t\t\terrors = _List_Cons(result.a, errors);\n",
       "\t\t\t}\n",
       "\t\t\treturn $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));\n",
       "\n",
       "\t\tcase 0:\n",
       "\t\t\treturn $elm$core$Result$Ok(decoder.a);\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Json_runArrayDecoder(decoder, value, toElmValue)\n",
       "{\n",
       "\tvar len = value.length;\n",
       "\tvar array = new Array(len);\n",
       "\tfor (var i = 0; i < len; i++)\n",
       "\t{\n",
       "\t\tvar result = _Json_runHelp(decoder, value[i]);\n",
       "\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t{\n",
       "\t\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));\n",
       "\t\t}\n",
       "\t\tarray[i] = result.a;\n",
       "\t}\n",
       "\treturn $elm$core$Result$Ok(toElmValue(array));\n",
       "}\n",
       "\n",
       "function _Json_isArray(value)\n",
       "{\n",
       "\treturn Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);\n",
       "}\n",
       "\n",
       "function _Json_toElmArray(array)\n",
       "{\n",
       "\treturn A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });\n",
       "}\n",
       "\n",
       "function _Json_expecting(type, value)\n",
       "{\n",
       "\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));\n",
       "}\n",
       "\n",
       "\n",
       "// EQUALITY\n",
       "\n",
       "function _Json_equality(x, y)\n",
       "{\n",
       "\tif (x === y)\n",
       "\t{\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\n",
       "\tif (x.$ !== y.$)\n",
       "\t{\n",
       "\t\treturn false;\n",
       "\t}\n",
       "\n",
       "\tswitch (x.$)\n",
       "\t{\n",
       "\t\tcase 0:\n",
       "\t\tcase 1:\n",
       "\t\t\treturn x.a === y.a;\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\treturn x.b === y.b;\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\treturn x.c === y.c;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\tcase 4:\n",
       "\t\tcase 8:\n",
       "\t\t\treturn _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\treturn x.d === y.d && _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 7:\n",
       "\t\t\treturn x.e === y.e && _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\treturn x.f === y.f && _Json_listEquality(x.g, y.g);\n",
       "\n",
       "\t\tcase 10:\n",
       "\t\t\treturn x.h === y.h && _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 11:\n",
       "\t\t\treturn _Json_listEquality(x.g, y.g);\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Json_listEquality(aDecoders, bDecoders)\n",
       "{\n",
       "\tvar len = aDecoders.length;\n",
       "\tif (len !== bDecoders.length)\n",
       "\t{\n",
       "\t\treturn false;\n",
       "\t}\n",
       "\tfor (var i = 0; i < len; i++)\n",
       "\t{\n",
       "\t\tif (!_Json_equality(aDecoders[i], bDecoders[i]))\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn true;\n",
       "}\n",
       "\n",
       "\n",
       "// ENCODE\n",
       "\n",
       "var _Json_encode = F2(function(indentLevel, value)\n",
       "{\n",
       "\treturn JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';\n",
       "});\n",
       "\n",
       "function _Json_wrap(value) { return { $: 0, a: value }; }\n",
       "function _Json_unwrap(value) { return value.a; }\n",
       "\n",
       "function _Json_wrap_UNUSED(value) { return value; }\n",
       "function _Json_unwrap_UNUSED(value) { return value; }\n",
       "\n",
       "function _Json_emptyArray() { return []; }\n",
       "function _Json_emptyObject() { return {}; }\n",
       "\n",
       "var _Json_addField = F3(function(key, value, object)\n",
       "{\n",
       "\tobject[key] = _Json_unwrap(value);\n",
       "\treturn object;\n",
       "});\n",
       "\n",
       "function _Json_addEntry(func)\n",
       "{\n",
       "\treturn F2(function(entry, array)\n",
       "\t{\n",
       "\t\tarray.push(_Json_unwrap(func(entry)));\n",
       "\t\treturn array;\n",
       "\t});\n",
       "}\n",
       "\n",
       "var _Json_encodeNull = _Json_wrap(null);\n",
       "\n",
       "\n",
       "\n",
       "// TASKS\n",
       "\n",
       "function _Scheduler_succeed(value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 0,\n",
       "\t\ta: value\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Scheduler_fail(error)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 1,\n",
       "\t\ta: error\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Scheduler_binding(callback)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 2,\n",
       "\t\tb: callback,\n",
       "\t\tc: null\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _Scheduler_andThen = F2(function(callback, task)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 3,\n",
       "\t\tb: callback,\n",
       "\t\td: task\n",
       "\t};\n",
       "});\n",
       "\n",
       "var _Scheduler_onError = F2(function(callback, task)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 4,\n",
       "\t\tb: callback,\n",
       "\t\td: task\n",
       "\t};\n",
       "});\n",
       "\n",
       "function _Scheduler_receive(callback)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 5,\n",
       "\t\tb: callback\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "// PROCESSES\n",
       "\n",
       "var _Scheduler_guid = 0;\n",
       "\n",
       "function _Scheduler_rawSpawn(task)\n",
       "{\n",
       "\tvar proc = {\n",
       "\t\t$: 0,\n",
       "\t\te: _Scheduler_guid++,\n",
       "\t\tf: task,\n",
       "\t\tg: null,\n",
       "\t\th: []\n",
       "\t};\n",
       "\n",
       "\t_Scheduler_enqueue(proc);\n",
       "\n",
       "\treturn proc;\n",
       "}\n",
       "\n",
       "function _Scheduler_spawn(task)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\tcallback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));\n",
       "\t});\n",
       "}\n",
       "\n",
       "function _Scheduler_rawSend(proc, msg)\n",
       "{\n",
       "\tproc.h.push(msg);\n",
       "\t_Scheduler_enqueue(proc);\n",
       "}\n",
       "\n",
       "var _Scheduler_send = F2(function(proc, msg)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\t_Scheduler_rawSend(proc, msg);\n",
       "\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t});\n",
       "});\n",
       "\n",
       "function _Scheduler_kill(proc)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\tvar task = proc.f;\n",
       "\t\tif (task.$ === 2 && task.c)\n",
       "\t\t{\n",
       "\t\t\ttask.c();\n",
       "\t\t}\n",
       "\n",
       "\t\tproc.f = null;\n",
       "\n",
       "\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t});\n",
       "}\n",
       "\n",
       "\n",
       "/* STEP PROCESSES\n",
       "\n",
       "type alias Process =\n",
       "  { $ : tag\n",
       "  , id : unique_id\n",
       "  , root : Task\n",
       "  , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }\n",
       "  , mailbox : [msg]\n",
       "  }\n",
       "\n",
       "*/\n",
       "\n",
       "\n",
       "var _Scheduler_working = false;\n",
       "var _Scheduler_queue = [];\n",
       "\n",
       "\n",
       "function _Scheduler_enqueue(proc)\n",
       "{\n",
       "\t_Scheduler_queue.push(proc);\n",
       "\tif (_Scheduler_working)\n",
       "\t{\n",
       "\t\treturn;\n",
       "\t}\n",
       "\t_Scheduler_working = true;\n",
       "\twhile (proc = _Scheduler_queue.shift())\n",
       "\t{\n",
       "\t\t_Scheduler_step(proc);\n",
       "\t}\n",
       "\t_Scheduler_working = false;\n",
       "}\n",
       "\n",
       "\n",
       "function _Scheduler_step(proc)\n",
       "{\n",
       "\twhile (proc.f)\n",
       "\t{\n",
       "\t\tvar rootTag = proc.f.$;\n",
       "\t\tif (rootTag === 0 || rootTag === 1)\n",
       "\t\t{\n",
       "\t\t\twhile (proc.g && proc.g.$ !== rootTag)\n",
       "\t\t\t{\n",
       "\t\t\t\tproc.g = proc.g.i;\n",
       "\t\t\t}\n",
       "\t\t\tif (!proc.g)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\t\t\tproc.f = proc.g.b(proc.f.a);\n",
       "\t\t\tproc.g = proc.g.i;\n",
       "\t\t}\n",
       "\t\telse if (rootTag === 2)\n",
       "\t\t{\n",
       "\t\t\tproc.f.c = proc.f.b(function(newRoot) {\n",
       "\t\t\t\tproc.f = newRoot;\n",
       "\t\t\t\t_Scheduler_enqueue(proc);\n",
       "\t\t\t});\n",
       "\t\t\treturn;\n",
       "\t\t}\n",
       "\t\telse if (rootTag === 5)\n",
       "\t\t{\n",
       "\t\t\tif (proc.h.length === 0)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\t\t\tproc.f = proc.f.b(proc.h.shift());\n",
       "\t\t}\n",
       "\t\telse // if (rootTag === 3 || rootTag === 4)\n",
       "\t\t{\n",
       "\t\t\tproc.g = {\n",
       "\t\t\t\t$: rootTag === 3 ? 0 : 1,\n",
       "\t\t\t\tb: proc.f.b,\n",
       "\t\t\t\ti: proc.g\n",
       "\t\t\t};\n",
       "\t\t\tproc.f = proc.f.d;\n",
       "\t\t}\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "function _Process_sleep(time)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\tvar id = setTimeout(function() {\n",
       "\t\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t\t}, time);\n",
       "\n",
       "\t\treturn function() { clearTimeout(id); };\n",
       "\t});\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "// PROGRAMS\n",
       "\n",
       "\n",
       "var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)\n",
       "{\n",
       "\treturn _Platform_initialize(\n",
       "\t\tflagDecoder,\n",
       "\t\targs,\n",
       "\t\timpl.init,\n",
       "\t\timpl.update,\n",
       "\t\timpl.subscriptions,\n",
       "\t\tfunction() { return function() {} }\n",
       "\t);\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// INITIALIZE A PROGRAM\n",
       "\n",
       "\n",
       "function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)\n",
       "{\n",
       "\tvar result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));\n",
       "\t$elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);\n",
       "\tvar managers = {};\n",
       "\tvar initPair = init(result.a);\n",
       "\tvar model = initPair.a;\n",
       "\tvar stepper = stepperBuilder(sendToApp, model);\n",
       "\tvar ports = _Platform_setupEffects(managers, sendToApp);\n",
       "\n",
       "\tfunction sendToApp(msg, viewMetadata)\n",
       "\t{\n",
       "\t\tvar pair = A2(update, msg, model);\n",
       "\t\tstepper(model = pair.a, viewMetadata);\n",
       "\t\t_Platform_enqueueEffects(managers, pair.b, subscriptions(model));\n",
       "\t}\n",
       "\n",
       "\t_Platform_enqueueEffects(managers, initPair.b, subscriptions(model));\n",
       "\n",
       "\treturn ports ? { ports: ports } : {};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// TRACK PRELOADS\n",
       "//\n",
       "// This is used by code in elm/browser and elm/http\n",
       "// to register any HTTP requests that are triggered by init.\n",
       "//\n",
       "\n",
       "\n",
       "var _Platform_preload;\n",
       "\n",
       "\n",
       "function _Platform_registerPreload(url)\n",
       "{\n",
       "\t_Platform_preload.add(url);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// EFFECT MANAGERS\n",
       "\n",
       "\n",
       "var _Platform_effectManagers = {};\n",
       "\n",
       "\n",
       "function _Platform_setupEffects(managers, sendToApp)\n",
       "{\n",
       "\tvar ports;\n",
       "\n",
       "\t// setup all necessary effect managers\n",
       "\tfor (var key in _Platform_effectManagers)\n",
       "\t{\n",
       "\t\tvar manager = _Platform_effectManagers[key];\n",
       "\n",
       "\t\tif (manager.a)\n",
       "\t\t{\n",
       "\t\t\tports = ports || {};\n",
       "\t\t\tports[key] = manager.a(key, sendToApp);\n",
       "\t\t}\n",
       "\n",
       "\t\tmanagers[key] = _Platform_instantiateManager(manager, sendToApp);\n",
       "\t}\n",
       "\n",
       "\treturn ports;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)\n",
       "{\n",
       "\treturn {\n",
       "\t\tb: init,\n",
       "\t\tc: onEffects,\n",
       "\t\td: onSelfMsg,\n",
       "\t\te: cmdMap,\n",
       "\t\tf: subMap\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_instantiateManager(info, sendToApp)\n",
       "{\n",
       "\tvar router = {\n",
       "\t\tg: sendToApp,\n",
       "\t\th: undefined\n",
       "\t};\n",
       "\n",
       "\tvar onEffects = info.c;\n",
       "\tvar onSelfMsg = info.d;\n",
       "\tvar cmdMap = info.e;\n",
       "\tvar subMap = info.f;\n",
       "\n",
       "\tfunction loop(state)\n",
       "\t{\n",
       "\t\treturn A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)\n",
       "\t\t{\n",
       "\t\t\tvar value = msg.a;\n",
       "\n",
       "\t\t\tif (msg.$ === 0)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn A3(onSelfMsg, router, value, state);\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\treturn cmdMap && subMap\n",
       "\t\t\t\t? A4(onEffects, router, value.i, value.j, state)\n",
       "\t\t\t\t: A3(onEffects, router, cmdMap ? value.i : value.j, state);\n",
       "\t\t}));\n",
       "\t}\n",
       "\n",
       "\treturn router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// ROUTING\n",
       "\n",
       "\n",
       "var _Platform_sendToApp = F2(function(router, msg)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback)\n",
       "\t{\n",
       "\t\trouter.g(msg);\n",
       "\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "var _Platform_sendToSelf = F2(function(router, msg)\n",
       "{\n",
       "\treturn A2(_Scheduler_send, router.h, {\n",
       "\t\t$: 0,\n",
       "\t\ta: msg\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// BAGS\n",
       "\n",
       "\n",
       "function _Platform_leaf(home)\n",
       "{\n",
       "\treturn function(value)\n",
       "\t{\n",
       "\t\treturn {\n",
       "\t\t\t$: 1,\n",
       "\t\t\tk: home,\n",
       "\t\t\tl: value\n",
       "\t\t};\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_batch(list)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 2,\n",
       "\t\tm: list\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "var _Platform_map = F2(function(tagger, bag)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 3,\n",
       "\t\tn: tagger,\n",
       "\t\to: bag\n",
       "\t}\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// PIPE BAGS INTO EFFECT MANAGERS\n",
       "//\n",
       "// Effects must be queued!\n",
       "//\n",
       "// Say your init contains a synchronous command, like Time.now or Time.here\n",
       "//\n",
       "//   - This will produce a batch of effects (FX_1)\n",
       "//   - The synchronous task triggers the subsequent `update` call\n",
       "//   - This will produce a batch of effects (FX_2)\n",
       "//\n",
       "// If we just start dispatching FX_2, subscriptions from FX_2 can be processed\n",
       "// before subscriptions from FX_1. No good! Earlier versions of this code had\n",
       "// this problem, leading to these reports:\n",
       "//\n",
       "//   https://github.com/elm/core/issues/980\n",
       "//   https://github.com/elm/core/pull/981\n",
       "//   https://github.com/elm/compiler/issues/1776\n",
       "//\n",
       "// The queue is necessary to avoid ordering issues for synchronous commands.\n",
       "\n",
       "\n",
       "// Why use true/false here? Why not just check the length of the queue?\n",
       "// The goal is to detect \"are we currently dispatching effects?\" If we\n",
       "// are, we need to bail and let the ongoing while loop handle things.\n",
       "//\n",
       "// Now say the queue has 1 element. When we dequeue the final element,\n",
       "// the queue will be empty, but we are still actively dispatching effects.\n",
       "// So you could get queue jumping in a really tricky category of cases.\n",
       "//\n",
       "var _Platform_effectsQueue = [];\n",
       "var _Platform_effectsActive = false;\n",
       "\n",
       "\n",
       "function _Platform_enqueueEffects(managers, cmdBag, subBag)\n",
       "{\n",
       "\t_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });\n",
       "\n",
       "\tif (_Platform_effectsActive) return;\n",
       "\n",
       "\t_Platform_effectsActive = true;\n",
       "\tfor (var fx; fx = _Platform_effectsQueue.shift(); )\n",
       "\t{\n",
       "\t\t_Platform_dispatchEffects(fx.p, fx.q, fx.r);\n",
       "\t}\n",
       "\t_Platform_effectsActive = false;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_dispatchEffects(managers, cmdBag, subBag)\n",
       "{\n",
       "\tvar effectsDict = {};\n",
       "\t_Platform_gatherEffects(true, cmdBag, effectsDict, null);\n",
       "\t_Platform_gatherEffects(false, subBag, effectsDict, null);\n",
       "\n",
       "\tfor (var home in managers)\n",
       "\t{\n",
       "\t\t_Scheduler_rawSend(managers[home], {\n",
       "\t\t\t$: 'fx',\n",
       "\t\t\ta: effectsDict[home] || { i: _List_Nil, j: _List_Nil }\n",
       "\t\t});\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)\n",
       "{\n",
       "\tswitch (bag.$)\n",
       "\t{\n",
       "\t\tcase 1:\n",
       "\t\t\tvar home = bag.k;\n",
       "\t\t\tvar effect = _Platform_toEffect(isCmd, home, taggers, bag.l);\n",
       "\t\t\teffectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\tfor (var list = bag.m; list.b; list = list.b) // WHILE_CONS\n",
       "\t\t\t{\n",
       "\t\t\t\t_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);\n",
       "\t\t\t}\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\t_Platform_gatherEffects(isCmd, bag.o, effectsDict, {\n",
       "\t\t\t\ts: bag.n,\n",
       "\t\t\t\tt: taggers\n",
       "\t\t\t});\n",
       "\t\t\treturn;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_toEffect(isCmd, home, taggers, value)\n",
       "{\n",
       "\tfunction applyTaggers(x)\n",
       "\t{\n",
       "\t\tfor (var temp = taggers; temp; temp = temp.t)\n",
       "\t\t{\n",
       "\t\t\tx = temp.s(x);\n",
       "\t\t}\n",
       "\t\treturn x;\n",
       "\t}\n",
       "\n",
       "\tvar map = isCmd\n",
       "\t\t? _Platform_effectManagers[home].e\n",
       "\t\t: _Platform_effectManagers[home].f;\n",
       "\n",
       "\treturn A2(map, applyTaggers, value)\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_insert(isCmd, newEffect, effects)\n",
       "{\n",
       "\teffects = effects || { i: _List_Nil, j: _List_Nil };\n",
       "\n",
       "\tisCmd\n",
       "\t\t? (effects.i = _List_Cons(newEffect, effects.i))\n",
       "\t\t: (effects.j = _List_Cons(newEffect, effects.j));\n",
       "\n",
       "\treturn effects;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// PORTS\n",
       "\n",
       "\n",
       "function _Platform_checkPortName(name)\n",
       "{\n",
       "\tif (_Platform_effectManagers[name])\n",
       "\t{\n",
       "\t\t_Debug_crash(3, name)\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// OUTGOING PORTS\n",
       "\n",
       "\n",
       "function _Platform_outgoingPort(name, converter)\n",
       "{\n",
       "\t_Platform_checkPortName(name);\n",
       "\t_Platform_effectManagers[name] = {\n",
       "\t\te: _Platform_outgoingPortMap,\n",
       "\t\tu: converter,\n",
       "\t\ta: _Platform_setupOutgoingPort\n",
       "\t};\n",
       "\treturn _Platform_leaf(name);\n",
       "}\n",
       "\n",
       "\n",
       "var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });\n",
       "\n",
       "\n",
       "function _Platform_setupOutgoingPort(name)\n",
       "{\n",
       "\tvar subs = [];\n",
       "\tvar converter = _Platform_effectManagers[name].u;\n",
       "\n",
       "\t// CREATE MANAGER\n",
       "\n",
       "\tvar init = _Process_sleep(0);\n",
       "\n",
       "\t_Platform_effectManagers[name].b = init;\n",
       "\t_Platform_effectManagers[name].c = F3(function(router, cmdList, state)\n",
       "\t{\n",
       "\t\tfor ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\t// grab a separate reference to subs in case unsubscribe is called\n",
       "\t\t\tvar currentSubs = subs;\n",
       "\t\t\tvar value = _Json_unwrap(converter(cmdList.a));\n",
       "\t\t\tfor (var i = 0; i < currentSubs.length; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tcurrentSubs[i](value);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\treturn init;\n",
       "\t});\n",
       "\n",
       "\t// PUBLIC API\n",
       "\n",
       "\tfunction subscribe(callback)\n",
       "\t{\n",
       "\t\tsubs.push(callback);\n",
       "\t}\n",
       "\n",
       "\tfunction unsubscribe(callback)\n",
       "\t{\n",
       "\t\t// copy subs into a new array in case unsubscribe is called within a\n",
       "\t\t// subscribed callback\n",
       "\t\tsubs = subs.slice();\n",
       "\t\tvar index = subs.indexOf(callback);\n",
       "\t\tif (index >= 0)\n",
       "\t\t{\n",
       "\t\t\tsubs.splice(index, 1);\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn {\n",
       "\t\tsubscribe: subscribe,\n",
       "\t\tunsubscribe: unsubscribe\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// INCOMING PORTS\n",
       "\n",
       "\n",
       "function _Platform_incomingPort(name, converter)\n",
       "{\n",
       "\t_Platform_checkPortName(name);\n",
       "\t_Platform_effectManagers[name] = {\n",
       "\t\tf: _Platform_incomingPortMap,\n",
       "\t\tu: converter,\n",
       "\t\ta: _Platform_setupIncomingPort\n",
       "\t};\n",
       "\treturn _Platform_leaf(name);\n",
       "}\n",
       "\n",
       "\n",
       "var _Platform_incomingPortMap = F2(function(tagger, finalTagger)\n",
       "{\n",
       "\treturn function(value)\n",
       "\t{\n",
       "\t\treturn tagger(finalTagger(value));\n",
       "\t};\n",
       "});\n",
       "\n",
       "\n",
       "function _Platform_setupIncomingPort(name, sendToApp)\n",
       "{\n",
       "\tvar subs = _List_Nil;\n",
       "\tvar converter = _Platform_effectManagers[name].u;\n",
       "\n",
       "\t// CREATE MANAGER\n",
       "\n",
       "\tvar init = _Scheduler_succeed(null);\n",
       "\n",
       "\t_Platform_effectManagers[name].b = init;\n",
       "\t_Platform_effectManagers[name].c = F3(function(router, subList, state)\n",
       "\t{\n",
       "\t\tsubs = subList;\n",
       "\t\treturn init;\n",
       "\t});\n",
       "\n",
       "\t// PUBLIC API\n",
       "\n",
       "\tfunction send(incomingValue)\n",
       "\t{\n",
       "\t\tvar result = A2(_Json_run, converter, _Json_wrap(incomingValue));\n",
       "\n",
       "\t\t$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);\n",
       "\n",
       "\t\tvar value = result.a;\n",
       "\t\tfor (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\tsendToApp(temp.a(value));\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn { send: send };\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// EXPORT ELM MODULES\n",
       "//\n",
       "// Have DEBUG and PROD versions so that we can (1) give nicer errors in\n",
       "// debug mode and (2) not pay for the bits needed for that in prod mode.\n",
       "//\n",
       "\n",
       "\n",
       "function _Platform_export_UNUSED(exports)\n",
       "{\n",
       "\tscope['Elm']\n",
       "\t\t? _Platform_mergeExportsProd(scope['Elm'], exports)\n",
       "\t\t: scope['Elm'] = exports;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_mergeExportsProd(obj, exports)\n",
       "{\n",
       "\tfor (var name in exports)\n",
       "\t{\n",
       "\t\t(name in obj)\n",
       "\t\t\t? (name == 'init')\n",
       "\t\t\t\t? _Debug_crash(6)\n",
       "\t\t\t\t: _Platform_mergeExportsProd(obj[name], exports[name])\n",
       "\t\t\t: (obj[name] = exports[name]);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_export(exports)\n",
       "{\n",
       "\tscope['Elm']\n",
       "\t\t? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)\n",
       "\t\t: scope['Elm'] = exports;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_mergeExportsDebug(moduleName, obj, exports)\n",
       "{\n",
       "\tfor (var name in exports)\n",
       "\t{\n",
       "\t\t(name in obj)\n",
       "\t\t\t? (name == 'init')\n",
       "\t\t\t\t? _Debug_crash(6, moduleName)\n",
       "\t\t\t\t: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])\n",
       "\t\t\t: (obj[name] = exports[name]);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "// HELPERS\n",
       "\n",
       "\n",
       "var _VirtualDom_divertHrefToApp;\n",
       "\n",
       "var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};\n",
       "\n",
       "\n",
       "function _VirtualDom_appendChild(parent, child)\n",
       "{\n",
       "\tparent.appendChild(child);\n",
       "}\n",
       "\n",
       "var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)\n",
       "{\n",
       "\t// NOTE: this function needs _Platform_export available to work\n",
       "\n",
       "\t/**_UNUSED/\n",
       "\tvar node = args['node'];\n",
       "\t//*/\n",
       "\t/**/\n",
       "\tvar node = args && args['node'] ? args['node'] : _Debug_crash(0);\n",
       "\t//*/\n",
       "\n",
       "\tnode.parentNode.replaceChild(\n",
       "\t\t_VirtualDom_render(virtualNode, function() {}),\n",
       "\t\tnode\n",
       "\t);\n",
       "\n",
       "\treturn {};\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// TEXT\n",
       "\n",
       "\n",
       "function _VirtualDom_text(string)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 0,\n",
       "\t\ta: string\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// NODE\n",
       "\n",
       "\n",
       "var _VirtualDom_nodeNS = F2(function(namespace, tag)\n",
       "{\n",
       "\treturn F2(function(factList, kidList)\n",
       "\t{\n",
       "\t\tfor (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\tvar kid = kidList.a;\n",
       "\t\t\tdescendantsCount += (kid.b || 0);\n",
       "\t\t\tkids.push(kid);\n",
       "\t\t}\n",
       "\t\tdescendantsCount += kids.length;\n",
       "\n",
       "\t\treturn {\n",
       "\t\t\t$: 1,\n",
       "\t\t\tc: tag,\n",
       "\t\t\td: _VirtualDom_organizeFacts(factList),\n",
       "\t\t\te: kids,\n",
       "\t\t\tf: namespace,\n",
       "\t\t\tb: descendantsCount\n",
       "\t\t};\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "var _VirtualDom_node = _VirtualDom_nodeNS(undefined);\n",
       "\n",
       "\n",
       "\n",
       "// KEYED NODE\n",
       "\n",
       "\n",
       "var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)\n",
       "{\n",
       "\treturn F2(function(factList, kidList)\n",
       "\t{\n",
       "\t\tfor (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\tvar kid = kidList.a;\n",
       "\t\t\tdescendantsCount += (kid.b.b || 0);\n",
       "\t\t\tkids.push(kid);\n",
       "\t\t}\n",
       "\t\tdescendantsCount += kids.length;\n",
       "\n",
       "\t\treturn {\n",
       "\t\t\t$: 2,\n",
       "\t\t\tc: tag,\n",
       "\t\t\td: _VirtualDom_organizeFacts(factList),\n",
       "\t\t\te: kids,\n",
       "\t\t\tf: namespace,\n",
       "\t\t\tb: descendantsCount\n",
       "\t\t};\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);\n",
       "\n",
       "\n",
       "\n",
       "// CUSTOM\n",
       "\n",
       "\n",
       "function _VirtualDom_custom(factList, model, render, diff)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 3,\n",
       "\t\td: _VirtualDom_organizeFacts(factList),\n",
       "\t\tg: model,\n",
       "\t\th: render,\n",
       "\t\ti: diff\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// MAP\n",
       "\n",
       "\n",
       "var _VirtualDom_map = F2(function(tagger, node)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 4,\n",
       "\t\tj: tagger,\n",
       "\t\tk: node,\n",
       "\t\tb: 1 + (node.b || 0)\n",
       "\t};\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// LAZY\n",
       "\n",
       "\n",
       "function _VirtualDom_thunk(refs, thunk)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 5,\n",
       "\t\tl: refs,\n",
       "\t\tm: thunk,\n",
       "\t\tk: undefined\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _VirtualDom_lazy = F2(function(func, a)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a], function() {\n",
       "\t\treturn func(a);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy2 = F3(function(func, a, b)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b], function() {\n",
       "\t\treturn A2(func, a, b);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy3 = F4(function(func, a, b, c)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c], function() {\n",
       "\t\treturn A3(func, a, b, c);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d], function() {\n",
       "\t\treturn A4(func, a, b, c, d);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e], function() {\n",
       "\t\treturn A5(func, a, b, c, d, e);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e, f], function() {\n",
       "\t\treturn A6(func, a, b, c, d, e, f);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {\n",
       "\t\treturn A7(func, a, b, c, d, e, f, g);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {\n",
       "\t\treturn A8(func, a, b, c, d, e, f, g, h);\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// FACTS\n",
       "\n",
       "\n",
       "var _VirtualDom_on = F2(function(key, handler)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a0',\n",
       "\t\tn: key,\n",
       "\t\to: handler\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_style = F2(function(key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a1',\n",
       "\t\tn: key,\n",
       "\t\to: value\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_property = F2(function(key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a2',\n",
       "\t\tn: key,\n",
       "\t\to: value\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_attribute = F2(function(key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a3',\n",
       "\t\tn: key,\n",
       "\t\to: value\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_attributeNS = F3(function(namespace, key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a4',\n",
       "\t\tn: key,\n",
       "\t\to: { f: namespace, o: value }\n",
       "\t};\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// XSS ATTACK VECTOR CHECKS\n",
       "\n",
       "\n",
       "function _VirtualDom_noScript(tag)\n",
       "{\n",
       "\treturn tag == 'script' ? 'p' : tag;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noOnOrFormAction(key)\n",
       "{\n",
       "\treturn /^(on|formAction$)/i.test(key) ? 'data-' + key : key;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noInnerHtmlOrFormAction(key)\n",
       "{\n",
       "\treturn key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptUri_UNUSED(value)\n",
       "{\n",
       "\treturn /^javascript:/i.test(value.replace(/\\s/g,'')) ? '' : value;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptUri(value)\n",
       "{\n",
       "\treturn /^javascript:/i.test(value.replace(/\\s/g,''))\n",
       "\t\t? 'javascript:alert(\"This is an XSS vector. Please use ports or web components instead.\")'\n",
       "\t\t: value;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)\n",
       "{\n",
       "\treturn /^\\s*(javascript:|data:text\\/html)/i.test(value) ? '' : value;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptOrHtmlUri(value)\n",
       "{\n",
       "\treturn /^\\s*(javascript:|data:text\\/html)/i.test(value)\n",
       "\t\t? 'javascript:alert(\"This is an XSS vector. Please use ports or web components instead.\")'\n",
       "\t\t: value;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// MAP FACTS\n",
       "\n",
       "\n",
       "var _VirtualDom_mapAttribute = F2(function(func, attr)\n",
       "{\n",
       "\treturn (attr.$ === 'a0')\n",
       "\t\t? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))\n",
       "\t\t: attr;\n",
       "});\n",
       "\n",
       "function _VirtualDom_mapHandler(func, handler)\n",
       "{\n",
       "\tvar tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);\n",
       "\n",
       "\t// 0 = Normal\n",
       "\t// 1 = MayStopPropagation\n",
       "\t// 2 = MayPreventDefault\n",
       "\t// 3 = Custom\n",
       "\n",
       "\treturn {\n",
       "\t\t$: handler.$,\n",
       "\t\ta:\n",
       "\t\t\t!tag\n",
       "\t\t\t\t? A2($elm$json$Json$Decode$map, func, handler.a)\n",
       "\t\t\t\t:\n",
       "\t\t\tA3($elm$json$Json$Decode$map2,\n",
       "\t\t\t\ttag < 3\n",
       "\t\t\t\t\t? _VirtualDom_mapEventTuple\n",
       "\t\t\t\t\t: _VirtualDom_mapEventRecord,\n",
       "\t\t\t\t$elm$json$Json$Decode$succeed(func),\n",
       "\t\t\t\thandler.a\n",
       "\t\t\t)\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _VirtualDom_mapEventTuple = F2(function(func, tuple)\n",
       "{\n",
       "\treturn _Utils_Tuple2(func(tuple.a), tuple.b);\n",
       "});\n",
       "\n",
       "var _VirtualDom_mapEventRecord = F2(function(func, record)\n",
       "{\n",
       "\treturn {\n",
       "\t\tmessage: func(record.message),\n",
       "\t\tstopPropagation: record.stopPropagation,\n",
       "\t\tpreventDefault: record.preventDefault\n",
       "\t}\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// ORGANIZE FACTS\n",
       "\n",
       "\n",
       "function _VirtualDom_organizeFacts(factList)\n",
       "{\n",
       "\tfor (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS\n",
       "\t{\n",
       "\t\tvar entry = factList.a;\n",
       "\n",
       "\t\tvar tag = entry.$;\n",
       "\t\tvar key = entry.n;\n",
       "\t\tvar value = entry.o;\n",
       "\n",
       "\t\tif (tag === 'a2')\n",
       "\t\t{\n",
       "\t\t\t(key === 'className')\n",
       "\t\t\t\t? _VirtualDom_addClass(facts, key, _Json_unwrap(value))\n",
       "\t\t\t\t: facts[key] = _Json_unwrap(value);\n",
       "\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar subFacts = facts[tag] || (facts[tag] = {});\n",
       "\t\t(tag === 'a3' && key === 'class')\n",
       "\t\t\t? _VirtualDom_addClass(subFacts, key, value)\n",
       "\t\t\t: subFacts[key] = value;\n",
       "\t}\n",
       "\n",
       "\treturn facts;\n",
       "}\n",
       "\n",
       "function _VirtualDom_addClass(object, key, newClass)\n",
       "{\n",
       "\tvar classes = object[key];\n",
       "\tobject[key] = classes ? classes + ' ' + newClass : newClass;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// RENDER\n",
       "\n",
       "\n",
       "function _VirtualDom_render(vNode, eventNode)\n",
       "{\n",
       "\tvar tag = vNode.$;\n",
       "\n",
       "\tif (tag === 5)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);\n",
       "\t}\n",
       "\n",
       "\tif (tag === 0)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_doc.createTextNode(vNode.a);\n",
       "\t}\n",
       "\n",
       "\tif (tag === 4)\n",
       "\t{\n",
       "\t\tvar subNode = vNode.k;\n",
       "\t\tvar tagger = vNode.j;\n",
       "\n",
       "\t\twhile (subNode.$ === 4)\n",
       "\t\t{\n",
       "\t\t\ttypeof tagger !== 'object'\n",
       "\t\t\t\t? tagger = [tagger, subNode.j]\n",
       "\t\t\t\t: tagger.push(subNode.j);\n",
       "\n",
       "\t\t\tsubNode = subNode.k;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar subEventRoot = { j: tagger, p: eventNode };\n",
       "\t\tvar domNode = _VirtualDom_render(subNode, subEventRoot);\n",
       "\t\tdomNode.elm_event_node_ref = subEventRoot;\n",
       "\t\treturn domNode;\n",
       "\t}\n",
       "\n",
       "\tif (tag === 3)\n",
       "\t{\n",
       "\t\tvar domNode = vNode.h(vNode.g);\n",
       "\t\t_VirtualDom_applyFacts(domNode, eventNode, vNode.d);\n",
       "\t\treturn domNode;\n",
       "\t}\n",
       "\n",
       "\t// at this point `tag` must be 1 or 2\n",
       "\n",
       "\tvar domNode = vNode.f\n",
       "\t\t? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)\n",
       "\t\t: _VirtualDom_doc.createElement(vNode.c);\n",
       "\n",
       "\tif (_VirtualDom_divertHrefToApp && vNode.c == 'a')\n",
       "\t{\n",
       "\t\tdomNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));\n",
       "\t}\n",
       "\n",
       "\t_VirtualDom_applyFacts(domNode, eventNode, vNode.d);\n",
       "\n",
       "\tfor (var kids = vNode.e, i = 0; i < kids.length; i++)\n",
       "\t{\n",
       "\t\t_VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));\n",
       "\t}\n",
       "\n",
       "\treturn domNode;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY FACTS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyFacts(domNode, eventNode, facts)\n",
       "{\n",
       "\tfor (var key in facts)\n",
       "\t{\n",
       "\t\tvar value = facts[key];\n",
       "\n",
       "\t\tkey === 'a1'\n",
       "\t\t\t? _VirtualDom_applyStyles(domNode, value)\n",
       "\t\t\t:\n",
       "\t\tkey === 'a0'\n",
       "\t\t\t? _VirtualDom_applyEvents(domNode, eventNode, value)\n",
       "\t\t\t:\n",
       "\t\tkey === 'a3'\n",
       "\t\t\t? _VirtualDom_applyAttrs(domNode, value)\n",
       "\t\t\t:\n",
       "\t\tkey === 'a4'\n",
       "\t\t\t? _VirtualDom_applyAttrsNS(domNode, value)\n",
       "\t\t\t:\n",
       "\t\t((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY STYLES\n",
       "\n",
       "\n",
       "function _VirtualDom_applyStyles(domNode, styles)\n",
       "{\n",
       "\tvar domNodeStyle = domNode.style;\n",
       "\n",
       "\tfor (var key in styles)\n",
       "\t{\n",
       "\t\tdomNodeStyle[key] = styles[key];\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY ATTRS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyAttrs(domNode, attrs)\n",
       "{\n",
       "\tfor (var key in attrs)\n",
       "\t{\n",
       "\t\tvar value = attrs[key];\n",
       "\t\ttypeof value !== 'undefined'\n",
       "\t\t\t? domNode.setAttribute(key, value)\n",
       "\t\t\t: domNode.removeAttribute(key);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY NAMESPACED ATTRS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyAttrsNS(domNode, nsAttrs)\n",
       "{\n",
       "\tfor (var key in nsAttrs)\n",
       "\t{\n",
       "\t\tvar pair = nsAttrs[key];\n",
       "\t\tvar namespace = pair.f;\n",
       "\t\tvar value = pair.o;\n",
       "\n",
       "\t\ttypeof value !== 'undefined'\n",
       "\t\t\t? domNode.setAttributeNS(namespace, key, value)\n",
       "\t\t\t: domNode.removeAttributeNS(namespace, key);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY EVENTS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyEvents(domNode, eventNode, events)\n",
       "{\n",
       "\tvar allCallbacks = domNode.elmFs || (domNode.elmFs = {});\n",
       "\n",
       "\tfor (var key in events)\n",
       "\t{\n",
       "\t\tvar newHandler = events[key];\n",
       "\t\tvar oldCallback = allCallbacks[key];\n",
       "\n",
       "\t\tif (!newHandler)\n",
       "\t\t{\n",
       "\t\t\tdomNode.removeEventListener(key, oldCallback);\n",
       "\t\t\tallCallbacks[key] = undefined;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tif (oldCallback)\n",
       "\t\t{\n",
       "\t\t\tvar oldHandler = oldCallback.q;\n",
       "\t\t\tif (oldHandler.$ === newHandler.$)\n",
       "\t\t\t{\n",
       "\t\t\t\toldCallback.q = newHandler;\n",
       "\t\t\t\tcontinue;\n",
       "\t\t\t}\n",
       "\t\t\tdomNode.removeEventListener(key, oldCallback);\n",
       "\t\t}\n",
       "\n",
       "\t\toldCallback = _VirtualDom_makeCallback(eventNode, newHandler);\n",
       "\t\tdomNode.addEventListener(key, oldCallback,\n",
       "\t\t\t_VirtualDom_passiveSupported\n",
       "\t\t\t&& { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }\n",
       "\t\t);\n",
       "\t\tallCallbacks[key] = oldCallback;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// PASSIVE EVENTS\n",
       "\n",
       "\n",
       "var _VirtualDom_passiveSupported;\n",
       "\n",
       "try\n",
       "{\n",
       "\twindow.addEventListener('t', null, Object.defineProperty({}, 'passive', {\n",
       "\t\tget: function() { _VirtualDom_passiveSupported = true; }\n",
       "\t}));\n",
       "}\n",
       "catch(e) {}\n",
       "\n",
       "\n",
       "\n",
       "// EVENT HANDLERS\n",
       "\n",
       "\n",
       "function _VirtualDom_makeCallback(eventNode, initialHandler)\n",
       "{\n",
       "\tfunction callback(event)\n",
       "\t{\n",
       "\t\tvar handler = callback.q;\n",
       "\t\tvar result = _Json_runHelp(handler.a, event);\n",
       "\n",
       "\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t{\n",
       "\t\t\treturn;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);\n",
       "\n",
       "\t\t// 0 = Normal\n",
       "\t\t// 1 = MayStopPropagation\n",
       "\t\t// 2 = MayPreventDefault\n",
       "\t\t// 3 = Custom\n",
       "\n",
       "\t\tvar value = result.a;\n",
       "\t\tvar message = !tag ? value : tag < 3 ? value.a : value.message;\n",
       "\t\tvar stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;\n",
       "\t\tvar currentEventNode = (\n",
       "\t\t\tstopPropagation && event.stopPropagation(),\n",
       "\t\t\t(tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(),\n",
       "\t\t\teventNode\n",
       "\t\t);\n",
       "\t\tvar tagger;\n",
       "\t\tvar i;\n",
       "\t\twhile (tagger = currentEventNode.j)\n",
       "\t\t{\n",
       "\t\t\tif (typeof tagger == 'function')\n",
       "\t\t\t{\n",
       "\t\t\t\tmessage = tagger(message);\n",
       "\t\t\t}\n",
       "\t\t\telse\n",
       "\t\t\t{\n",
       "\t\t\t\tfor (var i = tagger.length; i--; )\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\tmessage = tagger[i](message);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t\tcurrentEventNode = currentEventNode.p;\n",
       "\t\t}\n",
       "\t\tcurrentEventNode(message, stopPropagation); // stopPropagation implies isSync\n",
       "\t}\n",
       "\n",
       "\tcallback.q = initialHandler;\n",
       "\n",
       "\treturn callback;\n",
       "}\n",
       "\n",
       "function _VirtualDom_equalEvents(x, y)\n",
       "{\n",
       "\treturn x.$ == y.$ && _Json_equality(x.a, y.a);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// DIFF\n",
       "\n",
       "\n",
       "// TODO: Should we do patches like in iOS?\n",
       "//\n",
       "// type Patch\n",
       "//   = At Int Patch\n",
       "//   | Batch (List Patch)\n",
       "//   | Change ...\n",
       "//\n",
       "// How could it not be better?\n",
       "//\n",
       "function _VirtualDom_diff(x, y)\n",
       "{\n",
       "\tvar patches = [];\n",
       "\t_VirtualDom_diffHelp(x, y, patches, 0);\n",
       "\treturn patches;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_pushPatch(patches, type, index, data)\n",
       "{\n",
       "\tvar patch = {\n",
       "\t\t$: type,\n",
       "\t\tr: index,\n",
       "\t\ts: data,\n",
       "\t\tt: undefined,\n",
       "\t\tu: undefined\n",
       "\t};\n",
       "\tpatches.push(patch);\n",
       "\treturn patch;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_diffHelp(x, y, patches, index)\n",
       "{\n",
       "\tif (x === y)\n",
       "\t{\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\tvar xType = x.$;\n",
       "\tvar yType = y.$;\n",
       "\n",
       "\t// Bail if you run into different types of nodes. Implies that the\n",
       "\t// structure has changed significantly and it's not worth a diff.\n",
       "\tif (xType !== yType)\n",
       "\t{\n",
       "\t\tif (xType === 1 && yType === 2)\n",
       "\t\t{\n",
       "\t\t\ty = _VirtualDom_dekey(y);\n",
       "\t\t\tyType = 1;\n",
       "\t\t}\n",
       "\t\telse\n",
       "\t\t{\n",
       "\t\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\t\treturn;\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\t// Now we know that both nodes are the same $.\n",
       "\tswitch (yType)\n",
       "\t{\n",
       "\t\tcase 5:\n",
       "\t\t\tvar xRefs = x.l;\n",
       "\t\t\tvar yRefs = y.l;\n",
       "\t\t\tvar i = xRefs.length;\n",
       "\t\t\tvar same = i === yRefs.length;\n",
       "\t\t\twhile (same && i--)\n",
       "\t\t\t{\n",
       "\t\t\t\tsame = xRefs[i] === yRefs[i];\n",
       "\t\t\t}\n",
       "\t\t\tif (same)\n",
       "\t\t\t{\n",
       "\t\t\t\ty.k = x.k;\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\t\t\ty.k = y.m();\n",
       "\t\t\tvar subPatches = [];\n",
       "\t\t\t_VirtualDom_diffHelp(x.k, y.k, subPatches, 0);\n",
       "\t\t\tsubPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\t// gather nested taggers\n",
       "\t\t\tvar xTaggers = x.j;\n",
       "\t\t\tvar yTaggers = y.j;\n",
       "\t\t\tvar nesting = false;\n",
       "\n",
       "\t\t\tvar xSubNode = x.k;\n",
       "\t\t\twhile (xSubNode.$ === 4)\n",
       "\t\t\t{\n",
       "\t\t\t\tnesting = true;\n",
       "\n",
       "\t\t\t\ttypeof xTaggers !== 'object'\n",
       "\t\t\t\t\t? xTaggers = [xTaggers, xSubNode.j]\n",
       "\t\t\t\t\t: xTaggers.push(xSubNode.j);\n",
       "\n",
       "\t\t\t\txSubNode = xSubNode.k;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\tvar ySubNode = y.k;\n",
       "\t\t\twhile (ySubNode.$ === 4)\n",
       "\t\t\t{\n",
       "\t\t\t\tnesting = true;\n",
       "\n",
       "\t\t\t\ttypeof yTaggers !== 'object'\n",
       "\t\t\t\t\t? yTaggers = [yTaggers, ySubNode.j]\n",
       "\t\t\t\t\t: yTaggers.push(ySubNode.j);\n",
       "\n",
       "\t\t\t\tySubNode = ySubNode.k;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\t// Just bail if different numbers of taggers. This implies the\n",
       "\t\t\t// structure of the virtual DOM has changed.\n",
       "\t\t\tif (nesting && xTaggers.length !== yTaggers.length)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\t// check if taggers are \"the same\"\n",
       "\t\t\tif (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 2, index, yTaggers);\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\t// diff everything below the taggers\n",
       "\t\t\t_VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 0:\n",
       "\t\t\tif (x.a !== y.a)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 3, index, y.a);\n",
       "\t\t\t}\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\t_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\t_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tif (x.h !== y.h)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\tvar factsDiff = _VirtualDom_diffFacts(x.d, y.d);\n",
       "\t\t\tfactsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);\n",
       "\n",
       "\t\t\tvar patch = y.i(x.g, y.g);\n",
       "\t\t\tpatch && _VirtualDom_pushPatch(patches, 5, index, patch);\n",
       "\n",
       "\t\t\treturn;\n",
       "\t}\n",
       "}\n",
       "\n",
       "// assumes the incoming arrays are the same length\n",
       "function _VirtualDom_pairwiseRefEqual(as, bs)\n",
       "{\n",
       "\tfor (var i = 0; i < as.length; i++)\n",
       "\t{\n",
       "\t\tif (as[i] !== bs[i])\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn true;\n",
       "}\n",
       "\n",
       "function _VirtualDom_diffNodes(x, y, patches, index, diffKids)\n",
       "{\n",
       "\t// Bail if obvious indicators have changed. Implies more serious\n",
       "\t// structural changes such that it's not worth it to diff.\n",
       "\tif (x.c !== y.c || x.f !== y.f)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\tvar factsDiff = _VirtualDom_diffFacts(x.d, y.d);\n",
       "\tfactsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);\n",
       "\n",
       "\tdiffKids(x, y, patches, index);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// DIFF FACTS\n",
       "\n",
       "\n",
       "// TODO Instead of creating a new diff object, it's possible to just test if\n",
       "// there *is* a diff. During the actual patch, do the diff again and make the\n",
       "// modifications directly. This way, there's no new allocations. Worth it?\n",
       "function _VirtualDom_diffFacts(x, y, category)\n",
       "{\n",
       "\tvar diff;\n",
       "\n",
       "\t// look for changes and removals\n",
       "\tfor (var xKey in x)\n",
       "\t{\n",
       "\t\tif (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')\n",
       "\t\t{\n",
       "\t\t\tvar subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);\n",
       "\t\t\tif (subDiff)\n",
       "\t\t\t{\n",
       "\t\t\t\tdiff = diff || {};\n",
       "\t\t\t\tdiff[xKey] = subDiff;\n",
       "\t\t\t}\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// remove if not in the new facts\n",
       "\t\tif (!(xKey in y))\n",
       "\t\t{\n",
       "\t\t\tdiff = diff || {};\n",
       "\t\t\tdiff[xKey] =\n",
       "\t\t\t\t!category\n",
       "\t\t\t\t\t? (typeof x[xKey] === 'string' ? '' : null)\n",
       "\t\t\t\t\t:\n",
       "\t\t\t\t(category === 'a1')\n",
       "\t\t\t\t\t? ''\n",
       "\t\t\t\t\t:\n",
       "\t\t\t\t(category === 'a0' || category === 'a3')\n",
       "\t\t\t\t\t? undefined\n",
       "\t\t\t\t\t:\n",
       "\t\t\t\t{ f: x[xKey].f, o: undefined };\n",
       "\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar xValue = x[xKey];\n",
       "\t\tvar yValue = y[xKey];\n",
       "\n",
       "\t\t// reference equal, so don't worry about it\n",
       "\t\tif (xValue === yValue && xKey !== 'value' && xKey !== 'checked'\n",
       "\t\t\t|| category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))\n",
       "\t\t{\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tdiff = diff || {};\n",
       "\t\tdiff[xKey] = yValue;\n",
       "\t}\n",
       "\n",
       "\t// add new stuff\n",
       "\tfor (var yKey in y)\n",
       "\t{\n",
       "\t\tif (!(yKey in x))\n",
       "\t\t{\n",
       "\t\t\tdiff = diff || {};\n",
       "\t\t\tdiff[yKey] = y[yKey];\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn diff;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// DIFF KIDS\n",
       "\n",
       "\n",
       "function _VirtualDom_diffKids(xParent, yParent, patches, index)\n",
       "{\n",
       "\tvar xKids = xParent.e;\n",
       "\tvar yKids = yParent.e;\n",
       "\n",
       "\tvar xLen = xKids.length;\n",
       "\tvar yLen = yKids.length;\n",
       "\n",
       "\t// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS\n",
       "\n",
       "\tif (xLen > yLen)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 6, index, {\n",
       "\t\t\tv: yLen,\n",
       "\t\t\ti: xLen - yLen\n",
       "\t\t});\n",
       "\t}\n",
       "\telse if (xLen < yLen)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 7, index, {\n",
       "\t\t\tv: xLen,\n",
       "\t\t\te: yKids\n",
       "\t\t});\n",
       "\t}\n",
       "\n",
       "\t// PAIRWISE DIFF EVERYTHING ELSE\n",
       "\n",
       "\tfor (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)\n",
       "\t{\n",
       "\t\tvar xKid = xKids[i];\n",
       "\t\t_VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);\n",
       "\t\tindex += xKid.b || 0;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// KEYED DIFF\n",
       "\n",
       "\n",
       "function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)\n",
       "{\n",
       "\tvar localPatches = [];\n",
       "\n",
       "\tvar changes = {}; // Dict String Entry\n",
       "\tvar inserts = []; // Array { index : Int, entry : Entry }\n",
       "\t// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }\n",
       "\n",
       "\tvar xKids = xParent.e;\n",
       "\tvar yKids = yParent.e;\n",
       "\tvar xLen = xKids.length;\n",
       "\tvar yLen = yKids.length;\n",
       "\tvar xIndex = 0;\n",
       "\tvar yIndex = 0;\n",
       "\n",
       "\tvar index = rootIndex;\n",
       "\n",
       "\twhile (xIndex < xLen && yIndex < yLen)\n",
       "\t{\n",
       "\t\tvar x = xKids[xIndex];\n",
       "\t\tvar y = yKids[yIndex];\n",
       "\n",
       "\t\tvar xKey = x.a;\n",
       "\t\tvar yKey = y.a;\n",
       "\t\tvar xNode = x.b;\n",
       "\t\tvar yNode = y.b;\n",
       "\n",
       "\t\tvar newMatch = undefined;\n",
       "\t\tvar oldMatch = undefined;\n",
       "\n",
       "\t\t// check if keys match\n",
       "\n",
       "\t\tif (xKey === yKey)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNode, yNode, localPatches, index);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\txIndex++;\n",
       "\t\t\tyIndex++;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// look ahead 1 to detect insertions and removals.\n",
       "\n",
       "\t\tvar xNext = xKids[xIndex + 1];\n",
       "\t\tvar yNext = yKids[yIndex + 1];\n",
       "\n",
       "\t\tif (xNext)\n",
       "\t\t{\n",
       "\t\t\tvar xNextKey = xNext.a;\n",
       "\t\t\tvar xNextNode = xNext.b;\n",
       "\t\t\toldMatch = yKey === xNextKey;\n",
       "\t\t}\n",
       "\n",
       "\t\tif (yNext)\n",
       "\t\t{\n",
       "\t\t\tvar yNextKey = yNext.a;\n",
       "\t\t\tvar yNextNode = yNext.b;\n",
       "\t\t\tnewMatch = xKey === yNextKey;\n",
       "\t\t}\n",
       "\n",
       "\n",
       "\t\t// swap x and y\n",
       "\t\tif (newMatch && oldMatch)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);\n",
       "\t\t\t_VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);\n",
       "\t\t\tindex += xNextNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 2;\n",
       "\t\t\tyIndex += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// insert y\n",
       "\t\tif (newMatch)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);\n",
       "\t\t\t_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 1;\n",
       "\t\t\tyIndex += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// remove x\n",
       "\t\tif (oldMatch)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);\n",
       "\t\t\tindex += xNextNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 2;\n",
       "\t\t\tyIndex += 1;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// remove x, insert y\n",
       "\t\tif (xNext && xNextKey === yNextKey)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);\n",
       "\t\t\t_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);\n",
       "\t\t\tindex += xNextNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 2;\n",
       "\t\t\tyIndex += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tbreak;\n",
       "\t}\n",
       "\n",
       "\t// eat up any remaining nodes with removeNode and insertNode\n",
       "\n",
       "\twhile (xIndex < xLen)\n",
       "\t{\n",
       "\t\tindex++;\n",
       "\t\tvar x = xKids[xIndex];\n",
       "\t\tvar xNode = x.b;\n",
       "\t\t_VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);\n",
       "\t\tindex += xNode.b || 0;\n",
       "\t\txIndex++;\n",
       "\t}\n",
       "\n",
       "\twhile (yIndex < yLen)\n",
       "\t{\n",
       "\t\tvar endInserts = endInserts || [];\n",
       "\t\tvar y = yKids[yIndex];\n",
       "\t\t_VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);\n",
       "\t\tyIndex++;\n",
       "\t}\n",
       "\n",
       "\tif (localPatches.length > 0 || inserts.length > 0 || endInserts)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 8, rootIndex, {\n",
       "\t\t\tw: localPatches,\n",
       "\t\t\tx: inserts,\n",
       "\t\t\ty: endInserts\n",
       "\t\t});\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// CHANGES FROM KEYED DIFF\n",
       "\n",
       "\n",
       "var _VirtualDom_POSTFIX = '_elmW6BL';\n",
       "\n",
       "\n",
       "function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)\n",
       "{\n",
       "\tvar entry = changes[key];\n",
       "\n",
       "\t// never seen this key before\n",
       "\tif (!entry)\n",
       "\t{\n",
       "\t\tentry = {\n",
       "\t\t\tc: 0,\n",
       "\t\t\tz: vnode,\n",
       "\t\t\tr: yIndex,\n",
       "\t\t\ts: undefined\n",
       "\t\t};\n",
       "\n",
       "\t\tinserts.push({ r: yIndex, A: entry });\n",
       "\t\tchanges[key] = entry;\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key was removed earlier, a match!\n",
       "\tif (entry.c === 1)\n",
       "\t{\n",
       "\t\tinserts.push({ r: yIndex, A: entry });\n",
       "\n",
       "\t\tentry.c = 2;\n",
       "\t\tvar subPatches = [];\n",
       "\t\t_VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);\n",
       "\t\tentry.r = yIndex;\n",
       "\t\tentry.s.s = {\n",
       "\t\t\tw: subPatches,\n",
       "\t\t\tA: entry\n",
       "\t\t};\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key has already been inserted or moved, a duplicate!\n",
       "\t_VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)\n",
       "{\n",
       "\tvar entry = changes[key];\n",
       "\n",
       "\t// never seen this key before\n",
       "\tif (!entry)\n",
       "\t{\n",
       "\t\tvar patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);\n",
       "\n",
       "\t\tchanges[key] = {\n",
       "\t\t\tc: 1,\n",
       "\t\t\tz: vnode,\n",
       "\t\t\tr: index,\n",
       "\t\t\ts: patch\n",
       "\t\t};\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key was inserted earlier, a match!\n",
       "\tif (entry.c === 0)\n",
       "\t{\n",
       "\t\tentry.c = 2;\n",
       "\t\tvar subPatches = [];\n",
       "\t\t_VirtualDom_diffHelp(vnode, entry.z, subPatches, index);\n",
       "\n",
       "\t\t_VirtualDom_pushPatch(localPatches, 9, index, {\n",
       "\t\t\tw: subPatches,\n",
       "\t\t\tA: entry\n",
       "\t\t});\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key has already been removed or moved, a duplicate!\n",
       "\t_VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// ADD DOM NODES\n",
       "//\n",
       "// Each DOM node has an \"index\" assigned in order of traversal. It is important\n",
       "// to minimize our crawl over the actual DOM, so these indexes (along with the\n",
       "// descendantsCount of virtual nodes) let us skip touching entire subtrees of\n",
       "// the DOM if we know there are no patches there.\n",
       "\n",
       "\n",
       "function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)\n",
       "{\n",
       "\t_VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);\n",
       "}\n",
       "\n",
       "\n",
       "// assumes `patches` is non-empty and indexes increase monotonically.\n",
       "function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)\n",
       "{\n",
       "\tvar patch = patches[i];\n",
       "\tvar index = patch.r;\n",
       "\n",
       "\twhile (index === low)\n",
       "\t{\n",
       "\t\tvar patchType = patch.$;\n",
       "\n",
       "\t\tif (patchType === 1)\n",
       "\t\t{\n",
       "\t\t\t_VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);\n",
       "\t\t}\n",
       "\t\telse if (patchType === 8)\n",
       "\t\t{\n",
       "\t\t\tpatch.t = domNode;\n",
       "\t\t\tpatch.u = eventNode;\n",
       "\n",
       "\t\t\tvar subPatches = patch.s.w;\n",
       "\t\t\tif (subPatches.length > 0)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\telse if (patchType === 9)\n",
       "\t\t{\n",
       "\t\t\tpatch.t = domNode;\n",
       "\t\t\tpatch.u = eventNode;\n",
       "\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tif (data)\n",
       "\t\t\t{\n",
       "\t\t\t\tdata.A.s = domNode;\n",
       "\t\t\t\tvar subPatches = data.w;\n",
       "\t\t\t\tif (subPatches.length > 0)\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\t_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\telse\n",
       "\t\t{\n",
       "\t\t\tpatch.t = domNode;\n",
       "\t\t\tpatch.u = eventNode;\n",
       "\t\t}\n",
       "\n",
       "\t\ti++;\n",
       "\n",
       "\t\tif (!(patch = patches[i]) || (index = patch.r) > high)\n",
       "\t\t{\n",
       "\t\t\treturn i;\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\tvar tag = vNode.$;\n",
       "\n",
       "\tif (tag === 4)\n",
       "\t{\n",
       "\t\tvar subNode = vNode.k;\n",
       "\n",
       "\t\twhile (subNode.$ === 4)\n",
       "\t\t{\n",
       "\t\t\tsubNode = subNode.k;\n",
       "\t\t}\n",
       "\n",
       "\t\treturn _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);\n",
       "\t}\n",
       "\n",
       "\t// tag must be 1 or 2 at this point\n",
       "\n",
       "\tvar vKids = vNode.e;\n",
       "\tvar childNodes = domNode.childNodes;\n",
       "\tfor (var j = 0; j < vKids.length; j++)\n",
       "\t{\n",
       "\t\tlow++;\n",
       "\t\tvar vKid = tag === 1 ? vKids[j] : vKids[j].b;\n",
       "\t\tvar nextLow = low + (vKid.b || 0);\n",
       "\t\tif (low <= index && index <= nextLow)\n",
       "\t\t{\n",
       "\t\t\ti = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);\n",
       "\t\t\tif (!(patch = patches[i]) || (index = patch.r) > high)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn i;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tlow = nextLow;\n",
       "\t}\n",
       "\treturn i;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY PATCHES\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)\n",
       "{\n",
       "\tif (patches.length === 0)\n",
       "\t{\n",
       "\t\treturn rootDomNode;\n",
       "\t}\n",
       "\n",
       "\t_VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);\n",
       "\treturn _VirtualDom_applyPatchesHelp(rootDomNode, patches);\n",
       "}\n",
       "\n",
       "function _VirtualDom_applyPatchesHelp(rootDomNode, patches)\n",
       "{\n",
       "\tfor (var i = 0; i < patches.length; i++)\n",
       "\t{\n",
       "\t\tvar patch = patches[i];\n",
       "\t\tvar localDomNode = patch.t\n",
       "\t\tvar newNode = _VirtualDom_applyPatch(localDomNode, patch);\n",
       "\t\tif (localDomNode === rootDomNode)\n",
       "\t\t{\n",
       "\t\t\trootDomNode = newNode;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn rootDomNode;\n",
       "}\n",
       "\n",
       "function _VirtualDom_applyPatch(domNode, patch)\n",
       "{\n",
       "\tswitch (patch.$)\n",
       "\t{\n",
       "\t\tcase 0:\n",
       "\t\t\treturn _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\t_VirtualDom_applyFacts(domNode, patch.u, patch.s);\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tdomNode.replaceData(0, domNode.length, patch.s);\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\treturn _VirtualDom_applyPatchesHelp(domNode, patch.s);\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\tif (domNode.elm_event_node_ref)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.elm_event_node_ref.j = patch.s;\n",
       "\t\t\t}\n",
       "\t\t\telse\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.elm_event_node_ref = { j: patch.s, p: patch.u };\n",
       "\t\t\t}\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tfor (var i = 0; i < data.i; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.removeChild(domNode.childNodes[data.v]);\n",
       "\t\t\t}\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 7:\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tvar kids = data.e;\n",
       "\t\t\tvar i = data.v;\n",
       "\t\t\tvar theEnd = domNode.childNodes[i];\n",
       "\t\t\tfor (; i < kids.length; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);\n",
       "\t\t\t}\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tif (!data)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.parentNode.removeChild(domNode);\n",
       "\t\t\t\treturn domNode;\n",
       "\t\t\t}\n",
       "\t\t\tvar entry = data.A;\n",
       "\t\t\tif (typeof entry.r !== 'undefined')\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.parentNode.removeChild(domNode);\n",
       "\t\t\t}\n",
       "\t\t\tentry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 8:\n",
       "\t\t\treturn _VirtualDom_applyPatchReorder(domNode, patch);\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\treturn patch.s(domNode);\n",
       "\n",
       "\t\tdefault:\n",
       "\t\t\t_Debug_crash(10); // 'Ran into an unknown patch!'\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)\n",
       "{\n",
       "\tvar parentNode = domNode.parentNode;\n",
       "\tvar newNode = _VirtualDom_render(vNode, eventNode);\n",
       "\n",
       "\tif (!newNode.elm_event_node_ref)\n",
       "\t{\n",
       "\t\tnewNode.elm_event_node_ref = domNode.elm_event_node_ref;\n",
       "\t}\n",
       "\n",
       "\tif (parentNode && newNode !== domNode)\n",
       "\t{\n",
       "\t\tparentNode.replaceChild(newNode, domNode);\n",
       "\t}\n",
       "\treturn newNode;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatchReorder(domNode, patch)\n",
       "{\n",
       "\tvar data = patch.s;\n",
       "\n",
       "\t// remove end inserts\n",
       "\tvar frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);\n",
       "\n",
       "\t// removals\n",
       "\tdomNode = _VirtualDom_applyPatchesHelp(domNode, data.w);\n",
       "\n",
       "\t// inserts\n",
       "\tvar inserts = data.x;\n",
       "\tfor (var i = 0; i < inserts.length; i++)\n",
       "\t{\n",
       "\t\tvar insert = inserts[i];\n",
       "\t\tvar entry = insert.A;\n",
       "\t\tvar node = entry.c === 2\n",
       "\t\t\t? entry.s\n",
       "\t\t\t: _VirtualDom_render(entry.z, patch.u);\n",
       "\t\tdomNode.insertBefore(node, domNode.childNodes[insert.r]);\n",
       "\t}\n",
       "\n",
       "\t// add end inserts\n",
       "\tif (frag)\n",
       "\t{\n",
       "\t\t_VirtualDom_appendChild(domNode, frag);\n",
       "\t}\n",
       "\n",
       "\treturn domNode;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)\n",
       "{\n",
       "\tif (!endInserts)\n",
       "\t{\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\tvar frag = _VirtualDom_doc.createDocumentFragment();\n",
       "\tfor (var i = 0; i < endInserts.length; i++)\n",
       "\t{\n",
       "\t\tvar insert = endInserts[i];\n",
       "\t\tvar entry = insert.A;\n",
       "\t\t_VirtualDom_appendChild(frag, entry.c === 2\n",
       "\t\t\t? entry.s\n",
       "\t\t\t: _VirtualDom_render(entry.z, patch.u)\n",
       "\t\t);\n",
       "\t}\n",
       "\treturn frag;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_virtualize(node)\n",
       "{\n",
       "\t// TEXT NODES\n",
       "\n",
       "\tif (node.nodeType === 3)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_text(node.textContent);\n",
       "\t}\n",
       "\n",
       "\n",
       "\t// WEIRD NODES\n",
       "\n",
       "\tif (node.nodeType !== 1)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_text('');\n",
       "\t}\n",
       "\n",
       "\n",
       "\t// ELEMENT NODES\n",
       "\n",
       "\tvar attrList = _List_Nil;\n",
       "\tvar attrs = node.attributes;\n",
       "\tfor (var i = attrs.length; i--; )\n",
       "\t{\n",
       "\t\tvar attr = attrs[i];\n",
       "\t\tvar name = attr.name;\n",
       "\t\tvar value = attr.value;\n",
       "\t\tattrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );\n",
       "\t}\n",
       "\n",
       "\tvar tag = node.tagName.toLowerCase();\n",
       "\tvar kidList = _List_Nil;\n",
       "\tvar kids = node.childNodes;\n",
       "\n",
       "\tfor (var i = kids.length; i--; )\n",
       "\t{\n",
       "\t\tkidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);\n",
       "\t}\n",
       "\treturn A3(_VirtualDom_node, tag, attrList, kidList);\n",
       "}\n",
       "\n",
       "function _VirtualDom_dekey(keyedNode)\n",
       "{\n",
       "\tvar keyedKids = keyedNode.e;\n",
       "\tvar len = keyedKids.length;\n",
       "\tvar kids = new Array(len);\n",
       "\tfor (var i = 0; i < len; i++)\n",
       "\t{\n",
       "\t\tkids[i] = keyedKids[i].b;\n",
       "\t}\n",
       "\n",
       "\treturn {\n",
       "\t\t$: 1,\n",
       "\t\tc: keyedNode.c,\n",
       "\t\td: keyedNode.d,\n",
       "\t\te: kids,\n",
       "\t\tf: keyedNode.f,\n",
       "\t\tb: keyedNode.b\n",
       "\t};\n",
       "}\n",
       "var $elm$core$Basics$EQ = {$: 'EQ'};\n",
       "var $elm$core$Basics$GT = {$: 'GT'};\n",
       "var $elm$core$Basics$LT = {$: 'LT'};\n",
       "var $elm$core$List$cons = _List_cons;\n",
       "var $elm$core$Dict$foldr = F3(\n",
       "\tfunction (func, acc, t) {\n",
       "\t\tfoldr:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (t.$ === 'RBEmpty_elm_builtin') {\n",
       "\t\t\t\treturn acc;\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar key = t.b;\n",
       "\t\t\t\tvar value = t.c;\n",
       "\t\t\t\tvar left = t.d;\n",
       "\t\t\t\tvar right = t.e;\n",
       "\t\t\t\tvar $temp$func = func,\n",
       "\t\t\t\t\t$temp$acc = A3(\n",
       "\t\t\t\t\tfunc,\n",
       "\t\t\t\t\tkey,\n",
       "\t\t\t\t\tvalue,\n",
       "\t\t\t\t\tA3($elm$core$Dict$foldr, func, acc, right)),\n",
       "\t\t\t\t\t$temp$t = left;\n",
       "\t\t\t\tfunc = $temp$func;\n",
       "\t\t\t\tacc = $temp$acc;\n",
       "\t\t\t\tt = $temp$t;\n",
       "\t\t\t\tcontinue foldr;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Dict$toList = function (dict) {\n",
       "\treturn A3(\n",
       "\t\t$elm$core$Dict$foldr,\n",
       "\t\tF3(\n",
       "\t\t\tfunction (key, value, list) {\n",
       "\t\t\t\treturn A2(\n",
       "\t\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t\t_Utils_Tuple2(key, value),\n",
       "\t\t\t\t\tlist);\n",
       "\t\t\t}),\n",
       "\t\t_List_Nil,\n",
       "\t\tdict);\n",
       "};\n",
       "var $elm$core$Dict$keys = function (dict) {\n",
       "\treturn A3(\n",
       "\t\t$elm$core$Dict$foldr,\n",
       "\t\tF3(\n",
       "\t\t\tfunction (key, value, keyList) {\n",
       "\t\t\t\treturn A2($elm$core$List$cons, key, keyList);\n",
       "\t\t\t}),\n",
       "\t\t_List_Nil,\n",
       "\t\tdict);\n",
       "};\n",
       "var $elm$core$Set$toList = function (_v0) {\n",
       "\tvar dict = _v0.a;\n",
       "\treturn $elm$core$Dict$keys(dict);\n",
       "};\n",
       "var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;\n",
       "var $elm$core$Array$foldr = F3(\n",
       "\tfunction (func, baseCase, _v0) {\n",
       "\t\tvar tree = _v0.c;\n",
       "\t\tvar tail = _v0.d;\n",
       "\t\tvar helper = F2(\n",
       "\t\t\tfunction (node, acc) {\n",
       "\t\t\t\tif (node.$ === 'SubTree') {\n",
       "\t\t\t\t\tvar subTree = node.a;\n",
       "\t\t\t\t\treturn A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);\n",
       "\t\t\t\t} else {\n",
       "\t\t\t\t\tvar values = node.a;\n",
       "\t\t\t\t\treturn A3($elm$core$Elm$JsArray$foldr, func, acc, values);\n",
       "\t\t\t\t}\n",
       "\t\t\t});\n",
       "\t\treturn A3(\n",
       "\t\t\t$elm$core$Elm$JsArray$foldr,\n",
       "\t\t\thelper,\n",
       "\t\t\tA3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),\n",
       "\t\t\ttree);\n",
       "\t});\n",
       "var $elm$core$Array$toList = function (array) {\n",
       "\treturn A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);\n",
       "};\n",
       "var $elm$core$Result$Err = function (a) {\n",
       "\treturn {$: 'Err', a: a};\n",
       "};\n",
       "var $elm$json$Json$Decode$Failure = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Failure', a: a, b: b};\n",
       "\t});\n",
       "var $elm$json$Json$Decode$Field = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Field', a: a, b: b};\n",
       "\t});\n",
       "var $elm$json$Json$Decode$Index = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Index', a: a, b: b};\n",
       "\t});\n",
       "var $elm$core$Result$Ok = function (a) {\n",
       "\treturn {$: 'Ok', a: a};\n",
       "};\n",
       "var $elm$json$Json$Decode$OneOf = function (a) {\n",
       "\treturn {$: 'OneOf', a: a};\n",
       "};\n",
       "var $elm$core$Basics$False = {$: 'False'};\n",
       "var $elm$core$Basics$add = _Basics_add;\n",
       "var $elm$core$Maybe$Just = function (a) {\n",
       "\treturn {$: 'Just', a: a};\n",
       "};\n",
       "var $elm$core$Maybe$Nothing = {$: 'Nothing'};\n",
       "var $elm$core$String$all = _String_all;\n",
       "var $elm$core$Basics$and = _Basics_and;\n",
       "var $elm$core$Basics$append = _Utils_append;\n",
       "var $elm$json$Json$Encode$encode = _Json_encode;\n",
       "var $elm$core$String$fromInt = _String_fromNumber;\n",
       "var $elm$core$String$join = F2(\n",
       "\tfunction (sep, chunks) {\n",
       "\t\treturn A2(\n",
       "\t\t\t_String_join,\n",
       "\t\t\tsep,\n",
       "\t\t\t_List_toArray(chunks));\n",
       "\t});\n",
       "var $elm$core$String$split = F2(\n",
       "\tfunction (sep, string) {\n",
       "\t\treturn _List_fromArray(\n",
       "\t\t\tA2(_String_split, sep, string));\n",
       "\t});\n",
       "var $elm$json$Json$Decode$indent = function (str) {\n",
       "\treturn A2(\n",
       "\t\t$elm$core$String$join,\n",
       "\t\t'\\n    ',\n",
       "\t\tA2($elm$core$String$split, '\\n', str));\n",
       "};\n",
       "var $elm$core$List$foldl = F3(\n",
       "\tfunction (func, acc, list) {\n",
       "\t\tfoldl:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (!list.b) {\n",
       "\t\t\t\treturn acc;\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar x = list.a;\n",
       "\t\t\t\tvar xs = list.b;\n",
       "\t\t\t\tvar $temp$func = func,\n",
       "\t\t\t\t\t$temp$acc = A2(func, x, acc),\n",
       "\t\t\t\t\t$temp$list = xs;\n",
       "\t\t\t\tfunc = $temp$func;\n",
       "\t\t\t\tacc = $temp$acc;\n",
       "\t\t\t\tlist = $temp$list;\n",
       "\t\t\t\tcontinue foldl;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$List$length = function (xs) {\n",
       "\treturn A3(\n",
       "\t\t$elm$core$List$foldl,\n",
       "\t\tF2(\n",
       "\t\t\tfunction (_v0, i) {\n",
       "\t\t\t\treturn i + 1;\n",
       "\t\t\t}),\n",
       "\t\t0,\n",
       "\t\txs);\n",
       "};\n",
       "var $elm$core$List$map2 = _List_map2;\n",
       "var $elm$core$Basics$le = _Utils_le;\n",
       "var $elm$core$Basics$sub = _Basics_sub;\n",
       "var $elm$core$List$rangeHelp = F3(\n",
       "\tfunction (lo, hi, list) {\n",
       "\t\trangeHelp:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (_Utils_cmp(lo, hi) < 1) {\n",
       "\t\t\t\tvar $temp$lo = lo,\n",
       "\t\t\t\t\t$temp$hi = hi - 1,\n",
       "\t\t\t\t\t$temp$list = A2($elm$core$List$cons, hi, list);\n",
       "\t\t\t\tlo = $temp$lo;\n",
       "\t\t\t\thi = $temp$hi;\n",
       "\t\t\t\tlist = $temp$list;\n",
       "\t\t\t\tcontinue rangeHelp;\n",
       "\t\t\t} else {\n",
       "\t\t\t\treturn list;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$List$range = F2(\n",
       "\tfunction (lo, hi) {\n",
       "\t\treturn A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);\n",
       "\t});\n",
       "var $elm$core$List$indexedMap = F2(\n",
       "\tfunction (f, xs) {\n",
       "\t\treturn A3(\n",
       "\t\t\t$elm$core$List$map2,\n",
       "\t\t\tf,\n",
       "\t\t\tA2(\n",
       "\t\t\t\t$elm$core$List$range,\n",
       "\t\t\t\t0,\n",
       "\t\t\t\t$elm$core$List$length(xs) - 1),\n",
       "\t\t\txs);\n",
       "\t});\n",
       "var $elm$core$Char$toCode = _Char_toCode;\n",
       "var $elm$core$Char$isLower = function (_char) {\n",
       "\tvar code = $elm$core$Char$toCode(_char);\n",
       "\treturn (97 <= code) && (code <= 122);\n",
       "};\n",
       "var $elm$core$Char$isUpper = function (_char) {\n",
       "\tvar code = $elm$core$Char$toCode(_char);\n",
       "\treturn (code <= 90) && (65 <= code);\n",
       "};\n",
       "var $elm$core$Basics$or = _Basics_or;\n",
       "var $elm$core$Char$isAlpha = function (_char) {\n",
       "\treturn $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);\n",
       "};\n",
       "var $elm$core$Char$isDigit = function (_char) {\n",
       "\tvar code = $elm$core$Char$toCode(_char);\n",
       "\treturn (code <= 57) && (48 <= code);\n",
       "};\n",
       "var $elm$core$Char$isAlphaNum = function (_char) {\n",
       "\treturn $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));\n",
       "};\n",
       "var $elm$core$List$reverse = function (list) {\n",
       "\treturn A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);\n",
       "};\n",
       "var $elm$core$String$uncons = _String_uncons;\n",
       "var $elm$json$Json$Decode$errorOneOf = F2(\n",
       "\tfunction (i, error) {\n",
       "\t\treturn '\\n\\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(\n",
       "\t\t\t$elm$json$Json$Decode$errorToString(error))));\n",
       "\t});\n",
       "var $elm$json$Json$Decode$errorToString = function (error) {\n",
       "\treturn A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);\n",
       "};\n",
       "var $elm$json$Json$Decode$errorToStringHelp = F2(\n",
       "\tfunction (error, context) {\n",
       "\t\terrorToStringHelp:\n",
       "\t\twhile (true) {\n",
       "\t\t\tswitch (error.$) {\n",
       "\t\t\t\tcase 'Field':\n",
       "\t\t\t\t\tvar f = error.a;\n",
       "\t\t\t\t\tvar err = error.b;\n",
       "\t\t\t\t\tvar isSimple = function () {\n",
       "\t\t\t\t\t\tvar _v1 = $elm$core$String$uncons(f);\n",
       "\t\t\t\t\t\tif (_v1.$ === 'Nothing') {\n",
       "\t\t\t\t\t\t\treturn false;\n",
       "\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\tvar _v2 = _v1.a;\n",
       "\t\t\t\t\t\t\tvar _char = _v2.a;\n",
       "\t\t\t\t\t\t\tvar rest = _v2.b;\n",
       "\t\t\t\t\t\t\treturn $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);\n",
       "\t\t\t\t\t\t}\n",
       "\t\t\t\t\t}();\n",
       "\t\t\t\t\tvar fieldName = isSimple ? ('.' + f) : ('[\\'' + (f + '\\']'));\n",
       "\t\t\t\t\tvar $temp$error = err,\n",
       "\t\t\t\t\t\t$temp$context = A2($elm$core$List$cons, fieldName, context);\n",
       "\t\t\t\t\terror = $temp$error;\n",
       "\t\t\t\t\tcontext = $temp$context;\n",
       "\t\t\t\t\tcontinue errorToStringHelp;\n",
       "\t\t\t\tcase 'Index':\n",
       "\t\t\t\t\tvar i = error.a;\n",
       "\t\t\t\t\tvar err = error.b;\n",
       "\t\t\t\t\tvar indexName = '[' + ($elm$core$String$fromInt(i) + ']');\n",
       "\t\t\t\t\tvar $temp$error = err,\n",
       "\t\t\t\t\t\t$temp$context = A2($elm$core$List$cons, indexName, context);\n",
       "\t\t\t\t\terror = $temp$error;\n",
       "\t\t\t\t\tcontext = $temp$context;\n",
       "\t\t\t\t\tcontinue errorToStringHelp;\n",
       "\t\t\t\tcase 'OneOf':\n",
       "\t\t\t\t\tvar errors = error.a;\n",
       "\t\t\t\t\tif (!errors.b) {\n",
       "\t\t\t\t\t\treturn 'Ran into a Json.Decode.oneOf with no possibilities' + function () {\n",
       "\t\t\t\t\t\t\tif (!context.b) {\n",
       "\t\t\t\t\t\t\t\treturn '!';\n",
       "\t\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\t\treturn ' at json' + A2(\n",
       "\t\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t\t'',\n",
       "\t\t\t\t\t\t\t\t\t$elm$core$List$reverse(context));\n",
       "\t\t\t\t\t\t\t}\n",
       "\t\t\t\t\t\t}();\n",
       "\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\tif (!errors.b.b) {\n",
       "\t\t\t\t\t\t\tvar err = errors.a;\n",
       "\t\t\t\t\t\t\tvar $temp$error = err,\n",
       "\t\t\t\t\t\t\t\t$temp$context = context;\n",
       "\t\t\t\t\t\t\terror = $temp$error;\n",
       "\t\t\t\t\t\t\tcontext = $temp$context;\n",
       "\t\t\t\t\t\t\tcontinue errorToStringHelp;\n",
       "\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\tvar starter = function () {\n",
       "\t\t\t\t\t\t\t\tif (!context.b) {\n",
       "\t\t\t\t\t\t\t\t\treturn 'Json.Decode.oneOf';\n",
       "\t\t\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\t\t\treturn 'The Json.Decode.oneOf at json' + A2(\n",
       "\t\t\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t\t\t'',\n",
       "\t\t\t\t\t\t\t\t\t\t$elm$core$List$reverse(context));\n",
       "\t\t\t\t\t\t\t\t}\n",
       "\t\t\t\t\t\t\t}();\n",
       "\t\t\t\t\t\t\tvar introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(\n",
       "\t\t\t\t\t\t\t\t$elm$core$List$length(errors)) + ' ways:'));\n",
       "\t\t\t\t\t\t\treturn A2(\n",
       "\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t'\\n\\n',\n",
       "\t\t\t\t\t\t\t\tA2(\n",
       "\t\t\t\t\t\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t\t\t\t\t\tintroduction,\n",
       "\t\t\t\t\t\t\t\t\tA2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));\n",
       "\t\t\t\t\t\t}\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\tdefault:\n",
       "\t\t\t\t\tvar msg = error.a;\n",
       "\t\t\t\t\tvar json = error.b;\n",
       "\t\t\t\t\tvar introduction = function () {\n",
       "\t\t\t\t\t\tif (!context.b) {\n",
       "\t\t\t\t\t\t\treturn 'Problem with the given value:\\n\\n';\n",
       "\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\treturn 'Problem with the value at json' + (A2(\n",
       "\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t'',\n",
       "\t\t\t\t\t\t\t\t$elm$core$List$reverse(context)) + ':\\n\\n    ');\n",
       "\t\t\t\t\t\t}\n",
       "\t\t\t\t\t}();\n",
       "\t\t\t\t\treturn introduction + ($elm$json$Json$Decode$indent(\n",
       "\t\t\t\t\t\tA2($elm$json$Json$Encode$encode, 4, json)) + ('\\n\\n' + msg));\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Array$branchFactor = 32;\n",
       "var $elm$core$Array$Array_elm_builtin = F4(\n",
       "\tfunction (a, b, c, d) {\n",
       "\t\treturn {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};\n",
       "\t});\n",
       "var $elm$core$Elm$JsArray$empty = _JsArray_empty;\n",
       "var $elm$core$Basics$ceiling = _Basics_ceiling;\n",
       "var $elm$core$Basics$fdiv = _Basics_fdiv;\n",
       "var $elm$core$Basics$logBase = F2(\n",
       "\tfunction (base, number) {\n",
       "\t\treturn _Basics_log(number) / _Basics_log(base);\n",
       "\t});\n",
       "var $elm$core$Basics$toFloat = _Basics_toFloat;\n",
       "var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(\n",
       "\tA2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));\n",
       "var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);\n",
       "var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;\n",
       "var $elm$core$Array$Leaf = function (a) {\n",
       "\treturn {$: 'Leaf', a: a};\n",
       "};\n",
       "var $elm$core$Basics$apL = F2(\n",
       "\tfunction (f, x) {\n",
       "\t\treturn f(x);\n",
       "\t});\n",
       "var $elm$core$Basics$apR = F2(\n",
       "\tfunction (x, f) {\n",
       "\t\treturn f(x);\n",
       "\t});\n",
       "var $elm$core$Basics$eq = _Utils_equal;\n",
       "var $elm$core$Basics$floor = _Basics_floor;\n",
       "var $elm$core$Elm$JsArray$length = _JsArray_length;\n",
       "var $elm$core$Basics$gt = _Utils_gt;\n",
       "var $elm$core$Basics$max = F2(\n",
       "\tfunction (x, y) {\n",
       "\t\treturn (_Utils_cmp(x, y) > 0) ? x : y;\n",
       "\t});\n",
       "var $elm$core$Basics$mul = _Basics_mul;\n",
       "var $elm$core$Array$SubTree = function (a) {\n",
       "\treturn {$: 'SubTree', a: a};\n",
       "};\n",
       "var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;\n",
       "var $elm$core$Array$compressNodes = F2(\n",
       "\tfunction (nodes, acc) {\n",
       "\t\tcompressNodes:\n",
       "\t\twhile (true) {\n",
       "\t\t\tvar _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);\n",
       "\t\t\tvar node = _v0.a;\n",
       "\t\t\tvar remainingNodes = _v0.b;\n",
       "\t\t\tvar newAcc = A2(\n",
       "\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t$elm$core$Array$SubTree(node),\n",
       "\t\t\t\tacc);\n",
       "\t\t\tif (!remainingNodes.b) {\n",
       "\t\t\t\treturn $elm$core$List$reverse(newAcc);\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar $temp$nodes = remainingNodes,\n",
       "\t\t\t\t\t$temp$acc = newAcc;\n",
       "\t\t\t\tnodes = $temp$nodes;\n",
       "\t\t\t\tacc = $temp$acc;\n",
       "\t\t\t\tcontinue compressNodes;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Tuple$first = function (_v0) {\n",
       "\tvar x = _v0.a;\n",
       "\treturn x;\n",
       "};\n",
       "var $elm$core$Array$treeFromBuilder = F2(\n",
       "\tfunction (nodeList, nodeListSize) {\n",
       "\t\ttreeFromBuilder:\n",
       "\t\twhile (true) {\n",
       "\t\t\tvar newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);\n",
       "\t\t\tif (newNodeSize === 1) {\n",
       "\t\t\t\treturn A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),\n",
       "\t\t\t\t\t$temp$nodeListSize = newNodeSize;\n",
       "\t\t\t\tnodeList = $temp$nodeList;\n",
       "\t\t\t\tnodeListSize = $temp$nodeListSize;\n",
       "\t\t\t\tcontinue treeFromBuilder;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Array$builderToArray = F2(\n",
       "\tfunction (reverseNodeList, builder) {\n",
       "\t\tif (!builder.nodeListSize) {\n",
       "\t\t\treturn A4(\n",
       "\t\t\t\t$elm$core$Array$Array_elm_builtin,\n",
       "\t\t\t\t$elm$core$Elm$JsArray$length(builder.tail),\n",
       "\t\t\t\t$elm$core$Array$shiftStep,\n",
       "\t\t\t\t$elm$core$Elm$JsArray$empty,\n",
       "\t\t\t\tbuilder.tail);\n",
       "\t\t} else {\n",
       "\t\t\tvar treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;\n",
       "\t\t\tvar depth = $elm$core$Basics$floor(\n",
       "\t\t\t\tA2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));\n",
       "\t\t\tvar correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;\n",
       "\t\t\tvar tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);\n",
       "\t\t\treturn A4(\n",
       "\t\t\t\t$elm$core$Array$Array_elm_builtin,\n",
       "\t\t\t\t$elm$core$Elm$JsArray$length(builder.tail) + treeLen,\n",
       "\t\t\t\tA2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),\n",
       "\t\t\t\ttree,\n",
       "\t\t\t\tbuilder.tail);\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Basics$idiv = _Basics_idiv;\n",
       "var $elm$core$Basics$lt = _Utils_lt;\n",
       "var $elm$core$Array$initializeHelp = F5(\n",
       "\tfunction (fn, fromIndex, len, nodeList, tail) {\n",
       "\t\tinitializeHelp:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (fromIndex < 0) {\n",
       "\t\t\t\treturn A2(\n",
       "\t\t\t\t\t$elm$core$Array$builderToArray,\n",
       "\t\t\t\t\tfalse,\n",
       "\t\t\t\t\t{nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar leaf = $elm$core$Array$Leaf(\n",
       "\t\t\t\t\tA3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));\n",
       "\t\t\t\tvar $temp$fn = fn,\n",
       "\t\t\t\t\t$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,\n",
       "\t\t\t\t\t$temp$len = len,\n",
       "\t\t\t\t\t$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),\n",
       "\t\t\t\t\t$temp$tail = tail;\n",
       "\t\t\t\tfn = $temp$fn;\n",
       "\t\t\t\tfromIndex = $temp$fromIndex;\n",
       "\t\t\t\tlen = $temp$len;\n",
       "\t\t\t\tnodeList = $temp$nodeList;\n",
       "\t\t\t\ttail = $temp$tail;\n",
       "\t\t\t\tcontinue initializeHelp;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Basics$remainderBy = _Basics_remainderBy;\n",
       "var $elm$core$Array$initialize = F2(\n",
       "\tfunction (len, fn) {\n",
       "\t\tif (len <= 0) {\n",
       "\t\t\treturn $elm$core$Array$empty;\n",
       "\t\t} else {\n",
       "\t\t\tvar tailLen = len % $elm$core$Array$branchFactor;\n",
       "\t\t\tvar tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);\n",
       "\t\t\tvar initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;\n",
       "\t\t\treturn A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Basics$True = {$: 'True'};\n",
       "var $elm$core$Result$isOk = function (result) {\n",
       "\tif (result.$ === 'Ok') {\n",
       "\t\treturn true;\n",
       "\t} else {\n",
       "\t\treturn false;\n",
       "\t}\n",
       "};\n",
       "var $elm$json$Json$Decode$map = _Json_map1;\n",
       "var $elm$json$Json$Decode$map2 = _Json_map2;\n",
       "var $elm$json$Json$Decode$succeed = _Json_succeed;\n",
       "var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {\n",
       "\tswitch (handler.$) {\n",
       "\t\tcase 'Normal':\n",
       "\t\t\treturn 0;\n",
       "\t\tcase 'MayStopPropagation':\n",
       "\t\t\treturn 1;\n",
       "\t\tcase 'MayPreventDefault':\n",
       "\t\t\treturn 2;\n",
       "\t\tdefault:\n",
       "\t\t\treturn 3;\n",
       "\t}\n",
       "};\n",
       "var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;\n",
       "var $elm$html$Html$text = $elm$virtual_dom$VirtualDom$text;\n",
       "var $author$project$Main$main = $elm$html$Html$text('Hello');\n",
       "_Platform_export({'Main':{'init':_VirtualDom_init($author$project$Main$main)(0)(0)}});}(this));\n",
       "\n",
       "                cb();\n",
       "            }\n",
       "            ;\n",
       "\n",
       "            var obj = new Object();\n",
       "            defineElm.bind(obj)(function(){\n",
       "                var mountNode = document.getElementById('elm-div-3');\n",
       "                obj.Elm. Main.init({ node: mountNode });\n",
       "            });\n",
       "        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "main = Html.text \"Hello\"\n",
    "\n",
    "-- compile-code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Horizontale vorm \n",
    "\n",
    "Een bekende manier om een boom (hiërarchie) weer te geven is de horizontale vorm, waarbij de wortel van de boom \"links boven\" staat. \n",
    "De takken van de boom staan dan lager en ingesprongen.\n",
    "\n",
    "Deze vorm kom je bijvoorbeeld tegen bij de inhoudsopgave van een boek, of de lijst van bestanden in een filesysteem."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Html exposing (..)\n",
    "import String exposing (..)\n",
    "\n",
    "type Tree a\n",
    "  = Node a (List (Tree a))\n",
    "\n",
    "type alias Toc = Tree String\n",
    "\n",
    "printToc : Toc -> List (Html msg)\n",
    "printToc toc  =\n",
    "  printSubtocs [toc] \"\"\n",
    "\n",
    "printSubtocs : List Toc -> String -> List (Html msg)\n",
    "printSubtocs tocs pref =\n",
    "  case tocs of\n",
    "    (Node x s) :: xs ->\n",
    "      let \n",
    "        head = Html.div [] [Html.text (pref ++ \" \" ++ x)]\n",
    "        subs = printSubtocs s (pref ++ \"...\")\n",
    "        next = printSubtocs xs pref\n",
    "      in\n",
    "        head :: subs ++ next\n",
    "    \n",
    "    [] ->\n",
    "      []\n",
    "\n",
    "toc1 = Node \"Titel\" [hoofdstuk1, hoofdstuk2, hoofdstuk3]\n",
    "hoofdstuk1 = Node \"Hoofdstuk 1\" [sectie11, sectie12, sectie13]\n",
    "sectie11 = Node \"Sectie1-1\" []\n",
    "sectie12 = Node \"Sectie1-2\" []\n",
    "sectie13 = Node \"Sectie1-3\" []\n",
    "hoofdstuk2 = Node \"Hoofdstuk 2\" [sectie21, sectie22, sectie23]\n",
    "sectie21 = Node \"Sectie2-1\" []\n",
    "sectie22 = Node \"Sectie2-2\" []\n",
    "sectie23 = Node \"Sectie2-3\" []\n",
    "hoofdstuk3 = Node \"Hoofdstuk 3\" [sectie31, sectie32, sectie33]\n",
    "sectie31 = Node \"Sectie2-1\" []\n",
    "sectie32 = Node \"Sectie2-2\" []\n",
    "sectie33 = Node \"Sectie2-3\" []\n",
    "\n",
    "\n",
    "main = div [] (printToc toc1)\n",
    "\n",
    "-- compile-code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Opmerkingen\n",
    "\n",
    "Volgens mij hebben we hier geen Nil meer nodig: een lege lijst met subbomen is voldoende om aan te geven dat er geen subbomen zijn. Een boom zelf bestaat uit 1 wortel; we hebben dan geen lege boom.... (of: de lege boom is een boom zonder subbomen? Eigenlijk is hier sprake van een \"bos\", nl. een lijst van bomen.)\n",
    "\n",
    "Vgl. een bestandssysteem: een bestand is een \"document\", zonder subbomen; of een map, met subbomen. De wortel van een bestandssysteem is altijd een map (`/`) - niet een lege boom.\n",
    "\n",
    "**Opdracht** gebruik in plaats van div, een ul/li-structuur.\n",
    "\n",
    "**Opdracht** openklappen?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tekenen van een n-aire boom\n",
    "\n",
    "* tekenen van de subbomen gescheiden door een vaste breedte\n",
    "* tekenen van de bovenliggende knoop, in het midden van de totale breedte\n",
    "* per subboom heb je ook een \"midden\" nodig om de verbinding tussen de bovenliggende knoop en de subbomen te tekenen\n",
    "    * hoe \"midden\" is dat midden? - bij 2 subbomen, (of, bij een even aantal subbomen?) in het midden van de tussenruimte.\n",
    "    * bij meerdere subbomen (of bij een oneven aantal subbomen?): in het midden van de middelste boom?\n",
    "* eenvoudigste oplossing (voorlopig): het midden van de totale breedte.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- import Html exposing (..)\n",
    "import Svg exposing (..)\n",
    "import Svg.Attributes exposing (..)\n",
    "import String exposing (..)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "type Tree a\n",
    "  = Node a (List (Tree a))\n",
    "\n",
    "type alias Toc = Tree String\n",
    "\n",
    "unitwidth = 50\n",
    "unitheight = 30\n",
    "\n",
    "translate : (Int, Int) -> List (Svg msg) -> Svg msg\n",
    "translate (x, y) lst =\n",
    "  Svg.g\n",
    "    [transform (\"translate(\" ++ fromInt(x) ++ \",\" ++ fromInt(y) ++ \")\")]\n",
    "    lst\n",
    "\n",
    "twidth : List (Tree a) -> Int\n",
    "twidth trees =\n",
    "  case trees of\n",
    "    (Node head subs) :: next ->\n",
    "      let\n",
    "        headw = unitwidth\n",
    "        subsw = twidth subs\n",
    "        maxw = Basics.max headw subsw\n",
    "      in\n",
    "        maxw + (twidth next)\n",
    "    \n",
    "    [] ->\n",
    "      0\n",
    "    \n",
    "\n",
    "drawToc : Toc -> List (Svg msg)\n",
    "drawToc toc  =\n",
    "  drawSubtocs [toc] 0\n",
    "\n",
    "drawSubtocs : List Toc -> Int -> List (Svg msg)\n",
    "drawSubtocs tocs shift =\n",
    "  case tocs of\n",
    "    (Node x s) :: xs ->\n",
    "      let \n",
    "        head = translate (shift + unitwidth // 2, 0) [Svg.text_ [] [Svg.text (x ++ \"-\" ++ (fromInt maxw))]]\n",
    "        subs = translate (0, unitheight) (drawSubtocs s (shift + 50))\n",
    "        maxw = Basics.max unitwidth (twidth s)\n",
    "        next = drawSubtocs xs (shift + maxw + unitwidth)\n",
    "      in\n",
    "        head :: [subs] ++ next\n",
    "    \n",
    "    [] ->\n",
    "      []\n",
    "      \n",
    "hseparator = 15 \n",
    "vseparator = 30\n",
    "elemwidth = 50\n",
    "\n",
    "-- bij de breedte van een lijst moeten we rekening houden met 3 gevallen:\n",
    "-- de lege lijst (0), 1 element (geen separator), meerdere elementen (separators)\n",
    "\n",
    "treesWidth : List (Int, Svg msg) -> Int\n",
    "treesWidth lst =\n",
    "  case lst of\n",
    "    (tw, t) :: snd :: ts ->\n",
    "      tw + hseparator + treesWidth (snd :: ts)\n",
    "      \n",
    "    (tw, t) :: [] ->\n",
    "      tw\n",
    "      \n",
    "    [] ->\n",
    "      0\n",
    "\n",
    "-- het resultaat vran drawTrees is een lijst van getekende bomen.\n",
    "-- elke boom heeft een eigen breedte; we hebben de breedte van de totale lijst\n",
    "-- nog niet bepaald, dat komt pas bij de omvattende boom (als die er is.)\n",
    "-- eventueel later: per deel-boom ook een \"midden-punt\".\n",
    "\n",
    "drawTrees : List Toc -> List (Int, Svg msg)\n",
    "drawTrees lst =\n",
    "  case lst of\n",
    "    t :: ts ->\n",
    "      let\n",
    "        (headwidth, headsvg) = drawTree t 0\n",
    "        tail = drawTrees ts\n",
    "      in\n",
    "        (headwidth, headsvg ) :: tail\n",
    "      \n",
    "    [] ->\n",
    "      []\n",
    "      \n",
    "pushdownTrees : List (Int, Svg msg) -> Int -> List (Svg msg)\n",
    "pushdownTrees lst pref =\n",
    "  case lst of\n",
    "    (tw, t) :: ts :: x ->\n",
    "      (translate (pref, vseparator) [t]) :: (pushdownTrees (ts :: x) (pref + tw + hseparator))\n",
    "      \n",
    "    (tw, t) :: [] ->\n",
    "      [translate (pref, vseparator) [t]]\n",
    "    \n",
    "    [] ->\n",
    "      []\n",
    "      \n",
    "drawTree : Toc -> Int -> (Int, Svg msg)\n",
    "drawTree tree pref =\n",
    "  case tree of\n",
    "    Node t subs ->\n",
    "      let     \n",
    "        subtrees = drawTrees subs\n",
    "        subwidth = \n",
    "          if subtrees == [] then\n",
    "            elemwidth\n",
    "          else\n",
    "            treesWidth subtrees\n",
    " --       head = translate (pref + subwidth // 2, 0) [Svg.text_ [] [Svg.text (t ++ \"-\" ++ (fromInt subwidth))]]\n",
    "        head = translate (pref + subwidth // 2, 0) [Svg.text_ [] [Svg.text (t)]]\n",
    "        placedtrees = pushdownTrees subtrees pref\n",
    "      in\n",
    "        (subwidth, (translate (0, 0) (head::placedtrees)))\n",
    "    \n",
    "    \n",
    "-- een Tree heeft maar 1 alternatief...\n",
    "\n",
    "drawT : Toc -> Svg msg\n",
    "drawT toc =\n",
    "  let\n",
    "    (w, t) = drawTree toc 0\n",
    "  in\n",
    "    t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "toc1 = Node \"Titel\" [hoofdstuk1, hoofdstuk2, hoofdstuk3]\n",
    "hoofdstuk1 = Node \"H 1\" [sectie11, sectie12, sectie13]\n",
    "sectie11 = Node \"S 1-1\" []\n",
    "sectie12 = Node \"S 1-2\" []\n",
    "sectie13 = Node \"S 1-3\" []\n",
    "hoofdstuk2 = Node \"H 2\" [sectie21, sectie22, sectie23]\n",
    "sectie21 = Node \"S 2-1\" []\n",
    "sectie22 = Node \"S 2-2\" []\n",
    "sectie23 = Node \"S 2-3\" []\n",
    "hoofdstuk3 = Node \"H 3\" [sectie31, sectie32, sectie33]\n",
    "sectie31 = Node \"S 2-1\" []\n",
    "sectie32 = Node \"S 2-2\" []\n",
    "sectie33 = Node \"S 2-3\" []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div id=\"elm-div-11\"></div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "            var defineElm = function(cb) {\n",
       "                if (this.Elm) {\n",
       "                    this.oldElm = this.Elm;\n",
       "                }\n",
       "                var define = null;\n",
       "\n",
       "                (function(scope){\n",
       "'use strict';\n",
       "\n",
       "function F(arity, fun, wrapper) {\n",
       "  wrapper.a = arity;\n",
       "  wrapper.f = fun;\n",
       "  return wrapper;\n",
       "}\n",
       "\n",
       "function F2(fun) {\n",
       "  return F(2, fun, function(a) { return function(b) { return fun(a,b); }; })\n",
       "}\n",
       "function F3(fun) {\n",
       "  return F(3, fun, function(a) {\n",
       "    return function(b) { return function(c) { return fun(a, b, c); }; };\n",
       "  });\n",
       "}\n",
       "function F4(fun) {\n",
       "  return F(4, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return fun(a, b, c, d); }; }; };\n",
       "  });\n",
       "}\n",
       "function F5(fun) {\n",
       "  return F(5, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return fun(a, b, c, d, e); }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F6(fun) {\n",
       "  return F(6, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return fun(a, b, c, d, e, f); }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F7(fun) {\n",
       "  return F(7, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return function(g) { return fun(a, b, c, d, e, f, g); }; }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F8(fun) {\n",
       "  return F(8, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return function(g) { return function(h) {\n",
       "    return fun(a, b, c, d, e, f, g, h); }; }; }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "function F9(fun) {\n",
       "  return F(9, fun, function(a) { return function(b) { return function(c) {\n",
       "    return function(d) { return function(e) { return function(f) {\n",
       "    return function(g) { return function(h) { return function(i) {\n",
       "    return fun(a, b, c, d, e, f, g, h, i); }; }; }; }; }; }; }; };\n",
       "  });\n",
       "}\n",
       "\n",
       "function A2(fun, a, b) {\n",
       "  return fun.a === 2 ? fun.f(a, b) : fun(a)(b);\n",
       "}\n",
       "function A3(fun, a, b, c) {\n",
       "  return fun.a === 3 ? fun.f(a, b, c) : fun(a)(b)(c);\n",
       "}\n",
       "function A4(fun, a, b, c, d) {\n",
       "  return fun.a === 4 ? fun.f(a, b, c, d) : fun(a)(b)(c)(d);\n",
       "}\n",
       "function A5(fun, a, b, c, d, e) {\n",
       "  return fun.a === 5 ? fun.f(a, b, c, d, e) : fun(a)(b)(c)(d)(e);\n",
       "}\n",
       "function A6(fun, a, b, c, d, e, f) {\n",
       "  return fun.a === 6 ? fun.f(a, b, c, d, e, f) : fun(a)(b)(c)(d)(e)(f);\n",
       "}\n",
       "function A7(fun, a, b, c, d, e, f, g) {\n",
       "  return fun.a === 7 ? fun.f(a, b, c, d, e, f, g) : fun(a)(b)(c)(d)(e)(f)(g);\n",
       "}\n",
       "function A8(fun, a, b, c, d, e, f, g, h) {\n",
       "  return fun.a === 8 ? fun.f(a, b, c, d, e, f, g, h) : fun(a)(b)(c)(d)(e)(f)(g)(h);\n",
       "}\n",
       "function A9(fun, a, b, c, d, e, f, g, h, i) {\n",
       "  return fun.a === 9 ? fun.f(a, b, c, d, e, f, g, h, i) : fun(a)(b)(c)(d)(e)(f)(g)(h)(i);\n",
       "}\n",
       "\n",
       "console.warn('Compiled in DEV mode. Follow the advice at https://elm-lang.org/0.19.1/optimize for better performance and smaller assets.');\n",
       "\n",
       "\n",
       "var _JsArray_empty = [];\n",
       "\n",
       "function _JsArray_singleton(value)\n",
       "{\n",
       "    return [value];\n",
       "}\n",
       "\n",
       "function _JsArray_length(array)\n",
       "{\n",
       "    return array.length;\n",
       "}\n",
       "\n",
       "var _JsArray_initialize = F3(function(size, offset, func)\n",
       "{\n",
       "    var result = new Array(size);\n",
       "\n",
       "    for (var i = 0; i < size; i++)\n",
       "    {\n",
       "        result[i] = func(offset + i);\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_initializeFromList = F2(function (max, ls)\n",
       "{\n",
       "    var result = new Array(max);\n",
       "\n",
       "    for (var i = 0; i < max && ls.b; i++)\n",
       "    {\n",
       "        result[i] = ls.a;\n",
       "        ls = ls.b;\n",
       "    }\n",
       "\n",
       "    result.length = i;\n",
       "    return _Utils_Tuple2(result, ls);\n",
       "});\n",
       "\n",
       "var _JsArray_unsafeGet = F2(function(index, array)\n",
       "{\n",
       "    return array[index];\n",
       "});\n",
       "\n",
       "var _JsArray_unsafeSet = F3(function(index, value, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = array[i];\n",
       "    }\n",
       "\n",
       "    result[index] = value;\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_push = F2(function(value, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length + 1);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = array[i];\n",
       "    }\n",
       "\n",
       "    result[length] = value;\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_foldl = F3(function(func, acc, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        acc = A2(func, array[i], acc);\n",
       "    }\n",
       "\n",
       "    return acc;\n",
       "});\n",
       "\n",
       "var _JsArray_foldr = F3(function(func, acc, array)\n",
       "{\n",
       "    for (var i = array.length - 1; i >= 0; i--)\n",
       "    {\n",
       "        acc = A2(func, array[i], acc);\n",
       "    }\n",
       "\n",
       "    return acc;\n",
       "});\n",
       "\n",
       "var _JsArray_map = F2(function(func, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = func(array[i]);\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_indexedMap = F3(function(func, offset, array)\n",
       "{\n",
       "    var length = array.length;\n",
       "    var result = new Array(length);\n",
       "\n",
       "    for (var i = 0; i < length; i++)\n",
       "    {\n",
       "        result[i] = A2(func, offset + i, array[i]);\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "var _JsArray_slice = F3(function(from, to, array)\n",
       "{\n",
       "    return array.slice(from, to);\n",
       "});\n",
       "\n",
       "var _JsArray_appendN = F3(function(n, dest, source)\n",
       "{\n",
       "    var destLen = dest.length;\n",
       "    var itemsToCopy = n - destLen;\n",
       "\n",
       "    if (itemsToCopy > source.length)\n",
       "    {\n",
       "        itemsToCopy = source.length;\n",
       "    }\n",
       "\n",
       "    var size = destLen + itemsToCopy;\n",
       "    var result = new Array(size);\n",
       "\n",
       "    for (var i = 0; i < destLen; i++)\n",
       "    {\n",
       "        result[i] = dest[i];\n",
       "    }\n",
       "\n",
       "    for (var i = 0; i < itemsToCopy; i++)\n",
       "    {\n",
       "        result[i + destLen] = source[i];\n",
       "    }\n",
       "\n",
       "    return result;\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// LOG\n",
       "\n",
       "var _Debug_log_UNUSED = F2(function(tag, value)\n",
       "{\n",
       "\treturn value;\n",
       "});\n",
       "\n",
       "var _Debug_log = F2(function(tag, value)\n",
       "{\n",
       "\tconsole.log(tag + ': ' + _Debug_toString(value));\n",
       "\treturn value;\n",
       "});\n",
       "\n",
       "\n",
       "// TODOS\n",
       "\n",
       "function _Debug_todo(moduleName, region)\n",
       "{\n",
       "\treturn function(message) {\n",
       "\t\t_Debug_crash(8, moduleName, region, message);\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Debug_todoCase(moduleName, region, value)\n",
       "{\n",
       "\treturn function(message) {\n",
       "\t\t_Debug_crash(9, moduleName, region, value, message);\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "// TO STRING\n",
       "\n",
       "function _Debug_toString_UNUSED(value)\n",
       "{\n",
       "\treturn '<internals>';\n",
       "}\n",
       "\n",
       "function _Debug_toString(value)\n",
       "{\n",
       "\treturn _Debug_toAnsiString(false, value);\n",
       "}\n",
       "\n",
       "function _Debug_toAnsiString(ansi, value)\n",
       "{\n",
       "\tif (typeof value === 'function')\n",
       "\t{\n",
       "\t\treturn _Debug_internalColor(ansi, '<function>');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'boolean')\n",
       "\t{\n",
       "\t\treturn _Debug_ctorColor(ansi, value ? 'True' : 'False');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'number')\n",
       "\t{\n",
       "\t\treturn _Debug_numberColor(ansi, value + '');\n",
       "\t}\n",
       "\n",
       "\tif (value instanceof String)\n",
       "\t{\n",
       "\t\treturn _Debug_charColor(ansi, \"'\" + _Debug_addSlashes(value, true) + \"'\");\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'string')\n",
       "\t{\n",
       "\t\treturn _Debug_stringColor(ansi, '\"' + _Debug_addSlashes(value, false) + '\"');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'object' && '$' in value)\n",
       "\t{\n",
       "\t\tvar tag = value.$;\n",
       "\n",
       "\t\tif (typeof tag === 'number')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_internalColor(ansi, '<internals>');\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag[0] === '#')\n",
       "\t\t{\n",
       "\t\t\tvar output = [];\n",
       "\t\t\tfor (var k in value)\n",
       "\t\t\t{\n",
       "\t\t\t\tif (k === '$') continue;\n",
       "\t\t\t\toutput.push(_Debug_toAnsiString(ansi, value[k]));\n",
       "\t\t\t}\n",
       "\t\t\treturn '(' + output.join(',') + ')';\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === 'Set_elm_builtin')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_ctorColor(ansi, 'Set')\n",
       "\t\t\t\t+ _Debug_fadeColor(ansi, '.fromList') + ' '\n",
       "\t\t\t\t+ _Debug_toAnsiString(ansi, $elm$core$Set$toList(value));\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === 'RBNode_elm_builtin' || tag === 'RBEmpty_elm_builtin')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_ctorColor(ansi, 'Dict')\n",
       "\t\t\t\t+ _Debug_fadeColor(ansi, '.fromList') + ' '\n",
       "\t\t\t\t+ _Debug_toAnsiString(ansi, $elm$core$Dict$toList(value));\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === 'Array_elm_builtin')\n",
       "\t\t{\n",
       "\t\t\treturn _Debug_ctorColor(ansi, 'Array')\n",
       "\t\t\t\t+ _Debug_fadeColor(ansi, '.fromList') + ' '\n",
       "\t\t\t\t+ _Debug_toAnsiString(ansi, $elm$core$Array$toList(value));\n",
       "\t\t}\n",
       "\n",
       "\t\tif (tag === '::' || tag === '[]')\n",
       "\t\t{\n",
       "\t\t\tvar output = '[';\n",
       "\n",
       "\t\t\tvalue.b && (output += _Debug_toAnsiString(ansi, value.a), value = value.b)\n",
       "\n",
       "\t\t\tfor (; value.b; value = value.b) // WHILE_CONS\n",
       "\t\t\t{\n",
       "\t\t\t\toutput += ',' + _Debug_toAnsiString(ansi, value.a);\n",
       "\t\t\t}\n",
       "\t\t\treturn output + ']';\n",
       "\t\t}\n",
       "\n",
       "\t\tvar output = '';\n",
       "\t\tfor (var i in value)\n",
       "\t\t{\n",
       "\t\t\tif (i === '$') continue;\n",
       "\t\t\tvar str = _Debug_toAnsiString(ansi, value[i]);\n",
       "\t\t\tvar c0 = str[0];\n",
       "\t\t\tvar parenless = c0 === '{' || c0 === '(' || c0 === '[' || c0 === '<' || c0 === '\"' || str.indexOf(' ') < 0;\n",
       "\t\t\toutput += ' ' + (parenless ? str : '(' + str + ')');\n",
       "\t\t}\n",
       "\t\treturn _Debug_ctorColor(ansi, tag) + output;\n",
       "\t}\n",
       "\n",
       "\tif (typeof DataView === 'function' && value instanceof DataView)\n",
       "\t{\n",
       "\t\treturn _Debug_stringColor(ansi, '<' + value.byteLength + ' bytes>');\n",
       "\t}\n",
       "\n",
       "\tif (typeof File !== 'undefined' && value instanceof File)\n",
       "\t{\n",
       "\t\treturn _Debug_internalColor(ansi, '<' + value.name + '>');\n",
       "\t}\n",
       "\n",
       "\tif (typeof value === 'object')\n",
       "\t{\n",
       "\t\tvar output = [];\n",
       "\t\tfor (var key in value)\n",
       "\t\t{\n",
       "\t\t\tvar field = key[0] === '_' ? key.slice(1) : key;\n",
       "\t\t\toutput.push(_Debug_fadeColor(ansi, field) + ' = ' + _Debug_toAnsiString(ansi, value[key]));\n",
       "\t\t}\n",
       "\t\tif (output.length === 0)\n",
       "\t\t{\n",
       "\t\t\treturn '{}';\n",
       "\t\t}\n",
       "\t\treturn '{ ' + output.join(', ') + ' }';\n",
       "\t}\n",
       "\n",
       "\treturn _Debug_internalColor(ansi, '<internals>');\n",
       "}\n",
       "\n",
       "function _Debug_addSlashes(str, isChar)\n",
       "{\n",
       "\tvar s = str\n",
       "\t\t.replace(/\\\\/g, '\\\\\\\\')\n",
       "\t\t.replace(/\\n/g, '\\\\n')\n",
       "\t\t.replace(/\\t/g, '\\\\t')\n",
       "\t\t.replace(/\\r/g, '\\\\r')\n",
       "\t\t.replace(/\\v/g, '\\\\v')\n",
       "\t\t.replace(/\\0/g, '\\\\0');\n",
       "\n",
       "\tif (isChar)\n",
       "\t{\n",
       "\t\treturn s.replace(/\\'/g, '\\\\\\'');\n",
       "\t}\n",
       "\telse\n",
       "\t{\n",
       "\t\treturn s.replace(/\\\"/g, '\\\\\"');\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Debug_ctorColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[96m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_numberColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[95m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_stringColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[93m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_charColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[92m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_fadeColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[37m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_internalColor(ansi, string)\n",
       "{\n",
       "\treturn ansi ? '\\x1b[36m' + string + '\\x1b[0m' : string;\n",
       "}\n",
       "\n",
       "function _Debug_toHexDigit(n)\n",
       "{\n",
       "\treturn String.fromCharCode(n < 10 ? 48 + n : 55 + n);\n",
       "}\n",
       "\n",
       "\n",
       "// CRASH\n",
       "\n",
       "\n",
       "function _Debug_crash_UNUSED(identifier)\n",
       "{\n",
       "\tthrow new Error('https://github.com/elm/core/blob/1.0.0/hints/' + identifier + '.md');\n",
       "}\n",
       "\n",
       "\n",
       "function _Debug_crash(identifier, fact1, fact2, fact3, fact4)\n",
       "{\n",
       "\tswitch(identifier)\n",
       "\t{\n",
       "\t\tcase 0:\n",
       "\t\t\tthrow new Error('What node should I take over? In JavaScript I need something like:\\n\\n    Elm.Main.init({\\n        node: document.getElementById(\"elm-node\")\\n    })\\n\\nYou need to do this with any Browser.sandbox or Browser.element program.');\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\tthrow new Error('Browser.application programs cannot handle URLs like this:\\n\\n    ' + document.location.href + '\\n\\nWhat is the root? The root of your file system? Try looking at this program with `elm reactor` or some other server.');\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\tvar jsonErrorString = fact1;\n",
       "\t\t\tthrow new Error('Problem with the flags given to your Elm program on initialization.\\n\\n' + jsonErrorString);\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tvar portName = fact1;\n",
       "\t\t\tthrow new Error('There can only be one port named `' + portName + '`, but your program has multiple.');\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\tvar portName = fact1;\n",
       "\t\t\tvar problem = fact2;\n",
       "\t\t\tthrow new Error('Trying to send an unexpected type of value through port `' + portName + '`:\\n' + problem);\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\tthrow new Error('Trying to use `(==)` on functions.\\nThere is no way to know if functions are \"the same\" in the Elm sense.\\nRead more about this at https://package.elm-lang.org/packages/elm/core/latest/Basics#== which describes why it is this way and what the better version will look like.');\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\tvar moduleName = fact1;\n",
       "\t\t\tthrow new Error('Your page is loading multiple Elm scripts with a module named ' + moduleName + '. Maybe a duplicate script is getting loaded accidentally? If not, rename one of them so I know which is which!');\n",
       "\n",
       "\t\tcase 8:\n",
       "\t\t\tvar moduleName = fact1;\n",
       "\t\t\tvar region = fact2;\n",
       "\t\t\tvar message = fact3;\n",
       "\t\t\tthrow new Error('TODO in module `' + moduleName + '` ' + _Debug_regionToString(region) + '\\n\\n' + message);\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\tvar moduleName = fact1;\n",
       "\t\t\tvar region = fact2;\n",
       "\t\t\tvar value = fact3;\n",
       "\t\t\tvar message = fact4;\n",
       "\t\t\tthrow new Error(\n",
       "\t\t\t\t'TODO in module `' + moduleName + '` from the `case` expression '\n",
       "\t\t\t\t+ _Debug_regionToString(region) + '\\n\\nIt received the following value:\\n\\n    '\n",
       "\t\t\t\t+ _Debug_toString(value).replace('\\n', '\\n    ')\n",
       "\t\t\t\t+ '\\n\\nBut the branch that handles it says:\\n\\n    ' + message.replace('\\n', '\\n    ')\n",
       "\t\t\t);\n",
       "\n",
       "\t\tcase 10:\n",
       "\t\t\tthrow new Error('Bug in https://github.com/elm/virtual-dom/issues');\n",
       "\n",
       "\t\tcase 11:\n",
       "\t\t\tthrow new Error('Cannot perform mod 0. Division by zero error.');\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Debug_regionToString(region)\n",
       "{\n",
       "\tif (region.start.line === region.end.line)\n",
       "\t{\n",
       "\t\treturn 'on line ' + region.start.line;\n",
       "\t}\n",
       "\treturn 'on lines ' + region.start.line + ' through ' + region.end.line;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// EQUALITY\n",
       "\n",
       "function _Utils_eq(x, y)\n",
       "{\n",
       "\tfor (\n",
       "\t\tvar pair, stack = [], isEqual = _Utils_eqHelp(x, y, 0, stack);\n",
       "\t\tisEqual && (pair = stack.pop());\n",
       "\t\tisEqual = _Utils_eqHelp(pair.a, pair.b, 0, stack)\n",
       "\t\t)\n",
       "\t{}\n",
       "\n",
       "\treturn isEqual;\n",
       "}\n",
       "\n",
       "function _Utils_eqHelp(x, y, depth, stack)\n",
       "{\n",
       "\tif (x === y)\n",
       "\t{\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\n",
       "\tif (typeof x !== 'object' || x === null || y === null)\n",
       "\t{\n",
       "\t\ttypeof x === 'function' && _Debug_crash(5);\n",
       "\t\treturn false;\n",
       "\t}\n",
       "\n",
       "\tif (depth > 100)\n",
       "\t{\n",
       "\t\tstack.push(_Utils_Tuple2(x,y));\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\n",
       "\t/**/\n",
       "\tif (x.$ === 'Set_elm_builtin')\n",
       "\t{\n",
       "\t\tx = $elm$core$Set$toList(x);\n",
       "\t\ty = $elm$core$Set$toList(y);\n",
       "\t}\n",
       "\tif (x.$ === 'RBNode_elm_builtin' || x.$ === 'RBEmpty_elm_builtin')\n",
       "\t{\n",
       "\t\tx = $elm$core$Dict$toList(x);\n",
       "\t\ty = $elm$core$Dict$toList(y);\n",
       "\t}\n",
       "\t//*/\n",
       "\n",
       "\t/**_UNUSED/\n",
       "\tif (x.$ < 0)\n",
       "\t{\n",
       "\t\tx = $elm$core$Dict$toList(x);\n",
       "\t\ty = $elm$core$Dict$toList(y);\n",
       "\t}\n",
       "\t//*/\n",
       "\n",
       "\tfor (var key in x)\n",
       "\t{\n",
       "\t\tif (!_Utils_eqHelp(x[key], y[key], depth + 1, stack))\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn true;\n",
       "}\n",
       "\n",
       "var _Utils_equal = F2(_Utils_eq);\n",
       "var _Utils_notEqual = F2(function(a, b) { return !_Utils_eq(a,b); });\n",
       "\n",
       "\n",
       "\n",
       "// COMPARISONS\n",
       "\n",
       "// Code in Generate/JavaScript.hs, Basics.js, and List.js depends on\n",
       "// the particular integer values assigned to LT, EQ, and GT.\n",
       "\n",
       "function _Utils_cmp(x, y, ord)\n",
       "{\n",
       "\tif (typeof x !== 'object')\n",
       "\t{\n",
       "\t\treturn x === y ? /*EQ*/ 0 : x < y ? /*LT*/ -1 : /*GT*/ 1;\n",
       "\t}\n",
       "\n",
       "\t/**/\n",
       "\tif (x instanceof String)\n",
       "\t{\n",
       "\t\tvar a = x.valueOf();\n",
       "\t\tvar b = y.valueOf();\n",
       "\t\treturn a === b ? 0 : a < b ? -1 : 1;\n",
       "\t}\n",
       "\t//*/\n",
       "\n",
       "\t/**_UNUSED/\n",
       "\tif (typeof x.$ === 'undefined')\n",
       "\t//*/\n",
       "\t/**/\n",
       "\tif (x.$[0] === '#')\n",
       "\t//*/\n",
       "\t{\n",
       "\t\treturn (ord = _Utils_cmp(x.a, y.a))\n",
       "\t\t\t? ord\n",
       "\t\t\t: (ord = _Utils_cmp(x.b, y.b))\n",
       "\t\t\t\t? ord\n",
       "\t\t\t\t: _Utils_cmp(x.c, y.c);\n",
       "\t}\n",
       "\n",
       "\t// traverse conses until end of a list or a mismatch\n",
       "\tfor (; x.b && y.b && !(ord = _Utils_cmp(x.a, y.a)); x = x.b, y = y.b) {} // WHILE_CONSES\n",
       "\treturn ord || (x.b ? /*GT*/ 1 : y.b ? /*LT*/ -1 : /*EQ*/ 0);\n",
       "}\n",
       "\n",
       "var _Utils_lt = F2(function(a, b) { return _Utils_cmp(a, b) < 0; });\n",
       "var _Utils_le = F2(function(a, b) { return _Utils_cmp(a, b) < 1; });\n",
       "var _Utils_gt = F2(function(a, b) { return _Utils_cmp(a, b) > 0; });\n",
       "var _Utils_ge = F2(function(a, b) { return _Utils_cmp(a, b) >= 0; });\n",
       "\n",
       "var _Utils_compare = F2(function(x, y)\n",
       "{\n",
       "\tvar n = _Utils_cmp(x, y);\n",
       "\treturn n < 0 ? $elm$core$Basics$LT : n ? $elm$core$Basics$GT : $elm$core$Basics$EQ;\n",
       "});\n",
       "\n",
       "\n",
       "// COMMON VALUES\n",
       "\n",
       "var _Utils_Tuple0_UNUSED = 0;\n",
       "var _Utils_Tuple0 = { $: '#0' };\n",
       "\n",
       "function _Utils_Tuple2_UNUSED(a, b) { return { a: a, b: b }; }\n",
       "function _Utils_Tuple2(a, b) { return { $: '#2', a: a, b: b }; }\n",
       "\n",
       "function _Utils_Tuple3_UNUSED(a, b, c) { return { a: a, b: b, c: c }; }\n",
       "function _Utils_Tuple3(a, b, c) { return { $: '#3', a: a, b: b, c: c }; }\n",
       "\n",
       "function _Utils_chr_UNUSED(c) { return c; }\n",
       "function _Utils_chr(c) { return new String(c); }\n",
       "\n",
       "\n",
       "// RECORDS\n",
       "\n",
       "function _Utils_update(oldRecord, updatedFields)\n",
       "{\n",
       "\tvar newRecord = {};\n",
       "\n",
       "\tfor (var key in oldRecord)\n",
       "\t{\n",
       "\t\tnewRecord[key] = oldRecord[key];\n",
       "\t}\n",
       "\n",
       "\tfor (var key in updatedFields)\n",
       "\t{\n",
       "\t\tnewRecord[key] = updatedFields[key];\n",
       "\t}\n",
       "\n",
       "\treturn newRecord;\n",
       "}\n",
       "\n",
       "\n",
       "// APPEND\n",
       "\n",
       "var _Utils_append = F2(_Utils_ap);\n",
       "\n",
       "function _Utils_ap(xs, ys)\n",
       "{\n",
       "\t// append Strings\n",
       "\tif (typeof xs === 'string')\n",
       "\t{\n",
       "\t\treturn xs + ys;\n",
       "\t}\n",
       "\n",
       "\t// append Lists\n",
       "\tif (!xs.b)\n",
       "\t{\n",
       "\t\treturn ys;\n",
       "\t}\n",
       "\tvar root = _List_Cons(xs.a, ys);\n",
       "\txs = xs.b\n",
       "\tfor (var curr = root; xs.b; xs = xs.b) // WHILE_CONS\n",
       "\t{\n",
       "\t\tcurr = curr.b = _List_Cons(xs.a, ys);\n",
       "\t}\n",
       "\treturn root;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "var _List_Nil_UNUSED = { $: 0 };\n",
       "var _List_Nil = { $: '[]' };\n",
       "\n",
       "function _List_Cons_UNUSED(hd, tl) { return { $: 1, a: hd, b: tl }; }\n",
       "function _List_Cons(hd, tl) { return { $: '::', a: hd, b: tl }; }\n",
       "\n",
       "\n",
       "var _List_cons = F2(_List_Cons);\n",
       "\n",
       "function _List_fromArray(arr)\n",
       "{\n",
       "\tvar out = _List_Nil;\n",
       "\tfor (var i = arr.length; i--; )\n",
       "\t{\n",
       "\t\tout = _List_Cons(arr[i], out);\n",
       "\t}\n",
       "\treturn out;\n",
       "}\n",
       "\n",
       "function _List_toArray(xs)\n",
       "{\n",
       "\tfor (var out = []; xs.b; xs = xs.b) // WHILE_CONS\n",
       "\t{\n",
       "\t\tout.push(xs.a);\n",
       "\t}\n",
       "\treturn out;\n",
       "}\n",
       "\n",
       "var _List_map2 = F3(function(f, xs, ys)\n",
       "{\n",
       "\tfor (var arr = []; xs.b && ys.b; xs = xs.b, ys = ys.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A2(f, xs.a, ys.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_map3 = F4(function(f, xs, ys, zs)\n",
       "{\n",
       "\tfor (var arr = []; xs.b && ys.b && zs.b; xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A3(f, xs.a, ys.a, zs.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_map4 = F5(function(f, ws, xs, ys, zs)\n",
       "{\n",
       "\tfor (var arr = []; ws.b && xs.b && ys.b && zs.b; ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A4(f, ws.a, xs.a, ys.a, zs.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_map5 = F6(function(f, vs, ws, xs, ys, zs)\n",
       "{\n",
       "\tfor (var arr = []; vs.b && ws.b && xs.b && ys.b && zs.b; vs = vs.b, ws = ws.b, xs = xs.b, ys = ys.b, zs = zs.b) // WHILE_CONSES\n",
       "\t{\n",
       "\t\tarr.push(A5(f, vs.a, ws.a, xs.a, ys.a, zs.a));\n",
       "\t}\n",
       "\treturn _List_fromArray(arr);\n",
       "});\n",
       "\n",
       "var _List_sortBy = F2(function(f, xs)\n",
       "{\n",
       "\treturn _List_fromArray(_List_toArray(xs).sort(function(a, b) {\n",
       "\t\treturn _Utils_cmp(f(a), f(b));\n",
       "\t}));\n",
       "});\n",
       "\n",
       "var _List_sortWith = F2(function(f, xs)\n",
       "{\n",
       "\treturn _List_fromArray(_List_toArray(xs).sort(function(a, b) {\n",
       "\t\tvar ord = A2(f, a, b);\n",
       "\t\treturn ord === $elm$core$Basics$EQ ? 0 : ord === $elm$core$Basics$LT ? -1 : 1;\n",
       "\t}));\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// MATH\n",
       "\n",
       "var _Basics_add = F2(function(a, b) { return a + b; });\n",
       "var _Basics_sub = F2(function(a, b) { return a - b; });\n",
       "var _Basics_mul = F2(function(a, b) { return a * b; });\n",
       "var _Basics_fdiv = F2(function(a, b) { return a / b; });\n",
       "var _Basics_idiv = F2(function(a, b) { return (a / b) | 0; });\n",
       "var _Basics_pow = F2(Math.pow);\n",
       "\n",
       "var _Basics_remainderBy = F2(function(b, a) { return a % b; });\n",
       "\n",
       "// https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf\n",
       "var _Basics_modBy = F2(function(modulus, x)\n",
       "{\n",
       "\tvar answer = x % modulus;\n",
       "\treturn modulus === 0\n",
       "\t\t? _Debug_crash(11)\n",
       "\t\t:\n",
       "\t((answer > 0 && modulus < 0) || (answer < 0 && modulus > 0))\n",
       "\t\t? answer + modulus\n",
       "\t\t: answer;\n",
       "});\n",
       "\n",
       "\n",
       "// TRIGONOMETRY\n",
       "\n",
       "var _Basics_pi = Math.PI;\n",
       "var _Basics_e = Math.E;\n",
       "var _Basics_cos = Math.cos;\n",
       "var _Basics_sin = Math.sin;\n",
       "var _Basics_tan = Math.tan;\n",
       "var _Basics_acos = Math.acos;\n",
       "var _Basics_asin = Math.asin;\n",
       "var _Basics_atan = Math.atan;\n",
       "var _Basics_atan2 = F2(Math.atan2);\n",
       "\n",
       "\n",
       "// MORE MATH\n",
       "\n",
       "function _Basics_toFloat(x) { return x; }\n",
       "function _Basics_truncate(n) { return n | 0; }\n",
       "function _Basics_isInfinite(n) { return n === Infinity || n === -Infinity; }\n",
       "\n",
       "var _Basics_ceiling = Math.ceil;\n",
       "var _Basics_floor = Math.floor;\n",
       "var _Basics_round = Math.round;\n",
       "var _Basics_sqrt = Math.sqrt;\n",
       "var _Basics_log = Math.log;\n",
       "var _Basics_isNaN = isNaN;\n",
       "\n",
       "\n",
       "// BOOLEANS\n",
       "\n",
       "function _Basics_not(bool) { return !bool; }\n",
       "var _Basics_and = F2(function(a, b) { return a && b; });\n",
       "var _Basics_or  = F2(function(a, b) { return a || b; });\n",
       "var _Basics_xor = F2(function(a, b) { return a !== b; });\n",
       "\n",
       "\n",
       "\n",
       "var _String_cons = F2(function(chr, str)\n",
       "{\n",
       "\treturn chr + str;\n",
       "});\n",
       "\n",
       "function _String_uncons(string)\n",
       "{\n",
       "\tvar word = string.charCodeAt(0);\n",
       "\treturn !isNaN(word)\n",
       "\t\t? $elm$core$Maybe$Just(\n",
       "\t\t\t0xD800 <= word && word <= 0xDBFF\n",
       "\t\t\t\t? _Utils_Tuple2(_Utils_chr(string[0] + string[1]), string.slice(2))\n",
       "\t\t\t\t: _Utils_Tuple2(_Utils_chr(string[0]), string.slice(1))\n",
       "\t\t)\n",
       "\t\t: $elm$core$Maybe$Nothing;\n",
       "}\n",
       "\n",
       "var _String_append = F2(function(a, b)\n",
       "{\n",
       "\treturn a + b;\n",
       "});\n",
       "\n",
       "function _String_length(str)\n",
       "{\n",
       "\treturn str.length;\n",
       "}\n",
       "\n",
       "var _String_map = F2(function(func, string)\n",
       "{\n",
       "\tvar len = string.length;\n",
       "\tvar array = new Array(len);\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tarray[i] = func(_Utils_chr(string[i] + string[i+1]));\n",
       "\t\t\ti += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\t\tarray[i] = func(_Utils_chr(string[i]));\n",
       "\t\ti++;\n",
       "\t}\n",
       "\treturn array.join('');\n",
       "});\n",
       "\n",
       "var _String_filter = F2(function(isGood, str)\n",
       "{\n",
       "\tvar arr = [];\n",
       "\tvar len = str.length;\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar char = str[i];\n",
       "\t\tvar word = str.charCodeAt(i);\n",
       "\t\ti++;\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tchar += str[i];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\n",
       "\t\tif (isGood(_Utils_chr(char)))\n",
       "\t\t{\n",
       "\t\t\tarr.push(char);\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn arr.join('');\n",
       "});\n",
       "\n",
       "function _String_reverse(str)\n",
       "{\n",
       "\tvar len = str.length;\n",
       "\tvar arr = new Array(len);\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar word = str.charCodeAt(i);\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tarr[len - i] = str[i + 1];\n",
       "\t\t\ti++;\n",
       "\t\t\tarr[len - i] = str[i - 1];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\t\telse\n",
       "\t\t{\n",
       "\t\t\tarr[len - i] = str[i];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn arr.join('');\n",
       "}\n",
       "\n",
       "var _String_foldl = F3(function(func, state, string)\n",
       "{\n",
       "\tvar len = string.length;\n",
       "\tvar i = 0;\n",
       "\twhile (i < len)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\ti++;\n",
       "\t\tif (0xD800 <= word && word <= 0xDBFF)\n",
       "\t\t{\n",
       "\t\t\tchar += string[i];\n",
       "\t\t\ti++;\n",
       "\t\t}\n",
       "\t\tstate = A2(func, _Utils_chr(char), state);\n",
       "\t}\n",
       "\treturn state;\n",
       "});\n",
       "\n",
       "var _String_foldr = F3(function(func, state, string)\n",
       "{\n",
       "\tvar i = string.length;\n",
       "\twhile (i--)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xDC00 <= word && word <= 0xDFFF)\n",
       "\t\t{\n",
       "\t\t\ti--;\n",
       "\t\t\tchar = string[i] + char;\n",
       "\t\t}\n",
       "\t\tstate = A2(func, _Utils_chr(char), state);\n",
       "\t}\n",
       "\treturn state;\n",
       "});\n",
       "\n",
       "var _String_split = F2(function(sep, str)\n",
       "{\n",
       "\treturn str.split(sep);\n",
       "});\n",
       "\n",
       "var _String_join = F2(function(sep, strs)\n",
       "{\n",
       "\treturn strs.join(sep);\n",
       "});\n",
       "\n",
       "var _String_slice = F3(function(start, end, str) {\n",
       "\treturn str.slice(start, end);\n",
       "});\n",
       "\n",
       "function _String_trim(str)\n",
       "{\n",
       "\treturn str.trim();\n",
       "}\n",
       "\n",
       "function _String_trimLeft(str)\n",
       "{\n",
       "\treturn str.replace(/^\\s+/, '');\n",
       "}\n",
       "\n",
       "function _String_trimRight(str)\n",
       "{\n",
       "\treturn str.replace(/\\s+$/, '');\n",
       "}\n",
       "\n",
       "function _String_words(str)\n",
       "{\n",
       "\treturn _List_fromArray(str.trim().split(/\\s+/g));\n",
       "}\n",
       "\n",
       "function _String_lines(str)\n",
       "{\n",
       "\treturn _List_fromArray(str.split(/\\r\\n|\\r|\\n/g));\n",
       "}\n",
       "\n",
       "function _String_toUpper(str)\n",
       "{\n",
       "\treturn str.toUpperCase();\n",
       "}\n",
       "\n",
       "function _String_toLower(str)\n",
       "{\n",
       "\treturn str.toLowerCase();\n",
       "}\n",
       "\n",
       "var _String_any = F2(function(isGood, string)\n",
       "{\n",
       "\tvar i = string.length;\n",
       "\twhile (i--)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xDC00 <= word && word <= 0xDFFF)\n",
       "\t\t{\n",
       "\t\t\ti--;\n",
       "\t\t\tchar = string[i] + char;\n",
       "\t\t}\n",
       "\t\tif (isGood(_Utils_chr(char)))\n",
       "\t\t{\n",
       "\t\t\treturn true;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn false;\n",
       "});\n",
       "\n",
       "var _String_all = F2(function(isGood, string)\n",
       "{\n",
       "\tvar i = string.length;\n",
       "\twhile (i--)\n",
       "\t{\n",
       "\t\tvar char = string[i];\n",
       "\t\tvar word = string.charCodeAt(i);\n",
       "\t\tif (0xDC00 <= word && word <= 0xDFFF)\n",
       "\t\t{\n",
       "\t\t\ti--;\n",
       "\t\t\tchar = string[i] + char;\n",
       "\t\t}\n",
       "\t\tif (!isGood(_Utils_chr(char)))\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn true;\n",
       "});\n",
       "\n",
       "var _String_contains = F2(function(sub, str)\n",
       "{\n",
       "\treturn str.indexOf(sub) > -1;\n",
       "});\n",
       "\n",
       "var _String_startsWith = F2(function(sub, str)\n",
       "{\n",
       "\treturn str.indexOf(sub) === 0;\n",
       "});\n",
       "\n",
       "var _String_endsWith = F2(function(sub, str)\n",
       "{\n",
       "\treturn str.length >= sub.length &&\n",
       "\t\tstr.lastIndexOf(sub) === str.length - sub.length;\n",
       "});\n",
       "\n",
       "var _String_indexes = F2(function(sub, str)\n",
       "{\n",
       "\tvar subLen = sub.length;\n",
       "\n",
       "\tif (subLen < 1)\n",
       "\t{\n",
       "\t\treturn _List_Nil;\n",
       "\t}\n",
       "\n",
       "\tvar i = 0;\n",
       "\tvar is = [];\n",
       "\n",
       "\twhile ((i = str.indexOf(sub, i)) > -1)\n",
       "\t{\n",
       "\t\tis.push(i);\n",
       "\t\ti = i + subLen;\n",
       "\t}\n",
       "\n",
       "\treturn _List_fromArray(is);\n",
       "});\n",
       "\n",
       "\n",
       "// TO STRING\n",
       "\n",
       "function _String_fromNumber(number)\n",
       "{\n",
       "\treturn number + '';\n",
       "}\n",
       "\n",
       "\n",
       "// INT CONVERSIONS\n",
       "\n",
       "function _String_toInt(str)\n",
       "{\n",
       "\tvar total = 0;\n",
       "\tvar code0 = str.charCodeAt(0);\n",
       "\tvar start = code0 == 0x2B /* + */ || code0 == 0x2D /* - */ ? 1 : 0;\n",
       "\n",
       "\tfor (var i = start; i < str.length; ++i)\n",
       "\t{\n",
       "\t\tvar code = str.charCodeAt(i);\n",
       "\t\tif (code < 0x30 || 0x39 < code)\n",
       "\t\t{\n",
       "\t\t\treturn $elm$core$Maybe$Nothing;\n",
       "\t\t}\n",
       "\t\ttotal = 10 * total + code - 0x30;\n",
       "\t}\n",
       "\n",
       "\treturn i == start\n",
       "\t\t? $elm$core$Maybe$Nothing\n",
       "\t\t: $elm$core$Maybe$Just(code0 == 0x2D ? -total : total);\n",
       "}\n",
       "\n",
       "\n",
       "// FLOAT CONVERSIONS\n",
       "\n",
       "function _String_toFloat(s)\n",
       "{\n",
       "\t// check if it is a hex, octal, or binary number\n",
       "\tif (s.length === 0 || /[\\sxbo]/.test(s))\n",
       "\t{\n",
       "\t\treturn $elm$core$Maybe$Nothing;\n",
       "\t}\n",
       "\tvar n = +s;\n",
       "\t// faster isNaN check\n",
       "\treturn n === n ? $elm$core$Maybe$Just(n) : $elm$core$Maybe$Nothing;\n",
       "}\n",
       "\n",
       "function _String_fromList(chars)\n",
       "{\n",
       "\treturn _List_toArray(chars).join('');\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "function _Char_toCode(char)\n",
       "{\n",
       "\tvar code = char.charCodeAt(0);\n",
       "\tif (0xD800 <= code && code <= 0xDBFF)\n",
       "\t{\n",
       "\t\treturn (code - 0xD800) * 0x400 + char.charCodeAt(1) - 0xDC00 + 0x10000\n",
       "\t}\n",
       "\treturn code;\n",
       "}\n",
       "\n",
       "function _Char_fromCode(code)\n",
       "{\n",
       "\treturn _Utils_chr(\n",
       "\t\t(code < 0 || 0x10FFFF < code)\n",
       "\t\t\t? '\\uFFFD'\n",
       "\t\t\t:\n",
       "\t\t(code <= 0xFFFF)\n",
       "\t\t\t? String.fromCharCode(code)\n",
       "\t\t\t:\n",
       "\t\t(code -= 0x10000,\n",
       "\t\t\tString.fromCharCode(Math.floor(code / 0x400) + 0xD800, code % 0x400 + 0xDC00)\n",
       "\t\t)\n",
       "\t);\n",
       "}\n",
       "\n",
       "function _Char_toUpper(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toUpperCase());\n",
       "}\n",
       "\n",
       "function _Char_toLower(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toLowerCase());\n",
       "}\n",
       "\n",
       "function _Char_toLocaleUpper(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toLocaleUpperCase());\n",
       "}\n",
       "\n",
       "function _Char_toLocaleLower(char)\n",
       "{\n",
       "\treturn _Utils_chr(char.toLocaleLowerCase());\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "/**/\n",
       "function _Json_errorToString(error)\n",
       "{\n",
       "\treturn $elm$json$Json$Decode$errorToString(error);\n",
       "}\n",
       "//*/\n",
       "\n",
       "\n",
       "// CORE DECODERS\n",
       "\n",
       "function _Json_succeed(msg)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 0,\n",
       "\t\ta: msg\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Json_fail(msg)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 1,\n",
       "\t\ta: msg\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Json_decodePrim(decoder)\n",
       "{\n",
       "\treturn { $: 2, b: decoder };\n",
       "}\n",
       "\n",
       "var _Json_decodeInt = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value !== 'number')\n",
       "\t\t? _Json_expecting('an INT', value)\n",
       "\t\t:\n",
       "\t(-2147483647 < value && value < 2147483647 && (value | 0) === value)\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t:\n",
       "\t(isFinite(value) && !(value % 1))\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: _Json_expecting('an INT', value);\n",
       "});\n",
       "\n",
       "var _Json_decodeBool = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value === 'boolean')\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: _Json_expecting('a BOOL', value);\n",
       "});\n",
       "\n",
       "var _Json_decodeFloat = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value === 'number')\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: _Json_expecting('a FLOAT', value);\n",
       "});\n",
       "\n",
       "var _Json_decodeValue = _Json_decodePrim(function(value) {\n",
       "\treturn $elm$core$Result$Ok(_Json_wrap(value));\n",
       "});\n",
       "\n",
       "var _Json_decodeString = _Json_decodePrim(function(value) {\n",
       "\treturn (typeof value === 'string')\n",
       "\t\t? $elm$core$Result$Ok(value)\n",
       "\t\t: (value instanceof String)\n",
       "\t\t\t? $elm$core$Result$Ok(value + '')\n",
       "\t\t\t: _Json_expecting('a STRING', value);\n",
       "});\n",
       "\n",
       "function _Json_decodeList(decoder) { return { $: 3, b: decoder }; }\n",
       "function _Json_decodeArray(decoder) { return { $: 4, b: decoder }; }\n",
       "\n",
       "function _Json_decodeNull(value) { return { $: 5, c: value }; }\n",
       "\n",
       "var _Json_decodeField = F2(function(field, decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 6,\n",
       "\t\td: field,\n",
       "\t\tb: decoder\n",
       "\t};\n",
       "});\n",
       "\n",
       "var _Json_decodeIndex = F2(function(index, decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 7,\n",
       "\t\te: index,\n",
       "\t\tb: decoder\n",
       "\t};\n",
       "});\n",
       "\n",
       "function _Json_decodeKeyValuePairs(decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 8,\n",
       "\t\tb: decoder\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Json_mapMany(f, decoders)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 9,\n",
       "\t\tf: f,\n",
       "\t\tg: decoders\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _Json_andThen = F2(function(callback, decoder)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 10,\n",
       "\t\tb: decoder,\n",
       "\t\th: callback\n",
       "\t};\n",
       "});\n",
       "\n",
       "function _Json_oneOf(decoders)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 11,\n",
       "\t\tg: decoders\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "// DECODING OBJECTS\n",
       "\n",
       "var _Json_map1 = F2(function(f, d1)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1]);\n",
       "});\n",
       "\n",
       "var _Json_map2 = F3(function(f, d1, d2)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2]);\n",
       "});\n",
       "\n",
       "var _Json_map3 = F4(function(f, d1, d2, d3)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3]);\n",
       "});\n",
       "\n",
       "var _Json_map4 = F5(function(f, d1, d2, d3, d4)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4]);\n",
       "});\n",
       "\n",
       "var _Json_map5 = F6(function(f, d1, d2, d3, d4, d5)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5]);\n",
       "});\n",
       "\n",
       "var _Json_map6 = F7(function(f, d1, d2, d3, d4, d5, d6)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5, d6]);\n",
       "});\n",
       "\n",
       "var _Json_map7 = F8(function(f, d1, d2, d3, d4, d5, d6, d7)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7]);\n",
       "});\n",
       "\n",
       "var _Json_map8 = F9(function(f, d1, d2, d3, d4, d5, d6, d7, d8)\n",
       "{\n",
       "\treturn _Json_mapMany(f, [d1, d2, d3, d4, d5, d6, d7, d8]);\n",
       "});\n",
       "\n",
       "\n",
       "// DECODE\n",
       "\n",
       "var _Json_runOnString = F2(function(decoder, string)\n",
       "{\n",
       "\ttry\n",
       "\t{\n",
       "\t\tvar value = JSON.parse(string);\n",
       "\t\treturn _Json_runHelp(decoder, value);\n",
       "\t}\n",
       "\tcatch (e)\n",
       "\t{\n",
       "\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'This is not valid JSON! ' + e.message, _Json_wrap(string)));\n",
       "\t}\n",
       "});\n",
       "\n",
       "var _Json_run = F2(function(decoder, value)\n",
       "{\n",
       "\treturn _Json_runHelp(decoder, _Json_unwrap(value));\n",
       "});\n",
       "\n",
       "function _Json_runHelp(decoder, value)\n",
       "{\n",
       "\tswitch (decoder.$)\n",
       "\t{\n",
       "\t\tcase 2:\n",
       "\t\t\treturn decoder.b(value);\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\treturn (value === null)\n",
       "\t\t\t\t? $elm$core$Result$Ok(decoder.c)\n",
       "\t\t\t\t: _Json_expecting('null', value);\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tif (!_Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('a LIST', value);\n",
       "\t\t\t}\n",
       "\t\t\treturn _Json_runArrayDecoder(decoder.b, value, _List_fromArray);\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\tif (!_Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an ARRAY', value);\n",
       "\t\t\t}\n",
       "\t\t\treturn _Json_runArrayDecoder(decoder.b, value, _Json_toElmArray);\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\tvar field = decoder.d;\n",
       "\t\t\tif (typeof value !== 'object' || value === null || !(field in value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an OBJECT with a field named `' + field + '`', value);\n",
       "\t\t\t}\n",
       "\t\t\tvar result = _Json_runHelp(decoder.b, value[field]);\n",
       "\t\t\treturn ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, field, result.a));\n",
       "\n",
       "\t\tcase 7:\n",
       "\t\t\tvar index = decoder.e;\n",
       "\t\t\tif (!_Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an ARRAY', value);\n",
       "\t\t\t}\n",
       "\t\t\tif (index >= value.length)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('a LONGER array. Need index ' + index + ' but only see ' + value.length + ' entries', value);\n",
       "\t\t\t}\n",
       "\t\t\tvar result = _Json_runHelp(decoder.b, value[index]);\n",
       "\t\t\treturn ($elm$core$Result$isOk(result)) ? result : $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, index, result.a));\n",
       "\n",
       "\t\tcase 8:\n",
       "\t\t\tif (typeof value !== 'object' || value === null || _Json_isArray(value))\n",
       "\t\t\t{\n",
       "\t\t\t\treturn _Json_expecting('an OBJECT', value);\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\tvar keyValuePairs = _List_Nil;\n",
       "\t\t\t// TODO test perf of Object.keys and switch when support is good enough\n",
       "\t\t\tfor (var key in value)\n",
       "\t\t\t{\n",
       "\t\t\t\tif (value.hasOwnProperty(key))\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\tvar result = _Json_runHelp(decoder.b, value[key]);\n",
       "\t\t\t\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t\t\t\t{\n",
       "\t\t\t\t\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Field, key, result.a));\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\t\tkeyValuePairs = _List_Cons(_Utils_Tuple2(key, result.a), keyValuePairs);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t\treturn $elm$core$Result$Ok($elm$core$List$reverse(keyValuePairs));\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\tvar answer = decoder.f;\n",
       "\t\t\tvar decoders = decoder.g;\n",
       "\t\t\tfor (var i = 0; i < decoders.length; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tvar result = _Json_runHelp(decoders[i], value);\n",
       "\t\t\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\treturn result;\n",
       "\t\t\t\t}\n",
       "\t\t\t\tanswer = answer(result.a);\n",
       "\t\t\t}\n",
       "\t\t\treturn $elm$core$Result$Ok(answer);\n",
       "\n",
       "\t\tcase 10:\n",
       "\t\t\tvar result = _Json_runHelp(decoder.b, value);\n",
       "\t\t\treturn (!$elm$core$Result$isOk(result))\n",
       "\t\t\t\t? result\n",
       "\t\t\t\t: _Json_runHelp(decoder.h(result.a), value);\n",
       "\n",
       "\t\tcase 11:\n",
       "\t\t\tvar errors = _List_Nil;\n",
       "\t\t\tfor (var temp = decoder.g; temp.b; temp = temp.b) // WHILE_CONS\n",
       "\t\t\t{\n",
       "\t\t\t\tvar result = _Json_runHelp(temp.a, value);\n",
       "\t\t\t\tif ($elm$core$Result$isOk(result))\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\treturn result;\n",
       "\t\t\t\t}\n",
       "\t\t\t\terrors = _List_Cons(result.a, errors);\n",
       "\t\t\t}\n",
       "\t\t\treturn $elm$core$Result$Err($elm$json$Json$Decode$OneOf($elm$core$List$reverse(errors)));\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, decoder.a, _Json_wrap(value)));\n",
       "\n",
       "\t\tcase 0:\n",
       "\t\t\treturn $elm$core$Result$Ok(decoder.a);\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Json_runArrayDecoder(decoder, value, toElmValue)\n",
       "{\n",
       "\tvar len = value.length;\n",
       "\tvar array = new Array(len);\n",
       "\tfor (var i = 0; i < len; i++)\n",
       "\t{\n",
       "\t\tvar result = _Json_runHelp(decoder, value[i]);\n",
       "\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t{\n",
       "\t\t\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Index, i, result.a));\n",
       "\t\t}\n",
       "\t\tarray[i] = result.a;\n",
       "\t}\n",
       "\treturn $elm$core$Result$Ok(toElmValue(array));\n",
       "}\n",
       "\n",
       "function _Json_isArray(value)\n",
       "{\n",
       "\treturn Array.isArray(value) || (typeof FileList !== 'undefined' && value instanceof FileList);\n",
       "}\n",
       "\n",
       "function _Json_toElmArray(array)\n",
       "{\n",
       "\treturn A2($elm$core$Array$initialize, array.length, function(i) { return array[i]; });\n",
       "}\n",
       "\n",
       "function _Json_expecting(type, value)\n",
       "{\n",
       "\treturn $elm$core$Result$Err(A2($elm$json$Json$Decode$Failure, 'Expecting ' + type, _Json_wrap(value)));\n",
       "}\n",
       "\n",
       "\n",
       "// EQUALITY\n",
       "\n",
       "function _Json_equality(x, y)\n",
       "{\n",
       "\tif (x === y)\n",
       "\t{\n",
       "\t\treturn true;\n",
       "\t}\n",
       "\n",
       "\tif (x.$ !== y.$)\n",
       "\t{\n",
       "\t\treturn false;\n",
       "\t}\n",
       "\n",
       "\tswitch (x.$)\n",
       "\t{\n",
       "\t\tcase 0:\n",
       "\t\tcase 1:\n",
       "\t\t\treturn x.a === y.a;\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\treturn x.b === y.b;\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\treturn x.c === y.c;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\tcase 4:\n",
       "\t\tcase 8:\n",
       "\t\t\treturn _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\treturn x.d === y.d && _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 7:\n",
       "\t\t\treturn x.e === y.e && _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\treturn x.f === y.f && _Json_listEquality(x.g, y.g);\n",
       "\n",
       "\t\tcase 10:\n",
       "\t\t\treturn x.h === y.h && _Json_equality(x.b, y.b);\n",
       "\n",
       "\t\tcase 11:\n",
       "\t\t\treturn _Json_listEquality(x.g, y.g);\n",
       "\t}\n",
       "}\n",
       "\n",
       "function _Json_listEquality(aDecoders, bDecoders)\n",
       "{\n",
       "\tvar len = aDecoders.length;\n",
       "\tif (len !== bDecoders.length)\n",
       "\t{\n",
       "\t\treturn false;\n",
       "\t}\n",
       "\tfor (var i = 0; i < len; i++)\n",
       "\t{\n",
       "\t\tif (!_Json_equality(aDecoders[i], bDecoders[i]))\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn true;\n",
       "}\n",
       "\n",
       "\n",
       "// ENCODE\n",
       "\n",
       "var _Json_encode = F2(function(indentLevel, value)\n",
       "{\n",
       "\treturn JSON.stringify(_Json_unwrap(value), null, indentLevel) + '';\n",
       "});\n",
       "\n",
       "function _Json_wrap(value) { return { $: 0, a: value }; }\n",
       "function _Json_unwrap(value) { return value.a; }\n",
       "\n",
       "function _Json_wrap_UNUSED(value) { return value; }\n",
       "function _Json_unwrap_UNUSED(value) { return value; }\n",
       "\n",
       "function _Json_emptyArray() { return []; }\n",
       "function _Json_emptyObject() { return {}; }\n",
       "\n",
       "var _Json_addField = F3(function(key, value, object)\n",
       "{\n",
       "\tobject[key] = _Json_unwrap(value);\n",
       "\treturn object;\n",
       "});\n",
       "\n",
       "function _Json_addEntry(func)\n",
       "{\n",
       "\treturn F2(function(entry, array)\n",
       "\t{\n",
       "\t\tarray.push(_Json_unwrap(func(entry)));\n",
       "\t\treturn array;\n",
       "\t});\n",
       "}\n",
       "\n",
       "var _Json_encodeNull = _Json_wrap(null);\n",
       "\n",
       "\n",
       "\n",
       "// TASKS\n",
       "\n",
       "function _Scheduler_succeed(value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 0,\n",
       "\t\ta: value\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Scheduler_fail(error)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 1,\n",
       "\t\ta: error\n",
       "\t};\n",
       "}\n",
       "\n",
       "function _Scheduler_binding(callback)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 2,\n",
       "\t\tb: callback,\n",
       "\t\tc: null\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _Scheduler_andThen = F2(function(callback, task)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 3,\n",
       "\t\tb: callback,\n",
       "\t\td: task\n",
       "\t};\n",
       "});\n",
       "\n",
       "var _Scheduler_onError = F2(function(callback, task)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 4,\n",
       "\t\tb: callback,\n",
       "\t\td: task\n",
       "\t};\n",
       "});\n",
       "\n",
       "function _Scheduler_receive(callback)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 5,\n",
       "\t\tb: callback\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "// PROCESSES\n",
       "\n",
       "var _Scheduler_guid = 0;\n",
       "\n",
       "function _Scheduler_rawSpawn(task)\n",
       "{\n",
       "\tvar proc = {\n",
       "\t\t$: 0,\n",
       "\t\te: _Scheduler_guid++,\n",
       "\t\tf: task,\n",
       "\t\tg: null,\n",
       "\t\th: []\n",
       "\t};\n",
       "\n",
       "\t_Scheduler_enqueue(proc);\n",
       "\n",
       "\treturn proc;\n",
       "}\n",
       "\n",
       "function _Scheduler_spawn(task)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\tcallback(_Scheduler_succeed(_Scheduler_rawSpawn(task)));\n",
       "\t});\n",
       "}\n",
       "\n",
       "function _Scheduler_rawSend(proc, msg)\n",
       "{\n",
       "\tproc.h.push(msg);\n",
       "\t_Scheduler_enqueue(proc);\n",
       "}\n",
       "\n",
       "var _Scheduler_send = F2(function(proc, msg)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\t_Scheduler_rawSend(proc, msg);\n",
       "\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t});\n",
       "});\n",
       "\n",
       "function _Scheduler_kill(proc)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\tvar task = proc.f;\n",
       "\t\tif (task.$ === 2 && task.c)\n",
       "\t\t{\n",
       "\t\t\ttask.c();\n",
       "\t\t}\n",
       "\n",
       "\t\tproc.f = null;\n",
       "\n",
       "\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t});\n",
       "}\n",
       "\n",
       "\n",
       "/* STEP PROCESSES\n",
       "\n",
       "type alias Process =\n",
       "  { $ : tag\n",
       "  , id : unique_id\n",
       "  , root : Task\n",
       "  , stack : null | { $: SUCCEED | FAIL, a: callback, b: stack }\n",
       "  , mailbox : [msg]\n",
       "  }\n",
       "\n",
       "*/\n",
       "\n",
       "\n",
       "var _Scheduler_working = false;\n",
       "var _Scheduler_queue = [];\n",
       "\n",
       "\n",
       "function _Scheduler_enqueue(proc)\n",
       "{\n",
       "\t_Scheduler_queue.push(proc);\n",
       "\tif (_Scheduler_working)\n",
       "\t{\n",
       "\t\treturn;\n",
       "\t}\n",
       "\t_Scheduler_working = true;\n",
       "\twhile (proc = _Scheduler_queue.shift())\n",
       "\t{\n",
       "\t\t_Scheduler_step(proc);\n",
       "\t}\n",
       "\t_Scheduler_working = false;\n",
       "}\n",
       "\n",
       "\n",
       "function _Scheduler_step(proc)\n",
       "{\n",
       "\twhile (proc.f)\n",
       "\t{\n",
       "\t\tvar rootTag = proc.f.$;\n",
       "\t\tif (rootTag === 0 || rootTag === 1)\n",
       "\t\t{\n",
       "\t\t\twhile (proc.g && proc.g.$ !== rootTag)\n",
       "\t\t\t{\n",
       "\t\t\t\tproc.g = proc.g.i;\n",
       "\t\t\t}\n",
       "\t\t\tif (!proc.g)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\t\t\tproc.f = proc.g.b(proc.f.a);\n",
       "\t\t\tproc.g = proc.g.i;\n",
       "\t\t}\n",
       "\t\telse if (rootTag === 2)\n",
       "\t\t{\n",
       "\t\t\tproc.f.c = proc.f.b(function(newRoot) {\n",
       "\t\t\t\tproc.f = newRoot;\n",
       "\t\t\t\t_Scheduler_enqueue(proc);\n",
       "\t\t\t});\n",
       "\t\t\treturn;\n",
       "\t\t}\n",
       "\t\telse if (rootTag === 5)\n",
       "\t\t{\n",
       "\t\t\tif (proc.h.length === 0)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\t\t\tproc.f = proc.f.b(proc.h.shift());\n",
       "\t\t}\n",
       "\t\telse // if (rootTag === 3 || rootTag === 4)\n",
       "\t\t{\n",
       "\t\t\tproc.g = {\n",
       "\t\t\t\t$: rootTag === 3 ? 0 : 1,\n",
       "\t\t\t\tb: proc.f.b,\n",
       "\t\t\t\ti: proc.g\n",
       "\t\t\t};\n",
       "\t\t\tproc.f = proc.f.d;\n",
       "\t\t}\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "function _Process_sleep(time)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback) {\n",
       "\t\tvar id = setTimeout(function() {\n",
       "\t\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t\t}, time);\n",
       "\n",
       "\t\treturn function() { clearTimeout(id); };\n",
       "\t});\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "// PROGRAMS\n",
       "\n",
       "\n",
       "var _Platform_worker = F4(function(impl, flagDecoder, debugMetadata, args)\n",
       "{\n",
       "\treturn _Platform_initialize(\n",
       "\t\tflagDecoder,\n",
       "\t\targs,\n",
       "\t\timpl.init,\n",
       "\t\timpl.update,\n",
       "\t\timpl.subscriptions,\n",
       "\t\tfunction() { return function() {} }\n",
       "\t);\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// INITIALIZE A PROGRAM\n",
       "\n",
       "\n",
       "function _Platform_initialize(flagDecoder, args, init, update, subscriptions, stepperBuilder)\n",
       "{\n",
       "\tvar result = A2(_Json_run, flagDecoder, _Json_wrap(args ? args['flags'] : undefined));\n",
       "\t$elm$core$Result$isOk(result) || _Debug_crash(2 /**/, _Json_errorToString(result.a) /**/);\n",
       "\tvar managers = {};\n",
       "\tvar initPair = init(result.a);\n",
       "\tvar model = initPair.a;\n",
       "\tvar stepper = stepperBuilder(sendToApp, model);\n",
       "\tvar ports = _Platform_setupEffects(managers, sendToApp);\n",
       "\n",
       "\tfunction sendToApp(msg, viewMetadata)\n",
       "\t{\n",
       "\t\tvar pair = A2(update, msg, model);\n",
       "\t\tstepper(model = pair.a, viewMetadata);\n",
       "\t\t_Platform_enqueueEffects(managers, pair.b, subscriptions(model));\n",
       "\t}\n",
       "\n",
       "\t_Platform_enqueueEffects(managers, initPair.b, subscriptions(model));\n",
       "\n",
       "\treturn ports ? { ports: ports } : {};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// TRACK PRELOADS\n",
       "//\n",
       "// This is used by code in elm/browser and elm/http\n",
       "// to register any HTTP requests that are triggered by init.\n",
       "//\n",
       "\n",
       "\n",
       "var _Platform_preload;\n",
       "\n",
       "\n",
       "function _Platform_registerPreload(url)\n",
       "{\n",
       "\t_Platform_preload.add(url);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// EFFECT MANAGERS\n",
       "\n",
       "\n",
       "var _Platform_effectManagers = {};\n",
       "\n",
       "\n",
       "function _Platform_setupEffects(managers, sendToApp)\n",
       "{\n",
       "\tvar ports;\n",
       "\n",
       "\t// setup all necessary effect managers\n",
       "\tfor (var key in _Platform_effectManagers)\n",
       "\t{\n",
       "\t\tvar manager = _Platform_effectManagers[key];\n",
       "\n",
       "\t\tif (manager.a)\n",
       "\t\t{\n",
       "\t\t\tports = ports || {};\n",
       "\t\t\tports[key] = manager.a(key, sendToApp);\n",
       "\t\t}\n",
       "\n",
       "\t\tmanagers[key] = _Platform_instantiateManager(manager, sendToApp);\n",
       "\t}\n",
       "\n",
       "\treturn ports;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_createManager(init, onEffects, onSelfMsg, cmdMap, subMap)\n",
       "{\n",
       "\treturn {\n",
       "\t\tb: init,\n",
       "\t\tc: onEffects,\n",
       "\t\td: onSelfMsg,\n",
       "\t\te: cmdMap,\n",
       "\t\tf: subMap\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_instantiateManager(info, sendToApp)\n",
       "{\n",
       "\tvar router = {\n",
       "\t\tg: sendToApp,\n",
       "\t\th: undefined\n",
       "\t};\n",
       "\n",
       "\tvar onEffects = info.c;\n",
       "\tvar onSelfMsg = info.d;\n",
       "\tvar cmdMap = info.e;\n",
       "\tvar subMap = info.f;\n",
       "\n",
       "\tfunction loop(state)\n",
       "\t{\n",
       "\t\treturn A2(_Scheduler_andThen, loop, _Scheduler_receive(function(msg)\n",
       "\t\t{\n",
       "\t\t\tvar value = msg.a;\n",
       "\n",
       "\t\t\tif (msg.$ === 0)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn A3(onSelfMsg, router, value, state);\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\treturn cmdMap && subMap\n",
       "\t\t\t\t? A4(onEffects, router, value.i, value.j, state)\n",
       "\t\t\t\t: A3(onEffects, router, cmdMap ? value.i : value.j, state);\n",
       "\t\t}));\n",
       "\t}\n",
       "\n",
       "\treturn router.h = _Scheduler_rawSpawn(A2(_Scheduler_andThen, loop, info.b));\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// ROUTING\n",
       "\n",
       "\n",
       "var _Platform_sendToApp = F2(function(router, msg)\n",
       "{\n",
       "\treturn _Scheduler_binding(function(callback)\n",
       "\t{\n",
       "\t\trouter.g(msg);\n",
       "\t\tcallback(_Scheduler_succeed(_Utils_Tuple0));\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "var _Platform_sendToSelf = F2(function(router, msg)\n",
       "{\n",
       "\treturn A2(_Scheduler_send, router.h, {\n",
       "\t\t$: 0,\n",
       "\t\ta: msg\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// BAGS\n",
       "\n",
       "\n",
       "function _Platform_leaf(home)\n",
       "{\n",
       "\treturn function(value)\n",
       "\t{\n",
       "\t\treturn {\n",
       "\t\t\t$: 1,\n",
       "\t\t\tk: home,\n",
       "\t\t\tl: value\n",
       "\t\t};\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_batch(list)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 2,\n",
       "\t\tm: list\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "var _Platform_map = F2(function(tagger, bag)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 3,\n",
       "\t\tn: tagger,\n",
       "\t\to: bag\n",
       "\t}\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// PIPE BAGS INTO EFFECT MANAGERS\n",
       "//\n",
       "// Effects must be queued!\n",
       "//\n",
       "// Say your init contains a synchronous command, like Time.now or Time.here\n",
       "//\n",
       "//   - This will produce a batch of effects (FX_1)\n",
       "//   - The synchronous task triggers the subsequent `update` call\n",
       "//   - This will produce a batch of effects (FX_2)\n",
       "//\n",
       "// If we just start dispatching FX_2, subscriptions from FX_2 can be processed\n",
       "// before subscriptions from FX_1. No good! Earlier versions of this code had\n",
       "// this problem, leading to these reports:\n",
       "//\n",
       "//   https://github.com/elm/core/issues/980\n",
       "//   https://github.com/elm/core/pull/981\n",
       "//   https://github.com/elm/compiler/issues/1776\n",
       "//\n",
       "// The queue is necessary to avoid ordering issues for synchronous commands.\n",
       "\n",
       "\n",
       "// Why use true/false here? Why not just check the length of the queue?\n",
       "// The goal is to detect \"are we currently dispatching effects?\" If we\n",
       "// are, we need to bail and let the ongoing while loop handle things.\n",
       "//\n",
       "// Now say the queue has 1 element. When we dequeue the final element,\n",
       "// the queue will be empty, but we are still actively dispatching effects.\n",
       "// So you could get queue jumping in a really tricky category of cases.\n",
       "//\n",
       "var _Platform_effectsQueue = [];\n",
       "var _Platform_effectsActive = false;\n",
       "\n",
       "\n",
       "function _Platform_enqueueEffects(managers, cmdBag, subBag)\n",
       "{\n",
       "\t_Platform_effectsQueue.push({ p: managers, q: cmdBag, r: subBag });\n",
       "\n",
       "\tif (_Platform_effectsActive) return;\n",
       "\n",
       "\t_Platform_effectsActive = true;\n",
       "\tfor (var fx; fx = _Platform_effectsQueue.shift(); )\n",
       "\t{\n",
       "\t\t_Platform_dispatchEffects(fx.p, fx.q, fx.r);\n",
       "\t}\n",
       "\t_Platform_effectsActive = false;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_dispatchEffects(managers, cmdBag, subBag)\n",
       "{\n",
       "\tvar effectsDict = {};\n",
       "\t_Platform_gatherEffects(true, cmdBag, effectsDict, null);\n",
       "\t_Platform_gatherEffects(false, subBag, effectsDict, null);\n",
       "\n",
       "\tfor (var home in managers)\n",
       "\t{\n",
       "\t\t_Scheduler_rawSend(managers[home], {\n",
       "\t\t\t$: 'fx',\n",
       "\t\t\ta: effectsDict[home] || { i: _List_Nil, j: _List_Nil }\n",
       "\t\t});\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_gatherEffects(isCmd, bag, effectsDict, taggers)\n",
       "{\n",
       "\tswitch (bag.$)\n",
       "\t{\n",
       "\t\tcase 1:\n",
       "\t\t\tvar home = bag.k;\n",
       "\t\t\tvar effect = _Platform_toEffect(isCmd, home, taggers, bag.l);\n",
       "\t\t\teffectsDict[home] = _Platform_insert(isCmd, effect, effectsDict[home]);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\tfor (var list = bag.m; list.b; list = list.b) // WHILE_CONS\n",
       "\t\t\t{\n",
       "\t\t\t\t_Platform_gatherEffects(isCmd, list.a, effectsDict, taggers);\n",
       "\t\t\t}\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\t_Platform_gatherEffects(isCmd, bag.o, effectsDict, {\n",
       "\t\t\t\ts: bag.n,\n",
       "\t\t\t\tt: taggers\n",
       "\t\t\t});\n",
       "\t\t\treturn;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_toEffect(isCmd, home, taggers, value)\n",
       "{\n",
       "\tfunction applyTaggers(x)\n",
       "\t{\n",
       "\t\tfor (var temp = taggers; temp; temp = temp.t)\n",
       "\t\t{\n",
       "\t\t\tx = temp.s(x);\n",
       "\t\t}\n",
       "\t\treturn x;\n",
       "\t}\n",
       "\n",
       "\tvar map = isCmd\n",
       "\t\t? _Platform_effectManagers[home].e\n",
       "\t\t: _Platform_effectManagers[home].f;\n",
       "\n",
       "\treturn A2(map, applyTaggers, value)\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_insert(isCmd, newEffect, effects)\n",
       "{\n",
       "\teffects = effects || { i: _List_Nil, j: _List_Nil };\n",
       "\n",
       "\tisCmd\n",
       "\t\t? (effects.i = _List_Cons(newEffect, effects.i))\n",
       "\t\t: (effects.j = _List_Cons(newEffect, effects.j));\n",
       "\n",
       "\treturn effects;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// PORTS\n",
       "\n",
       "\n",
       "function _Platform_checkPortName(name)\n",
       "{\n",
       "\tif (_Platform_effectManagers[name])\n",
       "\t{\n",
       "\t\t_Debug_crash(3, name)\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// OUTGOING PORTS\n",
       "\n",
       "\n",
       "function _Platform_outgoingPort(name, converter)\n",
       "{\n",
       "\t_Platform_checkPortName(name);\n",
       "\t_Platform_effectManagers[name] = {\n",
       "\t\te: _Platform_outgoingPortMap,\n",
       "\t\tu: converter,\n",
       "\t\ta: _Platform_setupOutgoingPort\n",
       "\t};\n",
       "\treturn _Platform_leaf(name);\n",
       "}\n",
       "\n",
       "\n",
       "var _Platform_outgoingPortMap = F2(function(tagger, value) { return value; });\n",
       "\n",
       "\n",
       "function _Platform_setupOutgoingPort(name)\n",
       "{\n",
       "\tvar subs = [];\n",
       "\tvar converter = _Platform_effectManagers[name].u;\n",
       "\n",
       "\t// CREATE MANAGER\n",
       "\n",
       "\tvar init = _Process_sleep(0);\n",
       "\n",
       "\t_Platform_effectManagers[name].b = init;\n",
       "\t_Platform_effectManagers[name].c = F3(function(router, cmdList, state)\n",
       "\t{\n",
       "\t\tfor ( ; cmdList.b; cmdList = cmdList.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\t// grab a separate reference to subs in case unsubscribe is called\n",
       "\t\t\tvar currentSubs = subs;\n",
       "\t\t\tvar value = _Json_unwrap(converter(cmdList.a));\n",
       "\t\t\tfor (var i = 0; i < currentSubs.length; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tcurrentSubs[i](value);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\treturn init;\n",
       "\t});\n",
       "\n",
       "\t// PUBLIC API\n",
       "\n",
       "\tfunction subscribe(callback)\n",
       "\t{\n",
       "\t\tsubs.push(callback);\n",
       "\t}\n",
       "\n",
       "\tfunction unsubscribe(callback)\n",
       "\t{\n",
       "\t\t// copy subs into a new array in case unsubscribe is called within a\n",
       "\t\t// subscribed callback\n",
       "\t\tsubs = subs.slice();\n",
       "\t\tvar index = subs.indexOf(callback);\n",
       "\t\tif (index >= 0)\n",
       "\t\t{\n",
       "\t\t\tsubs.splice(index, 1);\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn {\n",
       "\t\tsubscribe: subscribe,\n",
       "\t\tunsubscribe: unsubscribe\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// INCOMING PORTS\n",
       "\n",
       "\n",
       "function _Platform_incomingPort(name, converter)\n",
       "{\n",
       "\t_Platform_checkPortName(name);\n",
       "\t_Platform_effectManagers[name] = {\n",
       "\t\tf: _Platform_incomingPortMap,\n",
       "\t\tu: converter,\n",
       "\t\ta: _Platform_setupIncomingPort\n",
       "\t};\n",
       "\treturn _Platform_leaf(name);\n",
       "}\n",
       "\n",
       "\n",
       "var _Platform_incomingPortMap = F2(function(tagger, finalTagger)\n",
       "{\n",
       "\treturn function(value)\n",
       "\t{\n",
       "\t\treturn tagger(finalTagger(value));\n",
       "\t};\n",
       "});\n",
       "\n",
       "\n",
       "function _Platform_setupIncomingPort(name, sendToApp)\n",
       "{\n",
       "\tvar subs = _List_Nil;\n",
       "\tvar converter = _Platform_effectManagers[name].u;\n",
       "\n",
       "\t// CREATE MANAGER\n",
       "\n",
       "\tvar init = _Scheduler_succeed(null);\n",
       "\n",
       "\t_Platform_effectManagers[name].b = init;\n",
       "\t_Platform_effectManagers[name].c = F3(function(router, subList, state)\n",
       "\t{\n",
       "\t\tsubs = subList;\n",
       "\t\treturn init;\n",
       "\t});\n",
       "\n",
       "\t// PUBLIC API\n",
       "\n",
       "\tfunction send(incomingValue)\n",
       "\t{\n",
       "\t\tvar result = A2(_Json_run, converter, _Json_wrap(incomingValue));\n",
       "\n",
       "\t\t$elm$core$Result$isOk(result) || _Debug_crash(4, name, result.a);\n",
       "\n",
       "\t\tvar value = result.a;\n",
       "\t\tfor (var temp = subs; temp.b; temp = temp.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\tsendToApp(temp.a(value));\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn { send: send };\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// EXPORT ELM MODULES\n",
       "//\n",
       "// Have DEBUG and PROD versions so that we can (1) give nicer errors in\n",
       "// debug mode and (2) not pay for the bits needed for that in prod mode.\n",
       "//\n",
       "\n",
       "\n",
       "function _Platform_export_UNUSED(exports)\n",
       "{\n",
       "\tscope['Elm']\n",
       "\t\t? _Platform_mergeExportsProd(scope['Elm'], exports)\n",
       "\t\t: scope['Elm'] = exports;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_mergeExportsProd(obj, exports)\n",
       "{\n",
       "\tfor (var name in exports)\n",
       "\t{\n",
       "\t\t(name in obj)\n",
       "\t\t\t? (name == 'init')\n",
       "\t\t\t\t? _Debug_crash(6)\n",
       "\t\t\t\t: _Platform_mergeExportsProd(obj[name], exports[name])\n",
       "\t\t\t: (obj[name] = exports[name]);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_export(exports)\n",
       "{\n",
       "\tscope['Elm']\n",
       "\t\t? _Platform_mergeExportsDebug('Elm', scope['Elm'], exports)\n",
       "\t\t: scope['Elm'] = exports;\n",
       "}\n",
       "\n",
       "\n",
       "function _Platform_mergeExportsDebug(moduleName, obj, exports)\n",
       "{\n",
       "\tfor (var name in exports)\n",
       "\t{\n",
       "\t\t(name in obj)\n",
       "\t\t\t? (name == 'init')\n",
       "\t\t\t\t? _Debug_crash(6, moduleName)\n",
       "\t\t\t\t: _Platform_mergeExportsDebug(moduleName + '.' + name, obj[name], exports[name])\n",
       "\t\t\t: (obj[name] = exports[name]);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "\n",
       "// HELPERS\n",
       "\n",
       "\n",
       "var _VirtualDom_divertHrefToApp;\n",
       "\n",
       "var _VirtualDom_doc = typeof document !== 'undefined' ? document : {};\n",
       "\n",
       "\n",
       "function _VirtualDom_appendChild(parent, child)\n",
       "{\n",
       "\tparent.appendChild(child);\n",
       "}\n",
       "\n",
       "var _VirtualDom_init = F4(function(virtualNode, flagDecoder, debugMetadata, args)\n",
       "{\n",
       "\t// NOTE: this function needs _Platform_export available to work\n",
       "\n",
       "\t/**_UNUSED/\n",
       "\tvar node = args['node'];\n",
       "\t//*/\n",
       "\t/**/\n",
       "\tvar node = args && args['node'] ? args['node'] : _Debug_crash(0);\n",
       "\t//*/\n",
       "\n",
       "\tnode.parentNode.replaceChild(\n",
       "\t\t_VirtualDom_render(virtualNode, function() {}),\n",
       "\t\tnode\n",
       "\t);\n",
       "\n",
       "\treturn {};\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// TEXT\n",
       "\n",
       "\n",
       "function _VirtualDom_text(string)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 0,\n",
       "\t\ta: string\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// NODE\n",
       "\n",
       "\n",
       "var _VirtualDom_nodeNS = F2(function(namespace, tag)\n",
       "{\n",
       "\treturn F2(function(factList, kidList)\n",
       "\t{\n",
       "\t\tfor (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\tvar kid = kidList.a;\n",
       "\t\t\tdescendantsCount += (kid.b || 0);\n",
       "\t\t\tkids.push(kid);\n",
       "\t\t}\n",
       "\t\tdescendantsCount += kids.length;\n",
       "\n",
       "\t\treturn {\n",
       "\t\t\t$: 1,\n",
       "\t\t\tc: tag,\n",
       "\t\t\td: _VirtualDom_organizeFacts(factList),\n",
       "\t\t\te: kids,\n",
       "\t\t\tf: namespace,\n",
       "\t\t\tb: descendantsCount\n",
       "\t\t};\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "var _VirtualDom_node = _VirtualDom_nodeNS(undefined);\n",
       "\n",
       "\n",
       "\n",
       "// KEYED NODE\n",
       "\n",
       "\n",
       "var _VirtualDom_keyedNodeNS = F2(function(namespace, tag)\n",
       "{\n",
       "\treturn F2(function(factList, kidList)\n",
       "\t{\n",
       "\t\tfor (var kids = [], descendantsCount = 0; kidList.b; kidList = kidList.b) // WHILE_CONS\n",
       "\t\t{\n",
       "\t\t\tvar kid = kidList.a;\n",
       "\t\t\tdescendantsCount += (kid.b.b || 0);\n",
       "\t\t\tkids.push(kid);\n",
       "\t\t}\n",
       "\t\tdescendantsCount += kids.length;\n",
       "\n",
       "\t\treturn {\n",
       "\t\t\t$: 2,\n",
       "\t\t\tc: tag,\n",
       "\t\t\td: _VirtualDom_organizeFacts(factList),\n",
       "\t\t\te: kids,\n",
       "\t\t\tf: namespace,\n",
       "\t\t\tb: descendantsCount\n",
       "\t\t};\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "var _VirtualDom_keyedNode = _VirtualDom_keyedNodeNS(undefined);\n",
       "\n",
       "\n",
       "\n",
       "// CUSTOM\n",
       "\n",
       "\n",
       "function _VirtualDom_custom(factList, model, render, diff)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 3,\n",
       "\t\td: _VirtualDom_organizeFacts(factList),\n",
       "\t\tg: model,\n",
       "\t\th: render,\n",
       "\t\ti: diff\n",
       "\t};\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// MAP\n",
       "\n",
       "\n",
       "var _VirtualDom_map = F2(function(tagger, node)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 4,\n",
       "\t\tj: tagger,\n",
       "\t\tk: node,\n",
       "\t\tb: 1 + (node.b || 0)\n",
       "\t};\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// LAZY\n",
       "\n",
       "\n",
       "function _VirtualDom_thunk(refs, thunk)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 5,\n",
       "\t\tl: refs,\n",
       "\t\tm: thunk,\n",
       "\t\tk: undefined\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _VirtualDom_lazy = F2(function(func, a)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a], function() {\n",
       "\t\treturn func(a);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy2 = F3(function(func, a, b)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b], function() {\n",
       "\t\treturn A2(func, a, b);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy3 = F4(function(func, a, b, c)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c], function() {\n",
       "\t\treturn A3(func, a, b, c);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy4 = F5(function(func, a, b, c, d)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d], function() {\n",
       "\t\treturn A4(func, a, b, c, d);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy5 = F6(function(func, a, b, c, d, e)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e], function() {\n",
       "\t\treturn A5(func, a, b, c, d, e);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy6 = F7(function(func, a, b, c, d, e, f)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e, f], function() {\n",
       "\t\treturn A6(func, a, b, c, d, e, f);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy7 = F8(function(func, a, b, c, d, e, f, g)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e, f, g], function() {\n",
       "\t\treturn A7(func, a, b, c, d, e, f, g);\n",
       "\t});\n",
       "});\n",
       "\n",
       "var _VirtualDom_lazy8 = F9(function(func, a, b, c, d, e, f, g, h)\n",
       "{\n",
       "\treturn _VirtualDom_thunk([func, a, b, c, d, e, f, g, h], function() {\n",
       "\t\treturn A8(func, a, b, c, d, e, f, g, h);\n",
       "\t});\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// FACTS\n",
       "\n",
       "\n",
       "var _VirtualDom_on = F2(function(key, handler)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a0',\n",
       "\t\tn: key,\n",
       "\t\to: handler\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_style = F2(function(key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a1',\n",
       "\t\tn: key,\n",
       "\t\to: value\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_property = F2(function(key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a2',\n",
       "\t\tn: key,\n",
       "\t\to: value\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_attribute = F2(function(key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a3',\n",
       "\t\tn: key,\n",
       "\t\to: value\n",
       "\t};\n",
       "});\n",
       "var _VirtualDom_attributeNS = F3(function(namespace, key, value)\n",
       "{\n",
       "\treturn {\n",
       "\t\t$: 'a4',\n",
       "\t\tn: key,\n",
       "\t\to: { f: namespace, o: value }\n",
       "\t};\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// XSS ATTACK VECTOR CHECKS\n",
       "\n",
       "\n",
       "function _VirtualDom_noScript(tag)\n",
       "{\n",
       "\treturn tag == 'script' ? 'p' : tag;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noOnOrFormAction(key)\n",
       "{\n",
       "\treturn /^(on|formAction$)/i.test(key) ? 'data-' + key : key;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noInnerHtmlOrFormAction(key)\n",
       "{\n",
       "\treturn key == 'innerHTML' || key == 'formAction' ? 'data-' + key : key;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptUri_UNUSED(value)\n",
       "{\n",
       "\treturn /^javascript:/i.test(value.replace(/\\s/g,'')) ? '' : value;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptUri(value)\n",
       "{\n",
       "\treturn /^javascript:/i.test(value.replace(/\\s/g,''))\n",
       "\t\t? 'javascript:alert(\"This is an XSS vector. Please use ports or web components instead.\")'\n",
       "\t\t: value;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptOrHtmlUri_UNUSED(value)\n",
       "{\n",
       "\treturn /^\\s*(javascript:|data:text\\/html)/i.test(value) ? '' : value;\n",
       "}\n",
       "\n",
       "function _VirtualDom_noJavaScriptOrHtmlUri(value)\n",
       "{\n",
       "\treturn /^\\s*(javascript:|data:text\\/html)/i.test(value)\n",
       "\t\t? 'javascript:alert(\"This is an XSS vector. Please use ports or web components instead.\")'\n",
       "\t\t: value;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// MAP FACTS\n",
       "\n",
       "\n",
       "var _VirtualDom_mapAttribute = F2(function(func, attr)\n",
       "{\n",
       "\treturn (attr.$ === 'a0')\n",
       "\t\t? A2(_VirtualDom_on, attr.n, _VirtualDom_mapHandler(func, attr.o))\n",
       "\t\t: attr;\n",
       "});\n",
       "\n",
       "function _VirtualDom_mapHandler(func, handler)\n",
       "{\n",
       "\tvar tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);\n",
       "\n",
       "\t// 0 = Normal\n",
       "\t// 1 = MayStopPropagation\n",
       "\t// 2 = MayPreventDefault\n",
       "\t// 3 = Custom\n",
       "\n",
       "\treturn {\n",
       "\t\t$: handler.$,\n",
       "\t\ta:\n",
       "\t\t\t!tag\n",
       "\t\t\t\t? A2($elm$json$Json$Decode$map, func, handler.a)\n",
       "\t\t\t\t:\n",
       "\t\t\tA3($elm$json$Json$Decode$map2,\n",
       "\t\t\t\ttag < 3\n",
       "\t\t\t\t\t? _VirtualDom_mapEventTuple\n",
       "\t\t\t\t\t: _VirtualDom_mapEventRecord,\n",
       "\t\t\t\t$elm$json$Json$Decode$succeed(func),\n",
       "\t\t\t\thandler.a\n",
       "\t\t\t)\n",
       "\t};\n",
       "}\n",
       "\n",
       "var _VirtualDom_mapEventTuple = F2(function(func, tuple)\n",
       "{\n",
       "\treturn _Utils_Tuple2(func(tuple.a), tuple.b);\n",
       "});\n",
       "\n",
       "var _VirtualDom_mapEventRecord = F2(function(func, record)\n",
       "{\n",
       "\treturn {\n",
       "\t\tmessage: func(record.message),\n",
       "\t\tstopPropagation: record.stopPropagation,\n",
       "\t\tpreventDefault: record.preventDefault\n",
       "\t}\n",
       "});\n",
       "\n",
       "\n",
       "\n",
       "// ORGANIZE FACTS\n",
       "\n",
       "\n",
       "function _VirtualDom_organizeFacts(factList)\n",
       "{\n",
       "\tfor (var facts = {}; factList.b; factList = factList.b) // WHILE_CONS\n",
       "\t{\n",
       "\t\tvar entry = factList.a;\n",
       "\n",
       "\t\tvar tag = entry.$;\n",
       "\t\tvar key = entry.n;\n",
       "\t\tvar value = entry.o;\n",
       "\n",
       "\t\tif (tag === 'a2')\n",
       "\t\t{\n",
       "\t\t\t(key === 'className')\n",
       "\t\t\t\t? _VirtualDom_addClass(facts, key, _Json_unwrap(value))\n",
       "\t\t\t\t: facts[key] = _Json_unwrap(value);\n",
       "\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar subFacts = facts[tag] || (facts[tag] = {});\n",
       "\t\t(tag === 'a3' && key === 'class')\n",
       "\t\t\t? _VirtualDom_addClass(subFacts, key, value)\n",
       "\t\t\t: subFacts[key] = value;\n",
       "\t}\n",
       "\n",
       "\treturn facts;\n",
       "}\n",
       "\n",
       "function _VirtualDom_addClass(object, key, newClass)\n",
       "{\n",
       "\tvar classes = object[key];\n",
       "\tobject[key] = classes ? classes + ' ' + newClass : newClass;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// RENDER\n",
       "\n",
       "\n",
       "function _VirtualDom_render(vNode, eventNode)\n",
       "{\n",
       "\tvar tag = vNode.$;\n",
       "\n",
       "\tif (tag === 5)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_render(vNode.k || (vNode.k = vNode.m()), eventNode);\n",
       "\t}\n",
       "\n",
       "\tif (tag === 0)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_doc.createTextNode(vNode.a);\n",
       "\t}\n",
       "\n",
       "\tif (tag === 4)\n",
       "\t{\n",
       "\t\tvar subNode = vNode.k;\n",
       "\t\tvar tagger = vNode.j;\n",
       "\n",
       "\t\twhile (subNode.$ === 4)\n",
       "\t\t{\n",
       "\t\t\ttypeof tagger !== 'object'\n",
       "\t\t\t\t? tagger = [tagger, subNode.j]\n",
       "\t\t\t\t: tagger.push(subNode.j);\n",
       "\n",
       "\t\t\tsubNode = subNode.k;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar subEventRoot = { j: tagger, p: eventNode };\n",
       "\t\tvar domNode = _VirtualDom_render(subNode, subEventRoot);\n",
       "\t\tdomNode.elm_event_node_ref = subEventRoot;\n",
       "\t\treturn domNode;\n",
       "\t}\n",
       "\n",
       "\tif (tag === 3)\n",
       "\t{\n",
       "\t\tvar domNode = vNode.h(vNode.g);\n",
       "\t\t_VirtualDom_applyFacts(domNode, eventNode, vNode.d);\n",
       "\t\treturn domNode;\n",
       "\t}\n",
       "\n",
       "\t// at this point `tag` must be 1 or 2\n",
       "\n",
       "\tvar domNode = vNode.f\n",
       "\t\t? _VirtualDom_doc.createElementNS(vNode.f, vNode.c)\n",
       "\t\t: _VirtualDom_doc.createElement(vNode.c);\n",
       "\n",
       "\tif (_VirtualDom_divertHrefToApp && vNode.c == 'a')\n",
       "\t{\n",
       "\t\tdomNode.addEventListener('click', _VirtualDom_divertHrefToApp(domNode));\n",
       "\t}\n",
       "\n",
       "\t_VirtualDom_applyFacts(domNode, eventNode, vNode.d);\n",
       "\n",
       "\tfor (var kids = vNode.e, i = 0; i < kids.length; i++)\n",
       "\t{\n",
       "\t\t_VirtualDom_appendChild(domNode, _VirtualDom_render(tag === 1 ? kids[i] : kids[i].b, eventNode));\n",
       "\t}\n",
       "\n",
       "\treturn domNode;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY FACTS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyFacts(domNode, eventNode, facts)\n",
       "{\n",
       "\tfor (var key in facts)\n",
       "\t{\n",
       "\t\tvar value = facts[key];\n",
       "\n",
       "\t\tkey === 'a1'\n",
       "\t\t\t? _VirtualDom_applyStyles(domNode, value)\n",
       "\t\t\t:\n",
       "\t\tkey === 'a0'\n",
       "\t\t\t? _VirtualDom_applyEvents(domNode, eventNode, value)\n",
       "\t\t\t:\n",
       "\t\tkey === 'a3'\n",
       "\t\t\t? _VirtualDom_applyAttrs(domNode, value)\n",
       "\t\t\t:\n",
       "\t\tkey === 'a4'\n",
       "\t\t\t? _VirtualDom_applyAttrsNS(domNode, value)\n",
       "\t\t\t:\n",
       "\t\t((key !== 'value' && key !== 'checked') || domNode[key] !== value) && (domNode[key] = value);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY STYLES\n",
       "\n",
       "\n",
       "function _VirtualDom_applyStyles(domNode, styles)\n",
       "{\n",
       "\tvar domNodeStyle = domNode.style;\n",
       "\n",
       "\tfor (var key in styles)\n",
       "\t{\n",
       "\t\tdomNodeStyle[key] = styles[key];\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY ATTRS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyAttrs(domNode, attrs)\n",
       "{\n",
       "\tfor (var key in attrs)\n",
       "\t{\n",
       "\t\tvar value = attrs[key];\n",
       "\t\ttypeof value !== 'undefined'\n",
       "\t\t\t? domNode.setAttribute(key, value)\n",
       "\t\t\t: domNode.removeAttribute(key);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY NAMESPACED ATTRS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyAttrsNS(domNode, nsAttrs)\n",
       "{\n",
       "\tfor (var key in nsAttrs)\n",
       "\t{\n",
       "\t\tvar pair = nsAttrs[key];\n",
       "\t\tvar namespace = pair.f;\n",
       "\t\tvar value = pair.o;\n",
       "\n",
       "\t\ttypeof value !== 'undefined'\n",
       "\t\t\t? domNode.setAttributeNS(namespace, key, value)\n",
       "\t\t\t: domNode.removeAttributeNS(namespace, key);\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY EVENTS\n",
       "\n",
       "\n",
       "function _VirtualDom_applyEvents(domNode, eventNode, events)\n",
       "{\n",
       "\tvar allCallbacks = domNode.elmFs || (domNode.elmFs = {});\n",
       "\n",
       "\tfor (var key in events)\n",
       "\t{\n",
       "\t\tvar newHandler = events[key];\n",
       "\t\tvar oldCallback = allCallbacks[key];\n",
       "\n",
       "\t\tif (!newHandler)\n",
       "\t\t{\n",
       "\t\t\tdomNode.removeEventListener(key, oldCallback);\n",
       "\t\t\tallCallbacks[key] = undefined;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tif (oldCallback)\n",
       "\t\t{\n",
       "\t\t\tvar oldHandler = oldCallback.q;\n",
       "\t\t\tif (oldHandler.$ === newHandler.$)\n",
       "\t\t\t{\n",
       "\t\t\t\toldCallback.q = newHandler;\n",
       "\t\t\t\tcontinue;\n",
       "\t\t\t}\n",
       "\t\t\tdomNode.removeEventListener(key, oldCallback);\n",
       "\t\t}\n",
       "\n",
       "\t\toldCallback = _VirtualDom_makeCallback(eventNode, newHandler);\n",
       "\t\tdomNode.addEventListener(key, oldCallback,\n",
       "\t\t\t_VirtualDom_passiveSupported\n",
       "\t\t\t&& { passive: $elm$virtual_dom$VirtualDom$toHandlerInt(newHandler) < 2 }\n",
       "\t\t);\n",
       "\t\tallCallbacks[key] = oldCallback;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// PASSIVE EVENTS\n",
       "\n",
       "\n",
       "var _VirtualDom_passiveSupported;\n",
       "\n",
       "try\n",
       "{\n",
       "\twindow.addEventListener('t', null, Object.defineProperty({}, 'passive', {\n",
       "\t\tget: function() { _VirtualDom_passiveSupported = true; }\n",
       "\t}));\n",
       "}\n",
       "catch(e) {}\n",
       "\n",
       "\n",
       "\n",
       "// EVENT HANDLERS\n",
       "\n",
       "\n",
       "function _VirtualDom_makeCallback(eventNode, initialHandler)\n",
       "{\n",
       "\tfunction callback(event)\n",
       "\t{\n",
       "\t\tvar handler = callback.q;\n",
       "\t\tvar result = _Json_runHelp(handler.a, event);\n",
       "\n",
       "\t\tif (!$elm$core$Result$isOk(result))\n",
       "\t\t{\n",
       "\t\t\treturn;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar tag = $elm$virtual_dom$VirtualDom$toHandlerInt(handler);\n",
       "\n",
       "\t\t// 0 = Normal\n",
       "\t\t// 1 = MayStopPropagation\n",
       "\t\t// 2 = MayPreventDefault\n",
       "\t\t// 3 = Custom\n",
       "\n",
       "\t\tvar value = result.a;\n",
       "\t\tvar message = !tag ? value : tag < 3 ? value.a : value.message;\n",
       "\t\tvar stopPropagation = tag == 1 ? value.b : tag == 3 && value.stopPropagation;\n",
       "\t\tvar currentEventNode = (\n",
       "\t\t\tstopPropagation && event.stopPropagation(),\n",
       "\t\t\t(tag == 2 ? value.b : tag == 3 && value.preventDefault) && event.preventDefault(),\n",
       "\t\t\teventNode\n",
       "\t\t);\n",
       "\t\tvar tagger;\n",
       "\t\tvar i;\n",
       "\t\twhile (tagger = currentEventNode.j)\n",
       "\t\t{\n",
       "\t\t\tif (typeof tagger == 'function')\n",
       "\t\t\t{\n",
       "\t\t\t\tmessage = tagger(message);\n",
       "\t\t\t}\n",
       "\t\t\telse\n",
       "\t\t\t{\n",
       "\t\t\t\tfor (var i = tagger.length; i--; )\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\tmessage = tagger[i](message);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t\tcurrentEventNode = currentEventNode.p;\n",
       "\t\t}\n",
       "\t\tcurrentEventNode(message, stopPropagation); // stopPropagation implies isSync\n",
       "\t}\n",
       "\n",
       "\tcallback.q = initialHandler;\n",
       "\n",
       "\treturn callback;\n",
       "}\n",
       "\n",
       "function _VirtualDom_equalEvents(x, y)\n",
       "{\n",
       "\treturn x.$ == y.$ && _Json_equality(x.a, y.a);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// DIFF\n",
       "\n",
       "\n",
       "// TODO: Should we do patches like in iOS?\n",
       "//\n",
       "// type Patch\n",
       "//   = At Int Patch\n",
       "//   | Batch (List Patch)\n",
       "//   | Change ...\n",
       "//\n",
       "// How could it not be better?\n",
       "//\n",
       "function _VirtualDom_diff(x, y)\n",
       "{\n",
       "\tvar patches = [];\n",
       "\t_VirtualDom_diffHelp(x, y, patches, 0);\n",
       "\treturn patches;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_pushPatch(patches, type, index, data)\n",
       "{\n",
       "\tvar patch = {\n",
       "\t\t$: type,\n",
       "\t\tr: index,\n",
       "\t\ts: data,\n",
       "\t\tt: undefined,\n",
       "\t\tu: undefined\n",
       "\t};\n",
       "\tpatches.push(patch);\n",
       "\treturn patch;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_diffHelp(x, y, patches, index)\n",
       "{\n",
       "\tif (x === y)\n",
       "\t{\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\tvar xType = x.$;\n",
       "\tvar yType = y.$;\n",
       "\n",
       "\t// Bail if you run into different types of nodes. Implies that the\n",
       "\t// structure has changed significantly and it's not worth a diff.\n",
       "\tif (xType !== yType)\n",
       "\t{\n",
       "\t\tif (xType === 1 && yType === 2)\n",
       "\t\t{\n",
       "\t\t\ty = _VirtualDom_dekey(y);\n",
       "\t\t\tyType = 1;\n",
       "\t\t}\n",
       "\t\telse\n",
       "\t\t{\n",
       "\t\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\t\treturn;\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\t// Now we know that both nodes are the same $.\n",
       "\tswitch (yType)\n",
       "\t{\n",
       "\t\tcase 5:\n",
       "\t\t\tvar xRefs = x.l;\n",
       "\t\t\tvar yRefs = y.l;\n",
       "\t\t\tvar i = xRefs.length;\n",
       "\t\t\tvar same = i === yRefs.length;\n",
       "\t\t\twhile (same && i--)\n",
       "\t\t\t{\n",
       "\t\t\t\tsame = xRefs[i] === yRefs[i];\n",
       "\t\t\t}\n",
       "\t\t\tif (same)\n",
       "\t\t\t{\n",
       "\t\t\t\ty.k = x.k;\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\t\t\ty.k = y.m();\n",
       "\t\t\tvar subPatches = [];\n",
       "\t\t\t_VirtualDom_diffHelp(x.k, y.k, subPatches, 0);\n",
       "\t\t\tsubPatches.length > 0 && _VirtualDom_pushPatch(patches, 1, index, subPatches);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\t// gather nested taggers\n",
       "\t\t\tvar xTaggers = x.j;\n",
       "\t\t\tvar yTaggers = y.j;\n",
       "\t\t\tvar nesting = false;\n",
       "\n",
       "\t\t\tvar xSubNode = x.k;\n",
       "\t\t\twhile (xSubNode.$ === 4)\n",
       "\t\t\t{\n",
       "\t\t\t\tnesting = true;\n",
       "\n",
       "\t\t\t\ttypeof xTaggers !== 'object'\n",
       "\t\t\t\t\t? xTaggers = [xTaggers, xSubNode.j]\n",
       "\t\t\t\t\t: xTaggers.push(xSubNode.j);\n",
       "\n",
       "\t\t\t\txSubNode = xSubNode.k;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\tvar ySubNode = y.k;\n",
       "\t\t\twhile (ySubNode.$ === 4)\n",
       "\t\t\t{\n",
       "\t\t\t\tnesting = true;\n",
       "\n",
       "\t\t\t\ttypeof yTaggers !== 'object'\n",
       "\t\t\t\t\t? yTaggers = [yTaggers, ySubNode.j]\n",
       "\t\t\t\t\t: yTaggers.push(ySubNode.j);\n",
       "\n",
       "\t\t\t\tySubNode = ySubNode.k;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\t// Just bail if different numbers of taggers. This implies the\n",
       "\t\t\t// structure of the virtual DOM has changed.\n",
       "\t\t\tif (nesting && xTaggers.length !== yTaggers.length)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\t// check if taggers are \"the same\"\n",
       "\t\t\tif (nesting ? !_VirtualDom_pairwiseRefEqual(xTaggers, yTaggers) : xTaggers !== yTaggers)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 2, index, yTaggers);\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\t// diff everything below the taggers\n",
       "\t\t\t_VirtualDom_diffHelp(xSubNode, ySubNode, patches, index + 1);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 0:\n",
       "\t\t\tif (x.a !== y.a)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 3, index, y.a);\n",
       "\t\t\t}\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\t_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKids);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\t_VirtualDom_diffNodes(x, y, patches, index, _VirtualDom_diffKeyedKids);\n",
       "\t\t\treturn;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tif (x.h !== y.h)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\t\t\treturn;\n",
       "\t\t\t}\n",
       "\n",
       "\t\t\tvar factsDiff = _VirtualDom_diffFacts(x.d, y.d);\n",
       "\t\t\tfactsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);\n",
       "\n",
       "\t\t\tvar patch = y.i(x.g, y.g);\n",
       "\t\t\tpatch && _VirtualDom_pushPatch(patches, 5, index, patch);\n",
       "\n",
       "\t\t\treturn;\n",
       "\t}\n",
       "}\n",
       "\n",
       "// assumes the incoming arrays are the same length\n",
       "function _VirtualDom_pairwiseRefEqual(as, bs)\n",
       "{\n",
       "\tfor (var i = 0; i < as.length; i++)\n",
       "\t{\n",
       "\t\tif (as[i] !== bs[i])\n",
       "\t\t{\n",
       "\t\t\treturn false;\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn true;\n",
       "}\n",
       "\n",
       "function _VirtualDom_diffNodes(x, y, patches, index, diffKids)\n",
       "{\n",
       "\t// Bail if obvious indicators have changed. Implies more serious\n",
       "\t// structural changes such that it's not worth it to diff.\n",
       "\tif (x.c !== y.c || x.f !== y.f)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 0, index, y);\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\tvar factsDiff = _VirtualDom_diffFacts(x.d, y.d);\n",
       "\tfactsDiff && _VirtualDom_pushPatch(patches, 4, index, factsDiff);\n",
       "\n",
       "\tdiffKids(x, y, patches, index);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// DIFF FACTS\n",
       "\n",
       "\n",
       "// TODO Instead of creating a new diff object, it's possible to just test if\n",
       "// there *is* a diff. During the actual patch, do the diff again and make the\n",
       "// modifications directly. This way, there's no new allocations. Worth it?\n",
       "function _VirtualDom_diffFacts(x, y, category)\n",
       "{\n",
       "\tvar diff;\n",
       "\n",
       "\t// look for changes and removals\n",
       "\tfor (var xKey in x)\n",
       "\t{\n",
       "\t\tif (xKey === 'a1' || xKey === 'a0' || xKey === 'a3' || xKey === 'a4')\n",
       "\t\t{\n",
       "\t\t\tvar subDiff = _VirtualDom_diffFacts(x[xKey], y[xKey] || {}, xKey);\n",
       "\t\t\tif (subDiff)\n",
       "\t\t\t{\n",
       "\t\t\t\tdiff = diff || {};\n",
       "\t\t\t\tdiff[xKey] = subDiff;\n",
       "\t\t\t}\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// remove if not in the new facts\n",
       "\t\tif (!(xKey in y))\n",
       "\t\t{\n",
       "\t\t\tdiff = diff || {};\n",
       "\t\t\tdiff[xKey] =\n",
       "\t\t\t\t!category\n",
       "\t\t\t\t\t? (typeof x[xKey] === 'string' ? '' : null)\n",
       "\t\t\t\t\t:\n",
       "\t\t\t\t(category === 'a1')\n",
       "\t\t\t\t\t? ''\n",
       "\t\t\t\t\t:\n",
       "\t\t\t\t(category === 'a0' || category === 'a3')\n",
       "\t\t\t\t\t? undefined\n",
       "\t\t\t\t\t:\n",
       "\t\t\t\t{ f: x[xKey].f, o: undefined };\n",
       "\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tvar xValue = x[xKey];\n",
       "\t\tvar yValue = y[xKey];\n",
       "\n",
       "\t\t// reference equal, so don't worry about it\n",
       "\t\tif (xValue === yValue && xKey !== 'value' && xKey !== 'checked'\n",
       "\t\t\t|| category === 'a0' && _VirtualDom_equalEvents(xValue, yValue))\n",
       "\t\t{\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tdiff = diff || {};\n",
       "\t\tdiff[xKey] = yValue;\n",
       "\t}\n",
       "\n",
       "\t// add new stuff\n",
       "\tfor (var yKey in y)\n",
       "\t{\n",
       "\t\tif (!(yKey in x))\n",
       "\t\t{\n",
       "\t\t\tdiff = diff || {};\n",
       "\t\t\tdiff[yKey] = y[yKey];\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\treturn diff;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// DIFF KIDS\n",
       "\n",
       "\n",
       "function _VirtualDom_diffKids(xParent, yParent, patches, index)\n",
       "{\n",
       "\tvar xKids = xParent.e;\n",
       "\tvar yKids = yParent.e;\n",
       "\n",
       "\tvar xLen = xKids.length;\n",
       "\tvar yLen = yKids.length;\n",
       "\n",
       "\t// FIGURE OUT IF THERE ARE INSERTS OR REMOVALS\n",
       "\n",
       "\tif (xLen > yLen)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 6, index, {\n",
       "\t\t\tv: yLen,\n",
       "\t\t\ti: xLen - yLen\n",
       "\t\t});\n",
       "\t}\n",
       "\telse if (xLen < yLen)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 7, index, {\n",
       "\t\t\tv: xLen,\n",
       "\t\t\te: yKids\n",
       "\t\t});\n",
       "\t}\n",
       "\n",
       "\t// PAIRWISE DIFF EVERYTHING ELSE\n",
       "\n",
       "\tfor (var minLen = xLen < yLen ? xLen : yLen, i = 0; i < minLen; i++)\n",
       "\t{\n",
       "\t\tvar xKid = xKids[i];\n",
       "\t\t_VirtualDom_diffHelp(xKid, yKids[i], patches, ++index);\n",
       "\t\tindex += xKid.b || 0;\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// KEYED DIFF\n",
       "\n",
       "\n",
       "function _VirtualDom_diffKeyedKids(xParent, yParent, patches, rootIndex)\n",
       "{\n",
       "\tvar localPatches = [];\n",
       "\n",
       "\tvar changes = {}; // Dict String Entry\n",
       "\tvar inserts = []; // Array { index : Int, entry : Entry }\n",
       "\t// type Entry = { tag : String, vnode : VNode, index : Int, data : _ }\n",
       "\n",
       "\tvar xKids = xParent.e;\n",
       "\tvar yKids = yParent.e;\n",
       "\tvar xLen = xKids.length;\n",
       "\tvar yLen = yKids.length;\n",
       "\tvar xIndex = 0;\n",
       "\tvar yIndex = 0;\n",
       "\n",
       "\tvar index = rootIndex;\n",
       "\n",
       "\twhile (xIndex < xLen && yIndex < yLen)\n",
       "\t{\n",
       "\t\tvar x = xKids[xIndex];\n",
       "\t\tvar y = yKids[yIndex];\n",
       "\n",
       "\t\tvar xKey = x.a;\n",
       "\t\tvar yKey = y.a;\n",
       "\t\tvar xNode = x.b;\n",
       "\t\tvar yNode = y.b;\n",
       "\n",
       "\t\tvar newMatch = undefined;\n",
       "\t\tvar oldMatch = undefined;\n",
       "\n",
       "\t\t// check if keys match\n",
       "\n",
       "\t\tif (xKey === yKey)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNode, yNode, localPatches, index);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\txIndex++;\n",
       "\t\t\tyIndex++;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// look ahead 1 to detect insertions and removals.\n",
       "\n",
       "\t\tvar xNext = xKids[xIndex + 1];\n",
       "\t\tvar yNext = yKids[yIndex + 1];\n",
       "\n",
       "\t\tif (xNext)\n",
       "\t\t{\n",
       "\t\t\tvar xNextKey = xNext.a;\n",
       "\t\t\tvar xNextNode = xNext.b;\n",
       "\t\t\toldMatch = yKey === xNextKey;\n",
       "\t\t}\n",
       "\n",
       "\t\tif (yNext)\n",
       "\t\t{\n",
       "\t\t\tvar yNextKey = yNext.a;\n",
       "\t\t\tvar yNextNode = yNext.b;\n",
       "\t\t\tnewMatch = xKey === yNextKey;\n",
       "\t\t}\n",
       "\n",
       "\n",
       "\t\t// swap x and y\n",
       "\t\tif (newMatch && oldMatch)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);\n",
       "\t\t\t_VirtualDom_insertNode(changes, localPatches, xKey, yNode, yIndex, inserts);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_removeNode(changes, localPatches, xKey, xNextNode, index);\n",
       "\t\t\tindex += xNextNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 2;\n",
       "\t\t\tyIndex += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// insert y\n",
       "\t\tif (newMatch)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);\n",
       "\t\t\t_VirtualDom_diffHelp(xNode, yNextNode, localPatches, index);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 1;\n",
       "\t\t\tyIndex += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// remove x\n",
       "\t\tif (oldMatch)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNextNode, yNode, localPatches, index);\n",
       "\t\t\tindex += xNextNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 2;\n",
       "\t\t\tyIndex += 1;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\t// remove x, insert y\n",
       "\t\tif (xNext && xNextKey === yNextKey)\n",
       "\t\t{\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_removeNode(changes, localPatches, xKey, xNode, index);\n",
       "\t\t\t_VirtualDom_insertNode(changes, localPatches, yKey, yNode, yIndex, inserts);\n",
       "\t\t\tindex += xNode.b || 0;\n",
       "\n",
       "\t\t\tindex++;\n",
       "\t\t\t_VirtualDom_diffHelp(xNextNode, yNextNode, localPatches, index);\n",
       "\t\t\tindex += xNextNode.b || 0;\n",
       "\n",
       "\t\t\txIndex += 2;\n",
       "\t\t\tyIndex += 2;\n",
       "\t\t\tcontinue;\n",
       "\t\t}\n",
       "\n",
       "\t\tbreak;\n",
       "\t}\n",
       "\n",
       "\t// eat up any remaining nodes with removeNode and insertNode\n",
       "\n",
       "\twhile (xIndex < xLen)\n",
       "\t{\n",
       "\t\tindex++;\n",
       "\t\tvar x = xKids[xIndex];\n",
       "\t\tvar xNode = x.b;\n",
       "\t\t_VirtualDom_removeNode(changes, localPatches, x.a, xNode, index);\n",
       "\t\tindex += xNode.b || 0;\n",
       "\t\txIndex++;\n",
       "\t}\n",
       "\n",
       "\twhile (yIndex < yLen)\n",
       "\t{\n",
       "\t\tvar endInserts = endInserts || [];\n",
       "\t\tvar y = yKids[yIndex];\n",
       "\t\t_VirtualDom_insertNode(changes, localPatches, y.a, y.b, undefined, endInserts);\n",
       "\t\tyIndex++;\n",
       "\t}\n",
       "\n",
       "\tif (localPatches.length > 0 || inserts.length > 0 || endInserts)\n",
       "\t{\n",
       "\t\t_VirtualDom_pushPatch(patches, 8, rootIndex, {\n",
       "\t\t\tw: localPatches,\n",
       "\t\t\tx: inserts,\n",
       "\t\t\ty: endInserts\n",
       "\t\t});\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// CHANGES FROM KEYED DIFF\n",
       "\n",
       "\n",
       "var _VirtualDom_POSTFIX = '_elmW6BL';\n",
       "\n",
       "\n",
       "function _VirtualDom_insertNode(changes, localPatches, key, vnode, yIndex, inserts)\n",
       "{\n",
       "\tvar entry = changes[key];\n",
       "\n",
       "\t// never seen this key before\n",
       "\tif (!entry)\n",
       "\t{\n",
       "\t\tentry = {\n",
       "\t\t\tc: 0,\n",
       "\t\t\tz: vnode,\n",
       "\t\t\tr: yIndex,\n",
       "\t\t\ts: undefined\n",
       "\t\t};\n",
       "\n",
       "\t\tinserts.push({ r: yIndex, A: entry });\n",
       "\t\tchanges[key] = entry;\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key was removed earlier, a match!\n",
       "\tif (entry.c === 1)\n",
       "\t{\n",
       "\t\tinserts.push({ r: yIndex, A: entry });\n",
       "\n",
       "\t\tentry.c = 2;\n",
       "\t\tvar subPatches = [];\n",
       "\t\t_VirtualDom_diffHelp(entry.z, vnode, subPatches, entry.r);\n",
       "\t\tentry.r = yIndex;\n",
       "\t\tentry.s.s = {\n",
       "\t\t\tw: subPatches,\n",
       "\t\t\tA: entry\n",
       "\t\t};\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key has already been inserted or moved, a duplicate!\n",
       "\t_VirtualDom_insertNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, yIndex, inserts);\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_removeNode(changes, localPatches, key, vnode, index)\n",
       "{\n",
       "\tvar entry = changes[key];\n",
       "\n",
       "\t// never seen this key before\n",
       "\tif (!entry)\n",
       "\t{\n",
       "\t\tvar patch = _VirtualDom_pushPatch(localPatches, 9, index, undefined);\n",
       "\n",
       "\t\tchanges[key] = {\n",
       "\t\t\tc: 1,\n",
       "\t\t\tz: vnode,\n",
       "\t\t\tr: index,\n",
       "\t\t\ts: patch\n",
       "\t\t};\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key was inserted earlier, a match!\n",
       "\tif (entry.c === 0)\n",
       "\t{\n",
       "\t\tentry.c = 2;\n",
       "\t\tvar subPatches = [];\n",
       "\t\t_VirtualDom_diffHelp(vnode, entry.z, subPatches, index);\n",
       "\n",
       "\t\t_VirtualDom_pushPatch(localPatches, 9, index, {\n",
       "\t\t\tw: subPatches,\n",
       "\t\t\tA: entry\n",
       "\t\t});\n",
       "\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\t// this key has already been removed or moved, a duplicate!\n",
       "\t_VirtualDom_removeNode(changes, localPatches, key + _VirtualDom_POSTFIX, vnode, index);\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// ADD DOM NODES\n",
       "//\n",
       "// Each DOM node has an \"index\" assigned in order of traversal. It is important\n",
       "// to minimize our crawl over the actual DOM, so these indexes (along with the\n",
       "// descendantsCount of virtual nodes) let us skip touching entire subtrees of\n",
       "// the DOM if we know there are no patches there.\n",
       "\n",
       "\n",
       "function _VirtualDom_addDomNodes(domNode, vNode, patches, eventNode)\n",
       "{\n",
       "\t_VirtualDom_addDomNodesHelp(domNode, vNode, patches, 0, 0, vNode.b, eventNode);\n",
       "}\n",
       "\n",
       "\n",
       "// assumes `patches` is non-empty and indexes increase monotonically.\n",
       "function _VirtualDom_addDomNodesHelp(domNode, vNode, patches, i, low, high, eventNode)\n",
       "{\n",
       "\tvar patch = patches[i];\n",
       "\tvar index = patch.r;\n",
       "\n",
       "\twhile (index === low)\n",
       "\t{\n",
       "\t\tvar patchType = patch.$;\n",
       "\n",
       "\t\tif (patchType === 1)\n",
       "\t\t{\n",
       "\t\t\t_VirtualDom_addDomNodes(domNode, vNode.k, patch.s, eventNode);\n",
       "\t\t}\n",
       "\t\telse if (patchType === 8)\n",
       "\t\t{\n",
       "\t\t\tpatch.t = domNode;\n",
       "\t\t\tpatch.u = eventNode;\n",
       "\n",
       "\t\t\tvar subPatches = patch.s.w;\n",
       "\t\t\tif (subPatches.length > 0)\n",
       "\t\t\t{\n",
       "\t\t\t\t_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\telse if (patchType === 9)\n",
       "\t\t{\n",
       "\t\t\tpatch.t = domNode;\n",
       "\t\t\tpatch.u = eventNode;\n",
       "\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tif (data)\n",
       "\t\t\t{\n",
       "\t\t\t\tdata.A.s = domNode;\n",
       "\t\t\t\tvar subPatches = data.w;\n",
       "\t\t\t\tif (subPatches.length > 0)\n",
       "\t\t\t\t{\n",
       "\t\t\t\t\t_VirtualDom_addDomNodesHelp(domNode, vNode, subPatches, 0, low, high, eventNode);\n",
       "\t\t\t\t}\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\telse\n",
       "\t\t{\n",
       "\t\t\tpatch.t = domNode;\n",
       "\t\t\tpatch.u = eventNode;\n",
       "\t\t}\n",
       "\n",
       "\t\ti++;\n",
       "\n",
       "\t\tif (!(patch = patches[i]) || (index = patch.r) > high)\n",
       "\t\t{\n",
       "\t\t\treturn i;\n",
       "\t\t}\n",
       "\t}\n",
       "\n",
       "\tvar tag = vNode.$;\n",
       "\n",
       "\tif (tag === 4)\n",
       "\t{\n",
       "\t\tvar subNode = vNode.k;\n",
       "\n",
       "\t\twhile (subNode.$ === 4)\n",
       "\t\t{\n",
       "\t\t\tsubNode = subNode.k;\n",
       "\t\t}\n",
       "\n",
       "\t\treturn _VirtualDom_addDomNodesHelp(domNode, subNode, patches, i, low + 1, high, domNode.elm_event_node_ref);\n",
       "\t}\n",
       "\n",
       "\t// tag must be 1 or 2 at this point\n",
       "\n",
       "\tvar vKids = vNode.e;\n",
       "\tvar childNodes = domNode.childNodes;\n",
       "\tfor (var j = 0; j < vKids.length; j++)\n",
       "\t{\n",
       "\t\tlow++;\n",
       "\t\tvar vKid = tag === 1 ? vKids[j] : vKids[j].b;\n",
       "\t\tvar nextLow = low + (vKid.b || 0);\n",
       "\t\tif (low <= index && index <= nextLow)\n",
       "\t\t{\n",
       "\t\t\ti = _VirtualDom_addDomNodesHelp(childNodes[j], vKid, patches, i, low, nextLow, eventNode);\n",
       "\t\t\tif (!(patch = patches[i]) || (index = patch.r) > high)\n",
       "\t\t\t{\n",
       "\t\t\t\treturn i;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t\tlow = nextLow;\n",
       "\t}\n",
       "\treturn i;\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "// APPLY PATCHES\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatches(rootDomNode, oldVirtualNode, patches, eventNode)\n",
       "{\n",
       "\tif (patches.length === 0)\n",
       "\t{\n",
       "\t\treturn rootDomNode;\n",
       "\t}\n",
       "\n",
       "\t_VirtualDom_addDomNodes(rootDomNode, oldVirtualNode, patches, eventNode);\n",
       "\treturn _VirtualDom_applyPatchesHelp(rootDomNode, patches);\n",
       "}\n",
       "\n",
       "function _VirtualDom_applyPatchesHelp(rootDomNode, patches)\n",
       "{\n",
       "\tfor (var i = 0; i < patches.length; i++)\n",
       "\t{\n",
       "\t\tvar patch = patches[i];\n",
       "\t\tvar localDomNode = patch.t\n",
       "\t\tvar newNode = _VirtualDom_applyPatch(localDomNode, patch);\n",
       "\t\tif (localDomNode === rootDomNode)\n",
       "\t\t{\n",
       "\t\t\trootDomNode = newNode;\n",
       "\t\t}\n",
       "\t}\n",
       "\treturn rootDomNode;\n",
       "}\n",
       "\n",
       "function _VirtualDom_applyPatch(domNode, patch)\n",
       "{\n",
       "\tswitch (patch.$)\n",
       "\t{\n",
       "\t\tcase 0:\n",
       "\t\t\treturn _VirtualDom_applyPatchRedraw(domNode, patch.s, patch.u);\n",
       "\n",
       "\t\tcase 4:\n",
       "\t\t\t_VirtualDom_applyFacts(domNode, patch.u, patch.s);\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 3:\n",
       "\t\t\tdomNode.replaceData(0, domNode.length, patch.s);\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 1:\n",
       "\t\t\treturn _VirtualDom_applyPatchesHelp(domNode, patch.s);\n",
       "\n",
       "\t\tcase 2:\n",
       "\t\t\tif (domNode.elm_event_node_ref)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.elm_event_node_ref.j = patch.s;\n",
       "\t\t\t}\n",
       "\t\t\telse\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.elm_event_node_ref = { j: patch.s, p: patch.u };\n",
       "\t\t\t}\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 6:\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tfor (var i = 0; i < data.i; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.removeChild(domNode.childNodes[data.v]);\n",
       "\t\t\t}\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 7:\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tvar kids = data.e;\n",
       "\t\t\tvar i = data.v;\n",
       "\t\t\tvar theEnd = domNode.childNodes[i];\n",
       "\t\t\tfor (; i < kids.length; i++)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.insertBefore(_VirtualDom_render(kids[i], patch.u), theEnd);\n",
       "\t\t\t}\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 9:\n",
       "\t\t\tvar data = patch.s;\n",
       "\t\t\tif (!data)\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.parentNode.removeChild(domNode);\n",
       "\t\t\t\treturn domNode;\n",
       "\t\t\t}\n",
       "\t\t\tvar entry = data.A;\n",
       "\t\t\tif (typeof entry.r !== 'undefined')\n",
       "\t\t\t{\n",
       "\t\t\t\tdomNode.parentNode.removeChild(domNode);\n",
       "\t\t\t}\n",
       "\t\t\tentry.s = _VirtualDom_applyPatchesHelp(domNode, data.w);\n",
       "\t\t\treturn domNode;\n",
       "\n",
       "\t\tcase 8:\n",
       "\t\t\treturn _VirtualDom_applyPatchReorder(domNode, patch);\n",
       "\n",
       "\t\tcase 5:\n",
       "\t\t\treturn patch.s(domNode);\n",
       "\n",
       "\t\tdefault:\n",
       "\t\t\t_Debug_crash(10); // 'Ran into an unknown patch!'\n",
       "\t}\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatchRedraw(domNode, vNode, eventNode)\n",
       "{\n",
       "\tvar parentNode = domNode.parentNode;\n",
       "\tvar newNode = _VirtualDom_render(vNode, eventNode);\n",
       "\n",
       "\tif (!newNode.elm_event_node_ref)\n",
       "\t{\n",
       "\t\tnewNode.elm_event_node_ref = domNode.elm_event_node_ref;\n",
       "\t}\n",
       "\n",
       "\tif (parentNode && newNode !== domNode)\n",
       "\t{\n",
       "\t\tparentNode.replaceChild(newNode, domNode);\n",
       "\t}\n",
       "\treturn newNode;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatchReorder(domNode, patch)\n",
       "{\n",
       "\tvar data = patch.s;\n",
       "\n",
       "\t// remove end inserts\n",
       "\tvar frag = _VirtualDom_applyPatchReorderEndInsertsHelp(data.y, patch);\n",
       "\n",
       "\t// removals\n",
       "\tdomNode = _VirtualDom_applyPatchesHelp(domNode, data.w);\n",
       "\n",
       "\t// inserts\n",
       "\tvar inserts = data.x;\n",
       "\tfor (var i = 0; i < inserts.length; i++)\n",
       "\t{\n",
       "\t\tvar insert = inserts[i];\n",
       "\t\tvar entry = insert.A;\n",
       "\t\tvar node = entry.c === 2\n",
       "\t\t\t? entry.s\n",
       "\t\t\t: _VirtualDom_render(entry.z, patch.u);\n",
       "\t\tdomNode.insertBefore(node, domNode.childNodes[insert.r]);\n",
       "\t}\n",
       "\n",
       "\t// add end inserts\n",
       "\tif (frag)\n",
       "\t{\n",
       "\t\t_VirtualDom_appendChild(domNode, frag);\n",
       "\t}\n",
       "\n",
       "\treturn domNode;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_applyPatchReorderEndInsertsHelp(endInserts, patch)\n",
       "{\n",
       "\tif (!endInserts)\n",
       "\t{\n",
       "\t\treturn;\n",
       "\t}\n",
       "\n",
       "\tvar frag = _VirtualDom_doc.createDocumentFragment();\n",
       "\tfor (var i = 0; i < endInserts.length; i++)\n",
       "\t{\n",
       "\t\tvar insert = endInserts[i];\n",
       "\t\tvar entry = insert.A;\n",
       "\t\t_VirtualDom_appendChild(frag, entry.c === 2\n",
       "\t\t\t? entry.s\n",
       "\t\t\t: _VirtualDom_render(entry.z, patch.u)\n",
       "\t\t);\n",
       "\t}\n",
       "\treturn frag;\n",
       "}\n",
       "\n",
       "\n",
       "function _VirtualDom_virtualize(node)\n",
       "{\n",
       "\t// TEXT NODES\n",
       "\n",
       "\tif (node.nodeType === 3)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_text(node.textContent);\n",
       "\t}\n",
       "\n",
       "\n",
       "\t// WEIRD NODES\n",
       "\n",
       "\tif (node.nodeType !== 1)\n",
       "\t{\n",
       "\t\treturn _VirtualDom_text('');\n",
       "\t}\n",
       "\n",
       "\n",
       "\t// ELEMENT NODES\n",
       "\n",
       "\tvar attrList = _List_Nil;\n",
       "\tvar attrs = node.attributes;\n",
       "\tfor (var i = attrs.length; i--; )\n",
       "\t{\n",
       "\t\tvar attr = attrs[i];\n",
       "\t\tvar name = attr.name;\n",
       "\t\tvar value = attr.value;\n",
       "\t\tattrList = _List_Cons( A2(_VirtualDom_attribute, name, value), attrList );\n",
       "\t}\n",
       "\n",
       "\tvar tag = node.tagName.toLowerCase();\n",
       "\tvar kidList = _List_Nil;\n",
       "\tvar kids = node.childNodes;\n",
       "\n",
       "\tfor (var i = kids.length; i--; )\n",
       "\t{\n",
       "\t\tkidList = _List_Cons(_VirtualDom_virtualize(kids[i]), kidList);\n",
       "\t}\n",
       "\treturn A3(_VirtualDom_node, tag, attrList, kidList);\n",
       "}\n",
       "\n",
       "function _VirtualDom_dekey(keyedNode)\n",
       "{\n",
       "\tvar keyedKids = keyedNode.e;\n",
       "\tvar len = keyedKids.length;\n",
       "\tvar kids = new Array(len);\n",
       "\tfor (var i = 0; i < len; i++)\n",
       "\t{\n",
       "\t\tkids[i] = keyedKids[i].b;\n",
       "\t}\n",
       "\n",
       "\treturn {\n",
       "\t\t$: 1,\n",
       "\t\tc: keyedNode.c,\n",
       "\t\td: keyedNode.d,\n",
       "\t\te: kids,\n",
       "\t\tf: keyedNode.f,\n",
       "\t\tb: keyedNode.b\n",
       "\t};\n",
       "}\n",
       "var $elm$core$List$cons = _List_cons;\n",
       "var $elm$core$Elm$JsArray$foldr = _JsArray_foldr;\n",
       "var $elm$core$Array$foldr = F3(\n",
       "\tfunction (func, baseCase, _v0) {\n",
       "\t\tvar tree = _v0.c;\n",
       "\t\tvar tail = _v0.d;\n",
       "\t\tvar helper = F2(\n",
       "\t\t\tfunction (node, acc) {\n",
       "\t\t\t\tif (node.$ === 'SubTree') {\n",
       "\t\t\t\t\tvar subTree = node.a;\n",
       "\t\t\t\t\treturn A3($elm$core$Elm$JsArray$foldr, helper, acc, subTree);\n",
       "\t\t\t\t} else {\n",
       "\t\t\t\t\tvar values = node.a;\n",
       "\t\t\t\t\treturn A3($elm$core$Elm$JsArray$foldr, func, acc, values);\n",
       "\t\t\t\t}\n",
       "\t\t\t});\n",
       "\t\treturn A3(\n",
       "\t\t\t$elm$core$Elm$JsArray$foldr,\n",
       "\t\t\thelper,\n",
       "\t\t\tA3($elm$core$Elm$JsArray$foldr, func, baseCase, tail),\n",
       "\t\t\ttree);\n",
       "\t});\n",
       "var $elm$core$Array$toList = function (array) {\n",
       "\treturn A3($elm$core$Array$foldr, $elm$core$List$cons, _List_Nil, array);\n",
       "};\n",
       "var $elm$core$Dict$foldr = F3(\n",
       "\tfunction (func, acc, t) {\n",
       "\t\tfoldr:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (t.$ === 'RBEmpty_elm_builtin') {\n",
       "\t\t\t\treturn acc;\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar key = t.b;\n",
       "\t\t\t\tvar value = t.c;\n",
       "\t\t\t\tvar left = t.d;\n",
       "\t\t\t\tvar right = t.e;\n",
       "\t\t\t\tvar $temp$func = func,\n",
       "\t\t\t\t\t$temp$acc = A3(\n",
       "\t\t\t\t\tfunc,\n",
       "\t\t\t\t\tkey,\n",
       "\t\t\t\t\tvalue,\n",
       "\t\t\t\t\tA3($elm$core$Dict$foldr, func, acc, right)),\n",
       "\t\t\t\t\t$temp$t = left;\n",
       "\t\t\t\tfunc = $temp$func;\n",
       "\t\t\t\tacc = $temp$acc;\n",
       "\t\t\t\tt = $temp$t;\n",
       "\t\t\t\tcontinue foldr;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Dict$toList = function (dict) {\n",
       "\treturn A3(\n",
       "\t\t$elm$core$Dict$foldr,\n",
       "\t\tF3(\n",
       "\t\t\tfunction (key, value, list) {\n",
       "\t\t\t\treturn A2(\n",
       "\t\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t\t_Utils_Tuple2(key, value),\n",
       "\t\t\t\t\tlist);\n",
       "\t\t\t}),\n",
       "\t\t_List_Nil,\n",
       "\t\tdict);\n",
       "};\n",
       "var $elm$core$Dict$keys = function (dict) {\n",
       "\treturn A3(\n",
       "\t\t$elm$core$Dict$foldr,\n",
       "\t\tF3(\n",
       "\t\t\tfunction (key, value, keyList) {\n",
       "\t\t\t\treturn A2($elm$core$List$cons, key, keyList);\n",
       "\t\t\t}),\n",
       "\t\t_List_Nil,\n",
       "\t\tdict);\n",
       "};\n",
       "var $elm$core$Set$toList = function (_v0) {\n",
       "\tvar dict = _v0.a;\n",
       "\treturn $elm$core$Dict$keys(dict);\n",
       "};\n",
       "var $elm$core$Basics$EQ = {$: 'EQ'};\n",
       "var $elm$core$Basics$GT = {$: 'GT'};\n",
       "var $elm$core$Basics$LT = {$: 'LT'};\n",
       "var $elm$core$Result$Err = function (a) {\n",
       "\treturn {$: 'Err', a: a};\n",
       "};\n",
       "var $elm$json$Json$Decode$Failure = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Failure', a: a, b: b};\n",
       "\t});\n",
       "var $elm$json$Json$Decode$Field = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Field', a: a, b: b};\n",
       "\t});\n",
       "var $elm$json$Json$Decode$Index = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Index', a: a, b: b};\n",
       "\t});\n",
       "var $elm$core$Result$Ok = function (a) {\n",
       "\treturn {$: 'Ok', a: a};\n",
       "};\n",
       "var $elm$json$Json$Decode$OneOf = function (a) {\n",
       "\treturn {$: 'OneOf', a: a};\n",
       "};\n",
       "var $elm$core$Basics$False = {$: 'False'};\n",
       "var $elm$core$Basics$add = _Basics_add;\n",
       "var $elm$core$Maybe$Just = function (a) {\n",
       "\treturn {$: 'Just', a: a};\n",
       "};\n",
       "var $elm$core$Maybe$Nothing = {$: 'Nothing'};\n",
       "var $elm$core$String$all = _String_all;\n",
       "var $elm$core$Basics$and = _Basics_and;\n",
       "var $elm$core$Basics$append = _Utils_append;\n",
       "var $elm$json$Json$Encode$encode = _Json_encode;\n",
       "var $elm$core$String$fromInt = _String_fromNumber;\n",
       "var $elm$core$String$join = F2(\n",
       "\tfunction (sep, chunks) {\n",
       "\t\treturn A2(\n",
       "\t\t\t_String_join,\n",
       "\t\t\tsep,\n",
       "\t\t\t_List_toArray(chunks));\n",
       "\t});\n",
       "var $elm$core$String$split = F2(\n",
       "\tfunction (sep, string) {\n",
       "\t\treturn _List_fromArray(\n",
       "\t\t\tA2(_String_split, sep, string));\n",
       "\t});\n",
       "var $elm$json$Json$Decode$indent = function (str) {\n",
       "\treturn A2(\n",
       "\t\t$elm$core$String$join,\n",
       "\t\t'\\n    ',\n",
       "\t\tA2($elm$core$String$split, '\\n', str));\n",
       "};\n",
       "var $elm$core$List$foldl = F3(\n",
       "\tfunction (func, acc, list) {\n",
       "\t\tfoldl:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (!list.b) {\n",
       "\t\t\t\treturn acc;\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar x = list.a;\n",
       "\t\t\t\tvar xs = list.b;\n",
       "\t\t\t\tvar $temp$func = func,\n",
       "\t\t\t\t\t$temp$acc = A2(func, x, acc),\n",
       "\t\t\t\t\t$temp$list = xs;\n",
       "\t\t\t\tfunc = $temp$func;\n",
       "\t\t\t\tacc = $temp$acc;\n",
       "\t\t\t\tlist = $temp$list;\n",
       "\t\t\t\tcontinue foldl;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$List$length = function (xs) {\n",
       "\treturn A3(\n",
       "\t\t$elm$core$List$foldl,\n",
       "\t\tF2(\n",
       "\t\t\tfunction (_v0, i) {\n",
       "\t\t\t\treturn i + 1;\n",
       "\t\t\t}),\n",
       "\t\t0,\n",
       "\t\txs);\n",
       "};\n",
       "var $elm$core$List$map2 = _List_map2;\n",
       "var $elm$core$Basics$le = _Utils_le;\n",
       "var $elm$core$Basics$sub = _Basics_sub;\n",
       "var $elm$core$List$rangeHelp = F3(\n",
       "\tfunction (lo, hi, list) {\n",
       "\t\trangeHelp:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (_Utils_cmp(lo, hi) < 1) {\n",
       "\t\t\t\tvar $temp$lo = lo,\n",
       "\t\t\t\t\t$temp$hi = hi - 1,\n",
       "\t\t\t\t\t$temp$list = A2($elm$core$List$cons, hi, list);\n",
       "\t\t\t\tlo = $temp$lo;\n",
       "\t\t\t\thi = $temp$hi;\n",
       "\t\t\t\tlist = $temp$list;\n",
       "\t\t\t\tcontinue rangeHelp;\n",
       "\t\t\t} else {\n",
       "\t\t\t\treturn list;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$List$range = F2(\n",
       "\tfunction (lo, hi) {\n",
       "\t\treturn A3($elm$core$List$rangeHelp, lo, hi, _List_Nil);\n",
       "\t});\n",
       "var $elm$core$List$indexedMap = F2(\n",
       "\tfunction (f, xs) {\n",
       "\t\treturn A3(\n",
       "\t\t\t$elm$core$List$map2,\n",
       "\t\t\tf,\n",
       "\t\t\tA2(\n",
       "\t\t\t\t$elm$core$List$range,\n",
       "\t\t\t\t0,\n",
       "\t\t\t\t$elm$core$List$length(xs) - 1),\n",
       "\t\t\txs);\n",
       "\t});\n",
       "var $elm$core$Char$toCode = _Char_toCode;\n",
       "var $elm$core$Char$isLower = function (_char) {\n",
       "\tvar code = $elm$core$Char$toCode(_char);\n",
       "\treturn (97 <= code) && (code <= 122);\n",
       "};\n",
       "var $elm$core$Char$isUpper = function (_char) {\n",
       "\tvar code = $elm$core$Char$toCode(_char);\n",
       "\treturn (code <= 90) && (65 <= code);\n",
       "};\n",
       "var $elm$core$Basics$or = _Basics_or;\n",
       "var $elm$core$Char$isAlpha = function (_char) {\n",
       "\treturn $elm$core$Char$isLower(_char) || $elm$core$Char$isUpper(_char);\n",
       "};\n",
       "var $elm$core$Char$isDigit = function (_char) {\n",
       "\tvar code = $elm$core$Char$toCode(_char);\n",
       "\treturn (code <= 57) && (48 <= code);\n",
       "};\n",
       "var $elm$core$Char$isAlphaNum = function (_char) {\n",
       "\treturn $elm$core$Char$isLower(_char) || ($elm$core$Char$isUpper(_char) || $elm$core$Char$isDigit(_char));\n",
       "};\n",
       "var $elm$core$List$reverse = function (list) {\n",
       "\treturn A3($elm$core$List$foldl, $elm$core$List$cons, _List_Nil, list);\n",
       "};\n",
       "var $elm$core$String$uncons = _String_uncons;\n",
       "var $elm$json$Json$Decode$errorOneOf = F2(\n",
       "\tfunction (i, error) {\n",
       "\t\treturn '\\n\\n(' + ($elm$core$String$fromInt(i + 1) + (') ' + $elm$json$Json$Decode$indent(\n",
       "\t\t\t$elm$json$Json$Decode$errorToString(error))));\n",
       "\t});\n",
       "var $elm$json$Json$Decode$errorToString = function (error) {\n",
       "\treturn A2($elm$json$Json$Decode$errorToStringHelp, error, _List_Nil);\n",
       "};\n",
       "var $elm$json$Json$Decode$errorToStringHelp = F2(\n",
       "\tfunction (error, context) {\n",
       "\t\terrorToStringHelp:\n",
       "\t\twhile (true) {\n",
       "\t\t\tswitch (error.$) {\n",
       "\t\t\t\tcase 'Field':\n",
       "\t\t\t\t\tvar f = error.a;\n",
       "\t\t\t\t\tvar err = error.b;\n",
       "\t\t\t\t\tvar isSimple = function () {\n",
       "\t\t\t\t\t\tvar _v1 = $elm$core$String$uncons(f);\n",
       "\t\t\t\t\t\tif (_v1.$ === 'Nothing') {\n",
       "\t\t\t\t\t\t\treturn false;\n",
       "\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\tvar _v2 = _v1.a;\n",
       "\t\t\t\t\t\t\tvar _char = _v2.a;\n",
       "\t\t\t\t\t\t\tvar rest = _v2.b;\n",
       "\t\t\t\t\t\t\treturn $elm$core$Char$isAlpha(_char) && A2($elm$core$String$all, $elm$core$Char$isAlphaNum, rest);\n",
       "\t\t\t\t\t\t}\n",
       "\t\t\t\t\t}();\n",
       "\t\t\t\t\tvar fieldName = isSimple ? ('.' + f) : ('[\\'' + (f + '\\']'));\n",
       "\t\t\t\t\tvar $temp$error = err,\n",
       "\t\t\t\t\t\t$temp$context = A2($elm$core$List$cons, fieldName, context);\n",
       "\t\t\t\t\terror = $temp$error;\n",
       "\t\t\t\t\tcontext = $temp$context;\n",
       "\t\t\t\t\tcontinue errorToStringHelp;\n",
       "\t\t\t\tcase 'Index':\n",
       "\t\t\t\t\tvar i = error.a;\n",
       "\t\t\t\t\tvar err = error.b;\n",
       "\t\t\t\t\tvar indexName = '[' + ($elm$core$String$fromInt(i) + ']');\n",
       "\t\t\t\t\tvar $temp$error = err,\n",
       "\t\t\t\t\t\t$temp$context = A2($elm$core$List$cons, indexName, context);\n",
       "\t\t\t\t\terror = $temp$error;\n",
       "\t\t\t\t\tcontext = $temp$context;\n",
       "\t\t\t\t\tcontinue errorToStringHelp;\n",
       "\t\t\t\tcase 'OneOf':\n",
       "\t\t\t\t\tvar errors = error.a;\n",
       "\t\t\t\t\tif (!errors.b) {\n",
       "\t\t\t\t\t\treturn 'Ran into a Json.Decode.oneOf with no possibilities' + function () {\n",
       "\t\t\t\t\t\t\tif (!context.b) {\n",
       "\t\t\t\t\t\t\t\treturn '!';\n",
       "\t\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\t\treturn ' at json' + A2(\n",
       "\t\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t\t'',\n",
       "\t\t\t\t\t\t\t\t\t$elm$core$List$reverse(context));\n",
       "\t\t\t\t\t\t\t}\n",
       "\t\t\t\t\t\t}();\n",
       "\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\tif (!errors.b.b) {\n",
       "\t\t\t\t\t\t\tvar err = errors.a;\n",
       "\t\t\t\t\t\t\tvar $temp$error = err,\n",
       "\t\t\t\t\t\t\t\t$temp$context = context;\n",
       "\t\t\t\t\t\t\terror = $temp$error;\n",
       "\t\t\t\t\t\t\tcontext = $temp$context;\n",
       "\t\t\t\t\t\t\tcontinue errorToStringHelp;\n",
       "\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\tvar starter = function () {\n",
       "\t\t\t\t\t\t\t\tif (!context.b) {\n",
       "\t\t\t\t\t\t\t\t\treturn 'Json.Decode.oneOf';\n",
       "\t\t\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\t\t\treturn 'The Json.Decode.oneOf at json' + A2(\n",
       "\t\t\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t\t\t'',\n",
       "\t\t\t\t\t\t\t\t\t\t$elm$core$List$reverse(context));\n",
       "\t\t\t\t\t\t\t\t}\n",
       "\t\t\t\t\t\t\t}();\n",
       "\t\t\t\t\t\t\tvar introduction = starter + (' failed in the following ' + ($elm$core$String$fromInt(\n",
       "\t\t\t\t\t\t\t\t$elm$core$List$length(errors)) + ' ways:'));\n",
       "\t\t\t\t\t\t\treturn A2(\n",
       "\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t'\\n\\n',\n",
       "\t\t\t\t\t\t\t\tA2(\n",
       "\t\t\t\t\t\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t\t\t\t\t\tintroduction,\n",
       "\t\t\t\t\t\t\t\t\tA2($elm$core$List$indexedMap, $elm$json$Json$Decode$errorOneOf, errors)));\n",
       "\t\t\t\t\t\t}\n",
       "\t\t\t\t\t}\n",
       "\t\t\t\tdefault:\n",
       "\t\t\t\t\tvar msg = error.a;\n",
       "\t\t\t\t\tvar json = error.b;\n",
       "\t\t\t\t\tvar introduction = function () {\n",
       "\t\t\t\t\t\tif (!context.b) {\n",
       "\t\t\t\t\t\t\treturn 'Problem with the given value:\\n\\n';\n",
       "\t\t\t\t\t\t} else {\n",
       "\t\t\t\t\t\t\treturn 'Problem with the value at json' + (A2(\n",
       "\t\t\t\t\t\t\t\t$elm$core$String$join,\n",
       "\t\t\t\t\t\t\t\t'',\n",
       "\t\t\t\t\t\t\t\t$elm$core$List$reverse(context)) + ':\\n\\n    ');\n",
       "\t\t\t\t\t\t}\n",
       "\t\t\t\t\t}();\n",
       "\t\t\t\t\treturn introduction + ($elm$json$Json$Decode$indent(\n",
       "\t\t\t\t\t\tA2($elm$json$Json$Encode$encode, 4, json)) + ('\\n\\n' + msg));\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Array$branchFactor = 32;\n",
       "var $elm$core$Array$Array_elm_builtin = F4(\n",
       "\tfunction (a, b, c, d) {\n",
       "\t\treturn {$: 'Array_elm_builtin', a: a, b: b, c: c, d: d};\n",
       "\t});\n",
       "var $elm$core$Elm$JsArray$empty = _JsArray_empty;\n",
       "var $elm$core$Basics$ceiling = _Basics_ceiling;\n",
       "var $elm$core$Basics$fdiv = _Basics_fdiv;\n",
       "var $elm$core$Basics$logBase = F2(\n",
       "\tfunction (base, number) {\n",
       "\t\treturn _Basics_log(number) / _Basics_log(base);\n",
       "\t});\n",
       "var $elm$core$Basics$toFloat = _Basics_toFloat;\n",
       "var $elm$core$Array$shiftStep = $elm$core$Basics$ceiling(\n",
       "\tA2($elm$core$Basics$logBase, 2, $elm$core$Array$branchFactor));\n",
       "var $elm$core$Array$empty = A4($elm$core$Array$Array_elm_builtin, 0, $elm$core$Array$shiftStep, $elm$core$Elm$JsArray$empty, $elm$core$Elm$JsArray$empty);\n",
       "var $elm$core$Elm$JsArray$initialize = _JsArray_initialize;\n",
       "var $elm$core$Array$Leaf = function (a) {\n",
       "\treturn {$: 'Leaf', a: a};\n",
       "};\n",
       "var $elm$core$Basics$apL = F2(\n",
       "\tfunction (f, x) {\n",
       "\t\treturn f(x);\n",
       "\t});\n",
       "var $elm$core$Basics$apR = F2(\n",
       "\tfunction (x, f) {\n",
       "\t\treturn f(x);\n",
       "\t});\n",
       "var $elm$core$Basics$eq = _Utils_equal;\n",
       "var $elm$core$Basics$floor = _Basics_floor;\n",
       "var $elm$core$Elm$JsArray$length = _JsArray_length;\n",
       "var $elm$core$Basics$gt = _Utils_gt;\n",
       "var $elm$core$Basics$max = F2(\n",
       "\tfunction (x, y) {\n",
       "\t\treturn (_Utils_cmp(x, y) > 0) ? x : y;\n",
       "\t});\n",
       "var $elm$core$Basics$mul = _Basics_mul;\n",
       "var $elm$core$Array$SubTree = function (a) {\n",
       "\treturn {$: 'SubTree', a: a};\n",
       "};\n",
       "var $elm$core$Elm$JsArray$initializeFromList = _JsArray_initializeFromList;\n",
       "var $elm$core$Array$compressNodes = F2(\n",
       "\tfunction (nodes, acc) {\n",
       "\t\tcompressNodes:\n",
       "\t\twhile (true) {\n",
       "\t\t\tvar _v0 = A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodes);\n",
       "\t\t\tvar node = _v0.a;\n",
       "\t\t\tvar remainingNodes = _v0.b;\n",
       "\t\t\tvar newAcc = A2(\n",
       "\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t$elm$core$Array$SubTree(node),\n",
       "\t\t\t\tacc);\n",
       "\t\t\tif (!remainingNodes.b) {\n",
       "\t\t\t\treturn $elm$core$List$reverse(newAcc);\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar $temp$nodes = remainingNodes,\n",
       "\t\t\t\t\t$temp$acc = newAcc;\n",
       "\t\t\t\tnodes = $temp$nodes;\n",
       "\t\t\t\tacc = $temp$acc;\n",
       "\t\t\t\tcontinue compressNodes;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Tuple$first = function (_v0) {\n",
       "\tvar x = _v0.a;\n",
       "\treturn x;\n",
       "};\n",
       "var $elm$core$Array$treeFromBuilder = F2(\n",
       "\tfunction (nodeList, nodeListSize) {\n",
       "\t\ttreeFromBuilder:\n",
       "\t\twhile (true) {\n",
       "\t\t\tvar newNodeSize = $elm$core$Basics$ceiling(nodeListSize / $elm$core$Array$branchFactor);\n",
       "\t\t\tif (newNodeSize === 1) {\n",
       "\t\t\t\treturn A2($elm$core$Elm$JsArray$initializeFromList, $elm$core$Array$branchFactor, nodeList).a;\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar $temp$nodeList = A2($elm$core$Array$compressNodes, nodeList, _List_Nil),\n",
       "\t\t\t\t\t$temp$nodeListSize = newNodeSize;\n",
       "\t\t\t\tnodeList = $temp$nodeList;\n",
       "\t\t\t\tnodeListSize = $temp$nodeListSize;\n",
       "\t\t\t\tcontinue treeFromBuilder;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Array$builderToArray = F2(\n",
       "\tfunction (reverseNodeList, builder) {\n",
       "\t\tif (!builder.nodeListSize) {\n",
       "\t\t\treturn A4(\n",
       "\t\t\t\t$elm$core$Array$Array_elm_builtin,\n",
       "\t\t\t\t$elm$core$Elm$JsArray$length(builder.tail),\n",
       "\t\t\t\t$elm$core$Array$shiftStep,\n",
       "\t\t\t\t$elm$core$Elm$JsArray$empty,\n",
       "\t\t\t\tbuilder.tail);\n",
       "\t\t} else {\n",
       "\t\t\tvar treeLen = builder.nodeListSize * $elm$core$Array$branchFactor;\n",
       "\t\t\tvar depth = $elm$core$Basics$floor(\n",
       "\t\t\t\tA2($elm$core$Basics$logBase, $elm$core$Array$branchFactor, treeLen - 1));\n",
       "\t\t\tvar correctNodeList = reverseNodeList ? $elm$core$List$reverse(builder.nodeList) : builder.nodeList;\n",
       "\t\t\tvar tree = A2($elm$core$Array$treeFromBuilder, correctNodeList, builder.nodeListSize);\n",
       "\t\t\treturn A4(\n",
       "\t\t\t\t$elm$core$Array$Array_elm_builtin,\n",
       "\t\t\t\t$elm$core$Elm$JsArray$length(builder.tail) + treeLen,\n",
       "\t\t\t\tA2($elm$core$Basics$max, 5, depth * $elm$core$Array$shiftStep),\n",
       "\t\t\t\ttree,\n",
       "\t\t\t\tbuilder.tail);\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Basics$idiv = _Basics_idiv;\n",
       "var $elm$core$Basics$lt = _Utils_lt;\n",
       "var $elm$core$Array$initializeHelp = F5(\n",
       "\tfunction (fn, fromIndex, len, nodeList, tail) {\n",
       "\t\tinitializeHelp:\n",
       "\t\twhile (true) {\n",
       "\t\t\tif (fromIndex < 0) {\n",
       "\t\t\t\treturn A2(\n",
       "\t\t\t\t\t$elm$core$Array$builderToArray,\n",
       "\t\t\t\t\tfalse,\n",
       "\t\t\t\t\t{nodeList: nodeList, nodeListSize: (len / $elm$core$Array$branchFactor) | 0, tail: tail});\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar leaf = $elm$core$Array$Leaf(\n",
       "\t\t\t\t\tA3($elm$core$Elm$JsArray$initialize, $elm$core$Array$branchFactor, fromIndex, fn));\n",
       "\t\t\t\tvar $temp$fn = fn,\n",
       "\t\t\t\t\t$temp$fromIndex = fromIndex - $elm$core$Array$branchFactor,\n",
       "\t\t\t\t\t$temp$len = len,\n",
       "\t\t\t\t\t$temp$nodeList = A2($elm$core$List$cons, leaf, nodeList),\n",
       "\t\t\t\t\t$temp$tail = tail;\n",
       "\t\t\t\tfn = $temp$fn;\n",
       "\t\t\t\tfromIndex = $temp$fromIndex;\n",
       "\t\t\t\tlen = $temp$len;\n",
       "\t\t\t\tnodeList = $temp$nodeList;\n",
       "\t\t\t\ttail = $temp$tail;\n",
       "\t\t\t\tcontinue initializeHelp;\n",
       "\t\t\t}\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Basics$remainderBy = _Basics_remainderBy;\n",
       "var $elm$core$Array$initialize = F2(\n",
       "\tfunction (len, fn) {\n",
       "\t\tif (len <= 0) {\n",
       "\t\t\treturn $elm$core$Array$empty;\n",
       "\t\t} else {\n",
       "\t\t\tvar tailLen = len % $elm$core$Array$branchFactor;\n",
       "\t\t\tvar tail = A3($elm$core$Elm$JsArray$initialize, tailLen, len - tailLen, fn);\n",
       "\t\t\tvar initialFromIndex = (len - tailLen) - $elm$core$Array$branchFactor;\n",
       "\t\t\treturn A5($elm$core$Array$initializeHelp, fn, initialFromIndex, len, _List_Nil, tail);\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$core$Basics$True = {$: 'True'};\n",
       "var $elm$core$Result$isOk = function (result) {\n",
       "\tif (result.$ === 'Ok') {\n",
       "\t\treturn true;\n",
       "\t} else {\n",
       "\t\treturn false;\n",
       "\t}\n",
       "};\n",
       "var $elm$json$Json$Decode$map = _Json_map1;\n",
       "var $elm$json$Json$Decode$map2 = _Json_map2;\n",
       "var $elm$json$Json$Decode$succeed = _Json_succeed;\n",
       "var $elm$virtual_dom$VirtualDom$toHandlerInt = function (handler) {\n",
       "\tswitch (handler.$) {\n",
       "\t\tcase 'Normal':\n",
       "\t\t\treturn 0;\n",
       "\t\tcase 'MayStopPropagation':\n",
       "\t\t\treturn 1;\n",
       "\t\tcase 'MayPreventDefault':\n",
       "\t\t\treturn 2;\n",
       "\t\tdefault:\n",
       "\t\t\treturn 3;\n",
       "\t}\n",
       "};\n",
       "var $author$project$Main$elemwidth = 50;\n",
       "var $author$project$Main$hseparator = 15;\n",
       "var $elm$svg$Svg$trustedNode = _VirtualDom_nodeNS('http://www.w3.org/2000/svg');\n",
       "var $elm$svg$Svg$g = $elm$svg$Svg$trustedNode('g');\n",
       "var $elm$svg$Svg$Attributes$transform = _VirtualDom_attribute('transform');\n",
       "var $author$project$Main$translate = F2(\n",
       "\tfunction (_v0, lst) {\n",
       "\t\tvar x = _v0.a;\n",
       "\t\tvar y = _v0.b;\n",
       "\t\treturn A2(\n",
       "\t\t\t$elm$svg$Svg$g,\n",
       "\t\t\t_List_fromArray(\n",
       "\t\t\t\t[\n",
       "\t\t\t\t\t$elm$svg$Svg$Attributes$transform(\n",
       "\t\t\t\t\t'translate(' + ($elm$core$String$fromInt(x) + (',' + ($elm$core$String$fromInt(y) + ')'))))\n",
       "\t\t\t\t]),\n",
       "\t\t\tlst);\n",
       "\t});\n",
       "var $author$project$Main$vseparator = 30;\n",
       "var $author$project$Main$pushdownTrees = F2(\n",
       "\tfunction (lst, pref) {\n",
       "\t\tif (lst.b) {\n",
       "\t\t\tif (lst.b.b) {\n",
       "\t\t\t\tvar _v1 = lst.a;\n",
       "\t\t\t\tvar tw = _v1.a;\n",
       "\t\t\t\tvar t = _v1.b;\n",
       "\t\t\t\tvar _v2 = lst.b;\n",
       "\t\t\t\tvar ts = _v2.a;\n",
       "\t\t\t\tvar x = _v2.b;\n",
       "\t\t\t\treturn A2(\n",
       "\t\t\t\t\t$elm$core$List$cons,\n",
       "\t\t\t\t\tA2(\n",
       "\t\t\t\t\t\t$author$project$Main$translate,\n",
       "\t\t\t\t\t\t_Utils_Tuple2(pref, $author$project$Main$vseparator),\n",
       "\t\t\t\t\t\t_List_fromArray(\n",
       "\t\t\t\t\t\t\t[t])),\n",
       "\t\t\t\t\tA2(\n",
       "\t\t\t\t\t\t$author$project$Main$pushdownTrees,\n",
       "\t\t\t\t\t\tA2($elm$core$List$cons, ts, x),\n",
       "\t\t\t\t\t\t(pref + tw) + $author$project$Main$hseparator));\n",
       "\t\t\t} else {\n",
       "\t\t\t\tvar _v3 = lst.a;\n",
       "\t\t\t\tvar tw = _v3.a;\n",
       "\t\t\t\tvar t = _v3.b;\n",
       "\t\t\t\treturn _List_fromArray(\n",
       "\t\t\t\t\t[\n",
       "\t\t\t\t\t\tA2(\n",
       "\t\t\t\t\t\t$author$project$Main$translate,\n",
       "\t\t\t\t\t\t_Utils_Tuple2(pref, $author$project$Main$vseparator),\n",
       "\t\t\t\t\t\t_List_fromArray(\n",
       "\t\t\t\t\t\t\t[t]))\n",
       "\t\t\t\t\t]);\n",
       "\t\t\t}\n",
       "\t\t} else {\n",
       "\t\t\treturn _List_Nil;\n",
       "\t\t}\n",
       "\t});\n",
       "var $elm$virtual_dom$VirtualDom$text = _VirtualDom_text;\n",
       "var $elm$svg$Svg$text = $elm$virtual_dom$VirtualDom$text;\n",
       "var $elm$svg$Svg$text_ = $elm$svg$Svg$trustedNode('text');\n",
       "var $author$project$Main$treesWidth = function (lst) {\n",
       "\tif (lst.b) {\n",
       "\t\tif (lst.b.b) {\n",
       "\t\t\tvar _v1 = lst.a;\n",
       "\t\t\tvar tw = _v1.a;\n",
       "\t\t\tvar t = _v1.b;\n",
       "\t\t\tvar _v2 = lst.b;\n",
       "\t\t\tvar snd = _v2.a;\n",
       "\t\t\tvar ts = _v2.b;\n",
       "\t\t\treturn (tw + $author$project$Main$hseparator) + $author$project$Main$treesWidth(\n",
       "\t\t\t\tA2($elm$core$List$cons, snd, ts));\n",
       "\t\t} else {\n",
       "\t\t\tvar _v3 = lst.a;\n",
       "\t\t\tvar tw = _v3.a;\n",
       "\t\t\tvar t = _v3.b;\n",
       "\t\t\treturn tw;\n",
       "\t\t}\n",
       "\t} else {\n",
       "\t\treturn 0;\n",
       "\t}\n",
       "};\n",
       "var $author$project$Main$drawTree = F2(\n",
       "\tfunction (tree, pref) {\n",
       "\t\tvar t = tree.a;\n",
       "\t\tvar subs = tree.b;\n",
       "\t\tvar subtrees = $author$project$Main$drawTrees(subs);\n",
       "\t\tvar subwidth = _Utils_eq(subtrees, _List_Nil) ? $author$project$Main$elemwidth : $author$project$Main$treesWidth(subtrees);\n",
       "\t\tvar placedtrees = A2($author$project$Main$pushdownTrees, subtrees, pref);\n",
       "\t\tvar head = A2(\n",
       "\t\t\t$author$project$Main$translate,\n",
       "\t\t\t_Utils_Tuple2(pref + ((subwidth / 2) | 0), 0),\n",
       "\t\t\t_List_fromArray(\n",
       "\t\t\t\t[\n",
       "\t\t\t\t\tA2(\n",
       "\t\t\t\t\t$elm$svg$Svg$text_,\n",
       "\t\t\t\t\t_List_Nil,\n",
       "\t\t\t\t\t_List_fromArray(\n",
       "\t\t\t\t\t\t[\n",
       "\t\t\t\t\t\t\t$elm$svg$Svg$text(t)\n",
       "\t\t\t\t\t\t]))\n",
       "\t\t\t\t]));\n",
       "\t\treturn _Utils_Tuple2(\n",
       "\t\t\tsubwidth,\n",
       "\t\t\tA2(\n",
       "\t\t\t\t$author$project$Main$translate,\n",
       "\t\t\t\t_Utils_Tuple2(0, 0),\n",
       "\t\t\t\tA2($elm$core$List$cons, head, placedtrees)));\n",
       "\t});\n",
       "var $author$project$Main$drawTrees = function (lst) {\n",
       "\tif (lst.b) {\n",
       "\t\tvar t = lst.a;\n",
       "\t\tvar ts = lst.b;\n",
       "\t\tvar tail = $author$project$Main$drawTrees(ts);\n",
       "\t\tvar _v1 = A2($author$project$Main$drawTree, t, 0);\n",
       "\t\tvar headwidth = _v1.a;\n",
       "\t\tvar headsvg = _v1.b;\n",
       "\t\treturn A2(\n",
       "\t\t\t$elm$core$List$cons,\n",
       "\t\t\t_Utils_Tuple2(headwidth, headsvg),\n",
       "\t\t\ttail);\n",
       "\t} else {\n",
       "\t\treturn _List_Nil;\n",
       "\t}\n",
       "};\n",
       "var $author$project$Main$drawT = function (toc) {\n",
       "\tvar _v0 = A2($author$project$Main$drawTree, toc, 0);\n",
       "\tvar w = _v0.a;\n",
       "\tvar t = _v0.b;\n",
       "\treturn t;\n",
       "};\n",
       "var $elm$svg$Svg$Attributes$height = _VirtualDom_attribute('height');\n",
       "var $elm$svg$Svg$svg = $elm$svg$Svg$trustedNode('svg');\n",
       "var $author$project$Main$Node = F2(\n",
       "\tfunction (a, b) {\n",
       "\t\treturn {$: 'Node', a: a, b: b};\n",
       "\t});\n",
       "var $author$project$Main$sectie11 = A2($author$project$Main$Node, 'S 1-1', _List_Nil);\n",
       "var $author$project$Main$sectie12 = A2($author$project$Main$Node, 'S 1-2', _List_Nil);\n",
       "var $author$project$Main$sectie13 = A2($author$project$Main$Node, 'S 1-3', _List_Nil);\n",
       "var $author$project$Main$hoofdstuk1 = A2(\n",
       "\t$author$project$Main$Node,\n",
       "\t'H 1',\n",
       "\t_List_fromArray(\n",
       "\t\t[$author$project$Main$sectie11, $author$project$Main$sectie12, $author$project$Main$sectie13]));\n",
       "var $author$project$Main$sectie21 = A2($author$project$Main$Node, 'S 2-1', _List_Nil);\n",
       "var $author$project$Main$sectie22 = A2($author$project$Main$Node, 'S 2-2', _List_Nil);\n",
       "var $author$project$Main$sectie23 = A2($author$project$Main$Node, 'S 2-3', _List_Nil);\n",
       "var $author$project$Main$hoofdstuk2 = A2(\n",
       "\t$author$project$Main$Node,\n",
       "\t'H 2',\n",
       "\t_List_fromArray(\n",
       "\t\t[$author$project$Main$sectie21, $author$project$Main$sectie22, $author$project$Main$sectie23]));\n",
       "var $author$project$Main$sectie31 = A2($author$project$Main$Node, 'S 2-1', _List_Nil);\n",
       "var $author$project$Main$sectie32 = A2($author$project$Main$Node, 'S 2-2', _List_Nil);\n",
       "var $author$project$Main$sectie33 = A2($author$project$Main$Node, 'S 2-3', _List_Nil);\n",
       "var $author$project$Main$hoofdstuk3 = A2(\n",
       "\t$author$project$Main$Node,\n",
       "\t'H 3',\n",
       "\t_List_fromArray(\n",
       "\t\t[$author$project$Main$sectie31, $author$project$Main$sectie32, $author$project$Main$sectie33]));\n",
       "var $author$project$Main$toc1 = A2(\n",
       "\t$author$project$Main$Node,\n",
       "\t'Titel',\n",
       "\t_List_fromArray(\n",
       "\t\t[$author$project$Main$hoofdstuk1, $author$project$Main$hoofdstuk2, $author$project$Main$hoofdstuk3]));\n",
       "var $elm$svg$Svg$Attributes$viewBox = _VirtualDom_attribute('viewBox');\n",
       "var $elm$svg$Svg$Attributes$width = _VirtualDom_attribute('width');\n",
       "var $author$project$Main$main = A2(\n",
       "\t$elm$svg$Svg$svg,\n",
       "\t_List_fromArray(\n",
       "\t\t[\n",
       "\t\t\t$elm$svg$Svg$Attributes$width('800'),\n",
       "\t\t\t$elm$svg$Svg$Attributes$height('400'),\n",
       "\t\t\t$elm$svg$Svg$Attributes$viewBox('0 0 800 400')\n",
       "\t\t]),\n",
       "\t_List_fromArray(\n",
       "\t\t[\n",
       "\t\t\tA2(\n",
       "\t\t\t$author$project$Main$translate,\n",
       "\t\t\t_Utils_Tuple2(10, 10),\n",
       "\t\t\t_List_fromArray(\n",
       "\t\t\t\t[\n",
       "\t\t\t\t\tA2(\n",
       "\t\t\t\t\t$elm$svg$Svg$text_,\n",
       "\t\t\t\t\t_List_Nil,\n",
       "\t\t\t\t\t_List_fromArray(\n",
       "\t\t\t\t\t\t[\n",
       "\t\t\t\t\t\t\t$elm$svg$Svg$text('hi')\n",
       "\t\t\t\t\t\t]))\n",
       "\t\t\t\t])),\n",
       "\t\t\tA2(\n",
       "\t\t\t$author$project$Main$translate,\n",
       "\t\t\t_Utils_Tuple2(100, 100),\n",
       "\t\t\t_List_fromArray(\n",
       "\t\t\t\t[\n",
       "\t\t\t\t\t$author$project$Main$drawT($author$project$Main$toc1)\n",
       "\t\t\t\t]))\n",
       "\t\t]));\n",
       "_Platform_export({'Main':{'init':_VirtualDom_init($author$project$Main$main)(0)(0)}});}(this));\n",
       "\n",
       "                cb();\n",
       "            }\n",
       "            ;\n",
       "\n",
       "            var obj = new Object();\n",
       "            defineElm.bind(obj)(function(){\n",
       "                var mountNode = document.getElementById('elm-div-11');\n",
       "                obj.Elm. Main.init({ node: mountNode });\n",
       "            });\n",
       "        "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "main = \n",
    "  svg\n",
    "    [ width \"800\"\n",
    "    , height \"400\"\n",
    "    , viewBox \"0 0 800 400\"\n",
    "--    , stroke \"black\"\n",
    "--    , strokeWidth \"0.5\"\n",
    "--    , fill \"None\"\n",
    "    ]\n",
    "    [ (translate (10, 10) [Svg.text_ [] [text \"hi\"]])\n",
    "    , (translate (100,100) [drawT toc1])\n",
    "    ]\n",
    "    \n",
    "--    ++ ( drawToc sectie11 ) ++ [Svg.text \"hi\"])\n",
    "\n",
    "-- compile-code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- import Html exposing (..)\n",
    "import Svg exposing (..)\n",
    "import Svg.Attributes exposing (..)\n",
    "import String exposing (..)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "unitwidth = 30\n",
    "unitheight = 40\n",
    "\n",
    "twidth : Tree -> (Int, Int)\n",
    "twidth t =\n",
    "  case t of        \n",
    "    Node str left right ->\n",
    "      let\n",
    "        (lw, _) = twidth left\n",
    "        (rw, _) = twidth right\n",
    "      in\n",
    "        (lw + unitwidth + rw, lw + (unitwidth // 2))\n",
    "\n",
    "    Nil ->\n",
    "      (0, 0)\n",
    "      \n",
    "swidth str =\n",
    "  length str * 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawLine : (Int, Int) -> (Int, Int) -> Svg msg\n",
    "drawLine (xa, ya) (xb, yb) =\n",
    "  Svg.line\n",
    "    [ x1 (fromInt xa)\n",
    "    , y1 (fromInt ya)\n",
    "    , x2 (fromInt xb)\n",
    "    , y2 (fromInt yb)\n",
    "    , stroke \"black\"\n",
    "    , strokeWidth \"1\"    \n",
    "    ]\n",
    "    []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "drawTree : Tree -> Svg msg\n",
    "drawTree t =\n",
    "  case t of\n",
    "    Node str Nil Nil ->\n",
    "      translate (unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
    "      \n",
    "    Node str Nil right ->\n",
    "      let\n",
    "        (rw, rm) = twidth right\n",
    "        rtree = translate (unitwidth, unitheight) [drawTree right]\n",
    "        node = translate (unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
    "        rightedge = drawLine (unitwidth // 2, 5) (unitwidth + rm, unitheight - 15)\n",
    "      in\n",
    "        Svg.g [] [node, rtree, rightedge]\n",
    "\n",
    "    Node str left Nil ->\n",
    "      let\n",
    "        (lw, lm) = twidth left\n",
    "        ltree = translate (0, unitheight) [drawTree left]\n",
    "        node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
    "        leftedge = drawLine (lw + unitwidth // 2, 5) (lm, unitheight - 15)\n",
    "      in\n",
    "        Svg.g [] [ltree, node, leftedge]     \n",
    "        \n",
    "    Node str left right ->\n",
    "      let\n",
    "        (lw, lm) = twidth left\n",
    "        (rw, rm) = twidth right\n",
    "        ltree = translate (0, unitheight) [drawTree left]\n",
    "        rtree = translate (lw + unitwidth, unitheight) [drawTree right]\n",
    "        node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
    "        leftedge = drawLine (lw + unitwidth // 2, 5) (lm, unitheight - 15)\n",
    "        rightedge = drawLine (lw + unitwidth // 2, 5) (lw + unitwidth + rm, unitheight - 15)\n",
    "      in\n",
    "        Svg.g [] [ltree, node, rtree, leftedge, rightedge]\n",
    "    Nil ->\n",
    "      Svg.text_ [] [text \".\"]\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<pre>\n",
       "Verifying dependencies (1/9)\n",
       "Verifying dependencies (2/9)\n",
       "Verifying dependencies (3/9)\n",
       "Verifying dependencies (4/9)\n",
       "Verifying dependencies (5/9)\n",
       "Verifying dependencies (6/9)\n",
       "Verifying dependencies (7/9)\n",
       "Verifying dependencies (8/9)\n",
       "Verifying dependencies (9/9)\n",
       "                            \n",
       "Dependencies ready!\n",
       "Compiling ...-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `translate` variable:\n",
       "\n",
       "82|    [ translate (10, 10) [drawTree tree4]\n",
       "         ^^^^^^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    truncate\n",
       "    animate\n",
       "    transform\n",
       "    drawLine\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Node` variant:\n",
       "\n",
       "77| tree4 = Node \"goeie\" (tree3)  (Node \"hi\" (Nil) (Node \"???\" tree1 Nil) )\n",
       "            ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Ok\n",
       "    True\n",
       "    EQ\n",
       "    Err\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Node` variant:\n",
       "\n",
       "77| tree4 = Node \"goeie\" (tree3)  (Node \"hi\" (Nil) (Node \"???\" tree1 Nil) )\n",
       "                                   ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Ok\n",
       "    True\n",
       "    EQ\n",
       "    Err\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Nil` variant:\n",
       "\n",
       "77| tree4 = Node \"goeie\" (tree3)  (Node \"hi\" (Nil) (Node \"???\" tree1 Nil) )\n",
       "                                              ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    EQ\n",
       "    Err\n",
       "    GT\n",
       "    LT\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Node` variant:\n",
       "\n",
       "77| tree4 = Node \"goeie\" (tree3)  (Node \"hi\" (Nil) (Node \"???\" tree1 Nil) )\n",
       "                                                    ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Ok\n",
       "    True\n",
       "    EQ\n",
       "    Err\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Nil` variant:\n",
       "\n",
       "77| tree4 = Node \"goeie\" (tree3)  (Node \"hi\" (Nil) (Node \"???\" tree1 Nil) )\n",
       "                                                                     ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    EQ\n",
       "    Err\n",
       "    GT\n",
       "    LT\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Node` variant:\n",
       "\n",
       "76| tree3 = Node \"moi\" tree2 tree2\n",
       "            ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Ok\n",
       "    True\n",
       "    EQ\n",
       "    Err\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Node` variant:\n",
       "\n",
       "75| tree2 = Node \"Hoi\" tree1 tree1\n",
       "            ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Ok\n",
       "    True\n",
       "    EQ\n",
       "    Err\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Node` variant:\n",
       "\n",
       "74| tree1 = Node \"hi\" Nil Nil\n",
       "            ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Ok\n",
       "    True\n",
       "    EQ\n",
       "    Err\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Nil` variant:\n",
       "\n",
       "74| tree1 = Node \"hi\" Nil Nil\n",
       "                      ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    EQ\n",
       "    Err\n",
       "    GT\n",
       "    LT\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Nil` variant:\n",
       "\n",
       "74| tree1 = Node \"hi\" Nil Nil\n",
       "                          ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    EQ\n",
       "    Err\n",
       "    GT\n",
       "    LT\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Nil` variant:\n",
       "\n",
       "73| tree0 = Nil\n",
       "            ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    EQ\n",
       "    Err\n",
       "    GT\n",
       "    LT\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Tree` type:\n",
       "\n",
       "35| drawTree : Tree -> Svg msg\n",
       "               ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Order\n",
       "    Bool\n",
       "    Char\n",
       "    Cmd\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `Tree` type:\n",
       "\n",
       "9| twidth : Tree -> (Int, Int)\n",
       "            ^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    Order\n",
       "    Bool\n",
       "    Char\n",
       "    Cmd\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `translate` variable:\n",
       "\n",
       "5| node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
       "          ^^^^^^^^^\n",
       "These names seem close though:\n",
       "\n",
       "    truncate\n",
       "    animate\n",
       "    transform\n",
       "    drawLine\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `lw` variable:\n",
       "\n",
       "5| node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
       "                     ^^\n",
       "These names seem close though:\n",
       "\n",
       "    a\n",
       "    all\n",
       "    by\n",
       "    cx\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `str` variable:\n",
       "\n",
       "5| node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
       "                                                  ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    dur\n",
       "    r\n",
       "    set\n",
       "    sin\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "-- NAMING ERROR - /var/folders/t5/4wldmnvn329cg867dbh3m0qm0000gn/T/tmp3ek2a_jw/input.elm\n",
       "\n",
       "I cannot find a `str` variable:\n",
       "\n",
       "5| node = translate (lw + unitwidth // 2 - swidth str, 0) [Svg.text_ [] [text str]]\n",
       "                                                                              ^^^\n",
       "These names seem close though:\n",
       "\n",
       "    dur\n",
       "    r\n",
       "    set\n",
       "    sin\n",
       "\n",
       "Hint: Read <https://elm-lang.org/0.19.1/imports> to see how `import`\n",
       "declarations work in Elm.\n",
       "\n",
       "\n",
       "Detected problems in 1 module.\n",
       "</pre>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree0 = Nil\n",
    "tree1 = Node \"hi\" Nil Nil\n",
    "tree2 = Node \"Hoi\" tree1 tree1\n",
    "tree3 = Node \"moi\" tree2 tree2\n",
    "tree4 = Node \"goeie\" (tree3)  (Node \"hi\" (Nil) (Node \"???\" tree1 Nil) )\n",
    "\n",
    "test x =\n",
    "  Svg.g\n",
    "   []\n",
    "   [ translate (10, 10) [drawTree tree4]\n",
    "   ]\n",
    "\n",
    "main =\n",
    "  svg\n",
    "    [ width \"800\"\n",
    "    , height \"400\"\n",
    "    , viewBox \"0 0 800 400\"\n",
    "--    , stroke \"black\"\n",
    "--    , strokeWidth \"0.5\"\n",
    "--    , fill \"None\"\n",
    "    ]\n",
    "    [ test 1\n",
    "    ]\n",
    "    \n",
    "-- compile-code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Elm",
   "language": "elm",
   "name": "elm"
  },
  "language_info": {
   "codemirror_mode": "elm",
   "file_extension": ".elm",
   "mimetype": "text/x-elm",
   "name": "elm"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}