diff --git a/.gitignore b/.gitignore
index 20e090a3..80e9047f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
 /.psc*
 /.purs*
 /.psa*
+/.stack*
diff --git a/bower.json b/bower.json
index 185876c7..2ffb3cd6 100644
--- a/bower.json
+++ b/bower.json
@@ -7,68 +7,61 @@
     "output"
   ],
   "dependencies": {
-    "purescript-console": "^3.0.0",
-    "purescript-foreign-generic": "^5.0.0",
-    "purescript-jquery": "^4.2.1",
-    "purescript-js-timers": "^3.0.0",
-    "purescript-parallel": "^3.2.0",
-    "purescript-prelude": "^3.1.0",
-    "purescript-random": "^3.0.0"
+    "purescript-console": "^4.1.0",
+    "purescript-foreign-generic": "^7.0.0",
+    "purescript-jquery": "^5.0.0",
+    "purescript-js-timers": "^4.0.1",
+    "purescript-parallel": "^4.0.0",
+    "purescript-prelude": "^4.1.0",
+    "purescript-random": "^4.0.0",
+    "purescript-web-html": "^1.2.0"
   },
   "devDependencies": {
     "ace": "^1.2.8",
     "jquery": "^3.2.1",
     "underscore": "^1.8.3",
-    "react": "^15.6.1",
+    "react": "^16.1.0",
     "mathbox": "^0.0.5",
-    "purescript-thermite": "^4.1.1",
-    "purescript-behaviors": "^5.2.0",
-    "purescript-slides": "^0.5.0",
-    "purescript-flare": "^3.2.0",
-    "purescript-arrays": "^4.1.2",
-    "purescript-bifunctors": "^3.0.0",
-    "purescript-console": "^3.0.0",
-    "purescript-const": "^3.0.0",
-    "purescript-contravariant": "^3.1.0",
-    "purescript-control": "^3.3.0",
-    "purescript-distributive": "^3.0.0",
-    "purescript-eff": "^3.1.0",
-    "purescript-either": "^3.1.0",
-    "purescript-enums": "^3.2.1",
-    "purescript-exceptions": "^3.1.0",
-    "purescript-exists": "^3.0.0",
-    "purescript-foldable-traversable": "^3.6.0",
-    "purescript-foreign": "^4.0.1",
-    "purescript-free": "^4.1.0",
-    "purescript-functions": "^3.0.0",
-    "purescript-functors": "^2.2.0",
-    "purescript-generics": "^4.0.0",
-    "purescript-generics-rep": "^5.2.0",
-    "purescript-globals": "^3.0.0",
-    "purescript-graphs": "^3.0.0",
-    "purescript-identity": "^3.1.0",
-    "purescript-inject": "^4.0.0",
-    "purescript-integers": "^3.1.0",
-    "purescript-lazy": "^3.0.0",
-    "purescript-maps": "^3.5.2",
+    "purescript-arrays": "^5.1.0",
+    "purescript-bifunctors": "^4.0.0",
+    "purescript-console": "^4.1.0",
+    "purescript-const": "^4.1.0",
+    "purescript-contravariant": "^4.0.0",
+    "purescript-control": "^4.1.0",
+    "purescript-distributive": "^4.0.0",
+    "purescript-effect": "^2.0.0",
+    "purescript-either": "^4.1.0",
+    "purescript-enums": "^4.0.0",
+    "purescript-exceptions": "^4.0.0",
+    "purescript-exists": "^4.0.0",
+    "purescript-foldable-traversable": "^4.1.0",
+    "purescript-foreign": "^5.0.0",
+    "purescript-foreign-object": "^1.0.0",
+    "purescript-free": "^5.1.0",
+    "purescript-functions": "^4.0.0",
+    "purescript-functors": "^3.1.0",
+    "purescript-generics-rep": "^6.1.0",
+    "purescript-globals": "^4.0.0",
+    "purescript-identity": "^4.1.0",
+    "purescript-integers": "^4.0.0",
+    "purescript-lazy": "^4.0.0",
     "purescript-math": "^2.1.0",
-    "purescript-maybe": "^3.0.0",
-    "purescript-monoid": "^3.1.0",
-    "purescript-prelude": "^3.1.0",
-    "purescript-profunctor": "^3.2.0",
-    "purescript-proxy": "^2.1.0",
-    "purescript-quickcheck": "^4.4.0",
-    "purescript-random": "^3.0.0",
-    "purescript-refs": "^3.0.0",
-    "purescript-semirings": "^4.0.0",
-    "purescript-sets": "^3.0.0",
-    "purescript-st": "^3.0.0",
-    "purescript-strings": "^3.3.1",
-    "purescript-tailrec": "^3.3.0",
-    "purescript-transformers": "^3.4.0",
-    "purescript-tuples": "^4.1.0",
-    "purescript-typelevel-prelude": "^2.4.0",
-    "purescript-unfoldable": "^3.0.0",
-    "purescript-validation": "^3.1.0"
+    "purescript-maybe": "^4.0.0",
+    "purescript-ordered-collections": "^1.0.0",
+    "purescript-prelude": "^4.1.0",
+    "purescript-profunctor": "^4.0.0",
+    "purescript-proxy": "^3.0.0",
+    "purescript-quickcheck": "^5.0.0",
+    "purescript-random": "^4.0.0",
+    "purescript-refs": "^4.1.0",
+    "purescript-semirings": "^5.0.0",
+    "purescript-st": "^4.0.0",
+    "purescript-strings": "^4.0.0",
+    "purescript-tailrec": "^4.0.0",
+    "purescript-transformers": "^4.1.0",
+    "purescript-tuples": "^5.1.0",
+    "purescript-typelevel-prelude": "^3.0.0",
+    "purescript-unfoldable": "^4.0.0",
+    "purescript-validation": "^4.0.0"
   }
 }
diff --git a/frame.html b/frame.html
new file mode 100644
index 00000000..ba347939
--- /dev/null
+++ b/frame.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Try PureScript!</title>
+  <meta content="text/html;charset=utf-8" http-equiv="Content-Type">
+  <meta content="utf-8" http-equiv="encoding">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <script src="js/frame.js"></script>
+</head>
+<body>
+<main id="main"></main>
+</body>
+</html>
diff --git a/index.html b/index.html
index 603810bf..344c6724 100644
--- a/index.html
+++ b/index.html
@@ -47,34 +47,6 @@
               </a>
             </li>
           </ul>
-        </li><li class="menu-item menu-dropdown no-mobile">
-          <label title="Select a Backend">Backend</label>
-          <ul id="backend">
-            <li>
-              <input type="radio" name="backend_inputs" value="core" id="backend_core" checked="true">
-              <label for="backend_core" title="Use the core libraries backend">Core</label>
-            </li>
-            <li>
-              <input type="radio" name="backend_inputs" value="thermite" id="backend_thermite">
-              <label for="backend_thermite" title="Use the try-thermite backend">Thermite</label>
-            </li>
-            <li>
-              <input type="radio" name="backend_inputs" value="slides" id="backend_slides">
-              <label for="backend_slides" title="Use the try-slides backend">Slides</label>
-            </li>
-            <li>
-              <input type="radio" name="backend_inputs" value="flare" id="backend_flare">
-              <label for="backend_flare" title="Use the try-flare backend">Flare</label>
-            </li>
-            <li>
-              <input type="radio" name="backend_inputs" value="mathbox" id="backend_mathbox">
-              <label for="backend_mathbox" title="Use the try-mathbox backend">Mathbox</label>
-            </li>
-            <li>
-              <input type="radio" name="backend_inputs" value="behaviors" id="backend_behaviors">
-              <label for="backend_behaviors" title="Use the try-behaviors backend">Behaviors</label>
-            </li>
-          </ul>
         </li><li class="menu-item view_gist_li mobile-only">
           <a class="view_gist" target="trypurs_gist">
             <label title="Open the original gist in a new window">View Gist</label>
@@ -186,30 +158,31 @@
       })(marker));
     }
 
-    function setupIFrame($ctr, html, js) {
-      var $iframe = $('<iframe id="output-iframe">');
+    function setupIFrame($ctr, data) {
+      var $iframe = $('<iframe sandbox="allow-scripts" id="output-iframe" src="frame.html">');
 
       $ctr
         .empty()
         .append($iframe);
 
-      var iframe = $iframe.get(0).contentWindow.document;
-      iframe.open();
-      iframe.write(html);
-      iframe.close();
-
-      var script = iframe.createElement('script');
-      script.appendChild(iframe.createTextNode(js));
-
-      $iframe.ready(function() {
-        var checkExists = setInterval(function() {
-          var body = iframe.getElementsByTagName('body')[0];
-          if (body) {
-            body.appendChild(script);
-            clearInterval(checkExists);
-          }
-        }, 100);
-      });
+      var tries = 0;
+      var sendSources = setInterval(function() {
+        // Stop after 10 seconds
+        if (tries >= 100) {
+          return clearInterval(sendSources);
+        }
+        tries++;
+        var iframe = $iframe.get(0).contentWindow;
+        if (iframe) {
+          iframe.postMessage(data, "*");
+        } else {
+          console.warn("Frame is not available");
+        }
+      }, 100);
+
+      window.addEventListener("message", function() {
+        clearInterval(sendSources);
+      }, { once: true });
 
       return $iframe;
     }
diff --git a/js/frame.js b/js/frame.js
new file mode 100644
index 00000000..7960b9c0
--- /dev/null
+++ b/js/frame.js
@@ -0,0 +1,39 @@
+(function() {
+  function evalSources(sources) {
+    var modules = {};
+    function dirname(str) {
+      var ix = str.lastIndexOf("/");
+      return ix < 0 ? "" : str.slice(0, ix);
+    }
+    function resolvePath(a, b) {
+      if (b[0] === "." && b[1] === "/") {
+        return dirname(a) + b.slice(1);
+      }
+      if (b[0] === "." && b[1] === "." && b[2] === "/") {
+        return dirname(dirname(a)) + b.slice(2);
+      }
+      return b;
+    }
+    return function load(name) {
+      if (modules[name]) {
+        return modules[name].exports;
+      }
+      function require(path) {
+        return load(resolvePath(name, path));
+      }
+      var module = modules[name] = { exports: {} };
+      new Function("module", "exports", "require", sources[name])(module, module.exports, require);
+      return module.exports;
+    };
+  }
+
+  document.addEventListener("DOMContentLoaded", function() {
+    window.addEventListener("message", function(event) {
+      event.source.postMessage("trypurescript", "*");
+      var file = evalSources(event.data)("<file>");
+      if (file.main && typeof file.main === "function") {
+        file.main();
+      }
+    }, { once: true });
+  }, { once: true });
+})();
diff --git a/js/index.js b/js/index.js
index 1db1a64d..cfc74adb 100644
--- a/js/index.js
+++ b/js/index.js
@@ -1,4 +1,4 @@
-// Generated by purs bundle 0.11.6
+// Generated by purs bundle 0.12.0
 var PS = {};
 (function(exports) {
     "use strict";
@@ -15,7 +15,7 @@ var PS = {};
   };
 })(PS["Data.Functor"] = PS["Data.Functor"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Semigroupoid = function (compose) {
       this.compose = compose;
@@ -30,20 +30,28 @@ var PS = {};
   var compose = function (dict) {
       return dict.compose;
   };
+  var composeFlipped = function (dictSemigroupoid) {
+      return function (f) {
+          return function (g) {
+              return compose(dictSemigroupoid)(g)(f);
+          };
+      };
+  };
   exports["compose"] = compose;
   exports["Semigroupoid"] = Semigroupoid;
+  exports["composeFlipped"] = composeFlipped;
   exports["semigroupoidFn"] = semigroupoidFn;
 })(PS["Control.Semigroupoid"] = PS["Control.Semigroupoid"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];        
-  var Category = function (Semigroupoid0, id) {
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];                 
+  var Category = function (Semigroupoid0, identity) {
       this.Semigroupoid0 = Semigroupoid0;
-      this.id = id;
+      this.identity = identity;
   };
-  var id = function (dict) {
-      return dict.id;
+  var identity = function (dict) {
+      return dict.identity;
   };
   var categoryFn = new Category(function () {
       return Control_Semigroupoid.semigroupoidFn;
@@ -51,28 +59,64 @@ var PS = {};
       return x;
   });
   exports["Category"] = Category;
-  exports["id"] = id;
+  exports["identity"] = identity;
   exports["categoryFn"] = categoryFn;
 })(PS["Control.Category"] = PS["Control.Category"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Category = PS["Control.Category"];
-  var flip = function (f) {
-      return function (b) {
-          return function (a) {
-              return f(a)(b);
-          };
-      };
+  var otherwise = true;
+  exports["otherwise"] = otherwise;
+})(PS["Data.Boolean"] = PS["Data.Boolean"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.refEq = function (r1) {
+    return function (r2) {
+      return r1 === r2;
+    };
   };
-  var $$const = function (a) {
-      return function (v) {
-          return a;
+})(PS["Data.Eq"] = PS["Data.Eq"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.boolConj = function (b1) {
+    return function (b2) {
+      return b1 && b2;
+    };
+  };
+
+  exports.boolDisj = function (b1) {
+    return function (b2) {
+      return b1 || b2;
+    };
+  };
+
+  exports.boolNot = function (b) {
+    return !b;
+  };
+})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Symbol"];      
+  var SProxy = (function () {
+      function SProxy() {
+
       };
+      SProxy.value = new SProxy();
+      return SProxy;
+  })();
+  var IsSymbol = function (reflectSymbol) {
+      this.reflectSymbol = reflectSymbol;
   };
-  exports["flip"] = flip;
-  exports["const"] = $$const;
-})(PS["Data.Function"] = PS["Data.Function"] || {});
+  var reflectSymbol = function (dict) {
+      return dict.reflectSymbol;
+  };
+  exports["IsSymbol"] = IsSymbol;
+  exports["reflectSymbol"] = reflectSymbol;
+  exports["SProxy"] = SProxy;
+})(PS["Data.Symbol"] = PS["Data.Symbol"] || {});
 (function(exports) {
     "use strict";
 
@@ -110,9 +154,24 @@ var PS = {};
   };
 })(PS["Data.Show"] = PS["Data.Show"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
+  "use strict";
+  var RLProxy = (function () {
+      function RLProxy() {
+
+      };
+      RLProxy.value = new RLProxy();
+      return RLProxy;
+  })();
+  exports["RLProxy"] = RLProxy;
+})(PS["Type.Data.RowList"] = PS["Type.Data.RowList"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Show"];     
+  var $foreign = PS["Data.Show"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
   var Show = function (show) {
       this.show = show;
   };
@@ -127,44 +186,111 @@ var PS = {};
   exports["showString"] = showString;
 })(PS["Data.Show"] = PS["Data.Show"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Unit"];
   var Data_Show = PS["Data.Show"];
   exports["unit"] = $foreign.unit;
 })(PS["Data.Unit"] = PS["Data.Unit"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Functor"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Unit = PS["Data.Unit"];        
-  var Functor = function (map) {
-      this.map = map;
+  var $foreign = PS["Data.HeytingAlgebra"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_Row = PS["Type.Data.Row"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var HeytingAlgebra = function (conj, disj, ff, implies, not, tt) {
+      this.conj = conj;
+      this.disj = disj;
+      this.ff = ff;
+      this.implies = implies;
+      this.not = not;
+      this.tt = tt;
   };
-  var map = function (dict) {
-      return dict.map;
+  var tt = function (dict) {
+      return dict.tt;
   };
-  var mapFlipped = function (dictFunctor) {
-      return function (fa) {
-          return function (f) {
-              return map(dictFunctor)(f)(fa);
+  var not = function (dict) {
+      return dict.not;
+  };
+  var implies = function (dict) {
+      return dict.implies;
+  };
+  var ff = function (dict) {
+      return dict.ff;
+  };
+  var disj = function (dict) {
+      return dict.disj;
+  };
+  var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
+      return function (b) {
+          return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
+      };
+  }, $foreign.boolNot, true);
+  var conj = function (dict) {
+      return dict.conj;
+  };
+  exports["HeytingAlgebra"] = HeytingAlgebra;
+  exports["tt"] = tt;
+  exports["ff"] = ff;
+  exports["implies"] = implies;
+  exports["conj"] = conj;
+  exports["disj"] = disj;
+  exports["not"] = not;
+  exports["heytingAlgebraBoolean"] = heytingAlgebraBoolean;
+})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Eq"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Data_Void = PS["Data.Void"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Eq = function (eq) {
+      this.eq = eq;
+  }; 
+  var eqString = new Eq($foreign.refEq);
+  var eqInt = new Eq($foreign.refEq);
+  var eqChar = new Eq($foreign.refEq);
+  var eqBoolean = new Eq($foreign.refEq);
+  var eq = function (dict) {
+      return dict.eq;
+  };
+  var notEq = function (dictEq) {
+      return function (x) {
+          return function (y) {
+              return eq(eqBoolean)(eq(dictEq)(x)(y))(false);
           };
       };
   };
-  var $$void = function (dictFunctor) {
-      return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
+  exports["Eq"] = Eq;
+  exports["eq"] = eq;
+  exports["notEq"] = notEq;
+  exports["eqBoolean"] = eqBoolean;
+  exports["eqInt"] = eqInt;
+  exports["eqChar"] = eqChar;
+  exports["eqString"] = eqString;
+})(PS["Data.Eq"] = PS["Data.Eq"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.unsafeCompareImpl = function (lt) {
+    return function (eq) {
+      return function (gt) {
+        return function (x) {
+          return function (y) {
+            return x < y ? lt : x === y ? eq : gt;
+          };
+        };
+      };
+    };
   };
-  var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
-  var functorArray = new Functor($foreign.arrayMap);
-  exports["Functor"] = Functor;
-  exports["map"] = map;
-  exports["mapFlipped"] = mapFlipped;
-  exports["void"] = $$void;
-  exports["functorFn"] = functorFn;
-  exports["functorArray"] = functorArray;
-})(PS["Data.Functor"] = PS["Data.Functor"] || {});
+})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
 (function(exports) {
     "use strict";
 
@@ -175,11 +301,14 @@ var PS = {};
   };
 })(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Semigroup"];
+  var Data_Symbol = PS["Data.Symbol"];
   var Data_Unit = PS["Data.Unit"];
-  var Data_Void = PS["Data.Void"];        
+  var Data_Void = PS["Data.Void"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
   var Semigroup = function (append) {
       this.append = append;
   }; 
@@ -192,65 +321,307 @@ var PS = {};
   exports["semigroupString"] = semigroupString;
 })(PS["Data.Semigroup"] = PS["Data.Semigroup"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Semigroup = PS["Data.Semigroup"];        
-  var Alt = function (Functor0, alt) {
-      this.Functor0 = Functor0;
-      this.alt = alt;
-  };                                                       
-  var alt = function (dict) {
-      return dict.alt;
-  };
-  exports["Alt"] = Alt;
-  exports["alt"] = alt;
-})(PS["Control.Alt"] = PS["Control.Alt"] || {});
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];                 
+  var LT = (function () {
+      function LT() {
+
+      };
+      LT.value = new LT();
+      return LT;
+  })();
+  var GT = (function () {
+      function GT() {
+
+      };
+      GT.value = new GT();
+      return GT;
+  })();
+  var EQ = (function () {
+      function EQ() {
+
+      };
+      EQ.value = new EQ();
+      return EQ;
+  })();
+  var eqOrdering = new Data_Eq.Eq(function (v) {
+      return function (v1) {
+          if (v instanceof LT && v1 instanceof LT) {
+              return true;
+          };
+          if (v instanceof GT && v1 instanceof GT) {
+              return true;
+          };
+          if (v instanceof EQ && v1 instanceof EQ) {
+              return true;
+          };
+          return false;
+      };
+  });
+  exports["LT"] = LT;
+  exports["GT"] = GT;
+  exports["EQ"] = EQ;
+  exports["eqOrdering"] = eqOrdering;
+})(PS["Data.Ordering"] = PS["Data.Ordering"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Ord.Unsafe"];
+  var Data_Ordering = PS["Data.Ordering"];                 
+  var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);
+  exports["unsafeCompare"] = unsafeCompare;
+})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
 (function(exports) {
     "use strict";
 
-  exports.arrayApply = function (fs) {
-    return function (xs) {
-      var result = [];
-      var n = 0;
-      for (var i = 0, l = fs.length; i < l; i++) {
-        for (var j = 0, k = xs.length; j < k; j++) {
-          result[n++] = fs[i](xs[j]);
-        }
-      }
-      return result;
+  exports.intSub = function (x) {
+    return function (y) {
+      /* jshint bitwise: false */
+      return x - y | 0;
     };
   };
-})(PS["Control.Apply"] = PS["Control.Apply"] || {});
+})(PS["Data.Ring"] = PS["Data.Ring"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Apply"];
-  var Control_Category = PS["Control.Category"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];        
-  var Apply = function (Functor0, apply) {
-      this.Functor0 = Functor0;
-      this.apply = apply;
-  }; 
-  var applyArray = new Apply(function () {
-      return Data_Functor.functorArray;
-  }, $foreign.arrayApply);
-  var apply = function (dict) {
-      return dict.apply;
+    "use strict";
+
+  exports.intAdd = function (x) {
+    return function (y) {
+      /* jshint bitwise: false */
+      return x + y | 0;
+    };
   };
-  var applySecond = function (dictApply) {
-      return function (a) {
-          return function (b) {
-              return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.id(Control_Category.categoryFn)))(a))(b);
-          };
-      };
+
+  exports.intMul = function (x) {
+    return function (y) {
+      /* jshint bitwise: false */
+      return x * y | 0;
+    };
   };
-  var lift2 = function (dictApply) {
-      return function (f) {
-          return function (a) {
-              return function (b) {
-                  return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
+})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_Row = PS["Type.Data.Row"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Semiring = function (add, mul, one, zero) {
+      this.add = add;
+      this.mul = mul;
+      this.one = one;
+      this.zero = zero;
+  };
+  var zero = function (dict) {
+      return dict.zero;
+  };                                                                            
+  var semiringInt = new Semiring($foreign.intAdd, $foreign.intMul, 1, 0);
+  var one = function (dict) {
+      return dict.one;
+  };
+  var mul = function (dict) {
+      return dict.mul;
+  };
+  var add = function (dict) {
+      return dict.add;
+  };
+  exports["Semiring"] = Semiring;
+  exports["add"] = add;
+  exports["zero"] = zero;
+  exports["mul"] = mul;
+  exports["one"] = one;
+  exports["semiringInt"] = semiringInt;
+})(PS["Data.Semiring"] = PS["Data.Semiring"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Ring = function (Semiring0, sub) {
+      this.Semiring0 = Semiring0;
+      this.sub = sub;
+  };
+  var sub = function (dict) {
+      return dict.sub;
+  };                  
+  var ringInt = new Ring(function () {
+      return Data_Semiring.semiringInt;
+  }, $foreign.intSub);
+  exports["Ring"] = Ring;
+  exports["sub"] = sub;
+  exports["ringInt"] = ringInt;
+})(PS["Data.Ring"] = PS["Data.Ring"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Ord"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Ord_Unsafe = PS["Data.Ord.Unsafe"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Data_Void = PS["Data.Void"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Ord = function (Eq0, compare) {
+      this.Eq0 = Eq0;
+      this.compare = compare;
+  }; 
+  var ordString = new Ord(function () {
+      return Data_Eq.eqString;
+  }, Data_Ord_Unsafe.unsafeCompare);
+  var ordInt = new Ord(function () {
+      return Data_Eq.eqInt;
+  }, Data_Ord_Unsafe.unsafeCompare);
+  var ordChar = new Ord(function () {
+      return Data_Eq.eqChar;
+  }, Data_Ord_Unsafe.unsafeCompare);
+  var compare = function (dict) {
+      return dict.compare;
+  };
+  var comparing = function (dictOrd) {
+      return function (f) {
+          return function (x) {
+              return function (y) {
+                  return compare(dictOrd)(f(x))(f(y));
+              };
+          };
+      };
+  };
+  exports["Ord"] = Ord;
+  exports["compare"] = compare;
+  exports["comparing"] = comparing;
+  exports["ordInt"] = ordInt;
+  exports["ordString"] = ordString;
+  exports["ordChar"] = ordChar;
+})(PS["Data.Ord"] = PS["Data.Ord"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Category = PS["Control.Category"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var flip = function (f) {
+      return function (b) {
+          return function (a) {
+              return f(a)(b);
+          };
+      };
+  };
+  var $$const = function (a) {
+      return function (v) {
+          return a;
+      };
+  };
+  exports["flip"] = flip;
+  exports["const"] = $$const;
+})(PS["Data.Function"] = PS["Data.Function"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Functor"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Unit = PS["Data.Unit"];                 
+  var Functor = function (map) {
+      this.map = map;
+  };
+  var map = function (dict) {
+      return dict.map;
+  };
+  var mapFlipped = function (dictFunctor) {
+      return function (fa) {
+          return function (f) {
+              return map(dictFunctor)(f)(fa);
+          };
+      };
+  };
+  var $$void = function (dictFunctor) {
+      return map(dictFunctor)(Data_Function["const"](Data_Unit.unit));
+  };
+  var functorFn = new Functor(Control_Semigroupoid.compose(Control_Semigroupoid.semigroupoidFn));
+  var functorArray = new Functor($foreign.arrayMap);
+  exports["Functor"] = Functor;
+  exports["map"] = map;
+  exports["mapFlipped"] = mapFlipped;
+  exports["void"] = $$void;
+  exports["functorFn"] = functorFn;
+  exports["functorArray"] = functorArray;
+})(PS["Data.Functor"] = PS["Data.Functor"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Semigroup = PS["Data.Semigroup"];                 
+  var Alt = function (Functor0, alt) {
+      this.Functor0 = Functor0;
+      this.alt = alt;
+  };                                                       
+  var alt = function (dict) {
+      return dict.alt;
+  };
+  exports["Alt"] = Alt;
+  exports["alt"] = alt;
+})(PS["Control.Alt"] = PS["Control.Alt"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.arrayApply = function (fs) {
+    return function (xs) {
+      var l = fs.length;
+      var k = xs.length;
+      var result = new Array(l*k);
+      var n = 0;
+      for (var i = 0; i < l; i++) {
+        var f = fs[i];
+        for (var j = 0; j < k; j++) {
+          result[n++] = f(xs[j]);
+        }
+      }
+      return result;
+    };
+  };
+})(PS["Control.Apply"] = PS["Control.Apply"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Control.Apply"];
+  var Control_Category = PS["Control.Category"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];                 
+  var Apply = function (Functor0, apply) {
+      this.Functor0 = Functor0;
+      this.apply = apply;
+  }; 
+  var applyArray = new Apply(function () {
+      return Data_Functor.functorArray;
+  }, $foreign.arrayApply);
+  var apply = function (dict) {
+      return dict.apply;
+  };
+  var applySecond = function (dictApply) {
+      return function (a) {
+          return function (b) {
+              return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Data_Function["const"](Control_Category.identity(Control_Category.categoryFn)))(a))(b);
+          };
+      };
+  };
+  var lift2 = function (dictApply) {
+      return function (f) {
+          return function (a) {
+              return function (b) {
+                  return apply(dictApply)(Data_Functor.map(dictApply.Functor0())(f)(a))(b);
               };
           };
       };
@@ -262,11 +633,11 @@ var PS = {};
   exports["applyArray"] = applyArray;
 })(PS["Control.Apply"] = PS["Control.Apply"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Apply = PS["Control.Apply"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
+  var Data_Unit = PS["Data.Unit"];                 
   var Applicative = function (Apply0, pure) {
       this.Apply0 = Apply0;
       this.pure = pure;
@@ -327,7 +698,7 @@ var PS = {};
   };
 })(PS["Control.Bind"] = PS["Control.Bind"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Control.Bind"];
   var Control_Applicative = PS["Control.Applicative"];
@@ -335,7 +706,7 @@ var PS = {};
   var Control_Category = PS["Control.Category"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
+  var Data_Unit = PS["Data.Unit"];                 
   var Bind = function (Apply0, bind) {
       this.Apply0 = Apply0;
       this.bind = bind;
@@ -352,6 +723,9 @@ var PS = {};
   var bind = function (dict) {
       return dict.bind;
   };
+  var bindFlipped = function (dictBind) {
+      return Data_Function.flip(bind(dictBind));
+  };
   var composeKleisli = function (dictBind) {
       return function (f) {
           return function (g) {
@@ -364,22 +738,29 @@ var PS = {};
   var discardUnit = new Discard(function (dictBind) {
       return bind(dictBind);
   });
+  var join = function (dictBind) {
+      return function (m) {
+          return bind(dictBind)(m)(Control_Category.identity(Control_Category.categoryFn));
+      };
+  };
   exports["Bind"] = Bind;
   exports["bind"] = bind;
+  exports["bindFlipped"] = bindFlipped;
   exports["Discard"] = Discard;
   exports["discard"] = discard;
+  exports["join"] = join;
   exports["composeKleisli"] = composeKleisli;
   exports["bindArray"] = bindArray;
   exports["discardUnit"] = discardUnit;
 })(PS["Control.Bind"] = PS["Control.Bind"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
+  var Data_Unit = PS["Data.Unit"];                 
   var Monad = function (Applicative0, Bind1) {
       this.Applicative0 = Applicative0;
       this.Bind1 = Bind1;
@@ -398,115 +779,231 @@ var PS = {};
   exports["Monad"] = Monad;
   exports["ap"] = ap;
 })(PS["Control.Monad"] = PS["Control.Monad"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Prelude = PS["Prelude"];                 
+  var MonadTrans = function (lift) {
+      this.lift = lift;
+  };
+  var lift = function (dict) {
+      return dict.lift;
+  };
+  exports["lift"] = lift;
+  exports["MonadTrans"] = MonadTrans;
+})(PS["Control.Monad.Trans.Class"] = PS["Control.Monad.Trans.Class"] || {});
 (function(exports) {
     "use strict";
 
-  exports.pureE = function (a) {
-    return function () {
-      return a;
-    };
+  exports.topInt = 2147483647;
+  exports.bottomInt = -2147483648;
+
+  exports.topChar = String.fromCharCode(65535);
+  exports.bottomChar = String.fromCharCode(0);
+})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Bounded"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Unit = PS["Data.Unit"];                 
+  var Bounded = function (Ord0, bottom, top) {
+      this.Ord0 = Ord0;
+      this.bottom = bottom;
+      this.top = top;
+  };
+  var top = function (dict) {
+      return dict.top;
+  };                                            
+  var boundedInt = new Bounded(function () {
+      return Data_Ord.ordInt;
+  }, $foreign.bottomInt, $foreign.topInt);
+  var boundedChar = new Bounded(function () {
+      return Data_Ord.ordChar;
+  }, $foreign.bottomChar, $foreign.topChar);
+  var bottom = function (dict) {
+      return dict.bottom;
   };
+  exports["Bounded"] = Bounded;
+  exports["bottom"] = bottom;
+  exports["top"] = top;
+  exports["boundedInt"] = boundedInt;
+  exports["boundedChar"] = boundedChar;
+})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+(function(exports) {
+    "use strict";
 
-  exports.bindE = function (a) {
-    return function (f) {
-      return function () {
-        return f(a())();
-      };
-    };
+  exports.intDegree = function (x) {
+    return Math.min(Math.abs(x), 2147483647);
   };
 
-  exports.runPure = function (f) {
-    return f();
+  // See the Euclidean definition in
+  // https://en.m.wikipedia.org/wiki/Modulo_operation.
+  exports.intDiv = function (x) {
+    return function (y) {
+      if (y === 0) return 0;
+      return y > 0 ? Math.floor(x / y) : -Math.floor(x / -y);
+    };
   };
 
-  exports.foreachE = function (as) {
-    return function (f) {
-      return function () {
-        for (var i = 0, l = as.length; i < l; i++) {
-          f(as[i])();
-        }
-      };
+  exports.intMod = function (x) {
+    return function (y) {
+      if (y === 0) return 0;
+      var yy = Math.abs(y);
+      return ((x % yy) + yy) % yy;
     };
   };
-})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
+})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Monad = PS["Control.Monad"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Unit = PS["Data.Unit"];        
-  var monadEff = new Control_Monad.Monad(function () {
-      return applicativeEff;
-  }, function () {
-      return bindEff;
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];                 
+  var CommutativeRing = function (Ring0) {
+      this.Ring0 = Ring0;
+  }; 
+  var commutativeRingInt = new CommutativeRing(function () {
+      return Data_Ring.ringInt;
   });
-  var bindEff = new Control_Bind.Bind(function () {
-      return applyEff;
-  }, $foreign.bindE);
-  var applyEff = new Control_Apply.Apply(function () {
-      return functorEff;
-  }, Control_Monad.ap(monadEff));
-  var applicativeEff = new Control_Applicative.Applicative(function () {
-      return applyEff;
-  }, $foreign.pureE);
-  var functorEff = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEff));
-  exports["functorEff"] = functorEff;
-  exports["applyEff"] = applyEff;
-  exports["applicativeEff"] = applicativeEff;
-  exports["bindEff"] = bindEff;
-  exports["monadEff"] = monadEff;
-  exports["runPure"] = $foreign.runPure;
-  exports["foreachE"] = $foreign.foreachE;
-})(PS["Control.Monad.Eff"] = PS["Control.Monad.Eff"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
+  exports["CommutativeRing"] = CommutativeRing;
+  exports["commutativeRingInt"] = commutativeRingInt;
+})(PS["Data.CommutativeRing"] = PS["Data.CommutativeRing"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Category = PS["Control.Category"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];        
-  var MonadEff = function (Monad0, liftEff) {
-      this.Monad0 = Monad0;
-      this.liftEff = liftEff;
-  };
-  var monadEffEff = new MonadEff(function () {
-      return Control_Monad_Eff.monadEff;
-  }, Control_Category.id(Control_Category.categoryFn));
-  var liftEff = function (dict) {
-      return dict.liftEff;
+  var $foreign = PS["Data.EuclideanRing"];
+  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];                 
+  var EuclideanRing = function (CommutativeRing0, degree, div, mod) {
+      this.CommutativeRing0 = CommutativeRing0;
+      this.degree = degree;
+      this.div = div;
+      this.mod = mod;
+  };
+  var mod = function (dict) {
+      return dict.mod;
+  }; 
+  var euclideanRingInt = new EuclideanRing(function () {
+      return Data_CommutativeRing.commutativeRingInt;
+  }, $foreign.intDegree, $foreign.intDiv, $foreign.intMod);
+  var div = function (dict) {
+      return dict.div;
+  };
+  var degree = function (dict) {
+      return dict.degree;
+  };
+  exports["EuclideanRing"] = EuclideanRing;
+  exports["degree"] = degree;
+  exports["div"] = div;
+  exports["mod"] = mod;
+  exports["euclideanRingInt"] = euclideanRingInt;
+})(PS["Data.EuclideanRing"] = PS["Data.EuclideanRing"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Symbol = PS["Data.Symbol"];
+  var Data_Unit = PS["Data.Unit"];
+  var Record_Unsafe = PS["Record.Unsafe"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];                 
+  var Monoid = function (Semigroup0, mempty) {
+      this.Semigroup0 = Semigroup0;
+      this.mempty = mempty;
+  };                 
+  var monoidString = new Monoid(function () {
+      return Data_Semigroup.semigroupString;
+  }, "");
+  var mempty = function (dict) {
+      return dict.mempty;
   };
-  exports["liftEff"] = liftEff;
-  exports["MonadEff"] = MonadEff;
-  exports["monadEffEff"] = monadEffEff;
-})(PS["Control.Monad.Eff.Class"] = PS["Control.Monad.Eff.Class"] || {});
+  exports["Monoid"] = Monoid;
+  exports["mempty"] = mempty;
+  exports["monoidString"] = monoidString;
+})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Function = PS["Data.Function"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad = PS["Control.Monad"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Eq = PS["Data.Eq"];
   var Data_Functor = PS["Data.Functor"];
-  var Prelude = PS["Prelude"];        
-  var Newtype = function (unwrap, wrap) {
-      this.unwrap = unwrap;
-      this.wrap = wrap;
-  };
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Prelude = PS["Prelude"];                 
+  var Disj = function (x) {
+      return x;
+  };
+  var semigroupDisj = function (dictHeytingAlgebra) {
+      return new Data_Semigroup.Semigroup(function (v) {
+          return function (v1) {
+              return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
+          };
+      });
+  };
+  var monoidDisj = function (dictHeytingAlgebra) {
+      return new Data_Monoid.Monoid(function () {
+          return semigroupDisj(dictHeytingAlgebra);
+      }, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
+  };
+  exports["Disj"] = Disj;
+  exports["semigroupDisj"] = semigroupDisj;
+  exports["monoidDisj"] = monoidDisj;
+})(PS["Data.Monoid.Disj"] = PS["Data.Monoid.Disj"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Semigroup_First = PS["Data.Semigroup.First"];
+  var Data_Semigroup_Last = PS["Data.Semigroup.Last"];
+  var Prelude = PS["Prelude"];                 
+  var Newtype = function (unwrap, wrap) {
+      this.unwrap = unwrap;
+      this.wrap = wrap;
+  };
   var wrap = function (dict) {
       return dict.wrap;
   };
   var unwrap = function (dict) {
       return dict.unwrap;
-  };
+  };                        
+  var newtypeDisj = new Newtype(function (v) {
+      return v;
+  }, Data_Monoid_Disj.Disj);
   var alaF = function (dictFunctor) {
       return function (dictFunctor1) {
           return function (dictNewtype) {
               return function (dictNewtype1) {
                   return function (v) {
                       return function (f) {
-                          return function ($64) {
-                              return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(wrap(dictNewtype))($64)));
+                          return function ($80) {
+                              return Data_Functor.map(dictFunctor1)(unwrap(dictNewtype1))(f(Data_Functor.map(dictFunctor)(wrap(dictNewtype))($80)));
                           };
                       };
                   };
@@ -518,16 +1015,86 @@ var PS = {};
   exports["wrap"] = wrap;
   exports["Newtype"] = Newtype;
   exports["alaF"] = alaF;
+  exports["newtypeDisj"] = newtypeDisj;
 })(PS["Data.Newtype"] = PS["Data.Newtype"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+    "use strict";
+
+  exports.pureE = function (a) {
+    return function () {
+      return a;
+    };
+  };
+
+  exports.bindE = function (a) {
+    return function (f) {
+      return function () {
+        return f(a())();
+      };
+    };
+  };
+})(PS["Effect"] = PS["Effect"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Effect"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad = PS["Control.Monad"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Prelude = PS["Prelude"];                 
+  var monadEffect = new Control_Monad.Monad(function () {
+      return applicativeEffect;
+  }, function () {
+      return bindEffect;
+  });
+  var bindEffect = new Control_Bind.Bind(function () {
+      return applyEffect;
+  }, $foreign.bindE);
+  var applyEffect = new Control_Apply.Apply(function () {
+      return functorEffect;
+  }, Control_Monad.ap(monadEffect));
+  var applicativeEffect = new Control_Applicative.Applicative(function () {
+      return applyEffect;
+  }, $foreign.pureE);
+  var functorEffect = new Data_Functor.Functor(Control_Applicative.liftA1(applicativeEffect));
+  exports["functorEffect"] = functorEffect;
+  exports["applyEffect"] = applyEffect;
+  exports["applicativeEffect"] = applicativeEffect;
+  exports["bindEffect"] = bindEffect;
+  exports["monadEffect"] = monadEffect;
+})(PS["Effect"] = PS["Effect"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Category = PS["Control.Category"];
+  var Control_Monad = PS["Control.Monad"];
+  var Effect = PS["Effect"];                 
+  var MonadEffect = function (Monad0, liftEffect) {
+      this.Monad0 = Monad0;
+      this.liftEffect = liftEffect;
+  };
+  var monadEffectEffect = new MonadEffect(function () {
+      return Effect.monadEffect;
+  }, Control_Category.identity(Control_Category.categoryFn));
+  var liftEffect = function (dict) {
+      return dict.liftEffect;
+  };
+  exports["liftEffect"] = liftEffect;
+  exports["MonadEffect"] = MonadEffect;
+  exports["monadEffectEffect"] = monadEffectEffect;
+})(PS["Effect.Class"] = PS["Effect.Class"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Monad = PS["Control.Monad"];
   var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
   var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
   var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
   var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
@@ -535,12 +1102,20 @@ var PS = {};
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Newtype = PS["Data.Newtype"];
+  var Effect_Class = PS["Effect.Class"];
   var Prelude = PS["Prelude"];
   var runContT = function (v) {
       return function (k) {
           return v(k);
       };
-  };
+  };        
+  var monadTransContT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {
+      return function (m) {
+          return function (k) {
+              return Control_Bind.bind(dictMonad.Bind1())(m)(k);
+          };
+      };
+  });
   var functorContT = function (dictFunctor) {
       return new Data_Functor.Functor(function (f) {
           return function (v) {
@@ -597,1389 +1172,1929 @@ var PS = {};
           return bindContT(dictMonad.Bind1());
       });
   };
+  var monadEffectContT = function (dictMonadEffect) {
+      return new Effect_Class.MonadEffect(function () {
+          return monadContT(dictMonadEffect.Monad0());
+      }, function ($46) {
+          return Control_Monad_Trans_Class.lift(monadTransContT)(dictMonadEffect.Monad0())(Effect_Class.liftEffect(dictMonadEffect)($46));
+      });
+  };
   exports["runContT"] = runContT;
   exports["functorContT"] = functorContT;
   exports["applyContT"] = applyContT;
   exports["applicativeContT"] = applicativeContT;
   exports["bindContT"] = bindContT;
   exports["monadContT"] = monadContT;
+  exports["monadTransContT"] = monadTransContT;
+  exports["monadEffectContT"] = monadEffectContT;
 })(PS["Control.Monad.Cont.Trans"] = PS["Control.Monad.Cont.Trans"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Category = PS["Control.Category"];                 
+  var Bifunctor = function (bimap) {
+      this.bimap = bimap;
+  };
+  var bimap = function (dict) {
+      return dict.bimap;
+  };
+  var lmap = function (dictBifunctor) {
+      return function (f) {
+          return bimap(dictBifunctor)(f)(Control_Category.identity(Control_Category.categoryFn));
+      };
+  };
+  exports["bimap"] = bimap;
+  exports["Bifunctor"] = Bifunctor;
+  exports["lmap"] = lmap;
+})(PS["Data.Bifunctor"] = PS["Data.Bifunctor"] || {});
 (function(exports) {
     "use strict";
 
-  exports.error = function (s) {
-    return function () {
-      console.error(s);
-      return {};
+  exports.foldrArray = function (f) {
+    return function (init) {
+      return function (xs) {
+        var acc = init;
+        var len = xs.length;
+        for (var i = len - 1; i >= 0; i--) {
+          acc = f(xs[i])(acc);
+        }
+        return acc;
+      };
+    };
+  };
+
+  exports.foldlArray = function (f) {
+    return function (init) {
+      return function (xs) {
+        var acc = init;
+        var len = xs.length;
+        for (var i = 0; i < len; i++) {
+          acc = f(acc)(xs[i]);
+        }
+        return acc;
+      };
     };
   };
-})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
+})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff.Console"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Unit = PS["Data.Unit"];
-  exports["error"] = $foreign.error;
-})(PS["Control.Monad.Eff.Console"] = PS["Control.Monad.Eff.Console"] || {});
+  var Control_Alt = PS["Control.Alt"];
+  var Data_Functor = PS["Data.Functor"];                 
+  var Plus = function (Alt0, empty) {
+      this.Alt0 = Alt0;
+      this.empty = empty;
+  };       
+  var empty = function (dict) {
+      return dict.empty;
+  };
+  exports["Plus"] = Plus;
+  exports["empty"] = empty;
+})(PS["Control.Plus"] = PS["Control.Plus"] || {});
 (function(exports) {
-  /* global exports */
+  // Generated by purs version 0.12.0
   "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Plus = PS["Control.Plus"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Nothing = (function () {
+      function Nothing() {
 
-  exports.ready = function(func) {
-      return function() {
-          jQuery(document).ready(func);
       };
-  };
-
-  exports.select = function(selector) {
-      return function() {
-          return jQuery(selector);
+      Nothing.value = new Nothing();
+      return Nothing;
+  })();
+  var Just = (function () {
+      function Just(value0) {
+          this.value0 = value0;
       };
-  };
-
-  exports.create = function(html) {
-      return function() {
-          return jQuery(html);
+      Just.create = function (value0) {
+          return new Just(value0);
       };
-  };
-
-  exports.setAttr = function(attr) {
-      return function(val) {
-          return function(ob) {
-              return function() {
-                  ob.attr(attr, val);
+      return Just;
+  })();
+  var maybe = function (v) {
+      return function (v1) {
+          return function (v2) {
+              if (v2 instanceof Nothing) {
+                  return v;
               };
+              if (v2 instanceof Just) {
+                  return v1(v2.value0);
+              };
+              throw new Error("Failed pattern match at Data.Maybe line 218, column 1 - line 218, column 51: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
           };
       };
   };
-
-  exports.attr = function(attrs) {
-      return function(ob) {
-          return function() {
-              ob.attr(attrs);
-          };
-      };
-  };
-
-  exports.toggleClass = function(cls) {
-      return function(ob) {
-          return function() {
-              ob.toggleClass(cls);
+  var isNothing = maybe(true)(Data_Function["const"](false));
+  var functorMaybe = new Data_Functor.Functor(function (v) {
+      return function (v1) {
+          if (v1 instanceof Just) {
+              return new Just(v(v1.value0));
           };
+          return Nothing.value;
       };
+  });
+  var fromMaybe = function (a) {
+      return maybe(a)(Control_Category.identity(Control_Category.categoryFn));
   };
-
-  exports.setClass = function(cls) {
-      return function(flag) {
-          return function(ob) {
-              return function() {
-                  ob.toggleClass(cls, flag);
+  var fromJust = function (dictPartial) {
+      return function (v) {
+          var $__unused = function (dictPartial1) {
+              return function ($dollar35) {
+                  return $dollar35;
               };
           };
+          return $__unused(dictPartial)((function () {
+              if (v instanceof Just) {
+                  return v.value0;
+              };
+              throw new Error("Failed pattern match at Data.Maybe line 269, column 1 - line 269, column 46: " + [ v.constructor.name ]);
+          })());
       };
   };
-
-  exports.setProp = function(p) {
-      return function(val) {
-          return function(ob) {
-              return function() {
-                  ob.prop(p, val);
-              };
+  var applyMaybe = new Control_Apply.Apply(function () {
+      return functorMaybe;
+  }, function (v) {
+      return function (v1) {
+          if (v instanceof Just) {
+              return Data_Functor.map(functorMaybe)(v.value0)(v1);
           };
+          if (v instanceof Nothing) {
+              return Nothing.value;
+          };
+          throw new Error("Failed pattern match at Data.Maybe line 67, column 1 - line 67, column 35: " + [ v.constructor.name, v1.constructor.name ]);
       };
-  };
-
-  exports.append = function(ob1) {
-      return function(ob) {
-          return function() {
-              ob.append(ob1);
-          };
-      };
-  };
-
-  exports.setText = function(text) {
-      return function(ob) {
-          return function() {
-              ob.text(text);
+  });
+  var bindMaybe = new Control_Bind.Bind(function () {
+      return applyMaybe;
+  }, function (v) {
+      return function (v1) {
+          if (v instanceof Just) {
+              return v1(v.value0);
           };
+          if (v instanceof Nothing) {
+              return Nothing.value;
+          };
+          throw new Error("Failed pattern match at Data.Maybe line 126, column 1 - line 126, column 33: " + [ v.constructor.name, v1.constructor.name ]);
       };
+  });
+  var applicativeMaybe = new Control_Applicative.Applicative(function () {
+      return applyMaybe;
+  }, Just.create);
+  exports["Nothing"] = Nothing;
+  exports["Just"] = Just;
+  exports["maybe"] = maybe;
+  exports["fromMaybe"] = fromMaybe;
+  exports["isNothing"] = isNothing;
+  exports["fromJust"] = fromJust;
+  exports["functorMaybe"] = functorMaybe;
+  exports["applyMaybe"] = applyMaybe;
+  exports["applicativeMaybe"] = applicativeMaybe;
+  exports["bindMaybe"] = bindMaybe;
+})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Foldable"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Foldable = function (foldMap, foldl, foldr) {
+      this.foldMap = foldMap;
+      this.foldl = foldl;
+      this.foldr = foldr;
   };
-
-  exports.setValue = function(val) {
-      return function(ob) {
-          return function() {
-              ob.val(val);
+  var foldr = function (dict) {
+      return dict.foldr;
+  };
+  var traverse_ = function (dictApplicative) {
+      return function (dictFoldable) {
+          return function (f) {
+              return foldr(dictFoldable)(function ($195) {
+                  return Control_Apply.applySecond(dictApplicative.Apply0())(f($195));
+              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
           };
       };
   };
-
-  exports.toggle = function(ob) {
-      return function() {
-          ob.toggle();
+  var for_ = function (dictApplicative) {
+      return function (dictFoldable) {
+          return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
       };
   };
-
-  exports.setVisible = function(flag) {
-      return function(ob) {
-          return function() {
-              ob.toggle(flag);
+  var foldl = function (dict) {
+      return dict.foldl;
+  };
+  var intercalate = function (dictFoldable) {
+      return function (dictMonoid) {
+          return function (sep) {
+              return function (xs) {
+                  var go = function (v) {
+                      return function (x) {
+                          if (v.init) {
+                              return {
+                                  init: false,
+                                  acc: x
+                              };
+                          };
+                          return {
+                              init: false,
+                              acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
+                          };
+                      };
+                  };
+                  return (foldl(dictFoldable)(go)({
+                      init: true,
+                      acc: Data_Monoid.mempty(dictMonoid)
+                  })(xs)).acc;
+              };
           };
       };
-  };
-
-  exports.on = function(evt) {
-      return function(act) {
-          return function(ob) {
-              return function() {
-                  ob.on(evt, function(e) {
-                      act(e)(jQuery(this))();
-                  });
+  }; 
+  var foldableMaybe = new Foldable(function (dictMonoid) {
+      return function (f) {
+          return function (v) {
+              if (v instanceof Data_Maybe.Nothing) {
+                  return Data_Monoid.mempty(dictMonoid);
+              };
+              if (v instanceof Data_Maybe.Just) {
+                  return f(v.value0);
               };
+              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ f.constructor.name, v.constructor.name ]);
+          };
+      };
+  }, function (v) {
+      return function (z) {
+          return function (v1) {
+              if (v1 instanceof Data_Maybe.Nothing) {
+                  return z;
+              };
+              if (v1 instanceof Data_Maybe.Just) {
+                  return v(z)(v1.value0);
+              };
+              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+          };
+      };
+  }, function (v) {
+      return function (z) {
+          return function (v1) {
+              if (v1 instanceof Data_Maybe.Nothing) {
+                  return z;
+              };
+              if (v1 instanceof Data_Maybe.Just) {
+                  return v(v1.value0)(z);
+              };
+              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+          };
+      };
+  });
+  var foldMapDefaultR = function (dictFoldable) {
+      return function (dictMonoid) {
+          return function (f) {
+              return foldr(dictFoldable)(function (x) {
+                  return function (acc) {
+                      return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
+                  };
+              })(Data_Monoid.mempty(dictMonoid));
           };
       };
   };
-})(PS["Control.Monad.Eff.JQuery"] = PS["Control.Monad.Eff.JQuery"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.unsafeFromForeign = function (value) {
-    return value;
-  };
-
-  exports.typeOf = function (value) {
-    return typeof value;
-  };
-
-  exports.tagOf = function (value) {
-    return Object.prototype.toString.call(value).slice(8, -1);
-  };
-
-  exports.isNull = function (value) {
-    return value === null;
-  };
-
-  exports.isUndefined = function (value) {
-    return value === undefined;
-  };
-
-  exports.isArray = Array.isArray || function (value) {
-    return Object.prototype.toString.call(value) === "[object Array]";
+  var foldableArray = new Foldable(function (dictMonoid) {
+      return foldMapDefaultR(foldableArray)(dictMonoid);
+  }, $foreign.foldlArray, $foreign.foldrArray);
+  var foldMap = function (dict) {
+      return dict.foldMap;
   };
-})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Category = PS["Control.Category"];        
-  var Bifunctor = function (bimap) {
-      this.bimap = bimap;
+  var fold = function (dictFoldable) {
+      return function (dictMonoid) {
+          return foldMap(dictFoldable)(dictMonoid)(Control_Category.identity(Control_Category.categoryFn));
+      };
   };
-  var bimap = function (dict) {
-      return dict.bimap;
+  var any = function (dictFoldable) {
+      return function (dictHeytingAlgebra) {
+          return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Newtype.newtypeDisj)(Data_Newtype.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
+      };
   };
-  var lmap = function (dictBifunctor) {
-      return function (f) {
-          return bimap(dictBifunctor)(f)(Control_Category.id(Control_Category.categoryFn));
+  var elem = function (dictFoldable) {
+      return function (dictEq) {
+          return function ($199) {
+              return any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Eq.eq(dictEq)($199));
+          };
       };
   };
-  exports["bimap"] = bimap;
-  exports["Bifunctor"] = Bifunctor;
-  exports["lmap"] = lmap;
-})(PS["Data.Bifunctor"] = PS["Data.Bifunctor"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.topInt = 2147483647;
-  exports.bottomInt = -2147483648;
-})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
+  exports["Foldable"] = Foldable;
+  exports["foldr"] = foldr;
+  exports["foldl"] = foldl;
+  exports["foldMap"] = foldMap;
+  exports["foldMapDefaultR"] = foldMapDefaultR;
+  exports["fold"] = fold;
+  exports["traverse_"] = traverse_;
+  exports["for_"] = for_;
+  exports["intercalate"] = intercalate;
+  exports["any"] = any;
+  exports["elem"] = elem;
+  exports["foldableArray"] = foldableArray;
+  exports["foldableMaybe"] = foldableMaybe;
+})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
 (function(exports) {
     "use strict";
 
-  exports.refEq = function (r1) {
-    return function (r2) {
-      return r1 === r2;
+  exports.mapWithIndexArray = function (f) {
+    return function (xs) {
+      var l = xs.length;
+      var result = Array(l);
+      for (var i = 0; i < l; i++) {
+        result[i] = f(i)(xs[i]);
+      }
+      return result;
     };
   };
-})(PS["Data.Eq"] = PS["Data.Eq"] || {});
+})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Eq"];
+  var $foreign = PS["Data.FunctorWithIndex"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
   var Data_Unit = PS["Data.Unit"];
-  var Data_Void = PS["Data.Void"];        
-  var Eq = function (eq) {
-      this.eq = eq;
+  var Prelude = PS["Prelude"];                 
+  var FunctorWithIndex = function (Functor0, mapWithIndex) {
+      this.Functor0 = Functor0;
+      this.mapWithIndex = mapWithIndex;
+  };
+  var mapWithIndex = function (dict) {
+      return dict.mapWithIndex;
   }; 
-  var eqString = new Eq($foreign.refEq);
-  var eqInt = new Eq($foreign.refEq);
-  var eq = function (dict) {
-      return dict.eq;
-  };
-  exports["Eq"] = Eq;
-  exports["eq"] = eq;
-  exports["eqInt"] = eqInt;
-  exports["eqString"] = eqString;
-})(PS["Data.Eq"] = PS["Data.Eq"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.unsafeCompareImpl = function (lt) {
-    return function (eq) {
-      return function (gt) {
-        return function (x) {
-          return function (y) {
-            return x < y ? lt : x === y ? eq : gt;
-          };
-        };
-      };
-    };
-  };
-})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
+  var functorWithIndexArray = new FunctorWithIndex(function () {
+      return Data_Functor.functorArray;
+  }, $foreign.mapWithIndexArray);
+  exports["FunctorWithIndex"] = FunctorWithIndex;
+  exports["mapWithIndex"] = mapWithIndex;
+  exports["functorWithIndexArray"] = functorWithIndexArray;
+})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Eq = PS["Data.Eq"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Newtype = PS["Data.Newtype"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];        
-  var LT = (function () {
-      function LT() {
-
-      };
-      LT.value = new LT();
-      return LT;
-  })();
-  var GT = (function () {
-      function GT() {
-
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var Tuple = (function () {
+      function Tuple(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
       };
-      GT.value = new GT();
-      return GT;
-  })();
-  var EQ = (function () {
-      function EQ() {
-
+      Tuple.create = function (value0) {
+          return function (value1) {
+              return new Tuple(value0, value1);
+          };
       };
-      EQ.value = new EQ();
-      return EQ;
+      return Tuple;
   })();
-  exports["LT"] = LT;
-  exports["GT"] = GT;
-  exports["EQ"] = EQ;
-})(PS["Data.Ordering"] = PS["Data.Ordering"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Ord.Unsafe"];
-  var Data_Ordering = PS["Data.Ordering"];        
-  var unsafeCompare = $foreign.unsafeCompareImpl(Data_Ordering.LT.value)(Data_Ordering.EQ.value)(Data_Ordering.GT.value);
-  exports["unsafeCompare"] = unsafeCompare;
-})(PS["Data.Ord.Unsafe"] = PS["Data.Ord.Unsafe"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Ord"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Ord_Unsafe = PS["Data.Ord.Unsafe"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Unit = PS["Data.Unit"];
-  var Data_Void = PS["Data.Void"];        
-  var Ord = function (Eq0, compare) {
-      this.Eq0 = Eq0;
-      this.compare = compare;
-  };                                
-  var ordInt = new Ord(function () {
-      return Data_Eq.eqInt;
-  }, Data_Ord_Unsafe.unsafeCompare);
-  var compare = function (dict) {
-      return dict.compare;
+  var FoldableWithIndex = function (Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
+      this.Foldable0 = Foldable0;
+      this.foldMapWithIndex = foldMapWithIndex;
+      this.foldlWithIndex = foldlWithIndex;
+      this.foldrWithIndex = foldrWithIndex;
   };
-  exports["Ord"] = Ord;
-  exports["compare"] = compare;
-  exports["ordInt"] = ordInt;
-})(PS["Data.Ord"] = PS["Data.Ord"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Bounded"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Unit = PS["Data.Unit"];        
-  var Bounded = function (Ord0, bottom, top) {
-      this.Ord0 = Ord0;
-      this.bottom = bottom;
-      this.top = top;
+  var foldrWithIndex = function (dict) {
+      return dict.foldrWithIndex;
   };
-  var top = function (dict) {
-      return dict.top;
-  };                                                 
-  var boundedInt = new Bounded(function () {
-      return Data_Ord.ordInt;
-  }, $foreign.bottomInt, $foreign.topInt);
-  var bottom = function (dict) {
-      return dict.bottom;
+  var traverseWithIndex_ = function (dictApplicative) {
+      return function (dictFoldableWithIndex) {
+          return function (f) {
+              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
+                  return function ($46) {
+                      return Control_Apply.applySecond(dictApplicative.Apply0())(f(i)($46));
+                  };
+              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
+          };
+      };
   };
-  exports["Bounded"] = Bounded;
-  exports["bottom"] = bottom;
-  exports["top"] = top;
-  exports["boundedInt"] = boundedInt;
-})(PS["Data.Bounded"] = PS["Data.Bounded"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.foldrArray = function (f) {
-    return function (init) {
-      return function (xs) {
-        var acc = init;
-        var len = xs.length;
-        for (var i = len - 1; i >= 0; i--) {
-          acc = f(xs[i])(acc);
-        }
-        return acc;
+  var forWithIndex_ = function (dictApplicative) {
+      return function (dictFoldableWithIndex) {
+          return Data_Function.flip(traverseWithIndex_(dictApplicative)(dictFoldableWithIndex));
       };
-    };
   };
-
-  exports.foldlArray = function (f) {
-    return function (init) {
-      return function (xs) {
-        var acc = init;
-        var len = xs.length;
-        for (var i = 0; i < len; i++) {
-          acc = f(acc)(xs[i]);
-        }
-        return acc;
+  var foldlWithIndex = function (dict) {
+      return dict.foldlWithIndex;
+  };
+  var foldMapWithIndexDefaultR = function (dictFoldableWithIndex) {
+      return function (dictMonoid) {
+          return function (f) {
+              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
+                  return function (x) {
+                      return function (acc) {
+                          return Data_Semigroup.append(dictMonoid.Semigroup0())(f(i)(x))(acc);
+                      };
+                  };
+              })(Data_Monoid.mempty(dictMonoid));
+          };
       };
-    };
   };
-})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Data_Functor = PS["Data.Functor"];        
-  var Plus = function (Alt0, empty) {
-      this.Alt0 = Alt0;
-      this.empty = empty;
-  };       
-  var empty = function (dict) {
-      return dict.empty;
+  var foldableWithIndexArray = new FoldableWithIndex(function () {
+      return Data_Foldable.foldableArray;
+  }, function (dictMonoid) {
+      return foldMapWithIndexDefaultR(foldableWithIndexArray)(dictMonoid);
+  }, function (f) {
+      return function (z) {
+          return function ($47) {
+              return Data_Foldable.foldl(Data_Foldable.foldableArray)(function (y) {
+                  return function (v) {
+                      return f(v.value0)(y)(v.value1);
+                  };
+              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($47));
+          };
+      };
+  }, function (f) {
+      return function (z) {
+          return function ($48) {
+              return Data_Foldable.foldr(Data_Foldable.foldableArray)(function (v) {
+                  return function (y) {
+                      return f(v.value0)(v.value1)(y);
+                  };
+              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($48));
+          };
+      };
+  });
+  var foldMapWithIndex = function (dict) {
+      return dict.foldMapWithIndex;
   };
-  exports["Plus"] = Plus;
-  exports["empty"] = empty;
-})(PS["Control.Plus"] = PS["Control.Plus"] || {});
+  exports["FoldableWithIndex"] = FoldableWithIndex;
+  exports["foldrWithIndex"] = foldrWithIndex;
+  exports["foldlWithIndex"] = foldlWithIndex;
+  exports["foldMapWithIndex"] = foldMapWithIndex;
+  exports["foldMapWithIndexDefaultR"] = foldMapWithIndexDefaultR;
+  exports["traverseWithIndex_"] = traverseWithIndex_;
+  exports["forWithIndex_"] = forWithIndex_;
+  exports["foldableWithIndexArray"] = foldableWithIndexArray;
+})(PS["Data.FoldableWithIndex"] = PS["Data.FoldableWithIndex"] || {});
 (function(exports) {
     "use strict";
 
-  exports.boolConj = function (b1) {
-    return function (b2) {
-      return b1 && b2;
-    };
-  };
+  // jshint maxparams: 3
 
-  exports.boolDisj = function (b1) {
-    return function (b2) {
-      return b1 || b2;
-    };
-  };
+  exports.traverseArrayImpl = function () {
+    function array1(a) {
+      return [a];
+    }
 
-  exports.boolNot = function (b) {
-    return !b;
-  };
-})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.HeytingAlgebra"];
-  var Data_Unit = PS["Data.Unit"];        
-  var HeytingAlgebra = function (conj, disj, ff, implies, not, tt) {
-      this.conj = conj;
-      this.disj = disj;
-      this.ff = ff;
-      this.implies = implies;
-      this.not = not;
-      this.tt = tt;
-  };
-  var tt = function (dict) {
-      return dict.tt;
-  };
-  var not = function (dict) {
-      return dict.not;
-  };
-  var implies = function (dict) {
-      return dict.implies;
-  };                 
-  var ff = function (dict) {
-      return dict.ff;
-  };
-  var disj = function (dict) {
-      return dict.disj;
-  };
-  var heytingAlgebraBoolean = new HeytingAlgebra($foreign.boolConj, $foreign.boolDisj, false, function (a) {
+    function array2(a) {
       return function (b) {
-          return disj(heytingAlgebraBoolean)(not(heytingAlgebraBoolean)(a))(b);
+        return [a, b];
       };
-  }, $foreign.boolNot, true);
-  var conj = function (dict) {
-      return dict.conj;
-  };
-  exports["HeytingAlgebra"] = HeytingAlgebra;
-  exports["tt"] = tt;
-  exports["ff"] = ff;
-  exports["implies"] = implies;
-  exports["conj"] = conj;
-  exports["disj"] = disj;
-  exports["not"] = not;
-  exports["heytingAlgebraBoolean"] = heytingAlgebraBoolean;
-})(PS["Data.HeytingAlgebra"] = PS["Data.HeytingAlgebra"] || {});
+    }
+
+    function array3(a) {
+      return function (b) {
+        return function (c) {
+          return [a, b, c];
+        };
+      };
+    }
+
+    function concat2(xs) {
+      return function (ys) {
+        return xs.concat(ys);
+      };
+    }
+
+    return function (apply) {
+      return function (map) {
+        return function (pure) {
+          return function (f) {
+            return function (array) {
+              function go(bot, top) {
+                switch (top - bot) {
+                case 0: return pure([]);
+                case 1: return map(array1)(f(array[bot]));
+                case 2: return apply(map(array2)(f(array[bot])))(f(array[bot + 1]));
+                case 3: return apply(apply(map(array3)(f(array[bot])))(f(array[bot + 1])))(f(array[bot + 2]));
+                default:
+                  // This slightly tricky pivot selection aims to produce two
+                  // even-length partitions where possible.
+                  var pivot = bot + Math.floor((top - bot) / 4) * 2;
+                  return apply(map(concat2)(go(bot, pivot)))(go(pivot, top));
+                }
+              }
+              return go(0, array.length);
+            };
+          };
+        };
+      };
+    };
+  }();
+})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var otherwise = true;
-  exports["otherwise"] = otherwise;
-})(PS["Data.Boolean"] = PS["Data.Boolean"] || {});
+  var $foreign = PS["Data.Traversable"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Category = PS["Control.Category"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
+  var Data_Maybe_Last = PS["Data.Maybe.Last"];
+  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
+  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
+  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
+  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
+  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
+  var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
+  var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
+  var Prelude = PS["Prelude"];                 
+  var Traversable = function (Foldable1, Functor0, sequence, traverse) {
+      this.Foldable1 = Foldable1;
+      this.Functor0 = Functor0;
+      this.sequence = sequence;
+      this.traverse = traverse;
+  };
+  var traverse = function (dict) {
+      return dict.traverse;
+  }; 
+  var sequenceDefault = function (dictTraversable) {
+      return function (dictApplicative) {
+          return traverse(dictTraversable)(dictApplicative)(Control_Category.identity(Control_Category.categoryFn));
+      };
+  };
+  var traversableArray = new Traversable(function () {
+      return Data_Foldable.foldableArray;
+  }, function () {
+      return Data_Functor.functorArray;
+  }, function (dictApplicative) {
+      return sequenceDefault(traversableArray)(dictApplicative);
+  }, function (dictApplicative) {
+      return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map((dictApplicative.Apply0()).Functor0()))(Control_Applicative.pure(dictApplicative));
+  });
+  var sequence = function (dict) {
+      return dict.sequence;
+  };
+  exports["Traversable"] = Traversable;
+  exports["traverse"] = traverse;
+  exports["sequence"] = sequence;
+  exports["sequenceDefault"] = sequenceDefault;
+  exports["traversableArray"] = traversableArray;
+})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Boolean = PS["Data.Boolean"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Bifoldable = PS["Data.Bifoldable"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
+  var Data_Bitraversable = PS["Data.Bitraversable"];
+  var Data_Bounded = PS["Data.Bounded"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_EuclideanRing = PS["Data.EuclideanRing"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Monoid = PS["Data.Monoid"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
   var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Monoid = function (Semigroup0, mempty) {
-      this.Semigroup0 = Semigroup0;
-      this.mempty = mempty;
-  };                 
-  var monoidString = new Monoid(function () {
-      return Data_Semigroup.semigroupString;
-  }, "");  
-  var mempty = function (dict) {
-      return dict.mempty;
+  var Prelude = PS["Prelude"];                 
+  var Left = (function () {
+      function Left(value0) {
+          this.value0 = value0;
+      };
+      Left.create = function (value0) {
+          return new Left(value0);
+      };
+      return Left;
+  })();
+  var Right = (function () {
+      function Right(value0) {
+          this.value0 = value0;
+      };
+      Right.create = function (value0) {
+          return new Right(value0);
+      };
+      return Right;
+  })();
+  var functorEither = new Data_Functor.Functor(function (f) {
+      return function (m) {
+          if (m instanceof Left) {
+              return new Left(m.value0);
+          };
+          if (m instanceof Right) {
+              return new Right(f(m.value0));
+          };
+          throw new Error("Failed pattern match at Data.Either line 38, column 8 - line 38, column 52: " + [ m.constructor.name ]);
+      };
+  });                                                                                                     
+  var fromRight = function (dictPartial) {
+      return function (v) {
+          var $__unused = function (dictPartial1) {
+              return function ($dollar71) {
+                  return $dollar71;
+              };
+          };
+          return $__unused(dictPartial)((function () {
+              if (v instanceof Right) {
+                  return v.value0;
+              };
+              throw new Error("Failed pattern match at Data.Either line 261, column 1 - line 261, column 52: " + [ v.constructor.name ]);
+          })());
+      };
+  };
+  var foldableEither = new Data_Foldable.Foldable(function (dictMonoid) {
+      return function (f) {
+          return function (v) {
+              if (v instanceof Left) {
+                  return Data_Monoid.mempty(dictMonoid);
+              };
+              if (v instanceof Right) {
+                  return f(v.value0);
+              };
+              throw new Error("Failed pattern match at Data.Either line 187, column 1 - line 187, column 47: " + [ f.constructor.name, v.constructor.name ]);
+          };
+      };
+  }, function (v) {
+      return function (z) {
+          return function (v1) {
+              if (v1 instanceof Left) {
+                  return z;
+              };
+              if (v1 instanceof Right) {
+                  return v(z)(v1.value0);
+              };
+              throw new Error("Failed pattern match at Data.Either line 187, column 1 - line 187, column 47: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+          };
+      };
+  }, function (v) {
+      return function (z) {
+          return function (v1) {
+              if (v1 instanceof Left) {
+                  return z;
+              };
+              if (v1 instanceof Right) {
+                  return v(v1.value0)(z);
+              };
+              throw new Error("Failed pattern match at Data.Either line 187, column 1 - line 187, column 47: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
+          };
+      };
+  });
+  var either = function (v) {
+      return function (v1) {
+          return function (v2) {
+              if (v2 instanceof Left) {
+                  return v(v2.value0);
+              };
+              if (v2 instanceof Right) {
+                  return v1(v2.value0);
+              };
+              throw new Error("Failed pattern match at Data.Either line 238, column 1 - line 238, column 64: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
+          };
+      };
+  };
+  var bifunctorEither = new Data_Bifunctor.Bifunctor(function (v) {
+      return function (v1) {
+          return function (v2) {
+              if (v2 instanceof Left) {
+                  return new Left(v(v2.value0));
+              };
+              if (v2 instanceof Right) {
+                  return new Right(v1(v2.value0));
+              };
+              throw new Error("Failed pattern match at Data.Either line 46, column 1 - line 46, column 45: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
+          };
+      };
+  });
+  var applyEither = new Control_Apply.Apply(function () {
+      return functorEither;
+  }, function (v) {
+      return function (v1) {
+          if (v instanceof Left) {
+              return new Left(v.value0);
+          };
+          if (v instanceof Right) {
+              return Data_Functor.map(functorEither)(v.value0)(v1);
+          };
+          throw new Error("Failed pattern match at Data.Either line 82, column 1 - line 82, column 41: " + [ v.constructor.name, v1.constructor.name ]);
+      };
+  });
+  var applicativeEither = new Control_Applicative.Applicative(function () {
+      return applyEither;
+  }, Right.create);
+  exports["Left"] = Left;
+  exports["Right"] = Right;
+  exports["either"] = either;
+  exports["fromRight"] = fromRight;
+  exports["functorEither"] = functorEither;
+  exports["bifunctorEither"] = bifunctorEither;
+  exports["applyEither"] = applyEither;
+  exports["applicativeEither"] = applicativeEither;
+  exports["foldableEither"] = foldableEither;
+})(PS["Data.Either"] = PS["Data.Either"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Unit = PS["Data.Unit"];
+  var Prelude = PS["Prelude"];                 
+  var MonadThrow = function (Monad0, throwError) {
+      this.Monad0 = Monad0;
+      this.throwError = throwError;
   };
-  exports["Monoid"] = Monoid;
-  exports["mempty"] = mempty;
-  exports["monoidString"] = monoidString;
-})(PS["Data.Monoid"] = PS["Data.Monoid"] || {});
+  var throwError = function (dict) {
+      return dict.throwError;
+  };
+  exports["throwError"] = throwError;
+  exports["MonadThrow"] = MonadThrow;
+})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
+  var Control_Biapplicative = PS["Control.Biapplicative"];
+  var Control_Biapply = PS["Control.Biapply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
+  var Control_Comonad = PS["Control.Comonad"];
   var Control_Extend = PS["Control.Extend"];
+  var Control_Lazy = PS["Control.Lazy"];
   var Control_Monad = PS["Control.Monad"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Bifoldable = PS["Data.Bifoldable"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
+  var Data_Bitraversable = PS["Data.Bitraversable"];
+  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
   var Data_Bounded = PS["Data.Bounded"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_Distributive = PS["Data.Distributive"];
   var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Maybe_First = PS["Data.Maybe.First"];
   var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
   var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Nothing = (function () {
-      function Nothing() {
-
-      };
-      Nothing.value = new Nothing();
-      return Nothing;
-  })();
-  var Just = (function () {
-      function Just(value0) {
+  var Prelude = PS["Prelude"];
+  var Type_Equality = PS["Type.Equality"];                 
+  var Tuple = (function () {
+      function Tuple(value0, value1) {
           this.value0 = value0;
+          this.value1 = value1;
       };
-      Just.create = function (value0) {
-          return new Just(value0);
-      };
-      return Just;
-  })();
-  var maybe = function (v) {
-      return function (v1) {
-          return function (v2) {
-              if (v2 instanceof Nothing) {
-                  return v;
-              };
-              if (v2 instanceof Just) {
-                  return v1(v2.value0);
-              };
-              throw new Error("Failed pattern match at Data.Maybe line 219, column 1 - line 219, column 51: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
-          };
-      };
-  };                                                      
-  var functorMaybe = new Data_Functor.Functor(function (v) {
-      return function (v1) {
-          if (v1 instanceof Just) {
-              return new Just(v(v1.value0));
+      Tuple.create = function (value0) {
+          return function (value1) {
+              return new Tuple(value0, value1);
           };
-          return Nothing.value;
       };
-  });
-  var fromMaybe = function (a) {
-      return maybe(a)(Control_Category.id(Control_Category.categoryFn));
+      return Tuple;
+  })();
+  var snd = function (v) {
+      return v.value1;
+  };                                                                                                    
+  var fst = function (v) {
+      return v.value0;
   };
-  exports["Nothing"] = Nothing;
-  exports["Just"] = Just;
-  exports["maybe"] = maybe;
-  exports["fromMaybe"] = fromMaybe;
-  exports["functorMaybe"] = functorMaybe;
-})(PS["Data.Maybe"] = PS["Data.Maybe"] || {});
+  exports["Tuple"] = Tuple;
+  exports["fst"] = fst;
+  exports["snd"] = snd;
+})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
+  var Control_Category = PS["Control.Category"];
   var Control_Monad = PS["Control.Monad"];
-  var Data_Bounded = PS["Data.Bounded"];
-  var Data_Eq = PS["Data.Eq"];
+  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
+  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
+  var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
+  var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
+  var Control_Monad_Writer_Class = PS["Control.Monad.Writer.Class"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Monoid = PS["Data.Monoid"];
   var Data_Newtype = PS["Data.Newtype"];
-  var Data_Ord = PS["Data.Ord"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Show = PS["Data.Show"];
-  var Prelude = PS["Prelude"];        
-  var Disj = function (x) {
+  var Data_Tuple = PS["Data.Tuple"];
+  var Effect_Class = PS["Effect.Class"];
+  var Prelude = PS["Prelude"];                 
+  var ExceptT = function (x) {
       return x;
   };
-  var semigroupDisj = function (dictHeytingAlgebra) {
-      return new Data_Semigroup.Semigroup(function (v) {
-          return function (v1) {
-              return Data_HeytingAlgebra.disj(dictHeytingAlgebra)(v)(v1);
+  var runExceptT = function (v) {
+      return v;
+  };          
+  var monadTransExceptT = new Control_Monad_Trans_Class.MonadTrans(function (dictMonad) {
+      return function (m) {
+          return Control_Bind.bind(dictMonad.Bind1())(m)(function (v) {
+              return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v));
+          });
+      };
+  });
+  var mapExceptT = function (f) {
+      return function (v) {
+          return f(v);
+      };
+  };
+  var functorExceptT = function (dictFunctor) {
+      return new Data_Functor.Functor(function (f) {
+          return mapExceptT(Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Either.functorEither)(f)));
+      });
+  };
+  var monadExceptT = function (dictMonad) {
+      return new Control_Monad.Monad(function () {
+          return applicativeExceptT(dictMonad);
+      }, function () {
+          return bindExceptT(dictMonad);
+      });
+  };
+  var bindExceptT = function (dictMonad) {
+      return new Control_Bind.Bind(function () {
+          return applyExceptT(dictMonad);
+      }, function (v) {
+          return function (k) {
+              return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either(function ($97) {
+                  return Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($97));
+              })(function (a) {
+                  var v1 = k(a);
+                  return v1;
+              }));
           };
       });
   };
-  var newtypeDisj = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Disj);
-  var monoidDisj = function (dictHeytingAlgebra) {
-      return new Data_Monoid.Monoid(function () {
-          return semigroupDisj(dictHeytingAlgebra);
-      }, Data_HeytingAlgebra.ff(dictHeytingAlgebra));
+  var applyExceptT = function (dictMonad) {
+      return new Control_Apply.Apply(function () {
+          return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
+      }, Control_Monad.ap(monadExceptT(dictMonad)));
   };
-  exports["Disj"] = Disj;
-  exports["newtypeDisj"] = newtypeDisj;
-  exports["semigroupDisj"] = semigroupDisj;
-  exports["monoidDisj"] = monoidDisj;
-})(PS["Data.Monoid.Disj"] = PS["Data.Monoid.Disj"] || {});
+  var applicativeExceptT = function (dictMonad) {
+      return new Control_Applicative.Applicative(function () {
+          return applyExceptT(dictMonad);
+      }, function ($98) {
+          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Right.create($98)));
+      });
+  };
+  var monadEffectExceptT = function (dictMonadEffect) {
+      return new Effect_Class.MonadEffect(function () {
+          return monadExceptT(dictMonadEffect.Monad0());
+      }, function ($99) {
+          return Control_Monad_Trans_Class.lift(monadTransExceptT)(dictMonadEffect.Monad0())(Effect_Class.liftEffect(dictMonadEffect)($99));
+      });
+  };
+  var monadThrowExceptT = function (dictMonad) {
+      return new Control_Monad_Error_Class.MonadThrow(function () {
+          return monadExceptT(dictMonad);
+      }, function ($102) {
+          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($102)));
+      });
+  };
+  var altExceptT = function (dictSemigroup) {
+      return function (dictMonad) {
+          return new Control_Alt.Alt(function () {
+              return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
+          }, function (v) {
+              return function (v1) {
+                  return Control_Bind.bind(dictMonad.Bind1())(v)(function (v2) {
+                      if (v2 instanceof Data_Either.Right) {
+                          return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v2.value0));
+                      };
+                      if (v2 instanceof Data_Either.Left) {
+                          return Control_Bind.bind(dictMonad.Bind1())(v1)(function (v3) {
+                              if (v3 instanceof Data_Either.Right) {
+                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v3.value0));
+                              };
+                              if (v3 instanceof Data_Either.Left) {
+                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Left(Data_Semigroup.append(dictSemigroup)(v2.value0)(v3.value0)));
+                              };
+                              throw new Error("Failed pattern match at Control.Monad.Except.Trans line 86, column 9 - line 88, column 49: " + [ v3.constructor.name ]);
+                          });
+                      };
+                      throw new Error("Failed pattern match at Control.Monad.Except.Trans line 82, column 5 - line 88, column 49: " + [ v2.constructor.name ]);
+                  });
+              };
+          });
+      };
+  };
+  exports["ExceptT"] = ExceptT;
+  exports["runExceptT"] = runExceptT;
+  exports["mapExceptT"] = mapExceptT;
+  exports["functorExceptT"] = functorExceptT;
+  exports["applyExceptT"] = applyExceptT;
+  exports["applicativeExceptT"] = applicativeExceptT;
+  exports["bindExceptT"] = bindExceptT;
+  exports["monadExceptT"] = monadExceptT;
+  exports["altExceptT"] = altExceptT;
+  exports["monadTransExceptT"] = monadTransExceptT;
+  exports["monadEffectExceptT"] = monadEffectExceptT;
+  exports["monadThrowExceptT"] = monadThrowExceptT;
+})(PS["Control.Monad.Except.Trans"] = PS["Control.Monad.Except.Trans"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foldable"];
   var Control_Alt = PS["Control.Alt"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Plus = PS["Control.Plus"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Control_Comonad = PS["Control.Comonad"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad = PS["Control.Monad"];
+  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Function = PS["Data.Function"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Functor = PS["Data.Functor"];
+  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
   var Data_Monoid = PS["Data.Monoid"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
   var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
   var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
   var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Foldable = function (foldMap, foldl, foldr) {
-      this.foldMap = foldMap;
-      this.foldl = foldl;
-      this.foldr = foldr;
-  };
-  var foldr = function (dict) {
-      return dict.foldr;
-  };
-  var traverse_ = function (dictApplicative) {
-      return function (dictFoldable) {
-          return function (f) {
-              return foldr(dictFoldable)(function ($184) {
-                  return Control_Apply.applySecond(dictApplicative.Apply0())(f($184));
-              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
-          };
-      };
-  };
-  var for_ = function (dictApplicative) {
-      return function (dictFoldable) {
-          return Data_Function.flip(traverse_(dictApplicative)(dictFoldable));
-      };
-  };
-  var foldl = function (dict) {
-      return dict.foldl;
+  var Prelude = PS["Prelude"];                 
+  var Identity = function (x) {
+      return x;
   };
-  var intercalate = function (dictFoldable) {
-      return function (dictMonoid) {
-          return function (sep) {
-              return function (xs) {
-                  var go = function (v) {
-                      return function (x) {
-                          if (v.init) {
-                              return {
-                                  init: false,
-                                  acc: x
-                              };
-                          };
-                          return {
-                              init: false,
-                              acc: Data_Semigroup.append(dictMonoid.Semigroup0())(v.acc)(Data_Semigroup.append(dictMonoid.Semigroup0())(sep)(x))
-                          };
-                      };
-                  };
-                  return (foldl(dictFoldable)(go)({
-                      init: true,
-                      acc: Data_Monoid.mempty(dictMonoid)
-                  })(xs)).acc;
-              };
-          };
-      };
-  }; 
-  var foldableMaybe = new Foldable(function (dictMonoid) {
-      return function (f) {
-          return function (v) {
-              if (v instanceof Data_Maybe.Nothing) {
-                  return Data_Monoid.mempty(dictMonoid);
-              };
-              if (v instanceof Data_Maybe.Just) {
-                  return f(v.value0);
-              };
-              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ f.constructor.name, v.constructor.name ]);
-          };
+  var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, Identity);
+  var functorIdentity = new Data_Functor.Functor(function (f) {
+      return function (m) {
+          return f(m);
       };
+  });
+  var applyIdentity = new Control_Apply.Apply(function () {
+      return functorIdentity;
   }, function (v) {
-      return function (z) {
-          return function (v1) {
-              if (v1 instanceof Data_Maybe.Nothing) {
-                  return z;
-              };
-              if (v1 instanceof Data_Maybe.Just) {
-                  return v(z)(v1.value0);
-              };
-              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
-          };
+      return function (v1) {
+          return v(v1);
       };
+  });
+  var bindIdentity = new Control_Bind.Bind(function () {
+      return applyIdentity;
   }, function (v) {
-      return function (z) {
-          return function (v1) {
-              if (v1 instanceof Data_Maybe.Nothing) {
-                  return z;
-              };
-              if (v1 instanceof Data_Maybe.Just) {
-                  return v(v1.value0)(z);
-              };
-              throw new Error("Failed pattern match at Data.Foldable line 129, column 1 - line 129, column 41: " + [ v.constructor.name, z.constructor.name, v1.constructor.name ]);
-          };
+      return function (f) {
+          return f(v);
       };
   });
-  var foldMapDefaultR = function (dictFoldable) {
-      return function (dictMonoid) {
-          return function (f) {
-              return foldr(dictFoldable)(function (x) {
-                  return function (acc) {
-                      return Data_Semigroup.append(dictMonoid.Semigroup0())(f(x))(acc);
-                  };
-              })(Data_Monoid.mempty(dictMonoid));
-          };
-      };
-  };
-  var foldableArray = new Foldable(function (dictMonoid) {
-      return foldMapDefaultR(foldableArray)(dictMonoid);
-  }, $foreign.foldlArray, $foreign.foldrArray);
-  var foldMap = function (dict) {
-      return dict.foldMap;
-  };
-  var fold = function (dictFoldable) {
-      return function (dictMonoid) {
-          return foldMap(dictFoldable)(dictMonoid)(Control_Category.id(Control_Category.categoryFn));
-      };
-  };
-  var any = function (dictFoldable) {
-      return function (dictHeytingAlgebra) {
-          return Data_Newtype.alaF(Data_Functor.functorFn)(Data_Functor.functorFn)(Data_Monoid_Disj.newtypeDisj)(Data_Monoid_Disj.newtypeDisj)(Data_Monoid_Disj.Disj)(foldMap(dictFoldable)(Data_Monoid_Disj.monoidDisj(dictHeytingAlgebra)));
-      };
+  var applicativeIdentity = new Control_Applicative.Applicative(function () {
+      return applyIdentity;
+  }, Identity);
+  var monadIdentity = new Control_Monad.Monad(function () {
+      return applicativeIdentity;
+  }, function () {
+      return bindIdentity;
+  });
+  exports["Identity"] = Identity;
+  exports["newtypeIdentity"] = newtypeIdentity;
+  exports["functorIdentity"] = functorIdentity;
+  exports["applyIdentity"] = applyIdentity;
+  exports["applicativeIdentity"] = applicativeIdentity;
+  exports["bindIdentity"] = bindIdentity;
+  exports["monadIdentity"] = monadIdentity;
+})(PS["Data.Identity"] = PS["Data.Identity"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Identity = PS["Data.Identity"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Prelude = PS["Prelude"];                                                           
+  var runExcept = function ($0) {
+      return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(Control_Monad_Except_Trans.runExceptT($0));
   };
-  var elem = function (dictFoldable) {
-      return function (dictEq) {
-          return function ($187) {
-              return any(dictFoldable)(Data_HeytingAlgebra.heytingAlgebraBoolean)(Data_Eq.eq(dictEq)($187));
-          };
-      };
+  var mapExcept = function (f) {
+      return Control_Monad_Except_Trans.mapExceptT(function ($1) {
+          return Data_Identity.Identity(f(Data_Newtype.unwrap(Data_Identity.newtypeIdentity)($1)));
+      });
   };
-  exports["Foldable"] = Foldable;
-  exports["foldr"] = foldr;
-  exports["foldl"] = foldl;
-  exports["foldMap"] = foldMap;
-  exports["foldMapDefaultR"] = foldMapDefaultR;
-  exports["fold"] = fold;
-  exports["traverse_"] = traverse_;
-  exports["for_"] = for_;
-  exports["intercalate"] = intercalate;
-  exports["any"] = any;
-  exports["elem"] = elem;
-  exports["foldableArray"] = foldableArray;
-  exports["foldableMaybe"] = foldableMaybe;
-})(PS["Data.Foldable"] = PS["Data.Foldable"] || {});
+  exports["runExcept"] = runExcept;
+  exports["mapExcept"] = mapExcept;
+})(PS["Control.Monad.Except"] = PS["Control.Monad.Except"] || {});
 (function(exports) {
     "use strict";
 
-  // jshint maxparams: 3
-
-  exports.traverseArrayImpl = function () {
-    function Cont(fn) {
-      this.fn = fn;
-    }
-
-    var emptyList = {};
-
-    var ConsCell = function (head, tail) {
-      this.head = head;
-      this.tail = tail;
-    };
-
-    function consList(x) {
-      return function (xs) {
-        return new ConsCell(x, xs);
+  exports.map_ = function (f) {
+    return function (a) {
+      return function () {
+        return f(a());
       };
-    }
-
-    function listToArray(list) {
-      var arr = [];
-      var xs = list;
-      while (xs !== emptyList) {
-        arr.push(xs.head);
-        xs = xs.tail;
-      }
-      return arr;
-    }
-
-    return function (apply) {
-      return function (map) {
-        return function (pure) {
-          return function (f) {
-            var buildFrom = function (x, ys) {
-              return apply(map(consList)(f(x)))(ys);
-            };
-
-            var go = function (acc, currentLen, xs) {
-              if (currentLen === 0) {
-                return acc;
-              } else {
-                var last = xs[currentLen - 1];
-                return new Cont(function () {
-                  return go(buildFrom(last, acc), currentLen - 1, xs);
-                });
-              }
-            };
+    };
+  };
 
-            return function (array) {
-              var result = go(pure(emptyList), array.length, array);
-              while (result instanceof Cont) {
-                result = result.fn();
-              }
+  exports.pure_ = function (a) {
+    return function () {
+      return a;
+    };
+  };
 
-              return map(listToArray)(result);
-            };
-          };
-        };
+  exports.bind_ = function (a) {
+    return function (f) {
+      return function () {
+        return f(a())();
       };
     };
-  }();
-})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Traversable"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Category = PS["Control.Category"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
-  var Data_Traversable_Accum = PS["Data.Traversable.Accum"];
-  var Data_Traversable_Accum_Internal = PS["Data.Traversable.Accum.Internal"];
-  var Prelude = PS["Prelude"];        
-  var Traversable = function (Foldable1, Functor0, sequence, traverse) {
-      this.Foldable1 = Foldable1;
-      this.Functor0 = Functor0;
-      this.sequence = sequence;
-      this.traverse = traverse;
   };
-  var traverse = function (dict) {
-      return dict.traverse;
-  }; 
-  var sequenceDefault = function (dictTraversable) {
-      return function (dictApplicative) {
-          return traverse(dictTraversable)(dictApplicative)(Control_Category.id(Control_Category.categoryFn));
+
+  exports.foreach = function (as) {
+    return function (f) {
+      return function () {
+        for (var i = 0, l = as.length; i < l; i++) {
+          f(as[i])();
+        }
       };
+    };
   };
-  var traversableArray = new Traversable(function () {
-      return Data_Foldable.foldableArray;
+})(PS["Control.Monad.ST.Internal"] = PS["Control.Monad.ST.Internal"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Control.Monad.ST.Internal"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Unit = PS["Data.Unit"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];
+  var functorST = new Data_Functor.Functor($foreign.map_);
+  var monadST = new Control_Monad.Monad(function () {
+      return applicativeST;
   }, function () {
-      return Data_Functor.functorArray;
-  }, function (dictApplicative) {
-      return sequenceDefault(traversableArray)(dictApplicative);
-  }, function (dictApplicative) {
-      return $foreign.traverseArrayImpl(Control_Apply.apply(dictApplicative.Apply0()))(Data_Functor.map((dictApplicative.Apply0()).Functor0()))(Control_Applicative.pure(dictApplicative));
+      return bindST;
   });
-  var sequence = function (dict) {
-      return dict.sequence;
+  var bindST = new Control_Bind.Bind(function () {
+      return applyST;
+  }, $foreign.bind_);
+  var applyST = new Control_Apply.Apply(function () {
+      return functorST;
+  }, Control_Monad.ap(monadST));
+  var applicativeST = new Control_Applicative.Applicative(function () {
+      return applyST;
+  }, $foreign.pure_);
+  exports["functorST"] = functorST;
+  exports["applyST"] = applyST;
+  exports["applicativeST"] = applicativeST;
+  exports["bindST"] = bindST;
+  exports["monadST"] = monadST;
+  exports["foreach"] = $foreign.foreach;
+})(PS["Control.Monad.ST.Internal"] = PS["Control.Monad.ST.Internal"] || {});
+(function(exports) {
+    "use strict";
+
+  // module Unsafe.Coerce
+
+  exports.unsafeCoerce = function (x) {
+    return x;
   };
-  exports["Traversable"] = Traversable;
-  exports["traverse"] = traverse;
-  exports["sequence"] = sequence;
-  exports["sequenceDefault"] = sequenceDefault;
-  exports["traversableArray"] = traversableArray;
-})(PS["Data.Traversable"] = PS["Data.Traversable"] || {});
+})(PS["Unsafe.Coerce"] = PS["Unsafe.Coerce"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Unsafe.Coerce"];
+  exports["unsafeCoerce"] = $foreign.unsafeCoerce;
+})(PS["Unsafe.Coerce"] = PS["Unsafe.Coerce"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
+  var Control_Comonad = PS["Control.Comonad"];
   var Control_Extend = PS["Control.Extend"];
+  var Control_Lazy = PS["Control.Lazy"];
   var Control_Monad = PS["Control.Monad"];
-  var Data_Bifoldable = PS["Data.Bifoldable"];
-  var Data_Bifunctor = PS["Data.Bifunctor"];
-  var Data_Bitraversable = PS["Data.Bitraversable"];
-  var Data_Bounded = PS["Data.Bounded"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Plus = PS["Control.Plus"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
-  var Data_Function = PS["Data.Function"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_Maybe = PS["Data.Maybe"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
   var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
-  var Left = (function () {
-      function Left(value0) {
-          this.value0 = value0;
-      };
-      Left.create = function (value0) {
-          return new Left(value0);
-      };
-      return Left;
-  })();
-  var Right = (function () {
-      function Right(value0) {
-          this.value0 = value0;
-      };
-      Right.create = function (value0) {
-          return new Right(value0);
-      };
-      return Right;
-  })();
-  var functorEither = new Data_Functor.Functor(function (v) {
-      return function (v1) {
-          if (v1 instanceof Left) {
-              return new Left(v1.value0);
-          };
-          if (v1 instanceof Right) {
-              return new Right(v(v1.value0));
-          };
-          throw new Error("Failed pattern match at Data.Either line 36, column 1 - line 36, column 45: " + [ v.constructor.name, v1.constructor.name ]);
-      };
-  });                                                                                                     
-  var fromRight = function (dictPartial) {
-      return function (v) {
-          var __unused = function (dictPartial1) {
-              return function ($dollar62) {
-                  return $dollar62;
-              };
-          };
-          return __unused(dictPartial)((function () {
-              if (v instanceof Right) {
-                  return v.value0;
-              };
-              throw new Error("Failed pattern match at Data.Either line 252, column 1 - line 252, column 52: " + [ v.constructor.name ]);
-          })());
-      };
-  };
-  var either = function (v) {
-      return function (v1) {
-          return function (v2) {
-              if (v2 instanceof Left) {
-                  return v(v2.value0);
-              };
-              if (v2 instanceof Right) {
-                  return v1(v2.value0);
-              };
-              throw new Error("Failed pattern match at Data.Either line 229, column 1 - line 229, column 64: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
-          };
-      };
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];                 
+  var App = function (x) {
+      return x;
   };
-  var bifunctorEither = new Data_Bifunctor.Bifunctor(function (v) {
-      return function (v1) {
-          return function (v2) {
-              if (v2 instanceof Left) {
-                  return new Left(v(v2.value0));
-              };
-              if (v2 instanceof Right) {
-                  return new Right(v1(v2.value0));
+  var semigroupApp = function (dictApply) {
+      return function (dictSemigroup) {
+          return new Data_Semigroup.Semigroup(function (v) {
+              return function (v1) {
+                  return Control_Apply.lift2(dictApply)(Data_Semigroup.append(dictSemigroup))(v)(v1);
               };
-              throw new Error("Failed pattern match at Data.Either line 43, column 1 - line 43, column 45: " + [ v.constructor.name, v1.constructor.name, v2.constructor.name ]);
-          };
-      };
-  });
-  var applyEither = new Control_Apply.Apply(function () {
-      return functorEither;
-  }, function (v) {
-      return function (v1) {
-          if (v instanceof Left) {
-              return new Left(v.value0);
-          };
-          if (v instanceof Right) {
-              return Data_Functor.map(functorEither)(v.value0)(v1);
-          };
-          throw new Error("Failed pattern match at Data.Either line 79, column 1 - line 79, column 41: " + [ v.constructor.name, v1.constructor.name ]);
+          });
       };
-  });
-  var applicativeEither = new Control_Applicative.Applicative(function () {
-      return applyEither;
-  }, Right.create);
-  exports["Left"] = Left;
-  exports["Right"] = Right;
-  exports["either"] = either;
-  exports["fromRight"] = fromRight;
-  exports["functorEither"] = functorEither;
-  exports["bifunctorEither"] = bifunctorEither;
-  exports["applyEither"] = applyEither;
-  exports["applicativeEither"] = applicativeEither;
-})(PS["Data.Either"] = PS["Data.Either"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var MonadThrow = function (Monad0, throwError) {
-      this.Monad0 = Monad0;
-      this.throwError = throwError;
   };
-  var throwError = function (dict) {
-      return dict.throwError;
+  var newtypeApp = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, App);
+  var applicativeApp = function (dictApplicative) {
+      return dictApplicative;
   };
-  exports["throwError"] = throwError;
-  exports["MonadThrow"] = MonadThrow;
-})(PS["Control.Monad.Error.Class"] = PS["Control.Monad.Error.Class"] || {});
+  exports["App"] = App;
+  exports["newtypeApp"] = newtypeApp;
+  exports["semigroupApp"] = semigroupApp;
+  exports["applicativeApp"] = applicativeApp;
+})(PS["Data.Functor.App"] = PS["Data.Functor.App"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
-  var Control_Biapplicative = PS["Control.Biapplicative"];
-  var Control_Biapply = PS["Control.Biapply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad = PS["Control.Monad"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Plus = PS["Control.Plus"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Bifoldable = PS["Data.Bifoldable"];
-  var Data_Bifunctor = PS["Data.Bifunctor"];
-  var Data_Bitraversable = PS["Data.Bitraversable"];
-  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
-  var Data_Bounded = PS["Data.Bounded"];
-  var Data_CommutativeRing = PS["Data.CommutativeRing"];
-  var Data_Distributive = PS["Data.Distributive"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Functor_App = PS["Data.Functor.App"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
   var Data_Traversable = PS["Data.Traversable"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];
-  var Type_Equality = PS["Type.Equality"];        
-  var Tuple = (function () {
-      function Tuple(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Prelude = PS["Prelude"];                 
+  var Compose = function (x) {
+      return x;
+  };          
+  var functorCompose = function (dictFunctor) {
+      return function (dictFunctor1) {
+          return new Data_Functor.Functor(function (f) {
+              return function (v) {
+                  return Compose(Data_Functor.map(dictFunctor)(Data_Functor.map(dictFunctor1)(f))(v));
+              };
+          });
+      };
+  };
+  var applyCompose = function (dictApply) {
+      return function (dictApply1) {
+          return new Control_Apply.Apply(function () {
+              return functorCompose(dictApply.Functor0())(dictApply1.Functor0());
+          }, function (v) {
+              return function (v1) {
+                  return Compose(Control_Apply.apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Control_Apply.apply(dictApply1))(v))(v1));
+              };
+          });
+      };
+  };
+  var applicativeCompose = function (dictApplicative) {
+      return function (dictApplicative1) {
+          return new Control_Applicative.Applicative(function () {
+              return applyCompose(dictApplicative.Apply0())(dictApplicative1.Apply0());
+          }, function ($104) {
+              return Compose(Control_Applicative.pure(dictApplicative)(Control_Applicative.pure(dictApplicative1)($104)));
+          });
+      };
+  };
+  exports["Compose"] = Compose;
+  exports["functorCompose"] = functorCompose;
+  exports["applyCompose"] = applyCompose;
+  exports["applicativeCompose"] = applicativeCompose;
+})(PS["Data.Functor.Compose"] = PS["Data.Functor.Compose"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.new = function (val) {
+    return function () {
+      return { value: val };
+    };
+  };
+
+  exports.read = function (ref) {
+    return function () {
+      return ref.value;
+    };
+  };
+
+  exports["modify'"] = function (f) {
+    return function (ref) {
+      return function () {
+        var t = f(ref.value);
+        ref.value = t.state;
+        return t.value;
+      };
+    };
+  };
+
+  exports.write = function (val) {
+    return function (ref) {
+      return function () {
+        ref.value = val;
+        return {};
       };
-      Tuple.create = function (value0) {
-          return function (value1) {
-              return new Tuple(value0, value1);
+    };
+  };
+})(PS["Effect.Ref"] = PS["Effect.Ref"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Effect.Ref"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];                 
+  var modify = function (f) {
+      return $foreign["modify'"](function (s) {
+          var s$prime = f(s);
+          return {
+              state: s$prime,
+              value: s$prime
           };
+      });
+  };
+  var modify_ = function (f) {
+      return function (s) {
+          return Data_Functor["void"](Effect.functorEffect)(modify(f)(s));
       };
-      return Tuple;
-  })();
-  exports["Tuple"] = Tuple;
-})(PS["Data.Tuple"] = PS["Data.Tuple"] || {});
+  };
+  exports["modify"] = modify;
+  exports["modify_"] = modify_;
+  exports["new"] = $foreign["new"];
+  exports["read"] = $foreign.read;
+  exports["write"] = $foreign.write;
+})(PS["Effect.Ref"] = PS["Effect.Ref"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_Monad_Cont_Class = PS["Control.Monad.Cont.Class"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
-  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
-  var Control_Monad_Reader_Class = PS["Control.Monad.Reader.Class"];
-  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
-  var Control_Monad_State_Class = PS["Control.Monad.State.Class"];
-  var Control_Monad_Trans_Class = PS["Control.Monad.Trans.Class"];
-  var Control_Monad_Writer_Class = PS["Control.Monad.Writer.Class"];
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Monad_Maybe_Trans = PS["Control.Monad.Maybe.Trans"];
+  var Control_Monad_Reader_Trans = PS["Control.Monad.Reader.Trans"];
+  var Control_Monad_Writer_Trans = PS["Control.Monad.Writer.Trans"];
   var Control_Plus = PS["Control.Plus"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Either = PS["Data.Either"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Functor_Compose = PS["Data.Functor.Compose"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Newtype = PS["Data.Newtype"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Tuple = PS["Data.Tuple"];
-  var Prelude = PS["Prelude"];        
-  var ExceptT = function (x) {
+  var Data_Unit = PS["Data.Unit"];
+  var Effect_Class = PS["Effect.Class"];
+  var Effect_Ref = PS["Effect.Ref"];
+  var Prelude = PS["Prelude"];                 
+  var ParCont = function (x) {
       return x;
   };
-  var runExceptT = function (v) {
-      return v;
-  }; 
-  var mapExceptT = function (f) {
-      return function (v) {
-          return f(v);
-      };
+  var Parallel = function (Applicative1, Monad0, parallel, sequential) {
+      this.Applicative1 = Applicative1;
+      this.Monad0 = Monad0;
+      this.parallel = parallel;
+      this.sequential = sequential;
   };
-  var functorExceptT = function (dictFunctor) {
-      return new Data_Functor.Functor(function (f) {
-          return mapExceptT(Data_Functor.map(dictFunctor)(Data_Functor.map(Data_Either.functorEither)(f)));
+  var sequential = function (dict) {
+      return dict.sequential;
+  };
+  var parallel = function (dict) {
+      return dict.parallel;
+  };
+  var monadParExceptT = function (dictParallel) {
+      return new Parallel(function () {
+          return Data_Functor_Compose.applicativeCompose(dictParallel.Applicative1())(Data_Either.applicativeEither);
+      }, function () {
+          return Control_Monad_Except_Trans.monadExceptT(dictParallel.Monad0());
+      }, function (v) {
+          return parallel(dictParallel)(v);
+      }, function (v) {
+          return sequential(dictParallel)(v);
       });
   };
-  var monadExceptT = function (dictMonad) {
-      return new Control_Monad.Monad(function () {
-          return applicativeExceptT(dictMonad);
+  var monadParParCont = function (dictMonadEffect) {
+      return new Parallel(function () {
+          return applicativeParCont(dictMonadEffect);
       }, function () {
-          return bindExceptT(dictMonad);
+          return Control_Monad_Cont_Trans.monadContT(dictMonadEffect.Monad0());
+      }, ParCont, function (v) {
+          return v;
       });
   };
-  var bindExceptT = function (dictMonad) {
-      return new Control_Bind.Bind(function () {
-          return applyExceptT(dictMonad);
-      }, function (v) {
-          return function (k) {
-              return Control_Bind.bind(dictMonad.Bind1())(v)(Data_Either.either(function ($97) {
-                  return Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($97));
-              })(function (a) {
-                  var v1 = k(a);
-                  return v1;
-              }));
+  var functorParCont = function (dictMonadEffect) {
+      return new Data_Functor.Functor(function (f) {
+          return function ($54) {
+              return parallel(monadParParCont(dictMonadEffect))(Data_Functor.map(Control_Monad_Cont_Trans.functorContT((((dictMonadEffect.Monad0()).Bind1()).Apply0()).Functor0()))(f)(sequential(monadParParCont(dictMonadEffect))($54)));
           };
       });
   };
-  var applyExceptT = function (dictMonad) {
+  var applyParCont = function (dictMonadEffect) {
       return new Control_Apply.Apply(function () {
-          return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
-      }, Control_Monad.ap(monadExceptT(dictMonad)));
+          return functorParCont(dictMonadEffect);
+      }, function (v) {
+          return function (v1) {
+              return ParCont(function (k) {
+                  return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref["new"](Data_Maybe.Nothing.value)))(function (v2) {
+                      return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref["new"](Data_Maybe.Nothing.value)))(function (v3) {
+                          return Control_Bind.discard(Control_Bind.discardUnit)((dictMonadEffect.Monad0()).Bind1())(Control_Monad_Cont_Trans.runContT(v)(function (a) {
+                              return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.read(v3)))(function (v4) {
+                                  if (v4 instanceof Data_Maybe.Nothing) {
+                                      return Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.write(new Data_Maybe.Just(a))(v2));
+                                  };
+                                  if (v4 instanceof Data_Maybe.Just) {
+                                      return k(a(v4.value0));
+                                  };
+                                  throw new Error("Failed pattern match at Control.Parallel.Class line 71, column 7 - line 73, column 26: " + [ v4.constructor.name ]);
+                              });
+                          }))(function () {
+                              return Control_Monad_Cont_Trans.runContT(v1)(function (b) {
+                                  return Control_Bind.bind((dictMonadEffect.Monad0()).Bind1())(Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.read(v2)))(function (v4) {
+                                      if (v4 instanceof Data_Maybe.Nothing) {
+                                          return Effect_Class.liftEffect(dictMonadEffect)(Effect_Ref.write(new Data_Maybe.Just(b))(v3));
+                                      };
+                                      if (v4 instanceof Data_Maybe.Just) {
+                                          return k(v4.value0(b));
+                                      };
+                                      throw new Error("Failed pattern match at Control.Parallel.Class line 77, column 7 - line 79, column 26: " + [ v4.constructor.name ]);
+                                  });
+                              });
+                          });
+                      });
+                  });
+              });
+          };
+      });
   };
-  var applicativeExceptT = function (dictMonad) {
+  var applicativeParCont = function (dictMonadEffect) {
       return new Control_Applicative.Applicative(function () {
-          return applyExceptT(dictMonad);
-      }, function ($98) {
-          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Right.create($98)));
+          return applyParCont(dictMonadEffect);
+      }, function ($55) {
+          return parallel(monadParParCont(dictMonadEffect))(Control_Applicative.pure(Control_Monad_Cont_Trans.applicativeContT((dictMonadEffect.Monad0()).Applicative0()))($55));
       });
   };
-  var monadThrowExceptT = function (dictMonad) {
-      return new Control_Monad_Error_Class.MonadThrow(function () {
-          return monadExceptT(dictMonad);
-      }, function ($102) {
-          return ExceptT(Control_Applicative.pure(dictMonad.Applicative0())(Data_Either.Left.create($102)));
+  exports["parallel"] = parallel;
+  exports["sequential"] = sequential;
+  exports["Parallel"] = Parallel;
+  exports["ParCont"] = ParCont;
+  exports["monadParExceptT"] = monadParExceptT;
+  exports["functorParCont"] = functorParCont;
+  exports["applyParCont"] = applyParCont;
+  exports["applicativeParCont"] = applicativeParCont;
+  exports["monadParParCont"] = monadParParCont;
+})(PS["Control.Parallel.Class"] = PS["Control.Parallel.Class"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Parallel_Class = PS["Control.Parallel.Class"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Prelude = PS["Prelude"];
+  var parTraverse = function (dictParallel) {
+      return function (dictTraversable) {
+          return function (f) {
+              return function ($19) {
+                  return Control_Parallel_Class.sequential(dictParallel)(Data_Traversable.traverse(dictTraversable)(dictParallel.Applicative1())(function ($20) {
+                      return Control_Parallel_Class.parallel(dictParallel)(f($20));
+                  })($19));
+              };
+          };
+      };
+  };
+  exports["parTraverse"] = parTraverse;
+})(PS["Control.Parallel"] = PS["Control.Parallel"] || {});
+(function(exports) {
+    "use strict";
+
+  //------------------------------------------------------------------------------
+  // Array creation --------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.range = function (start) {
+    return function (end) {
+      var step = start > end ? -1 : 1;
+      var result = new Array(step * (end - start) + 1);
+      var i = start, n = 0;
+      while (i !== end) {
+        result[n++] = i;
+        i += step;
+      }
+      result[n] = i;
+      return result;
+    };
+  };                                                                                             
+
+  exports.fromFoldableImpl = (function () {
+    function Cons(head, tail) {
+      this.head = head;
+      this.tail = tail;
+    }
+    var emptyList = {};
+
+    function curryCons(head) {
+      return function (tail) {
+        return new Cons(head, tail);
+      };
+    }
+
+    function listToArray(list) {
+      var result = [];
+      var count = 0;
+      var xs = list;
+      while (xs !== emptyList) {
+        result[count++] = xs.head;
+        xs = xs.tail;
+      }
+      return result;
+    }
+
+    return function (foldr) {
+      return function (xs) {
+        return listToArray(foldr(curryCons)(emptyList)(xs));
+      };
+    };
+  })();
+
+  //------------------------------------------------------------------------------
+  // Array size ------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.length = function (xs) {
+    return xs.length;
+  };
+
+  //------------------------------------------------------------------------------
+  // Indexed operations ----------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.indexImpl = function (just) {
+    return function (nothing) {
+      return function (xs) {
+        return function (i) {
+          return i < 0 || i >= xs.length ? nothing :  just(xs[i]);
+        };
+      };
+    };
+  };
+
+  //------------------------------------------------------------------------------
+  // Sorting ---------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.sortImpl = function (f) {
+    return function (l) {
+      return l.slice().sort(function (x, y) {
+        return f(x)(y);
       });
+    };
+  };
+
+  //------------------------------------------------------------------------------
+  // Subarrays -------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.slice = function (s) {
+    return function (e) {
+      return function (l) {
+        return l.slice(s, e);
+      };
+    };
+  };
+
+  //------------------------------------------------------------------------------
+  // Zipping ---------------------------------------------------------------------
+  //------------------------------------------------------------------------------
+
+  exports.zipWith = function (f) {
+    return function (xs) {
+      return function (ys) {
+        var l = xs.length < ys.length ? xs.length : ys.length;
+        var result = new Array(l);
+        for (var i = 0; i < l; i++) {
+          result[i] = f(xs[i])(ys[i]);
+        }
+        return result;
+      };
+    };
   };
-  var altExceptT = function (dictSemigroup) {
-      return function (dictMonad) {
-          return new Control_Alt.Alt(function () {
-              return functorExceptT(((dictMonad.Bind1()).Apply0()).Functor0());
-          }, function (v) {
-              return function (v1) {
-                  return Control_Bind.bind(dictMonad.Bind1())(v)(function (v2) {
-                      if (v2 instanceof Data_Either.Right) {
-                          return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v2.value0));
-                      };
-                      if (v2 instanceof Data_Either.Left) {
-                          return Control_Bind.bind(dictMonad.Bind1())(v1)(function (v3) {
-                              if (v3 instanceof Data_Either.Right) {
-                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Right(v3.value0));
-                              };
-                              if (v3 instanceof Data_Either.Left) {
-                                  return Control_Applicative.pure(dictMonad.Applicative0())(new Data_Either.Left(Data_Semigroup.append(dictSemigroup)(v2.value0)(v3.value0)));
-                              };
-                              throw new Error("Failed pattern match at Control.Monad.Except.Trans line 88, column 9 - line 90, column 49: " + [ v3.constructor.name ]);
-                          });
-                      };
-                      throw new Error("Failed pattern match at Control.Monad.Except.Trans line 84, column 5 - line 90, column 49: " + [ v2.constructor.name ]);
-                  });
-              };
-          });
+})(PS["Data.Array"] = PS["Data.Array"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.pushAll = function (as) {
+    return function (xs) {
+      return function () {
+        return xs.push.apply(xs, as);
       };
+    };
   };
-  exports["ExceptT"] = ExceptT;
-  exports["runExceptT"] = runExceptT;
-  exports["mapExceptT"] = mapExceptT;
-  exports["functorExceptT"] = functorExceptT;
-  exports["applyExceptT"] = applyExceptT;
-  exports["applicativeExceptT"] = applicativeExceptT;
-  exports["bindExceptT"] = bindExceptT;
-  exports["monadExceptT"] = monadExceptT;
-  exports["altExceptT"] = altExceptT;
-  exports["monadThrowExceptT"] = monadThrowExceptT;
-})(PS["Control.Monad.Except.Trans"] = PS["Control.Monad.Except.Trans"] || {});
+})(PS["Data.Array.ST"] = PS["Data.Array.ST"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
+  var $foreign = PS["Data.Array.ST"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad = PS["Control.Monad"];
-  var Data_BooleanAlgebra = PS["Data.BooleanAlgebra"];
-  var Data_Bounded = PS["Data.Bounded"];
-  var Data_CommutativeRing = PS["Data.CommutativeRing"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_EuclideanRing = PS["Data.EuclideanRing"];
-  var Data_Field = PS["Data.Field"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Invariant = PS["Data.Functor.Invariant"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Control_Monad_ST = PS["Control.Monad.ST"];
+  var Control_Monad_ST_Internal = PS["Control.Monad.ST.Internal"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
-  var Identity = function (x) {
-      return x;
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];                 
+  var unsafeThaw = function ($11) {
+      return Control_Applicative.pure(Control_Monad_ST_Internal.applicativeST)($11);
   };
-  var newtypeIdentity = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Identity);
-  var functorIdentity = new Data_Functor.Functor(function (f) {
-      return function (v) {
-          return f(v);
-      };
-  });
-  var applyIdentity = new Control_Apply.Apply(function () {
-      return functorIdentity;
-  }, function (v) {
-      return function (v1) {
-          return v(v1);
-      };
-  });
-  var bindIdentity = new Control_Bind.Bind(function () {
-      return applyIdentity;
-  }, function (v) {
-      return function (f) {
-          return f(v);
-      };
-  });
-  var applicativeIdentity = new Control_Applicative.Applicative(function () {
-      return applyIdentity;
-  }, Identity);
-  var monadIdentity = new Control_Monad.Monad(function () {
-      return applicativeIdentity;
-  }, function () {
-      return bindIdentity;
-  });
-  exports["Identity"] = Identity;
-  exports["newtypeIdentity"] = newtypeIdentity;
-  exports["functorIdentity"] = functorIdentity;
-  exports["applyIdentity"] = applyIdentity;
-  exports["applicativeIdentity"] = applicativeIdentity;
-  exports["bindIdentity"] = bindIdentity;
-  exports["monadIdentity"] = monadIdentity;
-})(PS["Data.Identity"] = PS["Data.Identity"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
-  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Identity = PS["Data.Identity"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Prelude = PS["Prelude"];                                                           
-  var runExcept = function ($0) {
-      return Data_Newtype.unwrap(Data_Identity.newtypeIdentity)(Control_Monad_Except_Trans.runExceptT($0));
+  var unsafeFreeze = function ($12) {
+      return Control_Applicative.pure(Control_Monad_ST_Internal.applicativeST)($12);
   };
-  var mapExcept = function (f) {
-      return Control_Monad_Except_Trans.mapExceptT(function ($1) {
-          return Data_Identity.Identity(f(Data_Newtype.unwrap(Data_Identity.newtypeIdentity)($1)));
-      });
+  var push = function (a) {
+      return $foreign.pushAll([ a ]);
   };
-  exports["runExcept"] = runExcept;
-  exports["mapExcept"] = mapExcept;
-})(PS["Control.Monad.Except"] = PS["Control.Monad.Except"] || {});
+  exports["push"] = push;
+  exports["unsafeFreeze"] = unsafeFreeze;
+  exports["unsafeThaw"] = unsafeThaw;
+})(PS["Data.Array.ST"] = PS["Data.Array.ST"] || {});
 (function(exports) {
     "use strict";
 
-  // module Data.Int
-
-  exports.fromNumberImpl = function (just) {
-    return function (nothing) {
-      return function (n) {
-        /* jshint bitwise: false */
-        return (n | 0) === n ? just(n) : nothing;
+  exports.unfoldrArrayImpl = function (isNothing) {
+    return function (fromJust) {
+      return function (fst) {
+        return function (snd) {
+          return function (f) {
+            return function (b) {
+              var result = [];
+              var value = b;
+              while (true) { // eslint-disable-line no-constant-condition
+                var maybe = f(value);
+                if (isNothing(maybe)) return result;
+                var tuple = fromJust(maybe);
+                result.push(fst(tuple));
+                value = snd(tuple);
+              }
+            };
+          };
+        };
       };
     };
   };
+})(PS["Data.Unfoldable"] = PS["Data.Unfoldable"] || {});
+(function(exports) {
+    "use strict";
 
-  exports.toNumber = function (n) {
-    return n;
-  };
-
-  exports.toStringAs = function (radix) {
-    return function (i) {
-      return i.toString(radix);
+  exports.unfoldr1ArrayImpl = function (isNothing) {
+    return function (fromJust) {
+      return function (fst) {
+        return function (snd) {
+          return function (f) {
+            return function (b) {
+              var result = [];
+              var value = b;
+              while (true) { // eslint-disable-line no-constant-condition
+                var tuple = f(value);
+                result.push(fst(tuple));
+                var maybe = snd(tuple);
+                if (isNothing(maybe)) return result;
+                value = fromJust(maybe);
+              }
+            };
+          };
+        };
+      };
     };
   };
-})(PS["Data.Int"] = PS["Data.Int"] || {});
-(function(exports) {
-  /* globals exports */
-  "use strict";         
-
-  exports.infinity = Infinity;  
-  exports.decodeURIComponent = decodeURIComponent;
-})(PS["Global"] = PS["Global"] || {});
+})(PS["Data.Unfoldable1"] = PS["Data.Unfoldable1"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Global"];
-  exports["infinity"] = $foreign.infinity;
-  exports["decodeURIComponent"] = $foreign["decodeURIComponent"];
-})(PS["Global"] = PS["Global"] || {});
-(function(exports) {
-    "use strict";        
-
-  exports.floor = Math.floor;
-})(PS["Math"] = PS["Math"] || {});
+  var $foreign = PS["Data.Unfoldable1"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];                 
+  var Unfoldable1 = function (unfoldr1) {
+      this.unfoldr1 = unfoldr1;
+  };
+  var unfoldr1 = function (dict) {
+      return dict.unfoldr1;
+  };
+  var unfoldable1Array = new Unfoldable1($foreign.unfoldr1ArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
+  exports["Unfoldable1"] = Unfoldable1;
+  exports["unfoldr1"] = unfoldr1;
+  exports["unfoldable1Array"] = unfoldable1Array;
+})(PS["Data.Unfoldable1"] = PS["Data.Unfoldable1"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Math"];
-  exports["floor"] = $foreign.floor;
-})(PS["Math"] = PS["Math"] || {});
+  var $foreign = PS["Data.Unfoldable"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Data_Unit = PS["Data.Unit"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];                 
+  var Unfoldable = function (Unfoldable10, unfoldr) {
+      this.Unfoldable10 = Unfoldable10;
+      this.unfoldr = unfoldr;
+  };
+  var unfoldr = function (dict) {
+      return dict.unfoldr;
+  };
+  var unfoldableArray = new Unfoldable(function () {
+      return Data_Unfoldable1.unfoldable1Array;
+  }, $foreign.unfoldrArrayImpl(Data_Maybe.isNothing)(Data_Maybe.fromJust())(Data_Tuple.fst)(Data_Tuple.snd));
+  exports["Unfoldable"] = Unfoldable;
+  exports["unfoldr"] = unfoldr;
+  exports["unfoldableArray"] = unfoldableArray;
+})(PS["Data.Unfoldable"] = PS["Data.Unfoldable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Int"];
+  var $foreign = PS["Data.Array"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Control_Monad_ST = PS["Control.Monad.ST"];
+  var Control_Monad_ST_Internal = PS["Control.Monad.ST.Internal"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Array_NonEmpty_Internal = PS["Data.Array.NonEmpty.Internal"];
+  var Data_Array_ST = PS["Data.Array.ST"];
+  var Data_Array_ST_Iterator = PS["Data.Array.ST.Iterator"];
   var Data_Boolean = PS["Data.Boolean"];
-  var Data_Bounded = PS["Data.Bounded"];
   var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Int_Bits = PS["Data.Int.Bits"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
-  var Data_Show = PS["Data.Show"];
-  var Global = PS["Global"];
-  var $$Math = PS["Math"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
   var Prelude = PS["Prelude"];
-  var hexadecimal = 16;             
-  var fromNumber = $foreign.fromNumberImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
-  var unsafeClamp = function (x) {
-      if (x === Global.infinity) {
-          return 0;
-      };
-      if (x === -Global.infinity) {
-          return 0;
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];
+  var sortBy = function (comp) {
+      return function (xs) {
+          var comp$prime = function (x) {
+              return function (y) {
+                  var v = comp(x)(y);
+                  if (v instanceof Data_Ordering.GT) {
+                      return 1;
+                  };
+                  if (v instanceof Data_Ordering.EQ) {
+                      return 0;
+                  };
+                  if (v instanceof Data_Ordering.LT) {
+                      return -1 | 0;
+                  };
+                  throw new Error("Failed pattern match at Data.Array line 702, column 15 - line 707, column 1: " + [ v.constructor.name ]);
+              };
+          };
+          return $foreign.sortImpl(comp$prime)(xs);
       };
-      if (x >= $foreign.toNumber(Data_Bounded.top(Data_Bounded.boundedInt))) {
-          return Data_Bounded.top(Data_Bounded.boundedInt);
+  };
+  var sortWith = function (dictOrd) {
+      return function (f) {
+          return sortBy(Data_Ord.comparing(dictOrd)(f));
       };
-      if (x <= $foreign.toNumber(Data_Bounded.bottom(Data_Bounded.boundedInt))) {
-          return Data_Bounded.bottom(Data_Bounded.boundedInt);
+  };
+  var singleton = function (a) {
+      return [ a ];
+  };
+  var mapWithIndex = function (f) {
+      return function (xs) {
+          return $foreign.zipWith(f)($foreign.range(0)($foreign.length(xs) - 1 | 0))(xs);
       };
-      if (Data_Boolean.otherwise) {
-          return Data_Maybe.fromMaybe(0)(fromNumber(x));
+  };
+  var index = $foreign.indexImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
+  var last = function (xs) {
+      return index(xs)($foreign.length(xs) - 1 | 0);
+  };
+  var head = function (xs) {
+      return index(xs)(0);
+  };
+  var nubBy = function (comp) {
+      return function (xs) {
+          var indexedAndSorted = sortBy(function (x) {
+              return function (y) {
+                  return comp(Data_Tuple.snd(x))(Data_Tuple.snd(y));
+              };
+          })(mapWithIndex(Data_Tuple.Tuple.create)(xs));
+          var v = head(indexedAndSorted);
+          if (v instanceof Data_Maybe.Nothing) {
+              return [  ];
+          };
+          if (v instanceof Data_Maybe.Just) {
+              return Data_Functor.map(Data_Functor.functorArray)(Data_Tuple.snd)(sortWith(Data_Ord.ordInt)(Data_Tuple.fst)((function __do() {
+                  var v1 = Data_Array_ST.unsafeThaw(singleton(v.value0))();
+                  Control_Monad_ST_Internal.foreach(indexedAndSorted)(function (v2) {
+                      return function __do() {
+                          var v3 = Data_Functor.map(Control_Monad_ST_Internal.functorST)(function ($111) {
+                              return Data_Tuple.snd((function ($112) {
+                                  return Data_Maybe.fromJust()(last($112));
+                              })($111));
+                          })(Data_Array_ST.unsafeFreeze(v1))();
+                          return Control_Applicative.when(Control_Monad_ST_Internal.applicativeST)(Data_Eq.notEq(Data_Ordering.eqOrdering)(comp(v3)(v2.value1))(Data_Ordering.EQ.value))(Data_Functor["void"](Control_Monad_ST_Internal.functorST)(Data_Array_ST.push(v2)(v1)))();
+                      };
+                  })();
+                  return Data_Array_ST.unsafeFreeze(v1)();
+              })()));
+          };
+          throw new Error("Failed pattern match at Data.Array line 903, column 17 - line 911, column 29: " + [ v.constructor.name ]);
       };
-      throw new Error("Failed pattern match at Data.Int line 64, column 1 - line 64, column 29: " + [ x.constructor.name ]);
   };
-  var floor = function ($14) {
-      return unsafeClamp($$Math.floor($14));
+  var fromFoldable = function (dictFoldable) {
+      return $foreign.fromFoldableImpl(Data_Foldable.foldr(dictFoldable));
+  };
+  var concatMap = Data_Function.flip(Control_Bind.bind(Control_Bind.bindArray));
+  var mapMaybe = function (f) {
+      return concatMap(function ($114) {
+          return Data_Maybe.maybe([  ])(singleton)(f($114));
+      });
   };
-  exports["fromNumber"] = fromNumber;
-  exports["floor"] = floor;
-  exports["hexadecimal"] = hexadecimal;
-  exports["toNumber"] = $foreign.toNumber;
-  exports["toStringAs"] = $foreign.toStringAs;
-})(PS["Data.Int"] = PS["Data.Int"] || {});
+  var catMaybes = mapMaybe(Control_Category.identity(Control_Category.categoryFn));
+  exports["fromFoldable"] = fromFoldable;
+  exports["singleton"] = singleton;
+  exports["head"] = head;
+  exports["last"] = last;
+  exports["index"] = index;
+  exports["concatMap"] = concatMap;
+  exports["mapMaybe"] = mapMaybe;
+  exports["catMaybes"] = catMaybes;
+  exports["mapWithIndex"] = mapWithIndex;
+  exports["sortBy"] = sortBy;
+  exports["sortWith"] = sortWith;
+  exports["nubBy"] = nubBy;
+  exports["range"] = $foreign.range;
+  exports["length"] = $foreign.length;
+  exports["zipWith"] = $foreign.zipWith;
+})(PS["Data.Array"] = PS["Data.Array"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
@@ -1987,16 +3102,26 @@ var PS = {};
   var Control_Apply = PS["Control.Apply"];
   var Control_Category = PS["Control.Category"];
   var Control_Plus = PS["Control.Plus"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
   var Data_Show = PS["Data.Show"];
   var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Prelude = PS["Prelude"];                 
   var NonEmpty = (function () {
       function NonEmpty(value0, value1) {
           this.value0 = value0;
@@ -2016,8 +3141,8 @@ var PS = {};
   };
   var functorNonEmpty = function (dictFunctor) {
       return new Data_Functor.Functor(function (f) {
-          return function (v) {
-              return new NonEmpty(f(v.value0), Data_Functor.map(dictFunctor)(f)(v.value1));
+          return function (m) {
+              return new NonEmpty(f(m.value0), Data_Functor.map(dictFunctor)(f)(m.value1));
           };
       });
   };
@@ -2048,598 +3173,571 @@ var PS = {};
   exports["foldableNonEmpty"] = foldableNonEmpty;
 })(PS["Data.NonEmpty"] = PS["Data.NonEmpty"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
   var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Control_Plus = PS["Control.Plus"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Array = PS["Data.Array"];
+  var Data_Array_NonEmpty_Internal = PS["Data.Array.NonEmpty.Internal"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
+  var Data_Boolean = PS["Data.Boolean"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
   var Data_NonEmpty = PS["Data.NonEmpty"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
-  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
   var Data_Tuple = PS["Data.Tuple"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Prelude = PS["Prelude"];        
-  var Nil = (function () {
-      function Nil() {
-
-      };
-      Nil.value = new Nil();
-      return Nil;
-  })();
-  var Cons = (function () {
-      function Cons(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      Cons.create = function (value0) {
-          return function (value1) {
-              return new Cons(value0, value1);
-          };
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];         
+  var toArray = Unsafe_Coerce.unsafeCoerce;  
+  var adaptAny = function (f) {
+      return function ($54) {
+          return f(toArray($54));
       };
-      return Cons;
-  })();
-  var NonEmptyList = function (x) {
-      return x;
   };
-  var toList = function (v) {
-      return new Cons(v.value0, v.value1);
+  var index = adaptAny(Data_Array.index);
+  exports["toArray"] = toArray;
+  exports["index"] = index;
+})(PS["Data.Array.NonEmpty"] = PS["Data.Array.NonEmpty"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.toCharCode = function (c) {
+    return c.charCodeAt(0);
   };
-  var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
-      return function (f) {
-          return Data_Foldable.foldl(foldableList)(function (acc) {
-              return function ($143) {
-                  return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f($143));
-              };
-          })(Data_Monoid.mempty(dictMonoid));
-      };
-  }, function (f) {
-      var go = function ($copy_b) {
-          return function ($copy_v) {
-              var $tco_var_b = $copy_b;
-              var $tco_done = false;
-              var $tco_result;
-              function $tco_loop(b, v) {
-                  if (v instanceof Nil) {
-                      $tco_done = true;
-                      return b;
-                  };
-                  if (v instanceof Cons) {
-                      $tco_var_b = f(b)(v.value0);
-                      $copy_v = v.value1;
-                      return;
-                  };
-                  throw new Error("Failed pattern match at Data.List.Types line 78, column 12 - line 80, column 30: " + [ v.constructor.name ]);
-              };
-              while (!$tco_done) {
-                  $tco_result = $tco_loop($tco_var_b, $copy_v);
-              };
-              return $tco_result;
-          };
-      };
-      return go;
-  }, function (f) {
-      return function (b) {
-          var rev = function ($copy_acc) {
-              return function ($copy_v) {
-                  var $tco_var_acc = $copy_acc;
-                  var $tco_done = false;
-                  var $tco_result;
-                  function $tco_loop(acc, v) {
-                      if (v instanceof Nil) {
-                          $tco_done = true;
-                          return acc;
-                      };
-                      if (v instanceof Cons) {
-                          $tco_var_acc = new Cons(v.value0, acc);
-                          $copy_v = v.value1;
-                          return;
-                      };
-                      throw new Error("Failed pattern match at Data.List.Types line 73, column 15 - line 75, column 33: " + [ v.constructor.name ]);
-                  };
-                  while (!$tco_done) {
-                      $tco_result = $tco_loop($tco_var_acc, $copy_v);
-                  };
-                  return $tco_result;
-              };
-          };
-          return function ($144) {
-              return Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b)(rev(Nil.value)($144));
-          };
-      };
-  });
-  var foldableNonEmptyList = Data_NonEmpty.foldableNonEmpty(foldableList);
-  var functorList = new Data_Functor.Functor(function (f) {
-      return Data_Foldable.foldr(foldableList)(function (x) {
-          return function (acc) {
-              return new Cons(f(x), acc);
-          };
-      })(Nil.value);
-  });
-  var functorNonEmptyList = Data_NonEmpty.functorNonEmpty(functorList);
-  var semigroupList = new Data_Semigroup.Semigroup(function (xs) {
-      return function (ys) {
-          return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);
-      };
-  });           
-  var semigroupNonEmptyList = new Data_Semigroup.Semigroup(function (v) {
-      return function (as$prime) {
-          return new Data_NonEmpty.NonEmpty(v.value0, Data_Semigroup.append(semigroupList)(v.value1)(toList(as$prime)));
-      };
-  });                                              
-  var altList = new Control_Alt.Alt(function () {
-      return functorList;
-  }, Data_Semigroup.append(semigroupList));
-  var plusList = new Control_Plus.Plus(function () {
-      return altList;
-  }, Nil.value);
-  exports["Nil"] = Nil;
-  exports["Cons"] = Cons;
-  exports["NonEmptyList"] = NonEmptyList;
-  exports["toList"] = toList;
-  exports["semigroupList"] = semigroupList;
-  exports["functorList"] = functorList;
-  exports["foldableList"] = foldableList;
-  exports["altList"] = altList;
-  exports["plusList"] = plusList;
-  exports["functorNonEmptyList"] = functorNonEmptyList;
-  exports["semigroupNonEmptyList"] = semigroupNonEmptyList;
-  exports["foldableNonEmptyList"] = foldableNonEmptyList;
-})(PS["Data.List.Types"] = PS["Data.List.Types"] || {});
+
+  exports.fromCharCode = function (c) {
+    return String.fromCharCode(c);
+  };
+})(PS["Data.Enum"] = PS["Data.Enum"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
+  var $foreign = PS["Data.Enum"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Bifunctor = PS["Data.Bifunctor"];
   var Data_Boolean = PS["Data.Boolean"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Newtype = PS["Data.Newtype"];
-  var Data_NonEmpty = PS["Data.NonEmpty"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
   var Data_Tuple = PS["Data.Tuple"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
   var Data_Unit = PS["Data.Unit"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
   var Prelude = PS["Prelude"];
-  var singleton = function (a) {
-      return new Data_List_Types.Cons(a, Data_List_Types.Nil.value);
+  var Enum = function (Ord0, pred, succ) {
+      this.Ord0 = Ord0;
+      this.pred = pred;
+      this.succ = succ;
   };
-  var $$null = function (v) {
-      if (v instanceof Data_List_Types.Nil) {
-          return true;
+  var BoundedEnum = function (Bounded0, Enum1, cardinality, fromEnum, toEnum) {
+      this.Bounded0 = Bounded0;
+      this.Enum1 = Enum1;
+      this.cardinality = cardinality;
+      this.fromEnum = fromEnum;
+      this.toEnum = toEnum;
+  };
+  var toEnum = function (dict) {
+      return dict.toEnum;
+  };
+  var succ = function (dict) {
+      return dict.succ;
+  }; 
+  var pred = function (dict) {
+      return dict.pred;
+  };              
+  var fromEnum = function (dict) {
+      return dict.fromEnum;
+  };
+  var toEnumWithDefaults = function (dictBoundedEnum) {
+      return function (low) {
+          return function (high) {
+              return function (x) {
+                  var v = toEnum(dictBoundedEnum)(x);
+                  if (v instanceof Data_Maybe.Just) {
+                      return v.value0;
+                  };
+                  if (v instanceof Data_Maybe.Nothing) {
+                      var $51 = x < fromEnum(dictBoundedEnum)(Data_Bounded.bottom(dictBoundedEnum.Bounded0()));
+                      if ($51) {
+                          return low;
+                      };
+                      return high;
+                  };
+                  throw new Error("Failed pattern match at Data.Enum line 158, column 33 - line 160, column 62: " + [ v.constructor.name ]);
+              };
+          };
       };
-      return false;
   };
-  var fromFoldable = function (dictFoldable) {
-      return Data_Foldable.foldr(dictFoldable)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);
+  var defaultSucc = function (toEnum$prime) {
+      return function (fromEnum$prime) {
+          return function (a) {
+              return toEnum$prime(fromEnum$prime(a) + 1 | 0);
+          };
+      };
   };
-  exports["fromFoldable"] = fromFoldable;
-  exports["singleton"] = singleton;
-  exports["null"] = $$null;
-})(PS["Data.List"] = PS["Data.List"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_List = PS["Data.List"];
-  var Data_List_Types = PS["Data.List.Types"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_NonEmpty = PS["Data.NonEmpty"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
-  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Data_Tuple = PS["Data.Tuple"];
-  var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];
-  var Prelude = PS["Prelude"];
-  var singleton = function ($160) {
-      return Data_List_Types.NonEmptyList(Data_NonEmpty.singleton(Data_List_Types.plusList)($160));
+  var defaultPred = function (toEnum$prime) {
+      return function (fromEnum$prime) {
+          return function (a) {
+              return toEnum$prime(fromEnum$prime(a) - 1 | 0);
+          };
+      };
   };
-  exports["singleton"] = singleton;
-})(PS["Data.List.NonEmpty"] = PS["Data.List.NonEmpty"] || {});
+  var charToEnum = function (v) {
+      if (v >= Data_Bounded.bottom(Data_Bounded.boundedInt) && v <= Data_Bounded.top(Data_Bounded.boundedInt)) {
+          return new Data_Maybe.Just($foreign.fromCharCode(v));
+      };
+      return Data_Maybe.Nothing.value;
+  };
+  var enumChar = new Enum(function () {
+      return Data_Ord.ordChar;
+  }, defaultPred(charToEnum)($foreign.toCharCode), defaultSucc(charToEnum)($foreign.toCharCode));
+  var cardinality = function (dict) {
+      return dict.cardinality;
+  }; 
+  var boundedEnumChar = new BoundedEnum(function () {
+      return Data_Bounded.boundedChar;
+  }, function () {
+      return enumChar;
+  }, $foreign.toCharCode(Data_Bounded.top(Data_Bounded.boundedChar)) - $foreign.toCharCode(Data_Bounded.bottom(Data_Bounded.boundedChar)) | 0, $foreign.toCharCode, charToEnum);
+  exports["Enum"] = Enum;
+  exports["succ"] = succ;
+  exports["pred"] = pred;
+  exports["BoundedEnum"] = BoundedEnum;
+  exports["cardinality"] = cardinality;
+  exports["toEnum"] = toEnum;
+  exports["fromEnum"] = fromEnum;
+  exports["toEnumWithDefaults"] = toEnumWithDefaults;
+  exports["defaultSucc"] = defaultSucc;
+  exports["defaultPred"] = defaultPred;
+  exports["enumChar"] = enumChar;
+  exports["boundedEnumChar"] = boundedEnumChar;
+})(PS["Data.Enum"] = PS["Data.Enum"] || {});
 (function(exports) {
     "use strict";
 
-  exports.length = function (s) {
-    return s.length;
-  };
-
-  exports.replace = function (s1) {
-    return function (s2) {
-      return function (s3) {
-        return s3.replace(s1, s2);
+  exports.runFn4 = function (fn) {
+    return function (a) {
+      return function (b) {
+        return function (c) {
+          return function (d) {
+            return fn(a, b, c, d);
+          };
+        };
       };
     };
   };
-
-  exports.replaceAll = function (s1) {
-    return function (s2) {
-      return function (s3) {
-        return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2);
+})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.Function.Uncurried"];
+  var Data_Unit = PS["Data.Unit"];
+  exports["runFn4"] = $foreign.runFn4;
+})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Maybe = PS["Data.Maybe"];                 
+  var Inl = (function () {
+      function Inl(value0) {
+          this.value0 = value0;
       };
-    };
+      Inl.create = function (value0) {
+          return new Inl(value0);
+      };
+      return Inl;
+  })();
+  var Inr = (function () {
+      function Inr(value0) {
+          this.value0 = value0;
+      };
+      Inr.create = function (value0) {
+          return new Inr(value0);
+      };
+      return Inr;
+  })();
+  var Constructor = function (x) {
+      return x;
   };
-
-  exports.take = function (n) {
-    return function (s) {
-      return s.substr(0, n);
-    };
+  var Generic = function (from, to) {
+      this.from = from;
+      this.to = to;
+  };
+  var to = function (dict) {
+      return dict.to;
+  }; 
+  var from = function (dict) {
+      return dict.from;
   };
+  exports["Generic"] = Generic;
+  exports["to"] = to;
+  exports["from"] = from;
+  exports["Inl"] = Inl;
+  exports["Inr"] = Inr;
+  exports["Constructor"] = Constructor;
+})(PS["Data.Generic.Rep"] = PS["Data.Generic.Rep"] || {});
+(function(exports) {
+    "use strict";
 
-  exports.drop = function (n) {
-    return function (s) {
-      return s.substring(n);
+  exports.fromNumberImpl = function (just) {
+    return function (nothing) {
+      return function (n) {
+        /* jshint bitwise: false */
+        return (n | 0) === n ? just(n) : nothing;
+      };
     };
   };
 
-  exports.split = function (sep) {
-    return function (s) {
-      return s.split(sep);
-    };
+  exports.toNumber = function (n) {
+    return n;
   };
 
-  exports.joinWith = function (s) {
-    return function (xs) {
-      return xs.join(s);
+  exports.toStringAs = function (radix) {
+    return function (i) {
+      return i.toString(radix);
     };
   };
-})(PS["Data.String"] = PS["Data.String"] || {});
+})(PS["Data.Int"] = PS["Data.Int"] || {});
+(function(exports) {
+  /* globals exports */
+  "use strict";         
+
+  exports.infinity = Infinity;
+})(PS["Global"] = PS["Global"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Global"];
+  exports["infinity"] = $foreign.infinity;
+})(PS["Global"] = PS["Global"] || {});
+(function(exports) {
+    "use strict";        
+
+  exports.floor = Math.floor;
+})(PS["Math"] = PS["Math"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Math"];
+  exports["floor"] = $foreign.floor;
+})(PS["Math"] = PS["Math"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.String"];
+  var $foreign = PS["Data.Int"];
+  var Control_Category = PS["Control.Category"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_CommutativeRing = PS["Data.CommutativeRing"];
+  var Data_DivisionRing = PS["Data.DivisionRing"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Function = PS["Data.Function"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Int_Bits = PS["Data.Int.Bits"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_String_Unsafe = PS["Data.String.Unsafe"];
-  var Prelude = PS["Prelude"];        
-  var Replacement = function (x) {
-      return x;
+  var Global = PS["Global"];
+  var $$Math = PS["Math"];
+  var Prelude = PS["Prelude"];
+  var hexadecimal = 16;             
+  var fromNumber = $foreign.fromNumberImpl(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
+  var unsafeClamp = function (x) {
+      if (x === Global.infinity) {
+          return 0;
+      };
+      if (x === -Global.infinity) {
+          return 0;
+      };
+      if (x >= $foreign.toNumber(Data_Bounded.top(Data_Bounded.boundedInt))) {
+          return Data_Bounded.top(Data_Bounded.boundedInt);
+      };
+      if (x <= $foreign.toNumber(Data_Bounded.bottom(Data_Bounded.boundedInt))) {
+          return Data_Bounded.bottom(Data_Bounded.boundedInt);
+      };
+      if (Data_Boolean.otherwise) {
+          return Data_Maybe.fromMaybe(0)(fromNumber(x));
+      };
+      throw new Error("Failed pattern match at Data.Int line 66, column 1 - line 66, column 29: " + [ x.constructor.name ]);
   };
-  var Pattern = function (x) {
-      return x;
+  var floor = function ($24) {
+      return unsafeClamp($$Math.floor($24));
   };
-  var newtypeReplacement = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Replacement);
-  var newtypePattern = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, Pattern);
-  exports["Pattern"] = Pattern;
-  exports["Replacement"] = Replacement;
-  exports["newtypePattern"] = newtypePattern;
-  exports["newtypeReplacement"] = newtypeReplacement;
-  exports["length"] = $foreign.length;
-  exports["replaceAll"] = $foreign.replaceAll;
-  exports["take"] = $foreign.take;
-  exports["drop"] = $foreign.drop;
-  exports["split"] = $foreign.split;
-  exports["joinWith"] = $foreign.joinWith;
-})(PS["Data.String"] = PS["Data.String"] || {});
+  exports["fromNumber"] = fromNumber;
+  exports["floor"] = floor;
+  exports["hexadecimal"] = hexadecimal;
+  exports["toNumber"] = $foreign.toNumber;
+  exports["toStringAs"] = $foreign.toStringAs;
+})(PS["Data.Int"] = PS["Data.Int"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foreign"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
-  var Control_Monad_Except = PS["Control.Monad.Except"];
-  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Comonad = PS["Control.Comonad"];
+  var Control_Extend = PS["Control.Extend"];
+  var Control_Monad = PS["Control.Monad"];
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Control_Plus = PS["Control.Plus"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
   var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Identity = PS["Data.Identity"];
-  var Data_Int = PS["Data.Int"];
-  var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
   var Data_Maybe = PS["Data.Maybe"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_NonEmpty = PS["Data.NonEmpty"];
   var Data_Ord = PS["Data.Ord"];
   var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_String = PS["Data.String"];
-  var Prelude = PS["Prelude"];        
-  var ForeignError = (function () {
-      function ForeignError(value0) {
-          this.value0 = value0;
-      };
-      ForeignError.create = function (value0) {
-          return new ForeignError(value0);
-      };
-      return ForeignError;
-  })();
-  var TypeMismatch = (function () {
-      function TypeMismatch(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      TypeMismatch.create = function (value0) {
-          return function (value1) {
-              return new TypeMismatch(value0, value1);
-          };
-      };
-      return TypeMismatch;
-  })();
-  var ErrorAtIndex = (function () {
-      function ErrorAtIndex(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      ErrorAtIndex.create = function (value0) {
-          return function (value1) {
-              return new ErrorAtIndex(value0, value1);
-          };
-      };
-      return ErrorAtIndex;
-  })();
-  var ErrorAtProperty = (function () {
-      function ErrorAtProperty(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      ErrorAtProperty.create = function (value0) {
-          return function (value1) {
-              return new ErrorAtProperty(value0, value1);
-          };
-      };
-      return ErrorAtProperty;
-  })();
-  var JSONError = (function () {
-      function JSONError(value0) {
-          this.value0 = value0;
-      };
-      JSONError.create = function (value0) {
-          return new JSONError(value0);
-      };
-      return JSONError;
-  })();
-  var showForeignError = new Data_Show.Show(function (v) {
-      if (v instanceof ForeignError) {
-          return "(ForeignError " + (Data_Show.show(Data_Show.showString)(v.value0) + ")");
-      };
-      if (v instanceof ErrorAtIndex) {
-          return "(ErrorAtIndex " + (Data_Show.show(Data_Show.showInt)(v.value0) + (" " + (Data_Show.show(showForeignError)(v.value1) + ")")));
-      };
-      if (v instanceof ErrorAtProperty) {
-          return "(ErrorAtProperty " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(showForeignError)(v.value1) + ")")));
-      };
-      if (v instanceof JSONError) {
-          return "(JSONError " + (Data_Show.show(Data_Show.showString)(v.value0) + ")");
-      };
-      if (v instanceof TypeMismatch) {
-          return "(TypeMismatch " + (Data_Show.show(Data_Show.showString)(v.value0) + (" " + (Data_Show.show(Data_Show.showString)(v.value1) + ")")));
-      };
-      throw new Error("Failed pattern match at Data.Foreign line 64, column 1 - line 64, column 47: " + [ v.constructor.name ]);
-  });
-  var renderForeignError = function (v) {
-      if (v instanceof ForeignError) {
-          return v.value0;
-      };
-      if (v instanceof ErrorAtIndex) {
-          return "Error at array index " + (Data_Show.show(Data_Show.showInt)(v.value0) + (": " + Data_Show.show(showForeignError)(v.value1)));
-      };
-      if (v instanceof ErrorAtProperty) {
-          return "Error at property " + (Data_Show.show(Data_Show.showString)(v.value0) + (": " + Data_Show.show(showForeignError)(v.value1)));
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unfoldable1 = PS["Data.Unfoldable1"];
+  var Prelude = PS["Prelude"];                 
+  var Nil = (function () {
+      function Nil() {
+
       };
-      if (v instanceof JSONError) {
-          return "JSON error: " + v.value0;
+      Nil.value = new Nil();
+      return Nil;
+  })();
+  var Cons = (function () {
+      function Cons(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
       };
-      if (v instanceof TypeMismatch) {
-          return "Type mismatch: expected " + (v.value0 + (", found " + v.value1));
+      Cons.create = function (value0) {
+          return function (value1) {
+              return new Cons(value0, value1);
+          };
       };
-      throw new Error("Failed pattern match at Data.Foreign line 74, column 1 - line 74, column 45: " + [ v.constructor.name ]);
+      return Cons;
+  })();
+  var NonEmptyList = function (x) {
+      return x;
   };
-  var fail = function ($121) {
-      return Control_Monad_Error_Class.throwError(Control_Monad_Except_Trans.monadThrowExceptT(Data_Identity.monadIdentity))(Data_List_NonEmpty.singleton($121));
+  var toList = function (v) {
+      return new Cons(v.value0, v.value1);
   };
-  var readArray = function (value) {
-      if ($foreign.isArray(value)) {
-          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
+  var foldableList = new Data_Foldable.Foldable(function (dictMonoid) {
+      return function (f) {
+          return Data_Foldable.foldl(foldableList)(function (acc) {
+              return function ($174) {
+                  return Data_Semigroup.append(dictMonoid.Semigroup0())(acc)(f($174));
+              };
+          })(Data_Monoid.mempty(dictMonoid));
       };
-      if (Data_Boolean.otherwise) {
-          return fail(new TypeMismatch("array", $foreign.tagOf(value)));
+  }, function (f) {
+      var go = function ($copy_b) {
+          return function ($copy_v) {
+              var $tco_var_b = $copy_b;
+              var $tco_done = false;
+              var $tco_result;
+              function $tco_loop(b, v) {
+                  if (v instanceof Nil) {
+                      $tco_done = true;
+                      return b;
+                  };
+                  if (v instanceof Cons) {
+                      $tco_var_b = f(b)(v.value0);
+                      $copy_v = v.value1;
+                      return;
+                  };
+                  throw new Error("Failed pattern match at Data.List.Types line 81, column 12 - line 83, column 30: " + [ v.constructor.name ]);
+              };
+              while (!$tco_done) {
+                  $tco_result = $tco_loop($tco_var_b, $copy_v);
+              };
+              return $tco_result;
+          };
       };
-      throw new Error("Failed pattern match at Data.Foreign line 145, column 1 - line 145, column 42: " + [ value.constructor.name ]);
-  };
-  var unsafeReadTagged = function (tag) {
-      return function (value) {
-          if ($foreign.tagOf(value) === tag) {
-              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
+      return go;
+  }, function (f) {
+      return function (b) {
+          var rev = Data_Foldable.foldl(foldableList)(Data_Function.flip(Cons.create))(Nil.value);
+          return function ($175) {
+              return Data_Foldable.foldl(foldableList)(Data_Function.flip(f))(b)(rev($175));
           };
-          if (Data_Boolean.otherwise) {
-              return fail(new TypeMismatch(tag, $foreign.tagOf(value)));
+      };
+  });
+  var foldableNonEmptyList = Data_NonEmpty.foldableNonEmpty(foldableList);
+  var functorList = new Data_Functor.Functor(function (f) {
+      return Data_Foldable.foldr(foldableList)(function (x) {
+          return function (acc) {
+              return new Cons(f(x), acc);
           };
-          throw new Error("Failed pattern match at Data.Foreign line 104, column 1 - line 104, column 55: " + [ tag.constructor.name, value.constructor.name ]);
+      })(Nil.value);
+  });
+  var functorNonEmptyList = Data_NonEmpty.functorNonEmpty(functorList);
+  var semigroupList = new Data_Semigroup.Semigroup(function (xs) {
+      return function (ys) {
+          return Data_Foldable.foldr(foldableList)(Cons.create)(ys)(xs);
       };
-  };                                            
-  var readNumber = unsafeReadTagged("Number");
-  var readInt = function (value) {
-      var error = Data_Either.Left.create(Data_List_NonEmpty.singleton(new TypeMismatch("Int", $foreign.tagOf(value))));
-      var fromNumber = function ($122) {
-          return Data_Maybe.maybe(error)(Control_Applicative.pure(Data_Either.applicativeEither))(Data_Int.fromNumber($122));
+  });           
+  var semigroupNonEmptyList = new Data_Semigroup.Semigroup(function (v) {
+      return function (as$prime) {
+          return new Data_NonEmpty.NonEmpty(v.value0, Data_Semigroup.append(semigroupList)(v.value1)(toList(as$prime)));
       };
-      return Control_Monad_Except.mapExcept(Data_Either.either(Data_Function["const"](error))(fromNumber))(readNumber(value));
-  };
-  var readString = unsafeReadTagged("String");
-  exports["ForeignError"] = ForeignError;
-  exports["TypeMismatch"] = TypeMismatch;
-  exports["ErrorAtIndex"] = ErrorAtIndex;
-  exports["ErrorAtProperty"] = ErrorAtProperty;
-  exports["JSONError"] = JSONError;
-  exports["renderForeignError"] = renderForeignError;
-  exports["unsafeReadTagged"] = unsafeReadTagged;
-  exports["readString"] = readString;
-  exports["readNumber"] = readNumber;
-  exports["readInt"] = readInt;
-  exports["readArray"] = readArray;
-  exports["fail"] = fail;
-  exports["showForeignError"] = showForeignError;
-  exports["typeOf"] = $foreign.typeOf;
-  exports["isNull"] = $foreign.isNull;
-  exports["isUndefined"] = $foreign.isUndefined;
-})(PS["Data.Foreign"] = PS["Data.Foreign"] || {});
+  });                                              
+  var altList = new Control_Alt.Alt(function () {
+      return functorList;
+  }, Data_Semigroup.append(semigroupList));
+  var plusList = new Control_Plus.Plus(function () {
+      return altList;
+  }, Nil.value);
+  exports["Nil"] = Nil;
+  exports["Cons"] = Cons;
+  exports["NonEmptyList"] = NonEmptyList;
+  exports["toList"] = toList;
+  exports["semigroupList"] = semigroupList;
+  exports["functorList"] = functorList;
+  exports["foldableList"] = foldableList;
+  exports["altList"] = altList;
+  exports["plusList"] = plusList;
+  exports["functorNonEmptyList"] = functorNonEmptyList;
+  exports["semigroupNonEmptyList"] = semigroupNonEmptyList;
+  exports["foldableNonEmptyList"] = foldableNonEmptyList;
+})(PS["Data.List.Types"] = PS["Data.List.Types"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff.JQuery"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var DOM = PS["DOM"];
-  var Data_Foreign = PS["Data.Foreign"];
+  var Control_Alt = PS["Control.Alt"];
+  var Control_Alternative = PS["Control.Alternative"];
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Apply = PS["Control.Apply"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Lazy = PS["Control.Lazy"];
+  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Bifunctor = PS["Data.Bifunctor"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_NonEmpty = PS["Data.NonEmpty"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Data_Unit = PS["Data.Unit"];
   var Prelude = PS["Prelude"];
-  var hide = $foreign.setVisible(false);  
-  var addClass = function (cls) {
-      return $foreign.setClass(cls)(true);
-  };
-  exports["addClass"] = addClass;
-  exports["hide"] = hide;
-  exports["ready"] = $foreign.ready;
-  exports["select"] = $foreign.select;
-  exports["create"] = $foreign.create;
-  exports["setAttr"] = $foreign.setAttr;
-  exports["attr"] = $foreign.attr;
-  exports["setProp"] = $foreign.setProp;
-  exports["append"] = $foreign.append;
-  exports["setText"] = $foreign.setText;
-  exports["setValue"] = $foreign.setValue;
-  exports["on"] = $foreign.on;
-})(PS["Control.Monad.Eff.JQuery"] = PS["Control.Monad.Eff.JQuery"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.empty = function(jq) {
-    return function() {
-      jq.empty();
-    };
-  };
-
-  exports.fadeIn = function(jq) {
-    return function() {
-      jq.fadeIn();
-    };
-  };
-
-  exports.fadeOut = function(jq) {
-    return function() {
-      jq.fadeOut();
-    };
-  };
-
-  exports.filter = function(jq) {
-    return function(sel) {
-      return function() {
-        return jq.filter(sel);
-      };
-    };
+  var singleton = function (a) {
+      return new Data_List_Types.Cons(a, Data_List_Types.Nil.value);
   };
-
-  exports.is = function(jq) {
-    return function(sel) {
-      return function() {
-        return jq.is(sel);
+  var $$null = function (v) {
+      if (v instanceof Data_List_Types.Nil) {
+          return true;
       };
-    };
-  };
-
-  exports.getValue = function(jq) {
-    return function() {
-      return jq.val();
-    };
+      return false;
   };
-})(PS["Control.Monad.Eff.JQuery.Extras"] = PS["Control.Monad.Eff.JQuery.Extras"] || {});
-(function(exports) {
-    "use strict";        
-
-  exports.nullable = function (a, r, f) {
-    return a == null ? r : f(a);
+  var fromFoldable = function (dictFoldable) {
+      return Data_Foldable.foldr(dictFoldable)(Data_List_Types.Cons.create)(Data_List_Types.Nil.value);
   };
-})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
+  exports["fromFoldable"] = fromFoldable;
+  exports["singleton"] = singleton;
+  exports["null"] = $$null;
+})(PS["Data.List"] = PS["Data.List"] || {});
 (function(exports) {
-    "use strict";
-
-  exports.runFn4 = function (fn) {
-    return function (a) {
-      return function (b) {
-        return function (c) {
-          return function (d) {
-            return fn(a, b, c, d);
-          };
-        };
-      };
-    };
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
+  var Data_List = PS["Data.List"];
+  var Data_List_Types = PS["Data.List.Types"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_NonEmpty = PS["Data.NonEmpty"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Semigroup_Foldable = PS["Data.Semigroup.Foldable"];
+  var Data_Semigroup_Traversable = PS["Data.Semigroup.Traversable"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Prelude = PS["Prelude"];
+  var singleton = function ($165) {
+      return Data_List_Types.NonEmptyList(Data_NonEmpty.singleton(Data_List_Types.plusList)($165));
   };
-})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+  exports["singleton"] = singleton;
+})(PS["Data.List.NonEmpty"] = PS["Data.List.NonEmpty"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.Function.Uncurried"];
-  var Data_Unit = PS["Data.Unit"];
-  exports["runFn4"] = $foreign.runFn4;
-})(PS["Data.Function.Uncurried"] = PS["Data.Function.Uncurried"] || {});
+    "use strict";        
+
+  exports.nullable = function (a, r, f) {
+    return a == null ? r : f(a);
+  };
+})(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Data.Nullable"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
@@ -2655,893 +3753,729 @@ var PS = {};
   };
   exports["toMaybe"] = toMaybe;
 })(PS["Data.Nullable"] = PS["Data.Nullable"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.JQuery.Extras"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_JQuery = PS["Control.Monad.Eff.JQuery"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Nullable = PS["Data.Nullable"];
-  var Prelude = PS["Prelude"];        
-  var getValueMaybe = function ($0) {
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Nullable.toMaybe)($foreign.getValue($0));
-  };
-  exports["getValueMaybe"] = getValueMaybe;
-  exports["empty"] = $foreign.empty;
-  exports["fadeIn"] = $foreign.fadeIn;
-  exports["fadeOut"] = $foreign.fadeOut;
-  exports["filter"] = $foreign.filter;
-  exports["is"] = $foreign.is;
-})(PS["Control.Monad.Eff.JQuery.Extras"] = PS["Control.Monad.Eff.JQuery.Extras"] || {});
 (function(exports) {
     "use strict";
-
-  exports.random = Math.random;
-})(PS["Control.Monad.Eff.Random"] = PS["Control.Monad.Eff.Random"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Random"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Int = PS["Data.Int"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ring = PS["Data.Ring"];
-  var Data_Semiring = PS["Data.Semiring"];
-  var Prelude = PS["Prelude"];
-  var randomInt = function (low) {
-      return function (high) {
-          return function __do() {
-              var v = $foreign.random();
-              var asNumber = ((Data_Int.toNumber(high) - Data_Int.toNumber(low)) + 1) * v + Data_Int.toNumber(low);
-              return Data_Int.floor(asNumber);
-          };
-      };
-  };
-  exports["randomInt"] = randomInt;
-})(PS["Control.Monad.Eff.Random"] = PS["Control.Monad.Eff.Random"] || {});
-(function(exports) {
-    "use strict";
-
-  exports.newRef = function (val) {
-    return function () {
-      return { value: val };
-    };
-  };
-
-  exports.readRef = function (ref) {
-    return function () {
-      return ref.value;
-    };
-  };
-
-  exports.writeRef = function (ref) {
-    return function (val) {
-      return function () {
-        ref.value = val;
-        return {};
-      };
+  /* global Symbol */
+
+  var hasArrayFrom = typeof Array.from === "function";
+  var hasStringIterator =
+    typeof Symbol !== "undefined" &&
+    Symbol != null &&
+    typeof Symbol.iterator !== "undefined" &&
+    typeof String.prototype[Symbol.iterator] === "function";
+  var hasFromCodePoint = typeof String.prototype.fromCodePoint === "function";
+  var hasCodePointAt = typeof String.prototype.codePointAt === "function";
+
+  exports._unsafeCodePointAt0 = function (fallback) {
+    return hasCodePointAt
+      ? function (str) { return str.codePointAt(0); }
+      : fallback;
+  };
+
+  exports._singleton = function (fallback) {
+    return hasFromCodePoint ? String.fromCodePoint : fallback;
+  };
+
+  exports._take = function (fallback) {
+    return function (n) {
+      if (hasStringIterator) {
+        return function (str) {
+          var accum = "";
+          var iter = str[Symbol.iterator]();
+          for (var i = 0; i < n; ++i) {
+            var o = iter.next();
+            if (o.done) return accum;
+            accum += o.value;
+          }
+          return accum;
+        };
+      }
+      return fallback(n);
     };
   };
-})(PS["Control.Monad.Eff.Ref"] = PS["Control.Monad.Eff.Ref"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Ref"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];
-  exports["newRef"] = $foreign.newRef;
-  exports["readRef"] = $foreign.readRef;
-  exports["writeRef"] = $foreign.writeRef;
-})(PS["Control.Monad.Eff.Ref"] = PS["Control.Monad.Eff.Ref"] || {});
-(function(exports) {
-  /* global exports */
-  "use strict";
 
-  exports.setTimeout = function (ms) {
-    return function (fn) {
-      return function () {
-        return setTimeout(fn, ms);
-      };
+  exports._toCodePointArray = function (fallback) {
+    return function (unsafeCodePointAt0) {
+      if (hasArrayFrom) {
+        return function (str) {
+          return Array.from(str, unsafeCodePointAt0);
+        };
+      }
+      return fallback;
     };
   };
-})(PS["Control.Monad.Eff.Timer"] = PS["Control.Monad.Eff.Timer"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Control.Monad.Eff.Timer"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Ord = PS["Data.Ord"];
-  var Prelude = PS["Prelude"];
-  exports["setTimeout"] = $foreign.setTimeout;
-})(PS["Control.Monad.Eff.Timer"] = PS["Control.Monad.Eff.Timer"] || {});
+})(PS["Data.String.CodePoints"] = PS["Data.String.CodePoints"] || {});
 (function(exports) {
     "use strict";
 
-  exports.mkEffFn1 = function mkEffFn1(fn) {
-    return function(x) {
-      return fn(x)();
-    };
+  exports.singleton = function (c) {
+    return c;
   };
 
-  exports.runEffFn1 = function runEffFn1(fn) {
-    return function(a) {
-      return function() {
-        return fn(a);
-      };
-    };
+  exports.length = function (s) {
+    return s.length;
   };
 
-  exports.runEffFn2 = function runEffFn2(fn) {
-    return function(a) {
-      return function(b) {
-        return function() {
-          return fn(a, b);
+  exports._indexOf = function (just) {
+    return function (nothing) {
+      return function (x) {
+        return function (s) {
+          var i = s.indexOf(x);
+          return i === -1 ? nothing : just(i);
         };
       };
     };
   };
 
-  exports.runEffFn3 = function runEffFn3(fn) {
-    return function(a) {
-      return function(b) {
-        return function(c) {
-          return function() {
-            return fn(a, b, c);
-          };
+  exports._lastIndexOf = function (just) {
+    return function (nothing) {
+      return function (x) {
+        return function (s) {
+          var i = s.lastIndexOf(x);
+          return i === -1 ? nothing : just(i);
         };
       };
     };
   };
 
-  exports.runEffFn4 = function runEffFn4(fn) {
-    return function(a) {
-      return function(b) {
-        return function(c) {
-          return function(d) {
-            return function() {
-              return fn(a, b, c, d);
-            };
-          };
-        };
-      };
+  exports.take = function (n) {
+    return function (s) {
+      return s.substr(0, n);
     };
   };
 
-  exports.runEffFn5 = function runEffFn5(fn) {
-    return function(a) {
-      return function(b) {
-        return function(c) {
-          return function(d) {
-            return function(e) {
-              return function() {
-                return fn(a, b, c, d, e);
-              };
-            };
-          };
-        };
-      };
+  exports.drop = function (n) {
+    return function (s) {
+      return s.substring(n);
     };
   };
-})(PS["Control.Monad.Eff.Uncurried"] = PS["Control.Monad.Eff.Uncurried"] || {});
+})(PS["Data.String.CodeUnits"] = PS["Data.String.CodeUnits"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff.Uncurried"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  exports["mkEffFn1"] = $foreign.mkEffFn1;
-  exports["runEffFn1"] = $foreign.runEffFn1;
-  exports["runEffFn2"] = $foreign.runEffFn2;
-  exports["runEffFn3"] = $foreign.runEffFn3;
-  exports["runEffFn4"] = $foreign.runEffFn4;
-  exports["runEffFn5"] = $foreign.runEffFn5;
-})(PS["Control.Monad.Eff.Uncurried"] = PS["Control.Monad.Eff.Uncurried"] || {});
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Prelude = PS["Prelude"];                 
+  var Replacement = function (x) {
+      return x;
+  };
+  var Pattern = function (x) {
+      return x;
+  }; 
+  var newtypeReplacement = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, Replacement);
+  var newtypePattern = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, Pattern);
+  exports["Pattern"] = Pattern;
+  exports["Replacement"] = Replacement;
+  exports["newtypePattern"] = newtypePattern;
+  exports["newtypeReplacement"] = newtypeReplacement;
+})(PS["Data.String.Pattern"] = PS["Data.String.Pattern"] || {});
 (function(exports) {
     "use strict";
 
-  exports.unsafeCoerceEff = function (f) {
-    return f;
+  exports.charAt = function (i) {
+    return function (s) {
+      if (i >= 0 && i < s.length) return s.charAt(i);
+      throw new Error("Data.String.Unsafe.charAt: Invalid index.");
+    };
   };
-})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
+})(PS["Data.String.Unsafe"] = PS["Data.String.Unsafe"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Control.Monad.Eff.Unsafe"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  exports["unsafeCoerceEff"] = $foreign.unsafeCoerceEff;
-})(PS["Control.Monad.Eff.Unsafe"] = PS["Control.Monad.Eff.Unsafe"] || {});
+  var $foreign = PS["Data.String.Unsafe"];
+  exports["charAt"] = $foreign.charAt;
+})(PS["Data.String.Unsafe"] = PS["Data.String.Unsafe"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Comonad = PS["Control.Comonad"];
-  var Control_Extend = PS["Control.Extend"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad = PS["Control.Monad"];
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Control_Plus = PS["Control.Plus"];
+  var $foreign = PS["Data.String.CodeUnits"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Boolean = PS["Data.Boolean"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Function = PS["Data.Function"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];
-  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
-  var App = function (x) {
-      return x;
+  var Data_Ring = PS["Data.Ring"];
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Unsafe = PS["Data.String.Unsafe"];
+  var Prelude = PS["Prelude"];                                                                        
+  var lastIndexOf = $foreign._lastIndexOf(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);  
+  var indexOf = $foreign._indexOf(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
+  var stripPrefix = function (v) {
+      return function (str) {
+          var v1 = indexOf(v)(str);
+          if (v1 instanceof Data_Maybe.Just && v1.value0 === 0) {
+              return Data_Maybe.Just.create($foreign.drop($foreign.length(v))(str));
+          };
+          return Data_Maybe.Nothing.value;
+      };
   };
-  var semigroupApp = function (dictApply) {
-      return function (dictSemigroup) {
-          return new Data_Semigroup.Semigroup(function (v) {
-              return function (v1) {
-                  return Control_Apply.lift2(dictApply)(Data_Semigroup.append(dictSemigroup))(v)(v1);
-              };
-          });
+  exports["stripPrefix"] = stripPrefix;
+  exports["indexOf"] = indexOf;
+  exports["lastIndexOf"] = lastIndexOf;
+  exports["singleton"] = $foreign.singleton;
+  exports["length"] = $foreign.length;
+  exports["take"] = $foreign.take;
+  exports["drop"] = $foreign.drop;
+})(PS["Data.String.CodeUnits"] = PS["Data.String.CodeUnits"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.replace = function (s1) {
+    return function (s2) {
+      return function (s3) {
+        return s3.replace(s1, s2);
       };
+    };
   };
-  var newtypeApp = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, App);
-  var applicativeApp = function (dictApplicative) {
-      return dictApplicative;
+
+  exports.replaceAll = function (s1) {
+    return function (s2) {
+      return function (s3) {
+        return s3.replace(new RegExp(s1.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "g"), s2); // eslint-disable-line no-useless-escape
+      };
+    };
   };
-  exports["App"] = App;
-  exports["newtypeApp"] = newtypeApp;
-  exports["semigroupApp"] = semigroupApp;
-  exports["applicativeApp"] = applicativeApp;
-})(PS["Data.Functor.App"] = PS["Data.Functor.App"] || {});
+
+  exports.split = function (sep) {
+    return function (s) {
+      return s.split(sep);
+    };
+  };
+})(PS["Data.String.Common"] = PS["Data.String.Common"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Plus = PS["Control.Plus"];
+  var $foreign = PS["Data.String.Common"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Ordering = PS["Data.Ordering"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Prelude = PS["Prelude"];
+  exports["replaceAll"] = $foreign.replaceAll;
+  exports["split"] = $foreign.split;
+})(PS["Data.String.Common"] = PS["Data.String.Common"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.String.CodePoints"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Array = PS["Data.Array"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Bounded = PS["Data.Bounded"];
+  var Data_Enum = PS["Data.Enum"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Function = PS["Data.Function"];
+  var Data_EuclideanRing = PS["Data.EuclideanRing"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_App = PS["Data.Functor.App"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Int = PS["Data.Int"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Ord = PS["Data.Ord"];
+  var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
-  var Compose = function (x) {
-      return x;
-  };          
-  var functorCompose = function (dictFunctor) {
-      return function (dictFunctor1) {
-          return new Data_Functor.Functor(function (f) {
-              return function (v) {
-                  return Compose(Data_Functor.map(dictFunctor)(Data_Functor.map(dictFunctor1)(f))(v));
-              };
-          });
+  var Data_Semiring = PS["Data.Semiring"];
+  var Data_Show = PS["Data.Show"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Unsafe = PS["Data.String.Unsafe"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Prelude = PS["Prelude"];
+  var unsurrogate = function (lead) {
+      return function (trail) {
+          return (((lead - 55296 | 0) * 1024 | 0) + (trail - 56320 | 0) | 0) + 65536 | 0;
       };
+  }; 
+  var isTrail = function (cu) {
+      return 56320 <= cu && cu <= 57343;
   };
-  var applyCompose = function (dictApply) {
-      return function (dictApply1) {
-          return new Control_Apply.Apply(function () {
-              return functorCompose(dictApply.Functor0())(dictApply1.Functor0());
-          }, function (v) {
-              return function (v1) {
-                  return Compose(Control_Apply.apply(dictApply)(Data_Functor.map(dictApply.Functor0())(Control_Apply.apply(dictApply1))(v))(v1));
-              };
+  var isLead = function (cu) {
+      return 55296 <= cu && cu <= 56319;
+  };
+  var uncons = function (s) {
+      var v = Data_String_CodeUnits.length(s);
+      if (v === 0) {
+          return Data_Maybe.Nothing.value;
+      };
+      if (v === 1) {
+          return new Data_Maybe.Just({
+              head: Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(0)(s)),
+              tail: ""
           });
       };
-  };
-  var applicativeCompose = function (dictApplicative) {
-      return function (dictApplicative1) {
-          return new Control_Applicative.Applicative(function () {
-              return applyCompose(dictApplicative.Apply0())(dictApplicative1.Apply0());
-          }, function ($75) {
-              return Compose(Control_Applicative.pure(dictApplicative)(Control_Applicative.pure(dictApplicative1)($75)));
+      var cu1 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(1)(s));
+      var cu0 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(0)(s));
+      var $21 = isLead(cu0) && isTrail(cu1);
+      if ($21) {
+          return new Data_Maybe.Just({
+              head: unsurrogate(cu0)(cu1),
+              tail: Data_String_CodeUnits.drop(2)(s)
           });
       };
+      return new Data_Maybe.Just({
+          head: cu0,
+          tail: Data_String_CodeUnits.drop(1)(s)
+      });
   };
-  exports["Compose"] = Compose;
-  exports["functorCompose"] = functorCompose;
-  exports["applyCompose"] = applyCompose;
-  exports["applicativeCompose"] = applicativeCompose;
-})(PS["Data.Functor.Compose"] = PS["Data.Functor.Compose"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
-  var Control_Monad_Eff_Ref = PS["Control.Monad.Eff.Ref"];
-  var Control_Monad_Eff_Unsafe = PS["Control.Monad.Eff.Unsafe"];
-  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Monad_Maybe_Trans = PS["Control.Monad.Maybe.Trans"];
-  var Control_Monad_Reader_Trans = PS["Control.Monad.Reader.Trans"];
-  var Control_Monad_Writer_Trans = PS["Control.Monad.Writer.Trans"];
-  var Control_Plus = PS["Control.Plus"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Functor_Compose = PS["Data.Functor.Compose"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var ParCont = function (x) {
-      return x;
+  var unconsButWithTuple = function (s) {
+      return Data_Functor.map(Data_Maybe.functorMaybe)(function (v) {
+          return new Data_Tuple.Tuple(v.head, v.tail);
+      })(uncons(s));
   };
-  var Parallel = function (Applicative1, Monad0, parallel, sequential) {
-      this.Applicative1 = Applicative1;
-      this.Monad0 = Monad0;
-      this.parallel = parallel;
-      this.sequential = sequential;
+  var toCodePointArrayFallback = function (s) {
+      return Data_Unfoldable.unfoldr(Data_Unfoldable.unfoldableArray)(unconsButWithTuple)(s);
   };
-  var unsafeWithRef = Control_Monad_Eff_Unsafe.unsafeCoerceEff;
-  var sequential = function (dict) {
-      return dict.sequential;
+  var unsafeCodePointAt0Fallback = function (s) {
+      var cu1 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(1)(s));
+      var cu0 = Data_Enum.fromEnum(Data_Enum.boundedEnumChar)(Data_String_Unsafe.charAt(0)(s));
+      var $25 = isLead(cu0) && isTrail(cu1);
+      if ($25) {
+          return unsurrogate(cu0)(cu1);
+      };
+      return cu0;
   };
-  var parallel = function (dict) {
-      return dict.parallel;
+  var unsafeCodePointAt0 = $foreign._unsafeCodePointAt0(unsafeCodePointAt0Fallback);
+  var toCodePointArray = $foreign._toCodePointArray(toCodePointArrayFallback)(unsafeCodePointAt0);
+  var length = function ($51) {
+      return Data_Array.length(toCodePointArray($51));
   };
-  var monadParExceptT = function (dictParallel) {
-      return new Parallel(function () {
-          return Data_Functor_Compose.applicativeCompose(dictParallel.Applicative1())(Data_Either.applicativeEither);
-      }, function () {
-          return Control_Monad_Except_Trans.monadExceptT(dictParallel.Monad0());
-      }, function (v) {
-          return parallel(dictParallel)(v);
-      }, function (v) {
-          return sequential(dictParallel)(v);
-      });
+  var lastIndexOf = function (p) {
+      return function (s) {
+          return Data_Functor.map(Data_Maybe.functorMaybe)(function (i) {
+              return length(Data_String_CodeUnits.take(i)(s));
+          })(Data_String_CodeUnits.lastIndexOf(p)(s));
+      };
   };
-  var monadParParCont = function (dictMonadEff) {
-      return new Parallel(function () {
-          return applicativeParCont(dictMonadEff);
-      }, function () {
-          return Control_Monad_Cont_Trans.monadContT(dictMonadEff.Monad0());
-      }, ParCont, function (v) {
-          return v;
-      });
+  var fromCharCode = function ($52) {
+      return Data_String_CodeUnits.singleton(Data_Enum.toEnumWithDefaults(Data_Enum.boundedEnumChar)(Data_Bounded.bottom(Data_Bounded.boundedChar))(Data_Bounded.top(Data_Bounded.boundedChar))($52));
   };
-  var functorParCont = function (dictMonadEff) {
-      return new Data_Functor.Functor(function (f) {
-          return function ($54) {
-              return parallel(monadParParCont(dictMonadEff))(Data_Functor.map(Control_Monad_Cont_Trans.functorContT((((dictMonadEff.Monad0()).Bind1()).Apply0()).Functor0()))(f)(sequential(monadParParCont(dictMonadEff))($54)));
+  var singletonFallback = function (v) {
+      if (v <= 65535) {
+          return fromCharCode(v);
+      };
+      var lead = Data_EuclideanRing.div(Data_EuclideanRing.euclideanRingInt)(v - 65536 | 0)(1024) + 55296 | 0;
+      var trail = Data_EuclideanRing.mod(Data_EuclideanRing.euclideanRingInt)(v - 65536 | 0)(1024) + 56320 | 0;
+      return fromCharCode(lead) + fromCharCode(trail);
+  };                                                                       
+  var singleton = $foreign._singleton(singletonFallback);
+  var takeFallback = function (n) {
+      return function (v) {
+          if (n < 1) {
+              return "";
           };
-      });
-  };
-  var applyParCont = function (dictMonadEff) {
-      return new Control_Apply.Apply(function () {
-          return functorParCont(dictMonadEff);
-      }, function (v) {
-          return function (v1) {
-              return ParCont(function (k) {
-                  return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.newRef(Data_Maybe.Nothing.value))))(function (v2) {
-                      return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.newRef(Data_Maybe.Nothing.value))))(function (v3) {
-                          return Control_Bind.discard(Control_Bind.discardUnit)((dictMonadEff.Monad0()).Bind1())(Control_Monad_Cont_Trans.runContT(v)(function (a) {
-                              return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.readRef(v3))))(function (v4) {
-                                  if (v4 instanceof Data_Maybe.Nothing) {
-                                      return Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.writeRef(v2)(new Data_Maybe.Just(a))));
-                                  };
-                                  if (v4 instanceof Data_Maybe.Just) {
-                                      return k(a(v4.value0));
-                                  };
-                                  throw new Error("Failed pattern match at Control.Parallel.Class line 81, column 7 - line 83, column 26: " + [ v4.constructor.name ]);
-                              });
-                          }))(function () {
-                              return Control_Monad_Cont_Trans.runContT(v1)(function (b) {
-                                  return Control_Bind.bind((dictMonadEff.Monad0()).Bind1())(Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.readRef(v2))))(function (v4) {
-                                      if (v4 instanceof Data_Maybe.Nothing) {
-                                          return Control_Monad_Eff_Class.liftEff(dictMonadEff)(unsafeWithRef(Control_Monad_Eff_Ref.writeRef(v3)(new Data_Maybe.Just(b))));
-                                      };
-                                      if (v4 instanceof Data_Maybe.Just) {
-                                          return k(v4.value0(b));
-                                      };
-                                      throw new Error("Failed pattern match at Control.Parallel.Class line 87, column 7 - line 89, column 26: " + [ v4.constructor.name ]);
-                                  });
-                              });
-                          });
-                      });
-                  });
-              });
+          var v1 = uncons(v);
+          if (v1 instanceof Data_Maybe.Just) {
+              return singleton(v1.value0.head) + takeFallback(n - 1 | 0)(v1.value0.tail);
           };
-      });
+          return v;
+      };
   };
-  var applicativeParCont = function (dictMonadEff) {
-      return new Control_Applicative.Applicative(function () {
-          return applyParCont(dictMonadEff);
-      }, function ($55) {
-          return parallel(monadParParCont(dictMonadEff))(Control_Applicative.pure(Control_Monad_Cont_Trans.applicativeContT((dictMonadEff.Monad0()).Applicative0()))($55));
-      });
+  var take = $foreign._take(takeFallback);
+  var drop = function (n) {
+      return function (s) {
+          return Data_String_CodeUnits.drop(Data_String_CodeUnits.length(take(n)(s)))(s);
+      };
   };
-  exports["Parallel"] = Parallel;
-  exports["parallel"] = parallel;
-  exports["sequential"] = sequential;
-  exports["ParCont"] = ParCont;
-  exports["monadParExceptT"] = monadParExceptT;
-  exports["functorParCont"] = functorParCont;
-  exports["applyParCont"] = applyParCont;
-  exports["applicativeParCont"] = applicativeParCont;
-  exports["monadParParCont"] = monadParParCont;
-})(PS["Control.Parallel.Class"] = PS["Control.Parallel.Class"] || {});
+  exports["singleton"] = singleton;
+  exports["toCodePointArray"] = toCodePointArray;
+  exports["uncons"] = uncons;
+  exports["length"] = length;
+  exports["lastIndexOf"] = lastIndexOf;
+  exports["take"] = take;
+  exports["drop"] = drop;
+})(PS["Data.String.CodePoints"] = PS["Data.String.CodePoints"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_Alternative = PS["Control.Alternative"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Parallel_Class = PS["Control.Parallel.Class"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];
-  var parTraverse = function (dictParallel) {
-      return function (dictTraversable) {
-          return function (f) {
-              return function ($18) {
-                  return Control_Parallel_Class.sequential(dictParallel)(Data_Traversable.traverse(dictTraversable)(dictParallel.Applicative1())(function ($19) {
-                      return Control_Parallel_Class.parallel(dictParallel)(f($19));
-                  })($18));
-              };
-          };
+    "use strict";
+
+  exports["regex'"] = function (left) {
+    return function (right) {
+      return function (s1) {
+        return function (s2) {
+          try {
+            return right(new RegExp(s1, s2));
+          } catch (e) {
+            return left(e.message);
+          }
+        };
       };
+    };
   };
-  exports["parTraverse"] = parTraverse;
-})(PS["Control.Parallel"] = PS["Control.Parallel"] || {});
-(function(exports) {
-  /* global window */
-  "use strict";
 
-  exports.window = function () {
-    return window;
+  exports._match = function (just) {
+    return function (nothing) {
+      return function (r) {
+        return function (s) {
+          var m = s.match(r);
+          if (m == null || m.length === 0) {
+            return nothing;
+          } else {
+            for (var i = 0; i < m.length; i++) {
+              m[i] = m[i] == null ? nothing : just(m[i]);
+            }
+            return just(m);
+          }
+        };
+      };
+    };
   };
-})(PS["DOM.HTML"] = PS["DOM.HTML"] || {});
+})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["DOM.HTML"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var DOM = PS["DOM"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  exports["window"] = $foreign.window;
-})(PS["DOM.HTML"] = PS["DOM.HTML"] || {});
+  var Control_MonadPlus = PS["Control.MonadPlus"];
+  var Control_MonadZero = PS["Control.MonadZero"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Monoid = PS["Data.Monoid"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_String = PS["Data.String"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Prelude = PS["Prelude"];                 
+  var RegexFlags = (function () {
+      function RegexFlags(value0) {
+          this.value0 = value0;
+      };
+      RegexFlags.create = function (value0) {
+          return new RegexFlags(value0);
+      };
+      return RegexFlags;
+  })();
+  var noFlags = new RegexFlags({
+      global: false,
+      ignoreCase: false,
+      multiline: false,
+      sticky: false,
+      unicode: false
+  });
+  exports["RegexFlags"] = RegexFlags;
+  exports["noFlags"] = noFlags;
+})(PS["Data.String.Regex.Flags"] = PS["Data.String.Regex.Flags"] || {});
 (function(exports) {
-    "use strict";
-
-  // ----------------------------------------------------------------------------
-
-  exports.href = function (location) {
-    return function () {
-      return location.href;
-    };
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Data.String.Regex"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Array_NonEmpty = PS["Data.Array.NonEmpty"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_Show = PS["Data.Show"];
+  var Data_String = PS["Data.String"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
+  var Prelude = PS["Prelude"];                                                    
+  var renderFlags = function (v) {
+      return (function () {
+          if (v.value0.global) {
+              return "g";
+          };
+          return "";
+      })() + ((function () {
+          if (v.value0.ignoreCase) {
+              return "i";
+          };
+          return "";
+      })() + ((function () {
+          if (v.value0.multiline) {
+              return "m";
+          };
+          return "";
+      })() + ((function () {
+          if (v.value0.sticky) {
+              return "y";
+          };
+          return "";
+      })() + (function () {
+          if (v.value0.unicode) {
+              return "u";
+          };
+          return "";
+      })())));
   };
-
-  exports.setHref = function (href) {
-    return function (location) {
-      return function () {
-        location.href = href;
+  var regex = function (s) {
+      return function (f) {
+          return $foreign["regex'"](Data_Either.Left.create)(Data_Either.Right.create)(s)(renderFlags(f));
+      };
+  };
+  var match = $foreign._match(Data_Maybe.Just.create)(Data_Maybe.Nothing.value);
+  exports["regex"] = regex;
+  exports["renderFlags"] = renderFlags;
+  exports["match"] = match;
+})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Either = PS["Data.Either"];
+  var Data_String_Regex = PS["Data.String.Regex"];
+  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
+  var Partial_Unsafe = PS["Partial.Unsafe"];                 
+  var unsafeRegex = function (s) {
+      return function (f) {
+          return Data_Either.fromRight()(Data_String_Regex.regex(s)(f));
       };
-    };
   };
-})(PS["DOM.HTML.Location"] = PS["DOM.HTML.Location"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["DOM.HTML.Location"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var DOM = PS["DOM"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  var Prelude = PS["Prelude"];
-  exports["setHref"] = $foreign.setHref;
-})(PS["DOM.HTML.Location"] = PS["DOM.HTML.Location"] || {});
+  exports["unsafeRegex"] = unsafeRegex;
+})(PS["Data.String.Regex.Unsafe"] = PS["Data.String.Regex.Unsafe"] || {});
 (function(exports) {
     "use strict";
 
-  exports.location = function (window) {
+  exports.error = function (s) {
     return function () {
-      return window.location;
-    };
-  };
-
-  exports.alert = function (str) {
-    return function (window) {
-      return function () {
-        window.alert(str);
-        return {};
-      };
-    };
-  };
-
-  exports.confirm = function (str) {
-    return function (window) {
-      return function () {
-        return window.confirm(str);
-      };
+      console.error(s);
+      return {};
     };
   };
-})(PS["DOM.HTML.Window"] = PS["DOM.HTML.Window"] || {});
+})(PS["Effect.Console"] = PS["Effect.Console"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["DOM.HTML.Window"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  var DOM_WebStorage_Types = PS["DOM.WebStorage.Types"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Nullable = PS["Data.Nullable"];
-  var Data_Ord = PS["Data.Ord"];
-  var Prelude = PS["Prelude"];
-  exports["location"] = $foreign.location;
-  exports["alert"] = $foreign.alert;
-  exports["confirm"] = $foreign.confirm;
-})(PS["DOM.HTML.Window"] = PS["DOM.HTML.Window"] || {});
+  var $foreign = PS["Effect.Console"];
+  var Data_Show = PS["Data.Show"];
+  var Data_Unit = PS["Data.Unit"];
+  var Effect = PS["Effect"];
+  exports["error"] = $foreign.error;
+})(PS["Effect.Console"] = PS["Effect.Console"] || {});
 (function(exports) {
     "use strict";
 
-  //------------------------------------------------------------------------------
-  // Array creation --------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
-  exports.range = function (start) {
-    return function (end) {
-      var step = start > end ? -1 : 1;
-      var result = [];
-      var i = start, n = 0;
-      while (i !== end) {
-        result[n++] = i;
-        i += step;
-      }
-      result[n] = i;
-      return result;
-    };
-  };                    
-
-  exports.fromFoldableImpl = (function () {
-    // jshint maxparams: 2
-    function Cons(head, tail) {
-      this.head = head;
-      this.tail = tail;
-    }
-    var emptyList = {};
-
-    function curryCons(head) {
-      return function (tail) {
-        return new Cons(head, tail);
-      };
-    }
-
-    function listToArray(list) {
-      var result = [];
-      var count = 0;
-      var xs = list;
-      while (xs !== emptyList) {
-        result[count++] = xs.head;
-        xs = xs.tail;
-      }
-      return result;
-    }
-
-    return function (foldr) {
-      return function (xs) {
-        return listToArray(foldr(curryCons)(emptyList)(xs));
-      };
-    };
-  })();
-
-  //------------------------------------------------------------------------------
-  // Array size ------------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
-  exports.length = function (xs) {
-    return xs.length;
-  };
-
-  //------------------------------------------------------------------------------
-  // Zipping ---------------------------------------------------------------------
-  //------------------------------------------------------------------------------
-
-  exports.zipWith = function (f) {
-    return function (xs) {
-      return function (ys) {
-        var l = xs.length < ys.length ? xs.length : ys.length;
-        var result = new Array(l);
-        for (var i = 0; i < l; i++) {
-          result[i] = f(xs[i])(ys[i]);
-        }
-        return result;
-      };
-    };
-  };
-})(PS["Data.Array"] = PS["Data.Array"] || {});
+  exports.random = Math.random;
+})(PS["Effect.Random"] = PS["Effect.Random"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Array"];
-  var Control_Alt = PS["Control.Alt"];
-  var Control_Alternative = PS["Control.Alternative"];
+  var $foreign = PS["Effect.Random"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Category = PS["Control.Category"];
-  var Control_Lazy = PS["Control.Lazy"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Rec_Class = PS["Control.Monad.Rec.Class"];
-  var Control_Monad_ST = PS["Control.Monad.ST"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Array_ST = PS["Data.Array.ST"];
-  var Data_Array_ST_Iterator = PS["Data.Array.ST.Iterator"];
-  var Data_Boolean = PS["Data.Boolean"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_NonEmpty = PS["Data.NonEmpty"];
+  var Data_Int = PS["Data.Int"];
   var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
   var Data_Ring = PS["Data.Ring"];
-  var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Data_Tuple = PS["Data.Tuple"];
-  var Data_Unfoldable = PS["Data.Unfoldable"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Effect = PS["Effect"];
   var Prelude = PS["Prelude"];
-  var singleton = function (a) {
-      return [ a ];
-  };
-  var fromFoldable = function (dictFoldable) {
-      return $foreign.fromFoldableImpl(Data_Foldable.foldr(dictFoldable));
-  };
-  var concatMap = Data_Function.flip(Control_Bind.bind(Control_Bind.bindArray));
-  var mapMaybe = function (f) {
-      return concatMap(function ($94) {
-          return Data_Maybe.maybe([  ])(singleton)(f($94));
-      });
+  var randomInt = function (low) {
+      return function (high) {
+          return function __do() {
+              var v = $foreign.random();
+              var asNumber = ((Data_Int.toNumber(high) - Data_Int.toNumber(low)) + 1) * v + Data_Int.toNumber(low);
+              return Data_Int.floor(asNumber);
+          };
+      };
   };
-  var catMaybes = mapMaybe(Control_Category.id(Control_Category.categoryFn));
-  exports["fromFoldable"] = fromFoldable;
-  exports["singleton"] = singleton;
-  exports["concatMap"] = concatMap;
-  exports["mapMaybe"] = mapMaybe;
-  exports["catMaybes"] = catMaybes;
-  exports["range"] = $foreign.range;
-  exports["length"] = $foreign.length;
-  exports["zipWith"] = $foreign.zipWith;
-})(PS["Data.Array"] = PS["Data.Array"] || {});
+  exports["randomInt"] = randomInt;
+})(PS["Effect.Random"] = PS["Effect.Random"] || {});
 (function(exports) {
     "use strict";
 
-  exports.mapWithIndexArray = function (f) {
-    return function (xs) {
-      var l = xs.length;
-      var result = Array(l);
-      for (var i = 0; i < l; i++) {
-        result[i] = f(i)(xs[i]);
-      }
-      return result;
-    };
+  exports.unsafePerformEffect = function (f) {
+    return f();
   };
-})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
+})(PS["Effect.Unsafe"] = PS["Effect.Unsafe"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.FunctorWithIndex"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var FunctorWithIndex = function (Functor0, mapWithIndex) {
-      this.Functor0 = Functor0;
-      this.mapWithIndex = mapWithIndex;
+  var $foreign = PS["Effect.Unsafe"];
+  var Effect = PS["Effect"];
+  exports["unsafePerformEffect"] = $foreign.unsafePerformEffect;
+})(PS["Effect.Unsafe"] = PS["Effect.Unsafe"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.unsafeFromForeign = function (value) {
+    return value;
   };
-  var mapWithIndex = function (dict) {
-      return dict.mapWithIndex;
-  }; 
-  var functorWithIndexArray = new FunctorWithIndex(function () {
-      return Data_Functor.functorArray;
-  }, $foreign.mapWithIndexArray);
-  exports["FunctorWithIndex"] = FunctorWithIndex;
-  exports["mapWithIndex"] = mapWithIndex;
-  exports["functorWithIndexArray"] = functorWithIndexArray;
-})(PS["Data.FunctorWithIndex"] = PS["Data.FunctorWithIndex"] || {});
+
+  exports.typeOf = function (value) {
+    return typeof value;
+  };
+
+  exports.tagOf = function (value) {
+    return Object.prototype.toString.call(value).slice(8, -1);
+  };
+
+  exports.isNull = function (value) {
+    return value === null;
+  };
+
+  exports.isUndefined = function (value) {
+    return value === undefined;
+  };
+
+  exports.isArray = Array.isArray || function (value) {
+    return Object.prototype.toString.call(value) === "[object Array]";
+  };
+})(PS["Foreign"] = PS["Foreign"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
+  var $foreign = PS["Foreign"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
-  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad_Error_Class = PS["Control.Monad.Error.Class"];
+  var Control_Monad_Except = PS["Control.Monad.Except"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Either = PS["Data.Either"];
+  var Data_Eq = PS["Data.Eq"];
   var Data_Function = PS["Data.Function"];
-  var Data_FunctorWithIndex = PS["Data.FunctorWithIndex"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Maybe_First = PS["Data.Maybe.First"];
-  var Data_Maybe_Last = PS["Data.Maybe.Last"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Monoid_Additive = PS["Data.Monoid.Additive"];
-  var Data_Monoid_Conj = PS["Data.Monoid.Conj"];
-  var Data_Monoid_Disj = PS["Data.Monoid.Disj"];
-  var Data_Monoid_Dual = PS["Data.Monoid.Dual"];
-  var Data_Monoid_Endo = PS["Data.Monoid.Endo"];
-  var Data_Monoid_Multiplicative = PS["Data.Monoid.Multiplicative"];
-  var Data_Newtype = PS["Data.Newtype"];
+  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
+  var Data_Identity = PS["Data.Identity"];
+  var Data_Int = PS["Data.Int"];
+  var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Ordering = PS["Data.Ordering"];
   var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Unit = PS["Data.Unit"];
-  var Prelude = PS["Prelude"];        
-  var Tuple = (function () {
-      function Tuple(value0, value1) {
+  var Data_Show = PS["Data.Show"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Prelude = PS["Prelude"];                 
+  var ForeignError = (function () {
+      function ForeignError(value0) {
+          this.value0 = value0;
+      };
+      ForeignError.create = function (value0) {
+          return new ForeignError(value0);
+      };
+      return ForeignError;
+  })();
+  var TypeMismatch = (function () {
+      function TypeMismatch(value0, value1) {
           this.value0 = value0;
           this.value1 = value1;
       };
-      Tuple.create = function (value0) {
+      TypeMismatch.create = function (value0) {
           return function (value1) {
-              return new Tuple(value0, value1);
+              return new TypeMismatch(value0, value1);
           };
       };
-      return Tuple;
+      return TypeMismatch;
   })();
-  var FoldableWithIndex = function (Foldable0, foldMapWithIndex, foldlWithIndex, foldrWithIndex) {
-      this.Foldable0 = Foldable0;
-      this.foldMapWithIndex = foldMapWithIndex;
-      this.foldlWithIndex = foldlWithIndex;
-      this.foldrWithIndex = foldrWithIndex;
-  };
-  var foldrWithIndex = function (dict) {
-      return dict.foldrWithIndex;
-  };
-  var traverseWithIndex_ = function (dictApplicative) {
-      return function (dictFoldableWithIndex) {
-          return function (f) {
-              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
-                  return function ($41) {
-                      return Control_Apply.applySecond(dictApplicative.Apply0())(f(i)($41));
-                  };
-              })(Control_Applicative.pure(dictApplicative)(Data_Unit.unit));
+  var ErrorAtIndex = (function () {
+      function ErrorAtIndex(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
+      };
+      ErrorAtIndex.create = function (value0) {
+          return function (value1) {
+              return new ErrorAtIndex(value0, value1);
           };
       };
-  };
-  var forWithIndex_ = function (dictApplicative) {
-      return function (dictFoldableWithIndex) {
-          return Data_Function.flip(traverseWithIndex_(dictApplicative)(dictFoldableWithIndex));
+      return ErrorAtIndex;
+  })();
+  var ErrorAtProperty = (function () {
+      function ErrorAtProperty(value0, value1) {
+          this.value0 = value0;
+          this.value1 = value1;
+      };
+      ErrorAtProperty.create = function (value0) {
+          return function (value1) {
+              return new ErrorAtProperty(value0, value1);
+          };
       };
+      return ErrorAtProperty;
+  })();
+  var renderForeignError = function (v) {
+      if (v instanceof ForeignError) {
+          return v.value0;
+      };
+      if (v instanceof ErrorAtIndex) {
+          return "Error at array index " + (Data_Show.show(Data_Show.showInt)(v.value0) + (": " + renderForeignError(v.value1)));
+      };
+      if (v instanceof ErrorAtProperty) {
+          return "Error at property " + (Data_Show.show(Data_Show.showString)(v.value0) + (": " + renderForeignError(v.value1)));
+      };
+      if (v instanceof TypeMismatch) {
+          return "Type mismatch: expected " + (v.value0 + (", found " + v.value1));
+      };
+      throw new Error("Failed pattern match at Foreign line 72, column 1 - line 72, column 45: " + [ v.constructor.name ]);
   };
-  var foldlWithIndex = function (dict) {
-      return dict.foldlWithIndex;
+  var fail = function ($107) {
+      return Control_Monad_Error_Class.throwError(Control_Monad_Except_Trans.monadThrowExceptT(Data_Identity.monadIdentity))(Data_List_NonEmpty.singleton($107));
   };
-  var foldMapWithIndexDefaultR = function (dictFoldableWithIndex) {
-      return function (dictMonoid) {
-          return function (f) {
-              return foldrWithIndex(dictFoldableWithIndex)(function (i) {
-                  return function (x) {
-                      return function (acc) {
-                          return Data_Semigroup.append(dictMonoid.Semigroup0())(f(i)(x))(acc);
-                      };
-                  };
-              })(Data_Monoid.mempty(dictMonoid));
-          };
+  var readArray = function (value) {
+      if ($foreign.isArray(value)) {
+          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
+      };
+      if (Data_Boolean.otherwise) {
+          return fail(new TypeMismatch("array", $foreign.tagOf(value)));
       };
+      throw new Error("Failed pattern match at Foreign line 147, column 1 - line 147, column 42: " + [ value.constructor.name ]);
   };
-  var foldableWithIndexArray = new FoldableWithIndex(function () {
-      return Data_Foldable.foldableArray;
-  }, function (dictMonoid) {
-      return foldMapWithIndexDefaultR(foldableWithIndexArray)(dictMonoid);
-  }, function (f) {
-      return function (z) {
-          return function ($42) {
-              return Data_Foldable.foldl(Data_Foldable.foldableArray)(function (y) {
-                  return function (v) {
-                      return f(v.value0)(y)(v.value1);
-                  };
-              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($42));
+  var unsafeReadTagged = function (tag) {
+      return function (value) {
+          if ($foreign.tagOf(value) === tag) {
+              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))($foreign.unsafeFromForeign(value));
           };
-      };
-  }, function (f) {
-      return function (z) {
-          return function ($43) {
-              return Data_Foldable.foldr(Data_Foldable.foldableArray)(function (v) {
-                  return function (y) {
-                      return f(v.value0)(v.value1)(y);
-                  };
-              })(z)(Data_FunctorWithIndex.mapWithIndex(Data_FunctorWithIndex.functorWithIndexArray)(Tuple.create)($43));
+          if (Data_Boolean.otherwise) {
+              return fail(new TypeMismatch(tag, $foreign.tagOf(value)));
           };
+          throw new Error("Failed pattern match at Foreign line 106, column 1 - line 106, column 55: " + [ tag.constructor.name, value.constructor.name ]);
       };
-  });
-  var foldMapWithIndex = function (dict) {
-      return dict.foldMapWithIndex;
+  };                                            
+  var readNumber = unsafeReadTagged("Number");
+  var readInt = function (value) {
+      var error = Data_Either.Left.create(Data_List_NonEmpty.singleton(new TypeMismatch("Int", $foreign.tagOf(value))));
+      var fromNumber = function ($108) {
+          return Data_Maybe.maybe(error)(Control_Applicative.pure(Data_Either.applicativeEither))(Data_Int.fromNumber($108));
+      };
+      return Control_Monad_Except.mapExcept(Data_Either.either(Data_Function["const"](error))(fromNumber))(readNumber(value));
   };
-  exports["FoldableWithIndex"] = FoldableWithIndex;
-  exports["foldrWithIndex"] = foldrWithIndex;
-  exports["foldlWithIndex"] = foldlWithIndex;
-  exports["foldMapWithIndex"] = foldMapWithIndex;
-  exports["foldMapWithIndexDefaultR"] = foldMapWithIndexDefaultR;
-  exports["traverseWithIndex_"] = traverseWithIndex_;
-  exports["forWithIndex_"] = forWithIndex_;
-  exports["foldableWithIndexArray"] = foldableWithIndexArray;
-})(PS["Data.FoldableWithIndex"] = PS["Data.FoldableWithIndex"] || {});
+  var readString = unsafeReadTagged("String");
+  exports["ForeignError"] = ForeignError;
+  exports["TypeMismatch"] = TypeMismatch;
+  exports["ErrorAtIndex"] = ErrorAtIndex;
+  exports["ErrorAtProperty"] = ErrorAtProperty;
+  exports["renderForeignError"] = renderForeignError;
+  exports["unsafeReadTagged"] = unsafeReadTagged;
+  exports["readString"] = readString;
+  exports["readNumber"] = readNumber;
+  exports["readInt"] = readInt;
+  exports["readArray"] = readArray;
+  exports["fail"] = fail;
+  exports["typeOf"] = $foreign.typeOf;
+  exports["isNull"] = $foreign.isNull;
+  exports["isUndefined"] = $foreign.isUndefined;
+})(PS["Foreign"] = PS["Foreign"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foreign.NullOrUndefined"];
+  var $foreign = PS["Foreign.NullOrUndefined"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foreign = PS["Data.Foreign"];
   var Data_Functor = PS["Data.Functor"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Identity = PS["Data.Identity"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_Newtype = PS["Data.Newtype"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Prelude = PS["Prelude"];        
-  var NullOrUndefined = function (x) {
-      return x;
-  };
+  var Foreign = PS["Foreign"];
+  var Prelude = PS["Prelude"];                 
   var readNullOrUndefined = function (v) {
       return function (value) {
-          if (Data_Foreign.isNull(value) || Data_Foreign.isUndefined(value)) {
+          if (Foreign.isNull(value) || Foreign.isUndefined(value)) {
               return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Maybe.Nothing.value);
           };
-          return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(function ($23) {
-              return NullOrUndefined(Data_Maybe.Just.create($23));
-          })(v(value));
+          return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Maybe.Just.create)(v(value));
       };
   };
-  var newtypeNullOrUndefined = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, NullOrUndefined);
-  exports["NullOrUndefined"] = NullOrUndefined;
   exports["readNullOrUndefined"] = readNullOrUndefined;
-  exports["newtypeNullOrUndefined"] = newtypeNullOrUndefined;
-})(PS["Data.Foreign.NullOrUndefined"] = PS["Data.Foreign.NullOrUndefined"] || {});
+})(PS["Foreign.NullOrUndefined"] = PS["Foreign.NullOrUndefined"] || {});
 (function(exports) {
     "use strict";
 
-  exports._copyEff = function (m) {
+  exports._copyST = function (m) {
     return function () {
       var r = {};
       for (var k in m) {
@@ -3551,10 +4485,12 @@ var PS = {};
       }
       return r;
     };
-  };                 
+  };
+
+  exports.empty = {};
 
   exports.runST = function (f) {
-    return f;
+    return f();
   };
 
   exports._foldM = function (bind) {
@@ -3593,7 +4529,7 @@ var PS = {};
       return r;
     };
   }
-})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
+})(PS["Foreign.Object"] = PS["Foreign.Object"] || {});
 (function(exports) {
     "use strict";
 
@@ -3601,9 +4537,9 @@ var PS = {};
     return {};
   };
 
-  exports.poke = function (m) {
-    return function (k) {
-      return function (v) {
+  exports.poke = function (k) {
+    return function (v) {
+      return function (m) {
         return function () {
           m[k] = v;
           return m;
@@ -3611,27 +4547,26 @@ var PS = {};
       };
     };
   };
-})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
+})(PS["Foreign.Object.ST"] = PS["Foreign.Object.ST"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.StrMap.ST"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
+  var $foreign = PS["Foreign.Object.ST"];
   var Control_Monad_ST = PS["Control.Monad.ST"];
   var Data_Maybe = PS["Data.Maybe"];
   exports["new"] = $foreign["new"];
   exports["poke"] = $foreign.poke;
-})(PS["Data.StrMap.ST"] = PS["Data.StrMap.ST"] || {});
+})(PS["Foreign.Object.ST"] = PS["Foreign.Object.ST"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.StrMap"];
+  var $foreign = PS["Foreign.Object"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Category = PS["Control.Category"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
   var Control_Monad_ST = PS["Control.Monad.ST"];
+  var Control_Monad_ST_Internal = PS["Control.Monad.ST.Internal"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
   var Data_Array = PS["Data.Array"];
   var Data_Eq = PS["Data.Eq"];
@@ -3647,27 +4582,21 @@ var PS = {};
   var Data_Ord = PS["Data.Ord"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Show = PS["Data.Show"];
-  var Data_StrMap_ST = PS["Data.StrMap.ST"];
   var Data_Traversable = PS["Data.Traversable"];
   var Data_TraversableWithIndex = PS["Data.TraversableWithIndex"];
   var Data_Tuple = PS["Data.Tuple"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Foreign_Object_ST = PS["Foreign.Object.ST"];
   var Prelude = PS["Prelude"];                                   
-  var thawST = $foreign._copyEff;
-  var pureST = function (f) {
-      return Control_Monad_Eff.runPure($foreign.runST(f));
-  };
+  var thawST = $foreign._copyST;
   var singleton = function (k) {
       return function (v) {
-          return pureST(function __do() {
-              var v1 = Data_StrMap_ST["new"]();
-              return Data_StrMap_ST.poke(v1)(k)(v)();
-          });
+          return $foreign.runST(Control_Bind.bindFlipped(Control_Monad_ST_Internal.bindST)(Foreign_Object_ST.poke(k)(v))(Foreign_Object_ST["new"]));
       };
   };
   var mutate = function (f) {
       return function (m) {
-          return pureST(function __do() {
+          return $foreign.runST(function __do() {
               var v = thawST(m)();
               var v1 = f(v)();
               return v;
@@ -3675,12 +4604,17 @@ var PS = {};
       };
   };
   var lookup = Data_Function_Uncurried.runFn4($foreign._lookup)(Data_Maybe.Nothing.value)(Data_Maybe.Just.create);
+  var insert = function (k) {
+      return function (v) {
+          return mutate(Foreign_Object_ST.poke(k)(v));
+      };
+  };
   var fromFoldable = function (dictFoldable) {
       return function (l) {
-          return pureST(function __do() {
-              var v = Data_StrMap_ST["new"]();
-              Control_Monad_Eff.foreachE(Data_Array.fromFoldable(dictFoldable)(l))(function (v1) {
-                  return Data_Functor["void"](Control_Monad_Eff.functorEff)(Data_StrMap_ST.poke(v)(v1.value0)(v1.value1));
+          return $foreign.runST(function __do() {
+              var v = Foreign_Object_ST["new"]();
+              Data_Foldable.for_(Control_Monad_ST_Internal.applicativeST)(Data_Foldable.foldableArray)(Data_Array.fromFoldable(dictFoldable)(l))(function (v1) {
+                  return Foreign_Object_ST.poke(v1.value0)(v1.value1)(v);
               })();
               return v;
           });
@@ -3693,39 +4627,28 @@ var PS = {};
           };
       };
   };
-  var semigroupStrMap = function (dictSemigroup) {
-      return new Data_Semigroup.Semigroup(function (m1) {
-          return function (m2) {
-              return mutate(function (s1) {
-                  return Data_Functor["void"](Control_Monad_Eff.functorEff)(foldM(Control_Monad_Eff.monadEff)(function (s2) {
-                      return function (k) {
-                          return function (v2) {
-                              return Data_StrMap_ST.poke(s2)(k)($foreign._lookup(v2, function (v1) {
-                                  return Data_Semigroup.append(dictSemigroup)(v1)(v2);
-                              }, k, m2));
-                          };
-                      };
-                  })(s1)(m1));
-              })(m2);
-          };
-      });
-  };
   var union = function (m) {
       return mutate(function (s) {
-          return Data_Functor["void"](Control_Monad_Eff.functorEff)(foldM(Control_Monad_Eff.monadEff)(Data_StrMap_ST.poke)(s)(m));
+          return foldM(Control_Monad_ST_Internal.monadST)(function (s$prime) {
+              return function (k) {
+                  return function (v) {
+                      return Foreign_Object_ST.poke(k)(v)(s$prime);
+                  };
+              };
+          })(s)(m);
       });
   };
   exports["singleton"] = singleton;
+  exports["insert"] = insert;
   exports["lookup"] = lookup;
   exports["fromFoldable"] = fromFoldable;
   exports["union"] = union;
   exports["foldM"] = foldM;
   exports["thawST"] = thawST;
-  exports["pureST"] = pureST;
-  exports["semigroupStrMap"] = semigroupStrMap;
-})(PS["Data.StrMap"] = PS["Data.StrMap"] || {});
+  exports["empty"] = $foreign.empty;
+})(PS["Foreign.Object"] = PS["Foreign.Object"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
@@ -3736,38 +4659,40 @@ var PS = {};
   var Data_Array = PS["Data.Array"];
   var Data_Bifunctor = PS["Data.Bifunctor"];
   var Data_Either = PS["Data.Either"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Internal = PS["Data.Foreign.Internal"];
-  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Identity = PS["Data.Identity"];
   var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_Traversable = PS["Data.Traversable"];
-  var Prelude = PS["Prelude"];        
+  var Data_Unit = PS["Data.Unit"];
+  var Data_Void = PS["Data.Void"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Internal = PS["Foreign.Internal"];
+  var Foreign_NullOrUndefined = PS["Foreign.NullOrUndefined"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var Prelude = PS["Prelude"];                 
   var Decode = function (decode) {
       this.decode = decode;
-  };                                                    
-  var stringDecode = new Decode(Data_Foreign.readString);
-  var intDecode = new Decode(Data_Foreign.readInt);
+  };                                                     
+  var stringDecode = new Decode(Foreign.readString);  
+  var intDecode = new Decode(Foreign.readInt);
   var decode = function (dict) {
       return dict.decode;
   };
-  var decodeNullOrUndefined = function (dictDecode) {
-      return new Decode(Data_Foreign_NullOrUndefined.readNullOrUndefined(decode(dictDecode)));
+  var maybeDecode = function (dictDecode) {
+      return new Decode(Foreign_NullOrUndefined.readNullOrUndefined(decode(dictDecode)));
   };
   var arrayDecode = function (dictDecode) {
       return new Decode((function () {
           var readElement = function (i) {
               return function (value) {
-                  return Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtIndex.create(i))))(decode(dictDecode)(value));
+                  return Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtIndex.create(i))))(decode(dictDecode)(value));
               };
           };
           var readElements = function (arr) {
               return Data_Traversable.sequence(Data_Traversable.traversableArray)(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_Array.zipWith(readElement)(Data_Array.range(0)(Data_Array.length(arr)))(arr));
           };
-          return Control_Bind.composeKleisli(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign.readArray)(readElements);
+          return Control_Bind.composeKleisli(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign.readArray)(readElements);
       })());
   };
   exports["decode"] = decode;
@@ -3775,10 +4700,10 @@ var PS = {};
   exports["stringDecode"] = stringDecode;
   exports["intDecode"] = intDecode;
   exports["arrayDecode"] = arrayDecode;
-  exports["decodeNullOrUndefined"] = decodeNullOrUndefined;
-})(PS["Data.Foreign.Class"] = PS["Data.Foreign.Class"] || {});
+  exports["maybeDecode"] = maybeDecode;
+})(PS["Foreign.Class"] = PS["Foreign.Class"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var TaggedObject = (function () {
       function TaggedObject(value0) {
@@ -3790,7 +4715,7 @@ var PS = {};
       return TaggedObject;
   })();
   exports["TaggedObject"] = TaggedObject;
-})(PS["Data.Foreign.Generic.Types"] = PS["Data.Foreign.Generic.Types"] || {});
+})(PS["Foreign.Generic.Types"] = PS["Foreign.Generic.Types"] || {});
 (function(exports) {
     "use strict";
 
@@ -3805,22 +4730,22 @@ var PS = {};
   exports.unsafeHasProperty = function (prop, value) {
     return prop in value;
   };
-})(PS["Data.Foreign.Index"] = PS["Data.Foreign.Index"] || {});
+})(PS["Foreign.Index"] = PS["Foreign.Index"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var $foreign = PS["Data.Foreign.Index"];
+  var $foreign = PS["Foreign.Index"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Data_Eq = PS["Data.Eq"];
-  var Data_Foreign = PS["Data.Foreign"];
   var Data_Function = PS["Data.Function"];
   var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
   var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
   var Data_Identity = PS["Data.Identity"];
   var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
-  var Prelude = PS["Prelude"];        
+  var Foreign = PS["Foreign"];
+  var Prelude = PS["Prelude"];                 
   var Index = function (errorAt, hasOwnProperty, hasProperty, index) {
       this.errorAt = errorAt;
       this.hasOwnProperty = hasOwnProperty;
@@ -3829,7 +4754,7 @@ var PS = {};
   };
   var unsafeReadProp = function (k) {
       return function (value) {
-          return $foreign.unsafeReadPropImpl(Data_Foreign.fail(new Data_Foreign.TypeMismatch("object", Data_Foreign.typeOf(value))), Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity)), k, value);
+          return $foreign.unsafeReadPropImpl(Foreign.fail(new Foreign.TypeMismatch("object", Foreign.typeOf(value))), Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity)), k, value);
       };
   };
   var readProp = unsafeReadProp;
@@ -3838,13 +4763,13 @@ var PS = {};
   }; 
   var hasPropertyImpl = function (v) {
       return function (value) {
-          if (Data_Foreign.isNull(value)) {
+          if (Foreign.isNull(value)) {
               return false;
           };
-          if (Data_Foreign.isUndefined(value)) {
+          if (Foreign.isUndefined(value)) {
               return false;
           };
-          if (Data_Foreign.typeOf(value) === "object" || Data_Foreign.typeOf(value) === "function") {
+          if (Foreign.typeOf(value) === "object" || Foreign.typeOf(value) === "function") {
               return $foreign.unsafeHasProperty(v, value);
           };
           return false;
@@ -3855,19 +4780,19 @@ var PS = {};
   };
   var hasOwnPropertyImpl = function (v) {
       return function (value) {
-          if (Data_Foreign.isNull(value)) {
+          if (Foreign.isNull(value)) {
               return false;
           };
-          if (Data_Foreign.isUndefined(value)) {
+          if (Foreign.isUndefined(value)) {
               return false;
           };
-          if (Data_Foreign.typeOf(value) === "object" || Data_Foreign.typeOf(value) === "function") {
+          if (Foreign.typeOf(value) === "object" || Foreign.typeOf(value) === "function") {
               return $foreign.unsafeHasOwnProperty(v, value);
           };
           return false;
       };
-  };                                                                                                                             
-  var indexString = new Index(Data_Foreign.ErrorAtProperty.create, hasOwnPropertyImpl, hasPropertyImpl, Data_Function.flip(readProp));
+  };                                                                                                                        
+  var indexString = new Index(Foreign.ErrorAtProperty.create, hasOwnPropertyImpl, hasPropertyImpl, Data_Function.flip(readProp));
   var hasOwnProperty = function (dict) {
       return dict.hasOwnProperty;
   };
@@ -3881,91 +4806,68 @@ var PS = {};
   exports["hasOwnProperty"] = hasOwnProperty;
   exports["errorAt"] = errorAt;
   exports["indexString"] = indexString;
-})(PS["Data.Foreign.Index"] = PS["Data.Foreign.Index"] || {});
+})(PS["Foreign.Index"] = PS["Foreign.Index"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Data_Maybe = PS["Data.Maybe"];        
-  var Inl = (function () {
-      function Inl(value0) {
-          this.value0 = value0;
-      };
-      Inl.create = function (value0) {
-          return new Inl(value0);
-      };
-      return Inl;
-  })();
-  var Inr = (function () {
-      function Inr(value0) {
-          this.value0 = value0;
-      };
-      Inr.create = function (value0) {
-          return new Inr(value0);
-      };
-      return Inr;
-  })();
-  var Product = (function () {
-      function Product(value0, value1) {
-          this.value0 = value0;
-          this.value1 = value1;
-      };
-      Product.create = function (value0) {
-          return function (value1) {
-              return new Product(value0, value1);
-          };
-      };
-      return Product;
-  })();
-  var Field = function (x) {
-      return x;
-  };
-  var Constructor = function (x) {
-      return x;
-  };
-  var Generic = function (from, to) {
-      this.from = from;
-      this.to = to;
+    "use strict";
+
+  exports.copyRecord = function(rec) {
+    var copy = {};
+    for (var key in rec) {
+      if ({}.hasOwnProperty.call(rec, key)) {
+        copy[key] = rec[key];
+      }
+    }
+    return copy;
   };
-  var to = function (dict) {
-      return dict.to;
-  }; 
-  var from = function (dict) {
-      return dict.from;
+
+  exports.unsafeInsert = function(l) {
+    return function(a) {
+      return function(rec) {
+        rec[l] = a;
+        return rec;
+      };
+    };
   };
-  exports["Generic"] = Generic;
-  exports["to"] = to;
-  exports["from"] = from;
-  exports["Inl"] = Inl;
-  exports["Inr"] = Inr;
-  exports["Product"] = Product;
-  exports["Constructor"] = Constructor;
-  exports["Field"] = Field;
-})(PS["Data.Generic.Rep"] = PS["Data.Generic.Rep"] || {});
+})(PS["Record.Builder"] = PS["Record.Builder"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Semigroup = PS["Data.Semigroup"];
+  var $foreign = PS["Record.Builder"];
+  var Control_Category = PS["Control.Category"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Function_Uncurried = PS["Data.Function.Uncurried"];
+  var Data_Symbol = PS["Data.Symbol"];
   var Prelude = PS["Prelude"];
-  var Unsafe_Coerce = PS["Unsafe.Coerce"];        
-  var SProxy = (function () {
-      function SProxy() {
-
+  var Record_Unsafe_Union = PS["Record.Unsafe.Union"];
+  var Type_Row = PS["Type.Row"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];
+  var semigroupoidBuilder = Control_Semigroupoid.semigroupoidFn;
+  var insert = function (dictCons) {
+      return function (dictLacks) {
+          return function (dictIsSymbol) {
+              return function (l) {
+                  return function (a) {
+                      return function (r1) {
+                          return $foreign.unsafeInsert(Data_Symbol.reflectSymbol(dictIsSymbol)(l))(a)(r1);
+                      };
+                  };
+              };
+          };
       };
-      SProxy.value = new SProxy();
-      return SProxy;
-  })();
-  var IsSymbol = function (reflectSymbol) {
-      this.reflectSymbol = reflectSymbol;
   };
-  var reflectSymbol = function (dict) {
-      return dict.reflectSymbol;
+  var categoryBuilder = Control_Category.categoryFn;
+  var build = function (v) {
+      return function (r1) {
+          return v($foreign.copyRecord(r1));
+      };
   };
-  exports["IsSymbol"] = IsSymbol;
-  exports["reflectSymbol"] = reflectSymbol;
-  exports["SProxy"] = SProxy;
-})(PS["Data.Symbol"] = PS["Data.Symbol"] || {});
+  exports["build"] = build;
+  exports["insert"] = insert;
+  exports["semigroupoidBuilder"] = semigroupoidBuilder;
+  exports["categoryBuilder"] = categoryBuilder;
+})(PS["Record.Builder"] = PS["Record.Builder"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Apply = PS["Control.Apply"];
@@ -3994,12 +4896,12 @@ var PS = {};
   exports["Proxy"] = $$Proxy;
 })(PS["Type.Proxy"] = PS["Type.Proxy"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Alt = PS["Control.Alt"];
   var Control_Applicative = PS["Control.Applicative"];
-  var Control_Apply = PS["Control.Apply"];
   var Control_Bind = PS["Control.Bind"];
+  var Control_Category = PS["Control.Category"];
   var Control_Monad_Except = PS["Control.Monad.Except"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
@@ -4007,10 +4909,6 @@ var PS = {};
   var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Class = PS["Data.Foreign.Class"];
-  var Data_Foreign_Generic_Types = PS["Data.Foreign.Generic.Types"];
-  var Data_Foreign_Index = PS["Data.Foreign.Index"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Generic_Rep = PS["Data.Generic.Rep"];
@@ -4022,41 +4920,51 @@ var PS = {};
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_Symbol = PS["Data.Symbol"];
   var Data_Unfoldable = PS["Data.Unfoldable"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Class = PS["Foreign.Class"];
+  var Foreign_Generic_Types = PS["Foreign.Generic.Types"];
+  var Foreign_Index = PS["Foreign.Index"];
+  var Foreign_Object = PS["Foreign.Object"];
   var Prelude = PS["Prelude"];
-  var Type_Proxy = PS["Type.Proxy"];        
+  var Record = PS["Record"];
+  var Record_Builder = PS["Record.Builder"];
+  var Type_Data_RowList = PS["Type.Data.RowList"];
+  var Type_Proxy = PS["Type.Proxy"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];                 
   var GenericDecode = function (decodeOpts) {
       this.decodeOpts = decodeOpts;
   };
   var GenericDecodeArgs = function (decodeArgs) {
       this.decodeArgs = decodeArgs;
   };
-  var GenericDecodeFields = function (decodeFields) {
-      this.decodeFields = decodeFields;
-  };
   var GenericCountArgs = function (countArgs) {
       this.countArgs = countArgs;
+  };
+  var Decode_ = function (decode_) {
+      this.decode_ = decode_;
+  };
+  var DecodeRecord = function (decodeRecord_) {
+      this.decodeRecord_ = decodeRecord_;
   }; 
-  var genericDecodeFieldsField = function (dictIsSymbol) {
-      return function (dictDecode) {
-          return new GenericDecodeFields(function (opts) {
-              return function (x) {
-                  var name = opts.fieldTransform(Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value));
-                  return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Field)(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign_Index.index(Data_Foreign_Index.indexString)(x)(name))(function ($158) {
-                      return Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtProperty.create(name))))(Data_Foreign_Class.decode(dictDecode)($158));
-                  }));
-              };
-          });
-      };
-  }; 
-  var genericDecodeArgsArgument = function (dictDecode) {
+  var genericCountArgsArgument = new GenericCountArgs(function (v) {
+      return new Data_Either.Right(1);
+  });
+  var decode_Other = function (dictDecode) {
+      return new Decode_(function (v) {
+          return Foreign_Class.decode(dictDecode);
+      });
+  };
+  var decode_ = function (dict) {
+      return dict.decode_;
+  };
+  var genericDecodeArgsArgument = function (dictDecode_) {
       return new GenericDecodeArgs(function (v) {
           return function (v1) {
               return function (v2) {
                   if (v2 instanceof Data_List_Types.Cons) {
-                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtIndex.create(v1))))(Data_Foreign_Class.decode(dictDecode)(v2.value0)))(function (v3) {
+                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtIndex.create(v1))))(decode_(dictDecode_)(v)(v2.value0)))(function (v3) {
                           return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))({
                               result: v3,
                               rest: v2.value1,
@@ -4064,65 +4972,67 @@ var PS = {};
                           });
                       });
                   };
-                  return Data_Foreign.fail(new Data_Foreign.ForeignError("Not enough constructor arguments"));
+                  return Foreign.fail(new Foreign.ForeignError("Not enough constructor arguments"));
               };
           };
       });
   };
-  var genericCountArgsRec = new GenericCountArgs(function (v) {
-      return new Data_Either.Right(1);
-  });
-  var genericCountArgsArgument = new GenericCountArgs(function (v) {
-      return new Data_Either.Right(1);
-  });
-  var decodeOpts = function (dict) {
-      return dict.decodeOpts;
+  var decodeRecord_ = function (dict) {
+      return dict.decodeRecord_;
   };
-  var genericDecodeSum = function (dictGenericDecode) {
-      return function (dictGenericDecode1) {
-          return new GenericDecode(function (opts) {
-              return function (f) {
-                  var opts$prime = (function () {
-                      var $111 = {};
-                      for (var $112 in opts) {
-                          if ({}.hasOwnProperty.call(opts, $112)) {
-                              $111[$112] = opts[$112];
-                          };
-                      };
-                      $111.unwrapSingleConstructors = false;
-                      return $111;
-                  })();
-                  return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inl.create)(decodeOpts(dictGenericDecode)(opts$prime)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inr.create)(decodeOpts(dictGenericDecode1)(opts$prime)(f)));
-              };
+  var decode_Record = function (dictRowToList) {
+      return function (dictDecodeRecord) {
+          return new Decode_(function (opts) {
+              return Data_Functor.map(Data_Functor.functorFn)(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Function.flip(Record_Builder.build)({})))(decodeRecord_(dictDecodeRecord)(Type_Data_RowList.RLProxy.value)(opts));
           });
       };
   };
-  var decodeFields = function (dict) {
-      return dict.decodeFields;
-  };
-  var genericDecodeArgsRec = function (dictGenericDecodeFields) {
-      return new GenericDecodeArgs(function (v) {
-          return function (v1) {
-              return function (v2) {
-                  if (v2 instanceof Data_List_Types.Cons) {
-                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtIndex.create(v1))))(decodeFields(dictGenericDecodeFields)(v)(v2.value0)))(function (v3) {
-                          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))({
-                              result: v3,
-                              rest: v2.value1,
-                              next: v1 + 1 | 0
-                          });
+  var decodeRecordNil = new DecodeRecord(function (v) {
+      return function (v1) {
+          return function (v2) {
+              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Control_Category.identity(Record_Builder.categoryBuilder));
+          };
+      };
+  });
+  var decodeRecordCons = function (dictCons) {
+      return function (dictDecodeRecord) {
+          return function (dictIsSymbol) {
+              return function (dictDecode_) {
+                  return function (dictLacks) {
+                      return new DecodeRecord(function (v) {
+                          return function (opts) {
+                              return function (f) {
+                                  return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(decodeRecord_(dictDecodeRecord)(Type_Data_RowList.RLProxy.value)(opts)(f))(function (v1) {
+                                      var l = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
+                                      var l_transformed = opts.fieldTransform(l);
+                                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Index.index(Foreign_Index.indexString)(f)(l_transformed))(function (v2) {
+                                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtProperty.create(l_transformed))))(decode_(dictDecode_)(opts)(v2)))(function (v3) {
+                                              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Control_Semigroupoid.composeFlipped(Record_Builder.semigroupoidBuilder)(v1)(Record_Builder.insert(dictCons)(dictLacks)(dictIsSymbol)(Data_Symbol.SProxy.value)(v3)));
+                                          });
+                                      });
+                                  });
+                              };
+                          };
                       });
                   };
-                  return Data_Foreign.fail(new Data_Foreign.ForeignError("Not enough constructor arguments"));
               };
           };
-      });
+      };
   };
-  var genericDecodeFieldsProduct = function (dictGenericDecodeFields) {
-      return function (dictGenericDecodeFields1) {
-          return new GenericDecodeFields(function (opts) {
-              return function (x) {
-                  return Control_Apply.apply(Control_Monad_Except_Trans.applyExceptT(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Product.create)(decodeFields(dictGenericDecodeFields)(opts)(x)))(decodeFields(dictGenericDecodeFields1)(opts)(x));
+  var decodeOpts = function (dict) {
+      return dict.decodeOpts;
+  };
+  var genericDecodeSum = function (dictGenericDecode) {
+      return function (dictGenericDecode1) {
+          return new GenericDecode(function (opts) {
+              return function (f) {
+                  var opts$prime = {
+                      unwrapSingleConstructors: false,
+                      fieldTransform: opts.fieldTransform,
+                      sumEncoding: opts.sumEncoding,
+                      unwrapSingleArguments: opts.unwrapSingleArguments
+                  };
+                  return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inl.create)(decodeOpts(dictGenericDecode)(opts$prime)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Inr.create)(decodeOpts(dictGenericDecode1)(opts$prime)(f)));
               };
           });
       };
@@ -4145,33 +5055,33 @@ var PS = {};
                           };
                           if (numArgs instanceof Data_Either.Right && (numArgs.value0 === 1 && opts.unwrapSingleArguments)) {
                               return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(decodeArgs(dictGenericDecodeArgs)(opts)(0)(Data_List.singleton(args)))(function (v) {
-                                  return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v.rest))(Data_Foreign.fail(new Data_Foreign.ForeignError("Expected a single argument"))))(function () {
+                                  return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v.rest))(Foreign.fail(new Foreign.ForeignError("Expected a single argument"))))(function () {
                                       return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v.result);
                                   });
                               });
                           };
                           if (numArgs instanceof Data_Either.Right) {
-                              return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign.readArray(args))(function (v) {
+                              return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign.readArray(args))(function (v) {
                                   return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(decodeArgs(dictGenericDecodeArgs)(opts)(0)(Data_List.fromFoldable(Data_Foldable.foldableArray)(v)))(function (v1) {
-                                      return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v1.rest))(Data_Foreign.fail(new Data_Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showInt)(numArgs.value0) + " constructor arguments")))))(function () {
+                                      return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(Data_List["null"](v1.rest))(Foreign.fail(new Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showInt)(numArgs.value0) + " constructor arguments")))))(function () {
                                           return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v1.result);
                                       });
                                   });
                               });
                           };
-                          throw new Error("Failed pattern match at Data.Foreign.Generic.Class line 74, column 9 - line 86, column 24: " + [ numArgs.constructor.name ]);
+                          throw new Error("Failed pattern match at Foreign.Generic.Class line 75, column 9 - line 87, column 24: " + [ numArgs.constructor.name ]);
                       };
                       var ctorName = Data_Symbol.reflectSymbol(dictIsSymbol)(Data_Symbol.SProxy.value);
                       if (opts.unwrapSingleConstructors) {
                           return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.Constructor)(readArguments(f));
                       };
-                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.contentsFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign_Index.index(Data_Foreign_Index.indexString)(f)(opts.sumEncoding.value0.tagFieldName))(Data_Foreign.readString))(function (v) {
+                      return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.tagFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Index.index(Foreign_Index.indexString)(f)(opts.sumEncoding.value0.tagFieldName))(Foreign.readString))(function (v) {
                           var expected = opts.sumEncoding.value0.constructorTagTransform(ctorName);
-                          return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(opts.sumEncoding.value0.constructorTagTransform(v) === expected)(Data_Foreign.fail(new Data_Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showString)(expected) + " tag")))))(function () {
+                          return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Applicative.unless(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v === expected)(Foreign.fail(new Foreign.ForeignError("Expected " + (Data_Show.show(Data_Show.showString)(expected) + " tag")))))(function () {
                               return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v);
                           });
                       })))(function (v) {
-                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Data_Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.contentsFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Data_Foreign_Index.index(Data_Foreign_Index.indexString)(f)(opts.sumEncoding.value0.contentsFieldName))(readArguments)))(function (v1) {
+                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Control_Monad_Except.mapExcept(Data_Bifunctor.lmap(Data_Either.bifunctorEither)(Data_Functor.map(Data_List_Types.functorNonEmptyList)(Foreign.ErrorAtProperty.create(opts.sumEncoding.value0.contentsFieldName))))(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Data_Identity.monadIdentity))(Foreign_Index.index(Foreign_Index.indexString)(f)(opts.sumEncoding.value0.contentsFieldName))(readArguments)))(function (v1) {
                               return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Data_Identity.monadIdentity))(v1);
                           });
                       });
@@ -4182,192 +5092,281 @@ var PS = {};
   };
   exports["countArgs"] = countArgs;
   exports["decodeArgs"] = decodeArgs;
-  exports["decodeFields"] = decodeFields;
   exports["decodeOpts"] = decodeOpts;
+  exports["decodeRecord_"] = decodeRecord_;
+  exports["decode_"] = decode_;
   exports["GenericDecode"] = GenericDecode;
   exports["GenericDecodeArgs"] = GenericDecodeArgs;
-  exports["GenericDecodeFields"] = GenericDecodeFields;
   exports["GenericCountArgs"] = GenericCountArgs;
+  exports["Decode_"] = Decode_;
+  exports["DecodeRecord"] = DecodeRecord;
   exports["genericDecodeConstructor"] = genericDecodeConstructor;
   exports["genericDecodeSum"] = genericDecodeSum;
   exports["genericDecodeArgsArgument"] = genericDecodeArgsArgument;
-  exports["genericDecodeArgsRec"] = genericDecodeArgsRec;
-  exports["genericDecodeFieldsField"] = genericDecodeFieldsField;
-  exports["genericDecodeFieldsProduct"] = genericDecodeFieldsProduct;
   exports["genericCountArgsArgument"] = genericCountArgsArgument;
-  exports["genericCountArgsRec"] = genericCountArgsRec;
-})(PS["Data.Foreign.Generic.Class"] = PS["Data.Foreign.Generic.Class"] || {});
+  exports["decode_Record"] = decode_Record;
+  exports["decode_Other"] = decode_Other;
+  exports["decodeRecordNil"] = decodeRecordNil;
+  exports["decodeRecordCons"] = decodeRecordCons;
+})(PS["Foreign.Generic.Class"] = PS["Foreign.Generic.Class"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  /* globals exports, JSON */
+  "use strict";                       
+  exports.unsafeDecodeURIComponent = decodeURIComponent;
+})(PS["Global.Unsafe"] = PS["Global.Unsafe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Global.Unsafe"];
+  exports["unsafeDecodeURIComponent"] = $foreign.unsafeDecodeURIComponent;
+})(PS["Global.Unsafe"] = PS["Global.Unsafe"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
   var Control_Bind = PS["Control.Bind"];
   var Control_Category = PS["Control.Category"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Class = PS["Data.Foreign.Class"];
-  var Data_Foreign_Generic_Class = PS["Data.Foreign.Generic.Class"];
-  var Data_Foreign_Generic_Types = PS["Data.Foreign.Generic.Types"];
-  var Data_Foreign_JSON = PS["Data.Foreign.JSON"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Generic_Rep = PS["Data.Generic.Rep"];
   var Data_Identity = PS["Data.Identity"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Class = PS["Foreign.Class"];
+  var Foreign_Generic_Class = PS["Foreign.Generic.Class"];
+  var Foreign_Generic_Types = PS["Foreign.Generic.Types"];
+  var Foreign_JSON = PS["Foreign.JSON"];
   var Global_Unsafe = PS["Global.Unsafe"];
   var Prelude = PS["Prelude"];
   var genericDecode = function (dictGeneric) {
       return function (dictGenericDecode) {
           return function (opts) {
               return function ($12) {
-                  return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.to(dictGeneric))(Data_Foreign_Generic_Class.decodeOpts(dictGenericDecode)(opts)($12));
+                  return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(Data_Generic_Rep.to(dictGeneric))(Foreign_Generic_Class.decodeOpts(dictGenericDecode)(opts)($12));
               };
           };
       };
   };
   var defaultOptions = {
-      sumEncoding: new Data_Foreign_Generic_Types.TaggedObject({
+      sumEncoding: new Foreign_Generic_Types.TaggedObject({
           tagFieldName: "tag",
           contentsFieldName: "contents",
-          constructorTagTransform: Control_Category.id(Control_Category.categoryFn)
+          constructorTagTransform: Control_Category.identity(Control_Category.categoryFn)
       }),
       unwrapSingleConstructors: false,
       unwrapSingleArguments: true,
-      fieldTransform: Control_Category.id(Control_Category.categoryFn)
+      fieldTransform: Control_Category.identity(Control_Category.categoryFn)
   };
   exports["defaultOptions"] = defaultOptions;
   exports["genericDecode"] = genericDecode;
-})(PS["Data.Foreign.Generic"] = PS["Data.Foreign.Generic"] || {});
+})(PS["Foreign.Generic"] = PS["Foreign.Generic"] || {});
 (function(exports) {
-    "use strict";
+  /* global exports */
+  "use strict";
 
-  exports["regex'"] = function (left) {
-    return function (right) {
-      return function (s1) {
-        return function (s2) {
-          try {
-            return right(new RegExp(s1, s2));
-          } catch (e) {
-            return left(e.message);
-          }
-        };
+  exports.ready = function(func) {
+      return function() {
+          jQuery(document).ready(func);
       };
-    };
   };
 
-  exports.replace = function (r) {
-    return function (s1) {
-      return function (s2) {
-        return s2.replace(r, s1);
+  exports.select = function(selector) {
+      return function() {
+          return jQuery(selector);
       };
-    };
   };
 
-  exports["replace'"] = function (r) {
-    return function (f) {
-      return function (s2) {
-        return s2.replace(r, function (match) {
-          return f(match)(Array.prototype.splice.call(arguments, 1, arguments.length - 3));
-        });
+  exports.create = function(html) {
+      return function() {
+          return jQuery(html);
       };
-    };
   };
-})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Control_MonadPlus = PS["Control.MonadPlus"];
-  var Control_MonadZero = PS["Control.MonadZero"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Functor = PS["Data.Functor"];
-  var Data_HeytingAlgebra = PS["Data.HeytingAlgebra"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_String = PS["Data.String"];
-  var Prelude = PS["Prelude"];        
-  var RegexFlags = (function () {
-      function RegexFlags(value0) {
-          this.value0 = value0;
+
+  exports.setAttr = function(attr) {
+      return function(val) {
+          return function(ob) {
+              return function() {
+                  ob.attr(attr, val);
+              };
+          };
       };
-      RegexFlags.create = function (value0) {
-          return new RegexFlags(value0);
+  };
+
+  exports.attr = function(attrs) {
+      return function(ob) {
+          return function() {
+              ob.attr(attrs);
+          };
       };
-      return RegexFlags;
-  })();
-  var global = new RegexFlags({
-      global: true,
-      ignoreCase: false,
-      multiline: false,
-      sticky: false,
-      unicode: false
-  });
-  exports["RegexFlags"] = RegexFlags;
-  exports["global"] = global;
-})(PS["Data.String.Regex.Flags"] = PS["Data.String.Regex.Flags"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Data.String.Regex"];
-  var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var Data_Either = PS["Data.Either"];
-  var Data_Function = PS["Data.Function"];
-  var Data_Maybe = PS["Data.Maybe"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_Show = PS["Data.Show"];
-  var Data_String = PS["Data.String"];
-  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
-  var Prelude = PS["Prelude"];                                                    
-  var renderFlags = function (v) {
-      return (function () {
-          if (v.value0.global) {
-              return "g";
+  };
+
+  exports.toggleClass = function(cls) {
+      return function(ob) {
+          return function() {
+              ob.toggleClass(cls);
           };
-          return "";
-      })() + ((function () {
-          if (v.value0.ignoreCase) {
-              return "i";
+      };
+  };
+
+  exports.setClass = function(cls) {
+      return function(flag) {
+          return function(ob) {
+              return function() {
+                  ob.toggleClass(cls, flag);
+              };
           };
-          return "";
-      })() + ((function () {
-          if (v.value0.multiline) {
-              return "m";
+      };
+  };
+
+  exports.setProp = function(p) {
+      return function(val) {
+          return function(ob) {
+              return function() {
+                  ob.prop(p, val);
+              };
           };
-          return "";
-      })() + ((function () {
-          if (v.value0.sticky) {
-              return "y";
+      };
+  };
+
+  exports.append = function(ob1) {
+      return function(ob) {
+          return function() {
+              ob.append(ob1);
           };
-          return "";
-      })() + (function () {
-          if (v.value0.unicode) {
-              return "u";
+      };
+  };
+
+  exports.setText = function(text) {
+      return function(ob) {
+          return function() {
+              ob.text(text);
           };
-          return "";
-      })())));
+      };
+  };
+
+  exports.setValue = function(val) {
+      return function(ob) {
+          return function() {
+              ob.val(val);
+          };
+      };
+  };
+
+  exports.toggle = function(ob) {
+      return function() {
+          ob.toggle();
+      };
+  };
+
+  exports.setVisible = function(flag) {
+      return function(ob) {
+          return function() {
+              ob.toggle(flag);
+          };
+      };
+  };
+
+  exports.on = function(evt) {
+      return function(act) {
+          return function(ob) {
+              return function() {
+                  ob.on(evt, function(e) {
+                      act(e)(jQuery(this))();
+                  });
+              };
+          };
+      };
+  };
+})(PS["JQuery"] = PS["JQuery"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["JQuery"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Effect = PS["Effect"];
+  var Foreign = PS["Foreign"];
+  var Prelude = PS["Prelude"];
+  var hide = $foreign.setVisible(false);  
+  var addClass = function (cls) {
+      return $foreign.setClass(cls)(true);
+  };
+  exports["addClass"] = addClass;
+  exports["hide"] = hide;
+  exports["ready"] = $foreign.ready;
+  exports["select"] = $foreign.select;
+  exports["create"] = $foreign.create;
+  exports["setAttr"] = $foreign.setAttr;
+  exports["attr"] = $foreign.attr;
+  exports["setProp"] = $foreign.setProp;
+  exports["append"] = $foreign.append;
+  exports["setText"] = $foreign.setText;
+  exports["setValue"] = $foreign.setValue;
+  exports["on"] = $foreign.on;
+})(PS["JQuery"] = PS["JQuery"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.empty = function(jq) {
+    return function() {
+      jq.empty();
+    };
   };
-  var regex = function (s) {
-      return function (f) {
-          return $foreign["regex'"](Data_Either.Left.create)(Data_Either.Right.create)(s)(renderFlags(f));
+
+  exports.fadeIn = function(jq) {
+    return function() {
+      jq.fadeIn();
+    };
+  };
+
+  exports.fadeOut = function(jq) {
+    return function() {
+      jq.fadeOut();
+    };
+  };
+
+  exports.filter = function(jq) {
+    return function(sel) {
+      return function() {
+        return jq.filter(sel);
       };
+    };
   };
-  exports["regex"] = regex;
-  exports["renderFlags"] = renderFlags;
-  exports["replace"] = $foreign.replace;
-  exports["replace'"] = $foreign["replace'"];
-})(PS["Data.String.Regex"] = PS["Data.String.Regex"] || {});
+
+  exports.is = function(jq) {
+    return function(sel) {
+      return function() {
+        return jq.is(sel);
+      };
+    };
+  };
+
+  exports.getValue = function(jq) {
+    return function() {
+      return jq.val();
+    };
+  };
+})(PS["JQuery.Extras"] = PS["JQuery.Extras"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
-  var Data_Either = PS["Data.Either"];
-  var Data_String_Regex = PS["Data.String.Regex"];
-  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];        
-  var unsafeRegex = function (s) {
-      return function (f) {
-          return Data_Either.fromRight()(Data_String_Regex.regex(s)(f));
-      };
+  var $foreign = PS["JQuery.Extras"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Nullable = PS["Data.Nullable"];
+  var Effect = PS["Effect"];
+  var JQuery = PS["JQuery"];
+  var Prelude = PS["Prelude"];                 
+  var getValueMaybe = function ($0) {
+      return Data_Functor.map(Effect.functorEffect)(Data_Nullable.toMaybe)($foreign.getValue($0));
   };
-  exports["unsafeRegex"] = unsafeRegex;
-})(PS["Data.String.Regex.Unsafe"] = PS["Data.String.Regex.Unsafe"] || {});
+  exports["getValueMaybe"] = getValueMaybe;
+  exports["empty"] = $foreign.empty;
+  exports["fadeIn"] = $foreign.fadeIn;
+  exports["fadeOut"] = $foreign.fadeOut;
+  exports["filter"] = $foreign.filter;
+  exports["is"] = $foreign.is;
+})(PS["JQuery.Extras"] = PS["JQuery.Extras"] || {});
 (function(exports) {
     "use strict";
 
@@ -4404,62 +5403,31 @@ var PS = {};
   }
 })(PS["Try.API"] = PS["Try.API"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var Data_Newtype = PS["Data.Newtype"];        
-  var JS = function (x) {
-      return x;
-  };
-  var newtypeJS = new Data_Newtype.Newtype(function (n) {
-      return n;
-  }, JS);
-  exports["JS"] = JS;
-  exports["newtypeJS"] = newtypeJS;
-})(PS["Try.Types"] = PS["Try.Types"] || {});
-(function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.API"];
   var Control_Alt = PS["Control.Alt"];
   var Control_Category = PS["Control.Category"];
   var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Class = PS["Control.Monad.Eff.Class"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Monad_Except = PS["Control.Monad.Except"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
-  var Control_Parallel = PS["Control.Parallel"];
-  var Control_Parallel_Class = PS["Control.Parallel.Class"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var Data_Array = PS["Data.Array"];
   var Data_Either = PS["Data.Either"];
-  var Data_Eq = PS["Data.Eq"];
-  var Data_Foldable = PS["Data.Foldable"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_Class = PS["Data.Foreign.Class"];
-  var Data_Foreign_Generic = PS["Data.Foreign.Generic"];
-  var Data_Foreign_Generic_Class = PS["Data.Foreign.Generic.Class"];
-  var Data_Foreign_Generic_Types = PS["Data.Foreign.Generic.Types"];
-  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
-  var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Generic_Rep = PS["Data.Generic.Rep"];
   var Data_Identity = PS["Data.Identity"];
   var Data_List_NonEmpty = PS["Data.List.NonEmpty"];
   var Data_List_Types = PS["Data.List.Types"];
-  var Data_Monoid = PS["Data.Monoid"];
-  var Data_Ord = PS["Data.Ord"];
-  var Data_Ordering = PS["Data.Ordering"];
-  var Data_Semigroup = PS["Data.Semigroup"];
-  var Data_String_Regex = PS["Data.String.Regex"];
-  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
-  var Data_String_Regex_Unsafe = PS["Data.String.Regex.Unsafe"];
+  var Data_Maybe = PS["Data.Maybe"];
   var Data_Symbol = PS["Data.Symbol"];
-  var Data_Traversable = PS["Data.Traversable"];
-  var Partial_Unsafe = PS["Partial.Unsafe"];
+  var Effect = PS["Effect"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Class = PS["Foreign.Class"];
+  var Foreign_Generic = PS["Foreign.Generic"];
+  var Foreign_Generic_Class = PS["Foreign.Generic.Class"];
+  var Foreign_Generic_Types = PS["Foreign.Generic.Types"];
   var Prelude = PS["Prelude"];
-  var Try_Types = PS["Try.Types"];
   var CompilerErrors = (function () {
       function CompilerErrors(value0) {
           this.value0 = value0;
@@ -4496,130 +5464,46 @@ var PS = {};
       };
       return CompileFailed;
   })();
-  var Core = (function () {
-      function Core() {
-
-      };
-      Core.value = new Core();
-      return Core;
-  })();
-  var Thermite = (function () {
-      function Thermite() {
-
-      };
-      Thermite.value = new Thermite();
-      return Thermite;
-  })();
-  var Slides = (function () {
-      function Slides() {
-
-      };
-      Slides.value = new Slides();
-      return Slides;
-  })();
-  var Mathbox = (function () {
-      function Mathbox() {
-
-      };
-      Mathbox.value = new Mathbox();
-      return Mathbox;
-  })();
-  var Behaviors = (function () {
-      function Behaviors() {
-
-      };
-      Behaviors.value = new Behaviors();
-      return Behaviors;
-  })();
-  var Flare = (function () {
-      function Flare() {
-
-      };
-      Flare.value = new Flare();
-      return Flare;
-  })();
   var get = function (uri) {
       return function (k) {
-          return Control_Monad_Eff_Uncurried.runEffFn3($foreign.get_)(uri)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($113) {
-              return k(Data_Either.Right.create($113));
-          }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($114) {
-              return k(Data_Either.Left.create($114));
-          }));
-      };
-  };
-  var getDefaultBundle = function (endpoint) {
-      return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Control_Monad_Cont_Trans.functorContT(Control_Monad_Eff.functorEff)))(Try_Types.JS)(get(endpoint + "/bundle"));
-  };
-  var getThermiteBundle = function (endpoint) {
-      var onComplete = function (dictPartial) {
-          return function (v) {
-              var __unused = function (dictPartial1) {
-                  return function ($dollar35) {
-                      return $dollar35;
-                  };
-              };
-              return __unused(dictPartial)((function () {
-                  if (v.length === 4) {
-                      var replaced = Data_String_Regex.replace(Data_String_Regex_Unsafe.unsafeRegex("require\\(\"react-dom\\/server\"\\)")(Data_String_Regex_Flags.global))("window.ReactDOM")(Data_String_Regex.replace(Data_String_Regex_Unsafe.unsafeRegex("require\\(\"react-dom\"\\)")(Data_String_Regex_Flags.global))("window.ReactDOM")(Data_String_Regex.replace(Data_String_Regex_Unsafe.unsafeRegex("require\\(\"react\"\\)")(Data_String_Regex_Flags.global))("window.React")(v[3])));
-                      return Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)("\x0a")([ v[0], v[1], v[2], replaced ]);
-                  };
-                  throw new Error("Failed pattern match at Try.API line 168, column 7 - line 170, column 23: " + [ v.constructor.name ]);
-              })());
+          return function () {
+              return $foreign.get_(uri, function ($35) {
+                  return k(Data_Either.Right.create($35))();
+              }, function ($36) {
+                  return k(Data_Either.Left.create($36))();
+              });
           };
       };
-      var getAll = Control_Parallel.parTraverse(Control_Parallel_Class.monadParExceptT(Control_Parallel_Class.monadParParCont(Control_Monad_Eff_Class.monadEffEff)))(Data_Traversable.traversableArray)(get)([ "js/console.js", "js/react.min.js", "js/react-dom.min.js", endpoint + "/bundle" ]);
-      return Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Control_Monad_Cont_Trans.functorContT(Control_Monad_Eff.functorEff)))(onComplete())(getAll);
   };
   var genericSuggestion = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.replaceRange, x.replacement);
+      return x;
   }, function (x) {
-      return {
-          replaceRange: x.value0,
-          replacement: x.value1
-      };
+      return x;
   });
   var genericSuccessResult = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.js, x.warnings);
+      return x;
   }, function (x) {
-      return {
-          js: x.value0,
-          warnings: x.value1
-      };
+      return x;
   });
   var genericFailedResult = new Data_Generic_Rep.Generic(function (x) {
-      return x.error;
+      return x;
   }, function (x) {
-      return {
-          error: x
-      };
+      return x;
   });
   var genericErrorPosition = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.endColumn, new Data_Generic_Rep.Product(x.endLine, new Data_Generic_Rep.Product(x.startColumn, x.startLine)));
+      return x;
   }, function (x) {
-      return {
-          endColumn: x.value0,
-          endLine: x.value1.value0,
-          startColumn: x.value1.value1.value0,
-          startLine: x.value1.value1.value1
-      };
+      return x;
   });
   var genericCompilerError = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.message, x.position);
+      return x;
   }, function (x) {
-      return {
-          message: x.value0,
-          position: x.value1
-      };
+      return x;
   });
   var genericCompileWarning = new Data_Generic_Rep.Generic(function (x) {
-      return new Data_Generic_Rep.Product(x.errorCode, new Data_Generic_Rep.Product(x.message, new Data_Generic_Rep.Product(x.position, x.suggestion)));
+      return x;
   }, function (x) {
-      return {
-          errorCode: x.value0,
-          message: x.value1.value0,
-          position: x.value1.value1.value0,
-          suggestion: x.value1.value1.value1
-      };
+      return x;
   });
   var genericCompileError = new Data_Generic_Rep.Generic(function (x) {
       if (x instanceof CompilerErrors) {
@@ -4628,7 +5512,7 @@ var PS = {};
       if (x instanceof OtherError) {
           return new Data_Generic_Rep.Inr(x.value0);
       };
-      throw new Error("Failed pattern match at Try.API line 72, column 8 - line 72, column 62: " + [ x.constructor.name ]);
+      throw new Error("Failed pattern match at Try.API line 62, column 8 - line 62, column 62: " + [ x.constructor.name ]);
   }, function (x) {
       if (x instanceof Data_Generic_Rep.Inl) {
           return new CompilerErrors(x.value0);
@@ -4636,204 +5520,96 @@ var PS = {};
       if (x instanceof Data_Generic_Rep.Inr) {
           return new OtherError(x.value0);
       };
-      throw new Error("Failed pattern match at Try.API line 72, column 8 - line 72, column 62: " + [ x.constructor.name ]);
+      throw new Error("Failed pattern match at Try.API line 62, column 8 - line 62, column 62: " + [ x.constructor.name ]);
   });
-  var decodingOptions = (function () {
-      var $104 = {};
-      for (var $105 in Data_Foreign_Generic.defaultOptions) {
-          if ({}.hasOwnProperty.call(Data_Foreign_Generic.defaultOptions, $105)) {
-              $104[$105] = Data_Foreign_Generic["defaultOptions"][$105];
-          };
-      };
-      $104.unwrapSingleConstructors = true;
-      return $104;
-  })();
-  var decodeErrorPosition = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericErrorPosition)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  var decodingOptions = {
+      sumEncoding: Foreign_Generic.defaultOptions.sumEncoding,
+      unwrapSingleConstructors: true,
+      unwrapSingleArguments: Foreign_Generic.defaultOptions.unwrapSingleArguments,
+      fieldTransform: Foreign_Generic.defaultOptions.fieldTransform
+  };
+  var decodeErrorPosition = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericErrorPosition)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "ErrorPosition";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "endColumn";
-  }))(Data_Foreign_Class.intDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "endLine";
-  }))(Data_Foreign_Class.intDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "startColumn";
-  }))(Data_Foreign_Class.intDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "startLine";
-  }))(Data_Foreign_Class.intDecode))))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));
-  var decodeSuggestion = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericSuggestion)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "startColumn";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "endLine";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "endColumn";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.intDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeSuggestion = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericSuggestion)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "Suggestion";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "replaceRange";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeErrorPosition)))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "replacement";
-  }))(Data_Foreign_Class.stringDecode))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));
-  var decodeCompilerError = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericCompilerError)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "replaceRange";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeErrorPosition)))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeCompilerError = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericCompilerError)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "CompilerError";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "message";
-  }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "position";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeErrorPosition)))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));
-  var decodeCompileWarning = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericCompileWarning)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
-      return "CompileWarning";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "errorCode";
-  }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeErrorPosition)))())(new Data_Symbol.IsSymbol(function () {
       return "message";
-  }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-      return "position";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeErrorPosition)))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeCompileWarning = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericCompileWarning)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+      return "CompileWarning";
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
       return "suggestion";
-  }))(Data_Foreign_Class.decodeNullOrUndefined(decodeSuggestion)))))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions));                                  
-  var decodeCompileError = new Data_Foreign_Class.Decode(Data_Foreign_Generic.genericDecode(genericCompileError)(Data_Foreign_Generic_Class.genericDecodeSum(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeSuggestion)))())(new Data_Symbol.IsSymbol(function () {
+      return "position";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(decodeErrorPosition)))())(new Data_Symbol.IsSymbol(function () {
+      return "message";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())(new Data_Symbol.IsSymbol(function () {
+      return "errorCode";
+  }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions));
+  var decodeCompileError = new Foreign_Class.Decode(Foreign_Generic.genericDecode(genericCompileError)(Foreign_Generic_Class.genericDecodeSum(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "CompilerErrors";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsArgument(Data_Foreign_Class.arrayDecode(decodeCompilerError)))(Data_Foreign_Generic_Class.genericCountArgsArgument))(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Other(Foreign_Class.arrayDecode(decodeCompilerError))))(Foreign_Generic_Class.genericCountArgsArgument))(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
       return "OtherError";
-  }))(Data_Foreign_Generic_Class.genericDecodeArgsArgument(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericCountArgsArgument)))((function () {
-      var $107 = {};
-      for (var $108 in Data_Foreign_Generic.defaultOptions) {
-          if ({}.hasOwnProperty.call(Data_Foreign_Generic.defaultOptions, $108)) {
-              $107[$108] = Data_Foreign_Generic["defaultOptions"][$108];
-          };
-      };
-      $107.sumEncoding = new Data_Foreign_Generic_Types.TaggedObject({
+  }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode)))(Foreign_Generic_Class.genericCountArgsArgument)))({
+      sumEncoding: new Foreign_Generic_Types.TaggedObject({
           tagFieldName: "tag",
           contentsFieldName: "contents",
-          constructorTagTransform: Control_Category.id(Control_Category.categoryFn)
-      });
-      return $107;
-  })()));
-  var decodeCompileResult = new Data_Foreign_Class.Decode(function (f) {
-      return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileSuccess.create)(Data_Foreign_Generic.genericDecode(genericSuccessResult)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+          constructorTagTransform: Control_Category.identity(Control_Category.categoryFn)
+      }),
+      unwrapSingleConstructors: Foreign_Generic.defaultOptions.unwrapSingleConstructors,
+      unwrapSingleArguments: Foreign_Generic.defaultOptions.unwrapSingleArguments,
+      fieldTransform: Foreign_Generic.defaultOptions.fieldTransform
+  }));
+  var decodeCompileResult = new Foreign_Class.Decode(function (f) {
+      return Control_Alt.alt(Control_Monad_Except_Trans.altExceptT(Data_List_Types.semigroupNonEmptyList)(Data_Identity.monadIdentity))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileSuccess.create)(Foreign_Generic.genericDecode(genericSuccessResult)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
           return "SuccessResult";
-      }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsProduct(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
-          return "js";
-      }))(Data_Foreign_Class.stringDecode))(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+      }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
           return "warnings";
-      }))(Data_Foreign_Class.decodeNullOrUndefined(Data_Foreign_Class.arrayDecode(decodeCompileWarning))))))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileFailed.create)(Data_Foreign_Generic.genericDecode(genericFailedResult)(Data_Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
+      }))(Foreign_Generic_Class.decode_Other(Foreign_Class.maybeDecode(Foreign_Class.arrayDecode(decodeCompileWarning))))())(new Data_Symbol.IsSymbol(function () {
+          return "js";
+      }))(Foreign_Generic_Class.decode_Other(Foreign_Class.stringDecode))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions)(f)))(Data_Functor.map(Control_Monad_Except_Trans.functorExceptT(Data_Identity.functorIdentity))(CompileFailed.create)(Foreign_Generic.genericDecode(genericFailedResult)(Foreign_Generic_Class.genericDecodeConstructor(new Data_Symbol.IsSymbol(function () {
           return "FailedResult";
-      }))(Data_Foreign_Generic_Class.genericDecodeArgsRec(Data_Foreign_Generic_Class.genericDecodeFieldsField(new Data_Symbol.IsSymbol(function () {
+      }))(Foreign_Generic_Class.genericDecodeArgsArgument(Foreign_Generic_Class.decode_Record()(Foreign_Generic_Class.decodeRecordCons()(Foreign_Generic_Class.decodeRecordNil)(new Data_Symbol.IsSymbol(function () {
           return "error";
-      }))(decodeCompileError)))(Data_Foreign_Generic_Class.genericCountArgsRec))(decodingOptions)(f)));
-  });                                                                                          
+      }))(Foreign_Generic_Class.decode_Other(decodeCompileError))())))(Foreign_Generic_Class.genericCountArgsArgument))(decodingOptions)(f)));
+  });                                                                                                                                 
   var compile = function (endpoint) {
       return function (code) {
           return function (k) {
-              return Control_Monad_Eff_Uncurried.runEffFn4($foreign.compile_)(endpoint)(code)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($115) {
-                  return k(Data_Either.Right.create(Control_Monad_Except.runExcept(Data_Foreign_Class.decode(decodeCompileResult)($115))));
-              }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($116) {
-                  return k(Data_Either.Left.create($116));
-              }));
-          };
-      };
-  };
-  var getBackendConfig = function (v) {
-      if (v instanceof Core) {
-          return {
-              backend: "core",
-              mainGist: "b57a766d417e109785540d584266fc33",
-              extra_styling: "",
-              extra_body: "",
-              compile: compile("https://compile.purescript.org/try"),
-              getBundle: getDefaultBundle("https://compile.purescript.org/try")
-          };
-      };
-      if (v instanceof Thermite) {
-          return {
-              backend: "thermite",
-              mainGist: "85383bb058471109cfef379bbb6bc11c",
-              extra_styling: "<link rel=\"stylesheet\" href=\"//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css\">",
-              extra_body: "<div id=\"app\"></div>",
-              compile: compile("https://compile.purescript.org/thermite"),
-              getBundle: getThermiteBundle("https://compile.purescript.org/thermite")
-          };
-      };
-      if (v instanceof Slides) {
-          return {
-              backend: "slides",
-              mainGist: "c62b5778a6a5f2bcd32dd97b294c068a",
-              extra_styling: "<link rel=\"stylesheet\" href=\"css/slides.css\">",
-              extra_body: "<div id=\"main\"></div>",
-              compile: compile("https://compile.purescript.org/slides"),
-              getBundle: getDefaultBundle("https://compile.purescript.org/slides")
-          };
-      };
-      if (v instanceof Mathbox) {
-          return {
-              backend: "mathbox",
-              mainGist: "81f8bb3261b9c819d677de2ea54a4d2e",
-              extra_styling: Data_Foldable.fold(Data_Foldable.foldableArray)(Data_Monoid.monoidString)([ "<script src=\"js/mathbox-bundle.js\"></script>", "<link rel=\"stylesheet\" href=\"css/mathbox.css\">" ]),
-              extra_body: "",
-              compile: compile("https://compile.purescript.org/purescript-mathbox"),
-              getBundle: getDefaultBundle("https://compile.purescript.org/purescript-mathbox")
-          };
-      };
-      if (v instanceof Behaviors) {
-          return {
-              backend: "behaviors",
-              mainGist: "ff1e87f0872d2d891e77d209d8f7706d",
-              extra_styling: "",
-              extra_body: "<canvas id=\"canvas\" width=\"800\" height=\"600\"></canvas>",
-              compile: compile("https://compile.purescript.org/behaviors"),
-              getBundle: getDefaultBundle("https://compile.purescript.org/behaviors")
-          };
-      };
-      if (v instanceof Flare) {
-          return {
-              backend: "flare",
-              mainGist: "4f54d6dd213caa54d736ead597e17fee",
-              extra_styling: "<link rel=\"stylesheet\" href=\"css/flare.css\">",
-              extra_body: Data_Foldable.fold(Data_Foldable.foldableArray)(Data_Monoid.monoidString)([ "<div id=\"controls\"></div>", "<div id=\"output\"></div>", "<div id=\"tests\"></div>", "<canvas id=\"canvas\" width=\"800\" height=\"600\"></canvas>" ]),
-              compile: compile("https://compile.purescript.org/flare"),
-              getBundle: getDefaultBundle("https://compile.purescript.org/flare")
-          };
-      };
-      throw new Error("Failed pattern match at Try.API line 238, column 1 - line 238, column 45: " + [ v.constructor.name ]);
-  };
-  var backendFromString = function (dictPartial) {
-      return function (v) {
-          var __unused = function (dictPartial1) {
-              return function ($dollar40) {
-                  return $dollar40;
+              return function () {
+                  return $foreign.compile_(endpoint, code, function ($37) {
+                      return k(Data_Either.Right.create(Control_Monad_Except.runExcept(Foreign_Class.decode(decodeCompileResult)($37))))();
+                  }, function ($38) {
+                      return k(Data_Either.Left.create($38))();
+                  });
               };
           };
-          return __unused(dictPartial)((function () {
-              if (v === "core") {
-                  return Core.value;
-              };
-              if (v === "thermite") {
-                  return Thermite.value;
-              };
-              if (v === "slides") {
-                  return Slides.value;
-              };
-              if (v === "mathbox") {
-                  return Mathbox.value;
-              };
-              if (v === "behaviors") {
-                  return Behaviors.value;
-              };
-              if (v === "flare") {
-                  return Flare.value;
-              };
-              throw new Error("Failed pattern match at Try.API line 219, column 1 - line 219, column 50: " + [ v.constructor.name ]);
-          })());
       };
   };
-  var getBackendConfigFromString = function (s) {
-      return getBackendConfig(backendFromString()(s));
-  };
   exports["CompilerErrors"] = CompilerErrors;
   exports["OtherError"] = OtherError;
   exports["CompileSuccess"] = CompileSuccess;
   exports["CompileFailed"] = CompileFailed;
-  exports["Core"] = Core;
-  exports["Thermite"] = Thermite;
-  exports["Slides"] = Slides;
-  exports["Mathbox"] = Mathbox;
-  exports["Behaviors"] = Behaviors;
-  exports["Flare"] = Flare;
-  exports["getBackendConfig"] = getBackendConfig;
-  exports["getBackendConfigFromString"] = getBackendConfigFromString;
+  exports["get"] = get;
+  exports["compile"] = compile;
   exports["genericErrorPosition"] = genericErrorPosition;
   exports["decodeErrorPosition"] = decodeErrorPosition;
   exports["genericCompilerError"] = genericCompilerError;
@@ -4848,6 +5624,15 @@ var PS = {};
   exports["genericFailedResult"] = genericFailedResult;
   exports["decodeCompileResult"] = decodeCompileResult;
 })(PS["Try.API"] = PS["Try.API"] || {});
+(function(exports) {
+    "use strict";
+  var mainGist = "b57a766d417e109785540d584266fc33";
+  var loaderUrl = "js/output";
+  var compileUrl = "http://localhost:8081";
+  exports["loaderUrl"] = loaderUrl;
+  exports["compileUrl"] = compileUrl;
+  exports["mainGist"] = mainGist;
+})(PS["Try.Config"] = PS["Try.Config"] || {});
 (function(exports) {
     "use strict";
 
@@ -4899,50 +5684,268 @@ var PS = {};
   };
 })(PS["Try.Gist"] = PS["Try.Gist"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
-  "use strict";
-  var $foreign = PS["Try.Gist"];
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Try.Gist"];
+  var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
+  var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Either = PS["Data.Either"];
+  var Effect = PS["Effect"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Prelude = PS["Prelude"];                 
+  var uploadGist = function (content) {
+      return function (k) {
+          return function () {
+              return $foreign.uploadGist_(content, function ($0) {
+                  return k(Data_Either.Right.create($0))();
+              }, function ($1) {
+                  return k(Data_Either.Left.create($1))();
+              });
+          };
+      };
+  };
+  var tryLoadFileFromGist = function (gi) {
+      return function (filename) {
+          return function (k) {
+              return function () {
+                  return $foreign.tryLoadFileFromGist_(gi, filename, function ($2) {
+                      return k(Data_Either.Right.create($2))();
+                  }, function ($3) {
+                      return k(Data_Either.Left.create($3))();
+                  });
+              };
+          };
+      };
+  };
+  var getGistById = function (id_) {
+      return function (k) {
+          return function () {
+              return $foreign.getGistById_(id_, function ($4) {
+                  return k(Data_Either.Right.create($4))();
+              }, function ($5) {
+                  return k(Data_Either.Left.create($5))();
+              });
+          };
+      };
+  };
+  exports["uploadGist"] = uploadGist;
+  exports["getGistById"] = getGistById;
+  exports["tryLoadFileFromGist"] = tryLoadFileFromGist;
+})(PS["Try.Gist"] = PS["Try.Gist"] || {});
+(function(exports) {
+    "use strict";
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Foreign_Object = PS["Foreign.Object"];                 
+  var shims = Foreign_Object.fromFoldable(Data_Foldable.foldableArray)([ new Data_Tuple.Tuple("react", {
+      url: "https://unpkg.com/react@16.6.3/umd/react.development.js",
+      deps: [  ]
+  }), new Data_Tuple.Tuple("react-dom", {
+      url: "https://unpkg.com/react-dom@16.6.3/umd/react-dom.development.js",
+      deps: [ "react" ]
+  }), new Data_Tuple.Tuple("react-dom/server", {
+      url: "https://unpkg.com/react-dom@16.6.3/umd/react-dom-server.browser.development.js",
+      deps: [ "react" ]
+  }) ]);
+  exports["shims"] = shims;
+})(PS["Try.Shim"] = PS["Try.Shim"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var Data_Newtype = PS["Data.Newtype"];
+  var Foreign_Class = PS["Foreign.Class"];                 
+  var JS = function (x) {
+      return x;
+  };
+  var newtypeJS = new Data_Newtype.Newtype(function (n) {
+      return n;
+  }, JS);
+  exports["JS"] = JS;
+  exports["newtypeJS"] = newtypeJS;
+})(PS["Try.Types"] = PS["Try.Types"] || {});
+(function(exports) {
+    "use strict";
+  var Control_Applicative = PS["Control.Applicative"];
+  var Control_Bind = PS["Control.Bind"];
+  var Control_Monad_Cont = PS["Control.Monad.Cont"];
   var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
+  var Control_Monad_Except = PS["Control.Monad.Except"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
+  var Control_Parallel = PS["Control.Parallel"];
+  var Control_Parallel_Class = PS["Control.Parallel.Class"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var Data_Either = PS["Data.Either"];
-  var Prelude = PS["Prelude"];        
-  var uploadGist = function (content) {
-      return function (k) {
-          return Control_Monad_Eff_Uncurried.runEffFn3($foreign.uploadGist_)(content)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($0) {
-              return k(Data_Either.Right.create($0));
-          }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($1) {
-              return k(Data_Either.Left.create($1));
-          }));
-      };
+  var Data_Array = PS["Data.Array"];
+  var Data_Array_NonEmpty = PS["Data.Array.NonEmpty"];
+  var Data_Boolean = PS["Data.Boolean"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Foldable = PS["Data.Foldable"];
+  var Data_Function = PS["Data.Function"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Ord = PS["Data.Ord"];
+  var Data_Semigroup = PS["Data.Semigroup"];
+  var Data_String = PS["Data.String"];
+  var Data_String_CodePoints = PS["Data.String.CodePoints"];
+  var Data_String_CodeUnits = PS["Data.String.CodeUnits"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
+  var Data_String_Regex = PS["Data.String.Regex"];
+  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
+  var Data_String_Regex_Unsafe = PS["Data.String.Regex.Unsafe"];
+  var Data_Traversable = PS["Data.Traversable"];
+  var Data_Tuple = PS["Data.Tuple"];
+  var Effect = PS["Effect"];
+  var Effect_Class = PS["Effect.Class"];
+  var Effect_Ref = PS["Effect.Ref"];
+  var Effect_Unsafe = PS["Effect.Unsafe"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var Prelude = PS["Prelude"];
+  var Try_API = PS["Try.API"];
+  var Try_Shim = PS["Try.Shim"];
+  var Try_Types = PS["Try.Types"];
+  var runLoader = function (v) {
+      return v;
   };
-  var tryLoadFileFromGist = function (gi) {
-      return function (filename) {
-          return function (k) {
-              return Control_Monad_Eff_Uncurried.runEffFn4($foreign.tryLoadFileFromGist_)(gi)(filename)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($2) {
-                  return k(Data_Either.Right.create($2));
-              }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($3) {
-                  return k(Data_Either.Left.create($3));
-              }));
+  var requireRegex = Data_String_Regex_Unsafe.unsafeRegex("^var\\s+\\S+\\s*=\\s*require\\([\"']([^\"']*)[\"']\\)")(Data_String_Regex_Flags.noFlags);
+  var ffiDep = function (name) {
+      return Try_Types.JS("throw new Error('FFI dependency not provided: " + (name + "');"));
+  };
+  var dirname = function (path) {
+      return Data_Maybe.fromMaybe("")(Control_Bind.bind(Data_Maybe.bindMaybe)(Data_String_CodePoints.lastIndexOf("/")(path))(function (v) {
+          return Control_Applicative.pure(Data_Maybe.applicativeMaybe)(Data_String_CodePoints.take(v)(path));
+      }));
+  };
+  var resolvePath = function (a) {
+      return function (b) {
+          if (Data_String_CodePoints.take(2)(b) === "./") {
+              return Data_Maybe.Just.create(dirname(a) + Data_String_CodePoints.drop(1)(b));
           };
+          if (Data_String_CodePoints.take(3)(b) === "../") {
+              return Data_Maybe.Just.create(dirname(dirname(a)) + Data_String_CodePoints.drop(2)(b));
+          };
+          if (Data_Boolean.otherwise) {
+              return Data_Maybe.Nothing.value;
+          };
+          throw new Error("Failed pattern match at Try.Loader line 55, column 1 - line 55, column 48: " + [ a.constructor.name, b.constructor.name ]);
       };
   };
-  var getGistById = function (id_) {
-      return function (k) {
-          return Control_Monad_Eff_Uncurried.runEffFn3($foreign.getGistById_)(id_)(Control_Monad_Eff_Uncurried.mkEffFn1(function ($4) {
-              return k(Data_Either.Right.create($4));
-          }))(Control_Monad_Eff_Uncurried.mkEffFn1(function ($5) {
-              return k(Data_Either.Left.create($5));
-          }));
+  var parseDeps = function (current) {
+      var go = function (line) {
+          return Control_Bind.bind(Data_Maybe.bindMaybe)(Data_String_Regex.match(requireRegex)(line))(function (v) {
+              return Control_Bind.bind(Data_Maybe.bindMaybe)(Control_Bind.join(Data_Maybe.bindMaybe)(Data_Array_NonEmpty.index(v)(1)))(function (v1) {
+                  return Control_Applicative.pure(Data_Maybe.applicativeMaybe)((function () {
+                      var v2 = resolvePath(current)(v1);
+                      if (v2 instanceof Data_Maybe.Just) {
+                          return {
+                              name: v2.value0,
+                              path: Data_String_CodeUnits.stripPrefix("/")(v2.value0)
+                          };
+                      };
+                      return {
+                          name: v1,
+                          path: Data_Maybe.Nothing.value
+                      };
+                  })());
+              });
+          });
+      };
+      return function ($44) {
+          return Data_Array.mapMaybe(go)(Data_String_Common.split("\x0a")(Data_Newtype.unwrap(Try_Types.newtypeJS)($44)));
       };
   };
-  exports["uploadGist"] = uploadGist;
-  exports["getGistById"] = getGistById;
-  exports["tryLoadFileFromGist"] = tryLoadFileFromGist;
-})(PS["Try.Gist"] = PS["Try.Gist"] || {});
+  var makeLoader = function (rootPath) {
+      var moduleCache = Effect_Unsafe.unsafePerformEffect(Effect_Ref["new"](Foreign_Object.empty));
+      var putModule = function (a) {
+          return function (b) {
+              return Effect_Ref.modify_(Foreign_Object.insert(a)(b))(moduleCache);
+          };
+      };
+      var getModule = function (a) {
+          return Data_Functor.map(Effect.functorEffect)(Foreign_Object.lookup(a))(Effect_Ref.read(moduleCache));
+      };
+      var load = function (v) {
+          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Effect_Class.liftEffect(Control_Monad_Except_Trans.monadEffectExceptT(Control_Monad_Cont_Trans.monadEffectContT(Effect_Class.monadEffectEffect)))(getModule(v.name)))(function (v1) {
+              if (v1 instanceof Data_Maybe.Just) {
+                  return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(v1.value0);
+              };
+              if (v1 instanceof Data_Maybe.Nothing) {
+                  return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))((function () {
+                      if (v.path instanceof Data_Maybe.Just) {
+                          return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Try_API.get(rootPath + ("/" + v.path.value0)))(function (v2) {
+                              var src = Try_Types.JS(v2 + ("\x0a//@ sourceURL=" + v.path.value0));
+                              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))({
+                                  name: v.name,
+                                  path: v.path,
+                                  deps: parseDeps(v.name)(src),
+                                  src: src
+                              });
+                          });
+                      };
+                      if (v.path instanceof Data_Maybe.Nothing) {
+                          var v2 = Foreign_Object.lookup(v.name)(Try_Shim.shims);
+                          if (v2 instanceof Data_Maybe.Just) {
+                              return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Try_API.get(v2.value0.url))(function (v3) {
+                                  var src = Try_Types.JS(v3 + ("\x0a//@ sourceURL=" + v2.value0.url));
+                                  var deps = Data_Functor.map(Data_Functor.functorArray)(function (v4) {
+                                      return {
+                                          name: v4,
+                                          path: Data_Maybe.Nothing.value
+                                      };
+                                  })(v2.value0.deps);
+                                  return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))({
+                                      name: v.name,
+                                      path: v.path,
+                                      deps: deps,
+                                      src: src
+                                  });
+                              });
+                          };
+                          if (v2 instanceof Data_Maybe.Nothing) {
+                              return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))({
+                                  name: v.name,
+                                  path: v.path,
+                                  deps: [  ],
+                                  src: ffiDep(v.name)
+                              });
+                          };
+                          throw new Error("Failed pattern match at Try.Loader line 107, column 24 - line 115, column 64: " + [ v2.constructor.name ]);
+                      };
+                      throw new Error("Failed pattern match at Try.Loader line 102, column 11 - line 115, column 64: " + [ v.path.constructor.name ]);
+                  })())(function (v2) {
+                      return Control_Bind.discard(Control_Bind.discardUnit)(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Effect_Class.liftEffect(Control_Monad_Except_Trans.monadEffectExceptT(Control_Monad_Cont_Trans.monadEffectContT(Effect_Class.monadEffectEffect)))(putModule(v.name)(v2)))(function () {
+                          return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(v2);
+                      });
+                  });
+              };
+              throw new Error("Failed pattern match at Try.Loader line 98, column 5 - line 117, column 17: " + [ v1.constructor.name ]);
+          });
+      };
+      var go = function (ms) {
+          return function (v) {
+              if (v.length === 0) {
+                  return Control_Applicative.pure(Control_Monad_Except_Trans.applicativeExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(ms);
+              };
+              return Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Control_Parallel.parTraverse(Control_Parallel_Class.monadParExceptT(Control_Parallel_Class.monadParParCont(Effect_Class.monadEffectEffect)))(Data_Traversable.traversableArray)(load)(v))(function (v1) {
+                  var ms$prime = Foreign_Object.union(ms)(Foreign_Object.fromFoldable(Data_Foldable.foldableArray)(Data_Functor.map(Data_Functor.functorArray)(function (v2) {
+                      return new Data_Tuple.Tuple(v2.name, v2.src);
+                  })(v1)));
+                  return go(ms$prime)(Data_Array.nubBy(Data_Ord.comparing(Data_Ord.ordString)(function (v2) {
+                      return v2.name;
+                  }))(Control_Bind.bindFlipped(Control_Bind.bindArray)(function (v2) {
+                      return v2.deps;
+                  })(v1)));
+              });
+          };
+      };
+      return function ($45) {
+          return go(Foreign_Object.empty)(parseDeps("<file>")($45));
+      };
+  };
+  exports["makeLoader"] = makeLoader;
+  exports["runLoader"] = runLoader;
+})(PS["Try.Loader"] = PS["Try.Loader"] || {});
 (function(exports) {
     "use strict";
 
@@ -4959,53 +5962,55 @@ var PS = {};
   };
 })(PS["Try.QueryString"] = PS["Try.QueryString"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.QueryString"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
   var Data_Array = PS["Data.Array"];
   var Data_Foldable = PS["Data.Foldable"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Newtype = PS["Data.Newtype"];
-  var Data_StrMap = PS["Data.StrMap"];
   var Data_String = PS["Data.String"];
+  var Data_String_CodePoints = PS["Data.String.CodePoints"];
+  var Data_String_Common = PS["Data.String.Common"];
+  var Data_String_Pattern = PS["Data.String.Pattern"];
   var Data_Tuple = PS["Data.Tuple"];
-  var Global = PS["Global"];
-  var Prelude = PS["Prelude"];        
+  var Effect = PS["Effect"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var Global_Unsafe = PS["Global.Unsafe"];
+  var Prelude = PS["Prelude"];                 
   var getQueryParams = (function () {
-      var spaces = Data_String.replaceAll(Data_Newtype.wrap(Data_String.newtypePattern)("+"))(Data_Newtype.wrap(Data_String.newtypeReplacement)(" "));
+      var spaces = Data_String_Common.replaceAll(Data_Newtype.wrap(Data_String_Pattern.newtypePattern)("+"))(Data_Newtype.wrap(Data_String_Pattern.newtypeReplacement)(" "));
       var parseQueryTerm = function (v) {
           if (v.length === 2) {
-              return new Data_Maybe.Just(new Data_Tuple.Tuple(v[0], Global["decodeURIComponent"](spaces(v[1]))));
+              return new Data_Maybe.Just(new Data_Tuple.Tuple(v[0], Global_Unsafe.unsafeDecodeURIComponent(spaces(v[1]))));
           };
           return Data_Maybe.Nothing.value;
       };
       var breakQueryString = function ($6) {
           return (function ($7) {
-              return Data_StrMap.fromFoldable(Data_Foldable.foldableArray)(Data_Array.catMaybes(Data_Functor.map(Data_Functor.functorArray)(function ($8) {
-                  return parseQueryTerm(Data_String.split(Data_Newtype.wrap(Data_String.newtypePattern)("="))($8));
+              return Foreign_Object.fromFoldable(Data_Foldable.foldableArray)(Data_Array.catMaybes(Data_Functor.map(Data_Functor.functorArray)(function ($8) {
+                  return parseQueryTerm(Data_String_Common.split(Data_Newtype.wrap(Data_String_Pattern.newtypePattern)("="))($8));
               })($7)));
-          })(Data_String.split(Data_Newtype.wrap(Data_String.newtypePattern)("&"))(Data_String.drop(1)($6)));
+          })(Data_String_Common.split(Data_Newtype.wrap(Data_String_Pattern.newtypePattern)("&"))(Data_String_CodePoints.drop(1)($6)));
       };
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(breakQueryString)($foreign.getQueryString);
+      return Data_Functor.map(Effect.functorEffect)(breakQueryString)($foreign.getQueryString);
   })();
   var getQueryStringMaybe = function (key) {
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_StrMap.lookup(key))(getQueryParams);
+      return Data_Functor.map(Effect.functorEffect)(Foreign_Object.lookup(key))(getQueryParams);
   };
   var setQueryStrings = function (ss) {
       return function __do() {
           var v = getQueryParams();
-          return Control_Monad_Eff_Uncurried.runEffFn1($foreign.setQueryParameters)(Data_StrMap.union(ss)(v))();
+          return $foreign.setQueryParameters(Foreign_Object.union(ss)(v));
       };
   };
   var setQueryString = function (k) {
       return function (v) {
-          return setQueryStrings(Data_StrMap.singleton(k)(v));
+          return setQueryStrings(Foreign_Object.singleton(k)(v));
       };
   };
   exports["getQueryParams"] = getQueryParams;
@@ -5034,16 +6039,12 @@ var PS = {};
   };
 })(PS["Try.Session"] = PS["Try.Session"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Try.Session"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Random = PS["Control.Monad.Eff.Random"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
   var Data_Functor = PS["Data.Functor"];
   var Data_Functor_App = PS["Data.Functor.App"];
   var Data_Int = PS["Data.Int"];
@@ -5054,24 +6055,32 @@ var PS = {};
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_String = PS["Data.String"];
+  var Data_String_CodePoints = PS["Data.String.CodePoints"];
+  var Effect = PS["Effect"];
+  var Effect_Random = PS["Effect.Random"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
   var Prelude = PS["Prelude"];
-  var Try_QueryString = PS["Try.QueryString"];        
+  var Try_QueryString = PS["Try.QueryString"];                 
   var tryRetrieveSession = function (sessionId) {
-      return Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Nullable.toMaybe)(Control_Monad_Eff_Uncurried.runEffFn1($foreign.tryRetrieveSession_)(sessionId));
+      return Data_Functor.map(Effect.functorEffect)(Data_Nullable.toMaybe)(function () {
+          return $foreign.tryRetrieveSession_(sessionId);
+      });
   };
   var storeSession = function (sessionId) {
       return function (values) {
-          return Control_Monad_Eff_Uncurried.runEffFn2($foreign.storeSession_)(sessionId)(values);
+          return function () {
+              return $foreign.storeSession_(sessionId, values);
+          };
       };
   };
   var randomGuid = (function () {
       var padLeft = function (s) {
-          return Data_String.drop(Data_String.length(s) - 1 | 0)("000" + s);
+          return Data_String_CodePoints.drop(Data_String_CodePoints.length(s) - 1 | 0)("000" + s);
       };
-      var s4 = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($4) {
+      var s4 = Data_Functor.map(Effect.functorEffect)(function ($4) {
           return padLeft(Data_Int.toStringAs(Data_Int.hexadecimal)($4));
-      })(Control_Monad_Eff_Random.randomInt(0)(256 * 256 | 0));
-      return Data_Newtype.unwrap(Data_Functor_App.newtypeApp)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Control_Monad_Eff.applicativeEff))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Control_Monad_Eff.applyEff)(Data_Semigroup.semigroupString))(s4)(s4))))))))))));
+      })(Effect_Random.randomInt(0)(256 * 256 | 0));
+      return Data_Newtype.unwrap(Data_Functor_App.newtypeApp)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(Control_Applicative.pure(Data_Functor_App.applicativeApp(Effect.applicativeEffect))("-"))(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(Data_Semigroup.append(Data_Functor_App.semigroupApp(Effect.applyEffect)(Data_Semigroup.semigroupString))(s4)(s4))))))))))));
   })();
   var createSessionIdIfNecessary = function (k) {
       return function __do() {
@@ -5080,9 +6089,9 @@ var PS = {};
               return k(v.value0)();
           };
           if (v instanceof Data_Maybe.Nothing) {
-              return Control_Bind.bind(Control_Monad_Eff.bindEff)(randomGuid)(Try_QueryString.setQueryString("session"))();
+              return Control_Bind.bind(Effect.bindEffect)(randomGuid)(Try_QueryString.setQueryString("session"))();
           };
-          throw new Error("Failed pattern match at Try.Session line 64, column 3 - line 66, column 46: " + [ v.constructor.name ]);
+          throw new Error("Failed pattern match at Try.Session line 57, column 3 - line 59, column 46: " + [ v.constructor.name ]);
       };
   };
   exports["storeSession"] = storeSession;
@@ -5090,85 +6099,233 @@ var PS = {};
   exports["createSessionIdIfNecessary"] = createSessionIdIfNecessary;
 })(PS["Try.Session"] = PS["Try.Session"] || {});
 (function(exports) {
-  // Generated by purs version 0.11.6
+  /* global window */
+  "use strict";
+
+  exports.window = function () {
+    return window;
+  };
+})(PS["Web.HTML"] = PS["Web.HTML"] || {});
+(function(exports) {
+    "use strict";
+
+  // ----------------------------------------------------------------------------
+
+  exports.href = function (location) {
+    return function () {
+      return location.href;
+    };
+  };
+
+  exports.setHref = function (href) {
+    return function (location) {
+      return function () {
+        location.href = href;
+      };
+    };
+  };
+})(PS["Web.HTML.Location"] = PS["Web.HTML.Location"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Web.HTML.Location"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];
+  exports["setHref"] = $foreign.setHref;
+})(PS["Web.HTML.Location"] = PS["Web.HTML.Location"] || {});
+(function(exports) {
+    "use strict";
+
+  exports.location = function (window) {
+    return function () {
+      return window.location;
+    };
+  };
+
+  exports.alert = function (str) {
+    return function (window) {
+      return function () {
+        window.alert(str);
+        return {};
+      };
+    };
+  };
+
+  exports.confirm = function (str) {
+    return function (window) {
+      return function () {
+        return window.confirm(str);
+      };
+    };
+  };
+})(PS["Web.HTML.Window"] = PS["Web.HTML.Window"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Web.HTML.Window"];
+  var Control_Semigroupoid = PS["Control.Semigroupoid"];
+  var Data_Eq = PS["Data.Eq"];
+  var Data_Functor = PS["Data.Functor"];
+  var Data_Maybe = PS["Data.Maybe"];
+  var Data_Newtype = PS["Data.Newtype"];
+  var Data_Nullable = PS["Data.Nullable"];
+  var Data_Ord = PS["Data.Ord"];
+  var Effect = PS["Effect"];
+  var Prelude = PS["Prelude"];
+  var Unsafe_Coerce = PS["Unsafe.Coerce"];
+  var Web_Event_EventTarget = PS["Web.Event.EventTarget"];
+  var Web_HTML_HTMLDocument = PS["Web.HTML.HTMLDocument"];
+  var Web_HTML_History = PS["Web.HTML.History"];
+  var Web_HTML_Location = PS["Web.HTML.Location"];
+  var Web_HTML_Navigator = PS["Web.HTML.Navigator"];
+  var Web_Storage_Storage = PS["Web.Storage.Storage"];
+  exports["location"] = $foreign.location;
+  exports["alert"] = $foreign.alert;
+  exports["confirm"] = $foreign.confirm;
+})(PS["Web.HTML.Window"] = PS["Web.HTML.Window"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
+  "use strict";
+  var $foreign = PS["Web.HTML"];
+  var Effect = PS["Effect"];
+  var Web_HTML_HTMLAnchorElement = PS["Web.HTML.HTMLAnchorElement"];
+  var Web_HTML_HTMLAreaElement = PS["Web.HTML.HTMLAreaElement"];
+  var Web_HTML_HTMLAudioElement = PS["Web.HTML.HTMLAudioElement"];
+  var Web_HTML_HTMLBRElement = PS["Web.HTML.HTMLBRElement"];
+  var Web_HTML_HTMLBaseElement = PS["Web.HTML.HTMLBaseElement"];
+  var Web_HTML_HTMLBodyElement = PS["Web.HTML.HTMLBodyElement"];
+  var Web_HTML_HTMLButtonElement = PS["Web.HTML.HTMLButtonElement"];
+  var Web_HTML_HTMLCanvasElement = PS["Web.HTML.HTMLCanvasElement"];
+  var Web_HTML_HTMLDListElement = PS["Web.HTML.HTMLDListElement"];
+  var Web_HTML_HTMLDataElement = PS["Web.HTML.HTMLDataElement"];
+  var Web_HTML_HTMLDataListElement = PS["Web.HTML.HTMLDataListElement"];
+  var Web_HTML_HTMLDivElement = PS["Web.HTML.HTMLDivElement"];
+  var Web_HTML_HTMLDocument = PS["Web.HTML.HTMLDocument"];
+  var Web_HTML_HTMLElement = PS["Web.HTML.HTMLElement"];
+  var Web_HTML_HTMLEmbedElement = PS["Web.HTML.HTMLEmbedElement"];
+  var Web_HTML_HTMLFieldSetElement = PS["Web.HTML.HTMLFieldSetElement"];
+  var Web_HTML_HTMLFormElement = PS["Web.HTML.HTMLFormElement"];
+  var Web_HTML_HTMLHRElement = PS["Web.HTML.HTMLHRElement"];
+  var Web_HTML_HTMLHeadElement = PS["Web.HTML.HTMLHeadElement"];
+  var Web_HTML_HTMLHeadingElement = PS["Web.HTML.HTMLHeadingElement"];
+  var Web_HTML_HTMLIFrameElement = PS["Web.HTML.HTMLIFrameElement"];
+  var Web_HTML_HTMLImageElement = PS["Web.HTML.HTMLImageElement"];
+  var Web_HTML_HTMLInputElement = PS["Web.HTML.HTMLInputElement"];
+  var Web_HTML_HTMLKeygenElement = PS["Web.HTML.HTMLKeygenElement"];
+  var Web_HTML_HTMLLIElement = PS["Web.HTML.HTMLLIElement"];
+  var Web_HTML_HTMLLabelElement = PS["Web.HTML.HTMLLabelElement"];
+  var Web_HTML_HTMLLegendElement = PS["Web.HTML.HTMLLegendElement"];
+  var Web_HTML_HTMLLinkElement = PS["Web.HTML.HTMLLinkElement"];
+  var Web_HTML_HTMLMapElement = PS["Web.HTML.HTMLMapElement"];
+  var Web_HTML_HTMLMediaElement = PS["Web.HTML.HTMLMediaElement"];
+  var Web_HTML_HTMLMetaElement = PS["Web.HTML.HTMLMetaElement"];
+  var Web_HTML_HTMLMeterElement = PS["Web.HTML.HTMLMeterElement"];
+  var Web_HTML_HTMLModElement = PS["Web.HTML.HTMLModElement"];
+  var Web_HTML_HTMLOListElement = PS["Web.HTML.HTMLOListElement"];
+  var Web_HTML_HTMLObjectElement = PS["Web.HTML.HTMLObjectElement"];
+  var Web_HTML_HTMLOptGroupElement = PS["Web.HTML.HTMLOptGroupElement"];
+  var Web_HTML_HTMLOptionElement = PS["Web.HTML.HTMLOptionElement"];
+  var Web_HTML_HTMLOutputElement = PS["Web.HTML.HTMLOutputElement"];
+  var Web_HTML_HTMLParagraphElement = PS["Web.HTML.HTMLParagraphElement"];
+  var Web_HTML_HTMLParamElement = PS["Web.HTML.HTMLParamElement"];
+  var Web_HTML_HTMLPreElement = PS["Web.HTML.HTMLPreElement"];
+  var Web_HTML_HTMLProgressElement = PS["Web.HTML.HTMLProgressElement"];
+  var Web_HTML_HTMLQuoteElement = PS["Web.HTML.HTMLQuoteElement"];
+  var Web_HTML_HTMLScriptElement = PS["Web.HTML.HTMLScriptElement"];
+  var Web_HTML_HTMLSelectElement = PS["Web.HTML.HTMLSelectElement"];
+  var Web_HTML_HTMLSourceElement = PS["Web.HTML.HTMLSourceElement"];
+  var Web_HTML_HTMLSpanElement = PS["Web.HTML.HTMLSpanElement"];
+  var Web_HTML_HTMLStyleElement = PS["Web.HTML.HTMLStyleElement"];
+  var Web_HTML_HTMLTableCaptionElement = PS["Web.HTML.HTMLTableCaptionElement"];
+  var Web_HTML_HTMLTableCellElement = PS["Web.HTML.HTMLTableCellElement"];
+  var Web_HTML_HTMLTableColElement = PS["Web.HTML.HTMLTableColElement"];
+  var Web_HTML_HTMLTableDataCellElement = PS["Web.HTML.HTMLTableDataCellElement"];
+  var Web_HTML_HTMLTableElement = PS["Web.HTML.HTMLTableElement"];
+  var Web_HTML_HTMLTableHeaderCellElement = PS["Web.HTML.HTMLTableHeaderCellElement"];
+  var Web_HTML_HTMLTableRowElement = PS["Web.HTML.HTMLTableRowElement"];
+  var Web_HTML_HTMLTableSectionElement = PS["Web.HTML.HTMLTableSectionElement"];
+  var Web_HTML_HTMLTemplateElement = PS["Web.HTML.HTMLTemplateElement"];
+  var Web_HTML_HTMLTextAreaElement = PS["Web.HTML.HTMLTextAreaElement"];
+  var Web_HTML_HTMLTimeElement = PS["Web.HTML.HTMLTimeElement"];
+  var Web_HTML_HTMLTitleElement = PS["Web.HTML.HTMLTitleElement"];
+  var Web_HTML_HTMLTrackElement = PS["Web.HTML.HTMLTrackElement"];
+  var Web_HTML_HTMLUListElement = PS["Web.HTML.HTMLUListElement"];
+  var Web_HTML_HTMLVideoElement = PS["Web.HTML.HTMLVideoElement"];
+  var Web_HTML_History = PS["Web.HTML.History"];
+  var Web_HTML_Location = PS["Web.HTML.Location"];
+  var Web_HTML_Navigator = PS["Web.HTML.Navigator"];
+  var Web_HTML_Window = PS["Web.HTML.Window"];
+  exports["window"] = $foreign.window;
+})(PS["Web.HTML"] = PS["Web.HTML"] || {});
+(function(exports) {
+  // Generated by purs version 0.12.0
   "use strict";
   var $foreign = PS["Main"];
   var Control_Applicative = PS["Control.Applicative"];
   var Control_Bind = PS["Control.Bind"];
   var Control_Monad_Cont_Trans = PS["Control.Monad.Cont.Trans"];
-  var Control_Monad_Eff = PS["Control.Monad.Eff"];
-  var Control_Monad_Eff_Console = PS["Control.Monad.Eff.Console"];
-  var Control_Monad_Eff_JQuery = PS["Control.Monad.Eff.JQuery"];
-  var Control_Monad_Eff_JQuery_Extras = PS["Control.Monad.Eff.JQuery.Extras"];
-  var Control_Monad_Eff_Random = PS["Control.Monad.Eff.Random"];
-  var Control_Monad_Eff_Timer = PS["Control.Monad.Eff.Timer"];
-  var Control_Monad_Eff_Uncurried = PS["Control.Monad.Eff.Uncurried"];
   var Control_Monad_Except_Trans = PS["Control.Monad.Except.Trans"];
   var Control_Semigroupoid = PS["Control.Semigroupoid"];
-  var DOM = PS["DOM"];
-  var DOM_HTML = PS["DOM.HTML"];
-  var DOM_HTML_Location = PS["DOM.HTML.Location"];
-  var DOM_HTML_Types = PS["DOM.HTML.Types"];
-  var DOM_HTML_Window = PS["DOM.HTML.Window"];
   var Data_Array = PS["Data.Array"];
   var Data_Either = PS["Data.Either"];
   var Data_Eq = PS["Data.Eq"];
   var Data_Foldable = PS["Data.Foldable"];
   var Data_FoldableWithIndex = PS["Data.FoldableWithIndex"];
-  var Data_Foreign = PS["Data.Foreign"];
-  var Data_Foreign_NullOrUndefined = PS["Data.Foreign.NullOrUndefined"];
   var Data_Function = PS["Data.Function"];
   var Data_Functor = PS["Data.Functor"];
   var Data_List_Types = PS["Data.List.Types"];
   var Data_Maybe = PS["Data.Maybe"];
   var Data_Monoid = PS["Data.Monoid"];
-  var Data_Newtype = PS["Data.Newtype"];
   var Data_Ring = PS["Data.Ring"];
   var Data_Semigroup = PS["Data.Semigroup"];
   var Data_Semiring = PS["Data.Semiring"];
   var Data_Show = PS["Data.Show"];
-  var Data_StrMap = PS["Data.StrMap"];
-  var Data_String = PS["Data.String"];
-  var Data_String_Regex = PS["Data.String.Regex"];
-  var Data_String_Regex_Flags = PS["Data.String.Regex.Flags"];
-  var Data_String_Regex_Unsafe = PS["Data.String.Regex.Unsafe"];
   var Data_Unit = PS["Data.Unit"];
+  var Effect = PS["Effect"];
+  var Effect_Console = PS["Effect.Console"];
+  var Effect_Uncurried = PS["Effect.Uncurried"];
+  var Foreign = PS["Foreign"];
+  var Foreign_Object = PS["Foreign.Object"];
+  var JQuery = PS["JQuery"];
+  var JQuery_Extras = PS["JQuery.Extras"];
   var Prelude = PS["Prelude"];
   var Try_API = PS["Try.API"];
+  var Try_Config = PS["Try.Config"];
   var Try_Gist = PS["Try.Gist"];
+  var Try_Loader = PS["Try.Loader"];
   var Try_QueryString = PS["Try.QueryString"];
   var Try_Session = PS["Try.Session"];
-  var Try_Types = PS["Try.Types"];        
+  var Try_Types = PS["Try.Types"];
+  var Web_HTML = PS["Web.HTML"];
+  var Web_HTML_Location = PS["Web.HTML.Location"];
+  var Web_HTML_Window = PS["Web.HTML.Window"];                 
   var setTextAreaContent = function (value) {
-      return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#code_textarea"))(Control_Monad_Eff_JQuery.setValue(value));
+      return Control_Bind.bind(Effect.bindEffect)(JQuery.select("#code_textarea"))(JQuery.setValue(value));
   };
   var navigateTo = function (uri) {
-      return Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.location))(DOM_HTML_Location.setHref(uri)));
+      return Data_Functor["void"](Effect.functorEffect)(Control_Bind.bind(Effect.bindEffect)(Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.location))(Web_HTML_Location.setHref(uri)));
   };
+  var loader = Try_Loader.makeLoader(Try_Config.loaderUrl);
   var loadFromGist = function (id_) {
-      return function (backend) {
-          return function (k) {
-              return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Control_Monad_Eff.monadEff)))(Try_Gist.getGistById(id_))(function (gi) {
-                  return Try_Gist.tryLoadFileFromGist(gi)("Main.purs");
-              })))(function (v) {
-                  if (v instanceof Data_Either.Left) {
-                      return function __do() {
-                          Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.alert(v.value0))();
-                          return k({
-                              code: "",
-                              backend: backend
-                          })();
-                      };
-                  };
-                  if (v instanceof Data_Either.Right) {
+      return function (k) {
+          return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Control_Bind.bind(Control_Monad_Except_Trans.bindExceptT(Control_Monad_Cont_Trans.monadContT(Effect.monadEffect)))(Try_Gist.getGistById(id_))(function (gi) {
+              return Try_Gist.tryLoadFileFromGist(gi)("Main.purs");
+          })))(function (v) {
+              if (v instanceof Data_Either.Left) {
+                  return function __do() {
+                      Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.alert(v.value0))();
                       return k({
-                          code: v.value0,
-                          backend: backend
-                      });
+                          code: ""
+                      })();
                   };
-                  throw new Error("Failed pattern match at Main line 293, column 5 - line 297, column 40: " + [ v.constructor.name ]);
-              });
-          };
+              };
+              if (v instanceof Data_Either.Right) {
+                  return k({
+                      code: v.value0
+                  });
+              };
+              throw new Error("Failed pattern match at Main line 228, column 5 - line 232, column 31: " + [ v.constructor.name ]);
+          });
       };
   };
   var withSession = function (sessionId) {
@@ -5176,311 +6333,260 @@ var PS = {};
           return function __do() {
               var v = Try_Session.tryRetrieveSession(sessionId)();
               if (v instanceof Data_Maybe.Just) {
-                  return k({
-                      code: v.value0.code,
-                      backend: Try_API.getBackendConfigFromString(v.value0.backend)
-                  })();
+                  return k(v.value0)();
               };
               if (v instanceof Data_Maybe.Nothing) {
-                  var v1 = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($136) {
-                      return Try_API.getBackendConfigFromString(Data_Maybe.fromMaybe("core")($136));
-                  })(Try_QueryString.getQueryStringMaybe("backend"))();
-                  var v2 = Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Maybe.fromMaybe(v1.mainGist))(Try_QueryString.getQueryStringMaybe("gist"))();
-                  return loadFromGist(v2)(v1)(k)();
+                  var v1 = Data_Functor.map(Effect.functorEffect)(Data_Maybe.fromMaybe(Try_Config.mainGist))(Try_QueryString.getQueryStringMaybe("gist"))();
+                  return loadFromGist(v1)(k)();
               };
-              throw new Error("Failed pattern match at Main line 319, column 3 - line 325, column 29: " + [ v.constructor.name ]);
+              throw new Error("Failed pattern match at Main line 240, column 3 - line 244, column 26: " + [ v.constructor.name ]);
           };
       };
   };
   var isShowJsChecked = function __do() {
-      var jq = Control_Monad_Eff_JQuery.select("#showjs")();
-      return Control_Monad_Eff_JQuery_Extras.is(jq)(":checked")();
+      var jq = JQuery.select("#showjs")();
+      return JQuery_Extras.is(jq)(":checked")();
   };
   var isAutoCompileChecked = function __do() {
-      var jq = Control_Monad_Eff_JQuery.select("#auto_compile")();
-      return Control_Monad_Eff_JQuery_Extras.is(jq)(":checked")();
-  };
-  var hideLoadingMessage = Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#loading"))(Control_Monad_Eff_JQuery_Extras.fadeOut);
-  var getTextAreaContent = Data_Functor.map(Control_Monad_Eff.functorEff)(Data_Foldable.fold(Data_Foldable.foldableMaybe)(Data_Monoid.monoidString))(Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#code_textarea"))(Control_Monad_Eff_JQuery_Extras.getValueMaybe));
-  var publishNewGist = function (v) {
-      return function __do() {
-          var v1 = Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.confirm(Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)("\x0a")([ "Do you really want to publish this code as an anonymous Gist?", "", "Note: this code will be available to anyone with a link to the Gist." ])))();
-          return Control_Applicative.when(Control_Monad_Eff.applicativeEff)(v1)(function __do() {
-              var v2 = getTextAreaContent();
-              return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Try_Gist.uploadGist(v2)))(function (v3) {
-                  if (v3 instanceof Data_Either.Left) {
-                      return function __do() {
-                          Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.alert("Failed to create gist"))();
-                          return Control_Monad_Eff_Console.error("Failed to create gist: " + v3.value0)();
-                      };
-                  };
-                  if (v3 instanceof Data_Either.Right) {
-                      return Try_QueryString.setQueryStrings(Data_Semigroup.append(Data_StrMap.semigroupStrMap(Data_Semigroup.semigroupString))(Data_StrMap.singleton("gist")(v3.value0))(Data_StrMap.singleton("backend")(v.backend)));
+      var jq = JQuery.select("#auto_compile")();
+      return JQuery_Extras.is(jq)(":checked")();
+  };
+  var hideLoadingMessage = Control_Bind.bind(Effect.bindEffect)(JQuery.select("#loading"))(JQuery_Extras.fadeOut);
+  var getTextAreaContent = Data_Functor.map(Effect.functorEffect)(Data_Foldable.fold(Data_Foldable.foldableMaybe)(Data_Monoid.monoidString))(Control_Bind.bind(Effect.bindEffect)(JQuery.select("#code_textarea"))(JQuery_Extras.getValueMaybe));
+  var publishNewGist = function __do() {
+      var v = Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.confirm(Data_Foldable.intercalate(Data_Foldable.foldableArray)(Data_Monoid.monoidString)("\x0a")([ "Do you really want to publish this code as an anonymous Gist?", "", "Note: this code will be available to anyone with a link to the Gist." ])))();
+      return Control_Applicative.when(Effect.applicativeEffect)(v)(function __do() {
+          var v1 = getTextAreaContent();
+          return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Try_Gist.uploadGist(v1)))(function (v2) {
+              if (v2 instanceof Data_Either.Left) {
+                  return function __do() {
+                      Control_Bind.bind(Effect.bindEffect)(Web_HTML.window)(Web_HTML_Window.alert("Failed to create gist"))();
+                      return Effect_Console.error("Failed to create gist: " + v2.value0)();
                   };
-                  throw new Error("Failed pattern match at Main line 359, column 7 - line 365, column 71: " + [ v3.constructor.name ]);
-              })();
+              };
+              if (v2 instanceof Data_Either.Right) {
+                  return Try_QueryString.setQueryStrings(Foreign_Object.singleton("gist")(v2.value0));
+              };
+              throw new Error("Failed pattern match at Main line 267, column 7 - line 272, column 59: " + [ v2.constructor.name ]);
           })();
-      };
+      })();
   };
   var execute = function (js) {
-      return function (bundle) {
-          return function (v) {
-              var replaced = Data_String_Regex["replace'"](Data_String_Regex_Unsafe.unsafeRegex("require\\(\"[^\"]*\"\\)")(Data_String_Regex_Flags.global))(function (s) {
-                  return function (v1) {
-                      return "PS['" + (Data_String.drop(12)(Data_String.take(Data_String.length(s) - 2 | 0)(s)) + "']");
-                  };
-              })(Data_Newtype.unwrap(Try_Types.newtypeJS)(js));
-              var wrapped = Data_String.joinWith("\x0a")([ "var module = {};", "(function(module) {", replaced, "})(module);", "module.exports.main && module.exports.main();" ]);
-              var scripts = Data_String.joinWith("\x0a")([ Data_Newtype.unwrap(Try_Types.newtypeJS)(bundle), wrapped ]);
-              var html = Data_String.joinWith("\x0a")([ "<!DOCTYPE html>", "<html>", "  <head>", "    <meta content=\"text/html;charset=utf-8\" http-equiv=\"Content-Type\">", "    <meta content=\"utf-8\" http-equiv=\"encoding\">", "    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">", "    <title>Try PureScript!</title>", "    <link rel=\"stylesheet\" href=\"css/style.css\">", v.extra_styling, "  </head>", "  <body>", v.extra_body, "  </body>", "</html>" ]);
-              return function __do() {
-                  var v1 = Control_Monad_Eff_JQuery.select("#column2")();
-                  return Control_Monad_Eff_Uncurried.runEffFn3($foreign.setupIFrame)(v1)(html)(scripts)();
-              };
+      return function (modules) {
+          var eventData = Foreign_Object.insert("<file>")(js)(modules);
+          return function __do() {
+              var v = JQuery.select("#column2")();
+              return $foreign.setupIFrame(v, eventData);
           };
       };
   };
   var displayPlainText = function (s) {
       return function __do() {
-          var v = Control_Monad_Eff_JQuery.select("#column2")();
-          Control_Monad_Eff_JQuery_Extras.empty(v)();
-          var v1 = Control_Monad_Eff_JQuery.create("<pre>")();
-          var v2 = Control_Monad_Eff_JQuery.create("<code>")();
-          Control_Monad_Eff_JQuery.append(v2)(v1)();
-          Control_Monad_Eff_JQuery.setText(s)(v2)();
-          return Control_Monad_Eff_JQuery.append(v1)(v)();
+          var v = JQuery.select("#column2")();
+          JQuery_Extras.empty(v)();
+          var v1 = JQuery.create("<pre>")();
+          var v2 = JQuery.create("<code>")();
+          JQuery.append(v2)(v1)();
+          JQuery.setText(s)(v2)();
+          return JQuery.append(v1)(v)();
       };
   };
-  var displayLoadingMessage = Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#loading"))(Control_Monad_Eff_JQuery_Extras.fadeIn);
+  var displayLoadingMessage = Control_Bind.bind(Effect.bindEffect)(JQuery.select("#loading"))(JQuery_Extras.fadeIn);
   var displayErrors = function (errs) {
       return function __do() {
-          var v = Control_Monad_Eff_JQuery.select("#column2")();
-          Control_Monad_Eff_JQuery_Extras.empty(v)();
-          return Data_FoldableWithIndex.forWithIndex_(Control_Monad_Eff.applicativeEff)(Data_FoldableWithIndex.foldableWithIndexArray)(errs)(function (i) {
+          var v = JQuery.select("#column2")();
+          JQuery_Extras.empty(v)();
+          return Data_FoldableWithIndex.forWithIndex_(Effect.applicativeEffect)(Data_FoldableWithIndex.foldableWithIndexArray)(errs)(function (i) {
               return function (v1) {
                   return function __do() {
-                      var v2 = Control_Monad_Eff_JQuery.create("<h1>")();
-                      Control_Monad_Eff_JQuery.addClass("error-banner")(v2)();
-                      Control_Monad_Eff_JQuery.setText("Error " + (Data_Show.show(Data_Show.showInt)(i + 1 | 0) + (" of " + Data_Show.show(Data_Show.showInt)(Data_Array.length(errs)))))(v2)();
-                      var v3 = Control_Monad_Eff_JQuery.create("<pre>")();
-                      var v4 = Control_Monad_Eff_JQuery.create("<code>")();
-                      Control_Monad_Eff_JQuery.append(v4)(v3)();
-                      Control_Monad_Eff_JQuery.setText(v1.message)(v4)();
-                      Control_Monad_Eff_JQuery.append(v2)(v)();
-                      return Control_Monad_Eff_JQuery.append(v3)(v)();
+                      var v2 = JQuery.create("<h1>")();
+                      JQuery.addClass("error-banner")(v2)();
+                      JQuery.setText("Error " + (Data_Show.show(Data_Show.showInt)(i + 1 | 0) + (" of " + Data_Show.show(Data_Show.showInt)(Data_Array.length(errs)))))(v2)();
+                      var v3 = JQuery.create("<pre>")();
+                      var v4 = JQuery.create("<code>")();
+                      JQuery.append(v4)(v3)();
+                      JQuery.setText(v1.message)(v4)();
+                      JQuery.append(v2)(v)();
+                      return JQuery.append(v3)(v)();
                   };
               };
           })();
       };
   };
-  var clearAnnotations = Control_Monad_Eff_Uncurried.runEffFn1($foreign.setAnnotations)([  ]);
-  var compile = function (v) {
-      return function __do() {
-          var v1 = getTextAreaContent();
-          displayLoadingMessage();
-          clearAnnotations();
-          return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(v.compile(v1)))(function (res_) {
-              if (res_ instanceof Data_Either.Left) {
-                  return displayPlainText(res_.value0);
-              };
-              if (res_ instanceof Data_Either.Right) {
-                  return function __do() {
-                      $foreign.cleanUpMarkers();
-                      if (res_.value0 instanceof Data_Either.Right && res_.value0.value0 instanceof Try_API.CompileSuccess) {
-                          var v2 = isShowJsChecked();
-                          if (v2) {
+  var clearAnnotations = function () {
+      return $foreign.setAnnotations([  ]);
+  };
+  var compile = function __do() {
+      var v = getTextAreaContent();
+      displayLoadingMessage();
+      clearAnnotations();
+      return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Try_API.compile(Try_Config.compileUrl)(v)))(function (res_) {
+          if (res_ instanceof Data_Either.Left) {
+              return displayPlainText(res_.value0);
+          };
+          if (res_ instanceof Data_Either.Right) {
+              return function __do() {
+                  $foreign.cleanUpMarkers();
+                  if (res_.value0 instanceof Data_Either.Right && res_.value0.value0 instanceof Try_API.CompileSuccess) {
+                      var v1 = isShowJsChecked();
+                      if (v1) {
+                          hideLoadingMessage();
+                          return displayPlainText(res_.value0.value0.value0.js)();
+                      };
+                      return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(Try_Loader.runLoader(loader)(res_.value0.value0.value0.js)))(function (sources) {
+                          return function __do() {
                               hideLoadingMessage();
-                              return displayPlainText(res_.value0.value0.value0.js)();
-                          };
-                          return Control_Monad_Cont_Trans.runContT(Control_Monad_Except_Trans.runExceptT(v.getBundle))(function (bundleResult) {
-                              return function __do() {
-                                  hideLoadingMessage();
-                                  if (bundleResult instanceof Data_Either.Left) {
-                                      return Control_Monad_Eff_Console.error("Unable to retrieve JS bundle: " + bundleResult.value0)();
-                                  };
-                                  if (bundleResult instanceof Data_Either.Right) {
-                                      Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(res_.value0.value0.value0.warnings))(function (warnings_) {
-                                          var toAnnotation = function (v3) {
-                                              return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(v3.position))(function (v4) {
-                                                  return {
-                                                      row: v4.startLine - 1 | 0,
-                                                      column: v4.startColumn - 1 | 0,
-                                                      type: "warning",
-                                                      text: v3.message
-                                                  };
-                                              });
+                              Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableMaybe)(res_.value0.value0.value0.warnings)(function (warnings_) {
+                                  var toAnnotation = function (v2) {
+                                      return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(v2.position)(function (v3) {
+                                          return {
+                                              row: v3.startLine - 1 | 0,
+                                              column: v3.startColumn - 1 | 0,
+                                              type: "warning",
+                                              text: v2.message
                                           };
-                                          return Control_Monad_Eff_Uncurried.runEffFn1($foreign.setAnnotations)(Data_Array.mapMaybe(toAnnotation)(warnings_));
-                                      })();
-                                      return execute(res_.value0.value0.value0.js)(bundleResult.value0)(v)();
+                                      });
+                                  };
+                                  return function () {
+                                      return $foreign.setAnnotations(Data_Array.mapMaybe(toAnnotation)(warnings_));
                                   };
-                                  throw new Error("Failed pattern match at Main line 159, column 22 - line 171, column 51: " + [ bundleResult.constructor.name ]);
-                              };
-                          })();
-                      };
-                      if (res_.value0 instanceof Data_Either.Right && res_.value0.value0 instanceof Try_API.CompileFailed) {
-                          hideLoadingMessage();
-                          if (res_.value0.value0.value0.error instanceof Try_API.CompilerErrors) {
-                              displayErrors(res_.value0.value0.value0.error.value0)();
-                              var toAnnotation = function (v2) {
-                                  return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(v2.position))(function (v3) {
-                                      return {
-                                          row: v3.startLine - 1 | 0,
-                                          column: v3.startColumn - 1 | 0,
-                                          type: "error",
-                                          text: v2.message
-                                      };
-                                  });
-                              };
-                              Control_Monad_Eff_Uncurried.runEffFn1($foreign.setAnnotations)(Data_Array.mapMaybe(toAnnotation)(res_.value0.value0.value0.error.value0))();
-                              return Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableArray)(res_.value0.value0.value0.error.value0)(function (v2) {
-                                  return Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableMaybe)(Data_Newtype.unwrap(Data_Foreign_NullOrUndefined.newtypeNullOrUndefined)(v2.position))(function (v3) {
-                                      return Control_Monad_Eff_Uncurried.runEffFn5($foreign.addMarker)("error")(v3.startLine)(v3.startColumn)(v3.endLine)(v3.endColumn);
-                                  });
                               })();
+                              return Data_Foldable.for_(Effect.applicativeEffect)(Data_Either.foldableEither)(sources)(execute(res_.value0.value0.value0.js))();
                           };
-                          if (res_.value0.value0.value0.error instanceof Try_API.OtherError) {
-                              return displayPlainText(res_.value0.value0.value0.error.value0)();
+                      })();
+                  };
+                  if (res_.value0 instanceof Data_Either.Right && res_.value0.value0 instanceof Try_API.CompileFailed) {
+                      hideLoadingMessage();
+                      if (res_.value0.value0.value0.error instanceof Try_API.CompilerErrors) {
+                          displayErrors(res_.value0.value0.value0.error.value0)();
+                          var toAnnotation = function (v1) {
+                              return Data_Functor.mapFlipped(Data_Maybe.functorMaybe)(v1.position)(function (v2) {
+                                  return {
+                                      row: v2.startLine - 1 | 0,
+                                      column: v2.startColumn - 1 | 0,
+                                      type: "error",
+                                      text: v1.message
+                                  };
+                              });
                           };
-                          throw new Error("Failed pattern match at Main line 174, column 13 - line 195, column 53: " + [ res_.value0.value0.value0.error.constructor.name ]);
+                          $foreign.setAnnotations(Data_Array.mapMaybe(toAnnotation)(res_.value0.value0.value0.error.value0));
+                          return Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableArray)(res_.value0.value0.value0.error.value0)(function (v1) {
+                              return Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableMaybe)(v1.position)(function (v2) {
+                                  return function () {
+                                      return $foreign.addMarker("error", v2.startLine, v2.startColumn, v2.endLine, v2.endColumn);
+                                  };
+                              });
+                          })();
                       };
-                      if (res_.value0 instanceof Data_Either.Left) {
-                          hideLoadingMessage();
-                          displayPlainText("Unable to parse the response from the server")();
-                          return Data_Foldable.traverse_(Control_Monad_Eff.applicativeEff)(Data_List_Types.foldableNonEmptyList)(function ($137) {
-                              return Control_Monad_Eff_Console.error(Data_Foreign.renderForeignError($137));
-                          })(res_.value0.value0)();
+                      if (res_.value0.value0.value0.error instanceof Try_API.OtherError) {
+                          return displayPlainText(res_.value0.value0.value0.error.value0)();
                       };
-                      throw new Error("Failed pattern match at Main line 151, column 9 - line 199, column 58: " + [ res_.value0.constructor.name ]);
+                      throw new Error("Failed pattern match at Main line 161, column 13 - line 182, column 53: " + [ res_.value0.value0.value0.error.constructor.name ]);
                   };
+                  if (res_.value0 instanceof Data_Either.Left) {
+                      hideLoadingMessage();
+                      displayPlainText("Unable to parse the response from the server")();
+                      return Data_Foldable.traverse_(Effect.applicativeEffect)(Data_List_Types.foldableNonEmptyList)(function ($110) {
+                          return Effect_Console.error(Foreign.renderForeignError($110));
+                      })(res_.value0.value0)();
+                  };
+                  throw new Error("Failed pattern match at Main line 141, column 9 - line 186, column 58: " + [ res_.value0.constructor.name ]);
               };
-              throw new Error("Failed pattern match at Main line 146, column 5 - line 199, column 58: " + [ res_.constructor.name ]);
-          })();
-      };
+          };
+          throw new Error("Failed pattern match at Main line 136, column 5 - line 186, column 58: " + [ res_.constructor.name ]);
+      })();
   };
   var changeViewMode = function (viewMode) {
-      return Data_Foldable.for_(Control_Monad_Eff.applicativeEff)(Data_Foldable.foldableMaybe)(viewMode)(function (viewMode_) {
-          return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#editor_view"))(Control_Monad_Eff_JQuery.setAttr("data-view-mode")(viewMode_));
+      return Data_Foldable.for_(Effect.applicativeEffect)(Data_Foldable.foldableMaybe)(viewMode)(function (viewMode_) {
+          return Control_Bind.bind(Effect.bindEffect)(JQuery.select("#editor_view"))(JQuery.setAttr("data-view-mode")(viewMode_));
       });
   };
-  var loadOptions = function (bc) {
-      return function __do() {
-          var v = Try_QueryString.getQueryStringMaybe("view")();
-          (function () {
-              if (v instanceof Data_Maybe.Just && Data_Foldable.elem(Data_Foldable.foldableArray)(Data_Eq.eqString)(v.value0)([ "sidebyside", "code", "output" ])) {
-                  return changeViewMode(v);
-              };
-              return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit);
-          })()();
-          var v1 = Try_QueryString.getQueryStringMaybe("js")();
-          (function () {
-              if (v1 instanceof Data_Maybe.Just) {
-                  return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input:checkbox[name=showjs]"))(Control_Monad_Eff_JQuery.setProp("checked")(v1.value0 === "true"));
-              };
-              return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit);
-          })()();
-          var v2 = Try_QueryString.getQueryStringMaybe("compile")();
-          (function () {
-              if (v2 instanceof Data_Maybe.Just) {
-                  return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input:checkbox[name=auto_compile]"))(Control_Monad_Eff_JQuery.setProp("checked")(v2.value0 === "true"));
-              };
-              return Control_Applicative.pure(Control_Monad_Eff.applicativeEff)(Data_Unit.unit);
-          })()();
-          var v3 = Try_QueryString.getQueryStringMaybe("gist")();
-          if (v3 instanceof Data_Maybe.Just) {
-              return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select(".view_gist"))(Control_Monad_Eff_JQuery.attr({
-                  href: "https://gist.github.com/" + v3.value0
-              }))();
-          };
-          if (v3 instanceof Data_Maybe.Nothing) {
-              return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select(".view_gist_li"))(Control_Monad_Eff_JQuery.hide)();
+  var loadOptions = function __do() {
+      var v = Try_QueryString.getQueryStringMaybe("view")();
+      (function () {
+          if (v instanceof Data_Maybe.Just && Data_Foldable.elem(Data_Foldable.foldableArray)(Data_Eq.eqString)(v.value0)([ "sidebyside", "code", "output" ])) {
+              return changeViewMode(v)();
           };
-          throw new Error("Failed pattern match at Main line 402, column 3 - line 404, column 61: " + [ v3.constructor.name ]);
-      };
-  };
-  var cacheCurrentCode = function (v) {
-      return function __do() {
-          var v1 = Try_QueryString.getQueryStringMaybe("session")();
+          return Data_Unit.unit;
+      })();
+      var v1 = Try_QueryString.getQueryStringMaybe("js")();
+      (function () {
           if (v1 instanceof Data_Maybe.Just) {
-              var v2 = getTextAreaContent();
-              return Try_Session.storeSession(v1.value0)({
-                  code: v2,
-                  backend: v.backend
-              })();
+              return Control_Bind.bind(Effect.bindEffect)(JQuery.select("input:checkbox[name=showjs]"))(JQuery.setProp("checked")(v1.value0 === "true"))();
           };
-          if (v1 instanceof Data_Maybe.Nothing) {
-              return Control_Monad_Eff_Console.error("No session ID")();
+          return Data_Unit.unit;
+      })();
+      var v2 = Try_QueryString.getQueryStringMaybe("compile")();
+      (function () {
+          if (v2 instanceof Data_Maybe.Just) {
+              return Control_Bind.bind(Effect.bindEffect)(JQuery.select("input:checkbox[name=auto_compile]"))(JQuery.setProp("checked")(v2.value0 === "true"))();
           };
-          throw new Error("Failed pattern match at Main line 334, column 3 - line 340, column 1: " + [ v1.constructor.name ]);
+          return Data_Unit.unit;
+      })();
+      var v3 = Try_QueryString.getQueryStringMaybe("gist")();
+      if (v3 instanceof Data_Maybe.Just) {
+          return Control_Bind.bind(Effect.bindEffect)(JQuery.select(".view_gist"))(JQuery.attr({
+              href: "https://gist.github.com/" + v3.value0
+          }))();
+      };
+      if (v3 instanceof Data_Maybe.Nothing) {
+          return Control_Bind.bind(Effect.bindEffect)(JQuery.select(".view_gist_li"))(JQuery.hide)();
       };
+      throw new Error("Failed pattern match at Main line 301, column 3 - line 303, column 61: " + [ v3.constructor.name ]);
   };
-  var setupBackendMenu = function (v) {
-      return function __do() {
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#backend_" + v.backend))(Control_Monad_Eff_JQuery.attr({
-              checked: "checked"
-          }))();
-          return Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input[name=backend_inputs]"))(Control_Monad_Eff_JQuery.on("change")(function (e) {
-              return function (jq) {
-                  return function __do() {
-                      var v1 = Data_Functor.map(Control_Monad_Eff.functorEff)(function ($138) {
-                          return Try_API.getBackendConfigFromString(Data_Maybe.fromMaybe("core")($138));
-                      })(Control_Monad_Eff_JQuery_Extras.getValueMaybe(jq))();
-                      var v2 = Control_Bind.bind(Control_Monad_Eff.bindEff)(DOM_HTML.window)(DOM_HTML_Window.confirm("Replace your current code with the " + (v1.backend + " backend sample code?")))();
-                      if (v2) {
-                          return navigateTo("?backend=" + v1.backend)();
-                      };
-                      return Data_Functor["void"](Control_Monad_Eff.functorEff)(Control_Monad_Eff_Timer.setTimeout(1000)(function __do() {
-                          compile(v1)();
-                          return cacheCurrentCode(v1)();
-                      }))();
-                  };
-              };
-          }))();
+  var cacheCurrentCode = function __do() {
+      var v = Try_QueryString.getQueryStringMaybe("session")();
+      if (v instanceof Data_Maybe.Just) {
+          var v1 = getTextAreaContent();
+          return Try_Session.storeSession(v.value0)({
+              code: v1
+          })();
+      };
+      if (v instanceof Data_Maybe.Nothing) {
+          return Effect_Console.error("No session ID")();
       };
+      throw new Error("Failed pattern match at Main line 250, column 3 - line 256, column 1: " + [ v.constructor.name ]);
   };
   var setupEditor = function (v) {
       return function __do() {
-          loadOptions(v.backend)();
-          setupBackendMenu(v.backend)();
+          loadOptions();
           setTextAreaContent(v.code)();
-          Control_Monad_Eff_Uncurried.runEffFn1($foreign.setEditorContent)(v.code)();
-          Control_Monad_Eff_Uncurried.runEffFn2($foreign.onEditorChanged)(Control_Monad_Eff_Uncurried.mkEffFn1(function (value) {
-              return function __do() {
-                  setTextAreaContent(value)();
-                  cacheCurrentCode(v.backend)();
-                  var v1 = isAutoCompileChecked();
-                  return Control_Applicative.when(Control_Monad_Eff.applicativeEff)(v1)(compile(v.backend))();
-              };
-          }))(750)();
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#showjs"))(Control_Monad_Eff_JQuery.on("change")(function (e) {
+          $foreign.setEditorContent(v.code);
+          $foreign.onEditorChanged(function (value) {
+              setTextAreaContent(value)();
+              cacheCurrentCode();
+              var v1 = isAutoCompileChecked();
+              return Control_Applicative.when(Effect.applicativeEffect)(v1)(compile)();
+          }, 750);
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#showjs"))(JQuery.on("change")(function (e) {
               return function (v1) {
-                  return compile(v.backend);
+                  return compile;
               };
           }))();
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#compile_label"))(Control_Monad_Eff_JQuery.on("click")(function (e) {
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#compile_label"))(JQuery.on("click")(function (e) {
               return function (v1) {
-                  return compile(v.backend);
+                  return compile;
               };
           }))();
-          Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("#gist_save"))(Control_Monad_Eff_JQuery.on("click")(function (e) {
+          Control_Bind.bind(Effect.bindEffect)(JQuery.select("#gist_save"))(JQuery.on("click")(function (e) {
               return function (v1) {
-                  return publishNewGist(v.backend);
+                  return publishNewGist;
               };
           }))();
-          compile(v.backend)();
-          return cacheCurrentCode(v.backend)();
+          compile();
+          return cacheCurrentCode();
       };
   };
-  var main = Control_Monad_Eff_JQuery.ready(function __do() {
-      Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery.select("input[name=view_mode]"))(Control_Monad_Eff_JQuery.on("change")(function (v) {
+  var main = JQuery.ready(function __do() {
+      Control_Bind.bind(Effect.bindEffect)(JQuery.select("input[name=view_mode]"))(JQuery.on("change")(function (v) {
           return function (jq) {
               return function __do() {
-                  var v1 = Control_Bind.bind(Control_Monad_Eff.bindEff)(Control_Monad_Eff_JQuery_Extras.filter(jq)(":checked"))(Control_Monad_Eff_JQuery_Extras.getValueMaybe)();
+                  var v1 = Control_Bind.bind(Effect.bindEffect)(JQuery_Extras.filter(jq)(":checked"))(JQuery_Extras.getValueMaybe)();
                   return changeViewMode(v1)();
               };
           };
       }))();
-      return Control_Monad_Cont_Trans.runContT(Control_Bind.bind(Control_Monad_Cont_Trans.bindContT(Control_Monad_Eff.bindEff))(Try_Session.createSessionIdIfNecessary)(function (v) {
+      return Control_Monad_Cont_Trans.runContT(Control_Bind.bind(Control_Monad_Cont_Trans.bindContT(Effect.bindEffect))(Try_Session.createSessionIdIfNecessary)(function (v) {
           return withSession(v);
       }))(setupEditor)();
   });
@@ -5494,6 +6600,7 @@ var PS = {};
   exports["getTextAreaContent"] = getTextAreaContent;
   exports["setTextAreaContent"] = setTextAreaContent;
   exports["clearAnnotations"] = clearAnnotations;
+  exports["loader"] = loader;
   exports["compile"] = compile;
   exports["execute"] = execute;
   exports["setupEditor"] = setupEditor;
@@ -5503,7 +6610,6 @@ var PS = {};
   exports["publishNewGist"] = publishNewGist;
   exports["navigateTo"] = navigateTo;
   exports["loadOptions"] = loadOptions;
-  exports["setupBackendMenu"] = setupBackendMenu;
   exports["main"] = main;
   exports["setEditorContent"] = $foreign.setEditorContent;
   exports["onEditorChanged"] = $foreign.onEditorChanged;
@@ -5512,4 +6618,4 @@ var PS = {};
   exports["setAnnotations"] = $foreign.setAnnotations;
   exports["setupIFrame"] = $foreign.setupIFrame;
 })(PS["Main"] = PS["Main"] || {});
-PS["Main"].main();
+PS["Main"].main();
\ No newline at end of file
diff --git a/package.json b/package.json
index d9d9143f..74396aae 100644
--- a/package.json
+++ b/package.json
@@ -3,7 +3,7 @@
   "scripts": {
     "clean": "rimraf output && rimraf .pulp-cache",
     "build": "pulp build -- --censor-lib --strict",
-    "bundle": "pulp build -O --to js/index.js && open index.html"
+    "bundle": "pulp build -O --to js/index.js"
   },
   "devDependencies": {
     "pulp": "^11.0.0",
diff --git a/src/Control/Monad/Eff/JQuery/Extras.purs b/src/Control/Monad/Eff/JQuery/Extras.purs
deleted file mode 100644
index 5ba8d381..00000000
--- a/src/Control/Monad/Eff/JQuery/Extras.purs
+++ /dev/null
@@ -1,41 +0,0 @@
-module Control.Monad.Eff.JQuery.Extras
-  ( click
-  , empty
-  , fadeIn
-  , fadeOut
-  , filter
-  , is
-  , getValueMaybe
-  ) where
-
-import Prelude
-
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.JQuery (JQuery, Selector)
-import DOM (DOM)
-import Data.Maybe (Maybe)
-import Data.Nullable (Nullable, toMaybe)
-
--- | Simulate a click event on the specified element.
-foreign import click :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Remove all elements from the specified container element.
-foreign import empty :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Fade in an element.
-foreign import fadeIn :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Fade out an element.
-foreign import fadeOut :: forall eff. JQuery -> Eff (dom :: DOM | eff) Unit
-
--- | Filter elements based on an additional selector.
-foreign import filter :: forall eff. JQuery -> Selector -> Eff (dom :: DOM | eff) JQuery
-
--- | Test whether elements match an additional selector.
-foreign import is :: forall eff. JQuery -> Selector -> Eff (dom :: DOM | eff) Boolean
-
--- | Get the value of the first element, if it exists.
-foreign import getValue :: forall eff. JQuery -> Eff (dom :: DOM | eff) (Nullable String)
-
-getValueMaybe :: forall eff. JQuery -> Eff (dom :: DOM | eff) (Maybe String)
-getValueMaybe = map toMaybe <<< getValue
diff --git a/src/Control/Monad/Eff/JQuery/Extras.js b/src/JQuery/Extras.js
similarity index 100%
rename from src/Control/Monad/Eff/JQuery/Extras.js
rename to src/JQuery/Extras.js
diff --git a/src/JQuery/Extras.purs b/src/JQuery/Extras.purs
new file mode 100644
index 00000000..4602893f
--- /dev/null
+++ b/src/JQuery/Extras.purs
@@ -0,0 +1,40 @@
+module JQuery.Extras
+  ( click
+  , empty
+  , fadeIn
+  , fadeOut
+  , filter
+  , is
+  , getValueMaybe
+  ) where
+
+import Prelude
+
+import Data.Maybe (Maybe)
+import Data.Nullable (Nullable, toMaybe)
+import Effect (Effect)
+import JQuery (JQuery, Selector)
+
+-- | Simulate a click event on the specified element.
+foreign import click :: JQuery -> Effect Unit
+
+-- | Remove all elements from the specified container element.
+foreign import empty :: JQuery -> Effect Unit
+
+-- | Fade in an element.
+foreign import fadeIn :: JQuery -> Effect Unit
+
+-- | Fade out an element.
+foreign import fadeOut :: JQuery -> Effect Unit
+
+-- | Filter elements based on an additional selector.
+foreign import filter :: JQuery -> Selector -> Effect JQuery
+
+-- | Test whether elements match an additional selector.
+foreign import is :: JQuery -> Selector -> Effect Boolean
+
+-- | Get the value of the first element, if it exists.
+foreign import getValue :: JQuery -> Effect (Nullable String)
+
+getValueMaybe :: JQuery -> Effect (Maybe String)
+getValueMaybe = map toMaybe <<< getValue
diff --git a/src/Main.purs b/src/Main.purs
index 10615a9d..cc5d7b15 100644
--- a/src/Main.purs
+++ b/src/Main.purs
@@ -3,51 +3,44 @@ module Main where
 import Prelude
 
 import Control.Monad.Cont.Trans (ContT(..), runContT)
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Console (CONSOLE, error)
-import Control.Monad.Eff.JQuery (JQuery, addClass, append, setText, setAttr, attr, create, hide, on, ready, select, setProp, setValue) as JQuery
-import Control.Monad.Eff.JQuery.Extras (empty, fadeIn, fadeOut, filter, getValueMaybe, is) as JQuery
-import Control.Monad.Eff.Random (RANDOM)
-import Control.Monad.Eff.Timer (TIMER, setTimeout)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn2, EffFn3, EffFn5, mkEffFn1, runEffFn1, runEffFn2, runEffFn3, runEffFn5)
 import Control.Monad.Except.Trans (runExceptT)
-import DOM (DOM)
-import DOM.HTML (window)
-import DOM.HTML.Location (setHref)
-import DOM.HTML.Types (ALERT, CONFIRM)
-import DOM.HTML.Window (alert, confirm, location)
 import Data.Array (mapMaybe)
 import Data.Array as Array
 import Data.Either (Either(..))
 import Data.Foldable (elem, fold, for_, intercalate, traverse_)
 import Data.FoldableWithIndex (forWithIndex_)
-import Data.Foreign (renderForeignError)
 import Data.Maybe (Maybe(..), fromMaybe)
-import Data.Newtype (unwrap)
-import Data.StrMap as StrMap
-import Data.String (joinWith)
-import Data.String as String
-import Data.String.Regex (replace')
-import Data.String.Regex.Flags (global)
-import Data.String.Regex.Unsafe (unsafeRegex)
-import Try.API (BackendConfig(..), CompileError(..), CompileResult(..), CompileWarning(..), CompilerError(..), ErrorPosition(..), FailedResult(..), SuccessResult(..), getBackendConfigFromString)
+import Effect (Effect)
+import Effect.Console (error)
+import Effect.Uncurried (EffectFn1, EffectFn2, EffectFn5, mkEffectFn1, runEffectFn1, runEffectFn2, runEffectFn5)
+import Foreign (renderForeignError)
+import Foreign.Object (Object)
+import Foreign.Object as Object
+import JQuery as JQuery
+import JQuery.Extras as JQueryExtras
+import Try.API (CompileError(..), CompileResult(..), CompileWarning(..), CompilerError(..), ErrorPosition(..), FailedResult(..), SuccessResult(..))
 import Try.API as API
+import Try.Config as Config
 import Try.Gist (getGistById, tryLoadFileFromGist, uploadGist)
+import Try.Loader (Loader, makeLoader, runLoader)
 import Try.QueryString (getQueryStringMaybe, setQueryStrings)
 import Try.Session (createSessionIdIfNecessary, storeSession, tryRetrieveSession)
 import Try.Types (JS(..))
+import Web.HTML (window)
+import Web.HTML.Location (setHref)
+import Web.HTML.Window (alert, confirm, location)
 
-displayLoadingMessage :: forall eff. Eff (dom :: DOM | eff) Unit
-displayLoadingMessage = JQuery.select "#loading" >>= JQuery.fadeIn
+displayLoadingMessage :: Effect Unit
+displayLoadingMessage = JQuery.select "#loading" >>= JQueryExtras.fadeIn
 
-hideLoadingMessage :: forall eff. Eff (dom :: DOM | eff) Unit
-hideLoadingMessage = JQuery.select "#loading" >>= JQuery.fadeOut
+hideLoadingMessage :: Effect Unit
+hideLoadingMessage = JQuery.select "#loading" >>= JQueryExtras.fadeOut
 
 -- | Display a list of errors in the right hand column.
-displayErrors :: forall eff. Array CompilerError -> Eff (dom :: DOM | eff) Unit
+displayErrors :: Array CompilerError -> Effect Unit
 displayErrors errs = do
   column2 <- JQuery.select "#column2"
-  JQuery.empty column2
+  JQueryExtras.empty column2
 
   forWithIndex_ errs \i (CompilerError{ message }) -> do
     h1 <- JQuery.create "<h1>"
@@ -64,52 +57,49 @@ displayErrors errs = do
 
 -- | Display plain text in the right hand column.
 displayPlainText
-  :: forall eff
-   . String
-  -> Eff (dom :: DOM | eff) Unit
+  :: String
+  -> Effect Unit
 displayPlainText s = do
   column2 <- JQuery.select "#column2"
-  JQuery.empty column2
+  JQueryExtras.empty column2
   pre <- JQuery.create "<pre>"
   code_ <- JQuery.create "<code>"
   JQuery.append code_ pre
   JQuery.setText s code_
   JQuery.append pre column2
 
-isShowJsChecked :: forall eff. Eff (dom :: DOM | eff) Boolean
-isShowJsChecked = JQuery.select "#showjs" >>= \jq -> JQuery.is jq ":checked"
+isShowJsChecked :: Effect Boolean
+isShowJsChecked = JQuery.select "#showjs" >>= \jq -> JQueryExtras.is jq ":checked"
 
-isAutoCompileChecked :: forall eff. Eff (dom :: DOM | eff) Boolean
-isAutoCompileChecked = JQuery.select "#auto_compile" >>= \jq -> JQuery.is jq ":checked"
+isAutoCompileChecked :: Effect Boolean
+isAutoCompileChecked = JQuery.select "#auto_compile" >>= \jq -> JQueryExtras.is jq ":checked"
 
 -- | Update the view mode based on the menu selection
-changeViewMode :: forall eff. Maybe String -> Eff (dom :: DOM | eff) Unit
+changeViewMode :: Maybe String -> Effect Unit
 changeViewMode viewMode =
   for_ viewMode \viewMode_ ->
     JQuery.select "#editor_view" >>= JQuery.setAttr "data-view-mode" viewMode_
 
-getTextAreaContent :: forall eff. Eff (dom :: DOM | eff) String
-getTextAreaContent = fold <$> (JQuery.select "#code_textarea" >>= JQuery.getValueMaybe)
+getTextAreaContent :: Effect String
+getTextAreaContent = fold <$> (JQuery.select "#code_textarea" >>= JQueryExtras.getValueMaybe)
 
-setTextAreaContent :: forall eff. String -> Eff (dom :: DOM | eff) Unit
+setTextAreaContent :: String -> Effect Unit
 setTextAreaContent value = JQuery.select "#code_textarea" >>= JQuery.setValue value
 
 -- | Set the editor content to the specified string.
-foreign import setEditorContent :: forall eff. EffFn1 (dom :: DOM | eff) String Unit
+foreign import setEditorContent :: EffectFn1 String Unit
 
 -- | Register a callback for editor change events.
 foreign import onEditorChanged
-  :: forall eff
-   . EffFn2 (dom :: DOM | eff)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Int
-            Unit
+  :: EffectFn2 (EffectFn1 String Unit)
+               Int
+               Unit
 
 -- | Clean up any global state associated with any visible error markers.
-foreign import cleanUpMarkers :: forall eff. Eff (dom :: DOM | eff) Unit
+foreign import cleanUpMarkers :: Effect Unit
 
 -- | Add a visible marker at the specified location.
-foreign import addMarker :: forall eff. EffFn5 (dom :: DOM | eff) String Int Int Int Int Unit
+foreign import addMarker :: EffectFn5 String Int Int Int Int Unit
 
 type Annotation =
   { row :: Int
@@ -119,30 +109,30 @@ type Annotation =
   }
 
 -- | Set the gutter annotations
-foreign import setAnnotations :: forall eff. EffFn1 (dom :: DOM | eff) (Array Annotation) Unit
+foreign import setAnnotations :: EffectFn1 (Array Annotation) Unit
 
-clearAnnotations :: forall eff. Eff (dom :: DOM | eff) Unit
-clearAnnotations = runEffFn1 setAnnotations []
+clearAnnotations :: Effect Unit
+clearAnnotations = runEffectFn1 setAnnotations []
 
 -- | Set up a fresh iframe in the specified container, and use it
 -- | to execute the provided JavaScript code.
 foreign import setupIFrame
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
-            JQuery.JQuery
-            String
-            String
-            Unit
+  :: EffectFn2 JQuery.JQuery
+               (Object JS)
+               Unit
+
+loader :: Loader
+loader = makeLoader Config.loaderUrl
 
 -- | Compile the current code and execute it.
-compile :: forall eff. BackendConfig -> Eff (console :: CONSOLE, dom :: DOM | eff) Unit
-compile bc@(BackendConfig backend) = do
+compile :: Effect Unit
+compile = do
   code <- getTextAreaContent
 
   displayLoadingMessage
   clearAnnotations
 
-  runContT (runExceptT (backend.compile code)) \res_ ->
+  runContT (runExceptT (API.compile Config.compileUrl code)) \res_ ->
     case res_ of
       Left err -> displayPlainText err
       Right res -> do
@@ -154,21 +144,18 @@ compile bc@(BackendConfig backend) = do
             if showJs
               then do hideLoadingMessage
                       displayPlainText js
-              else runContT (runExceptT backend.getBundle) \bundleResult -> do
+              else runContT (runExceptT $ runLoader loader (JS js)) \sources -> do
                      hideLoadingMessage
-                     case bundleResult of
-                       Left err -> error ("Unable to retrieve JS bundle: " <> err)
-                       Right bundle -> do
-                         for_ (unwrap warnings) \warnings_ -> do
-                           let toAnnotation (CompileWarning{ errorCode, position, message }) =
-                                 unwrap position <#> \(ErrorPosition pos) ->
-                                   { row: pos.startLine - 1
-                                   , column: pos.startColumn - 1
-                                   , type: "warning"
-                                   , text: message
-                                   }
-                           runEffFn1 setAnnotations (mapMaybe toAnnotation warnings_)
-                         execute (JS js) bundle bc
+                     for_ warnings \warnings_ -> do
+                       let toAnnotation (CompileWarning{ errorCode, position, message }) =
+                             position <#> \(ErrorPosition pos) ->
+                               { row: pos.startLine - 1
+                               , column: pos.startColumn - 1
+                               , type: "warning"
+                               , text: message
+                               }
+                       runEffectFn1 setAnnotations (mapMaybe toAnnotation warnings_)
+                     for_ sources (execute (JS js))
           Right (CompileFailed (FailedResult { error })) -> do
             hideLoadingMessage
             case error of
@@ -176,17 +163,17 @@ compile bc@(BackendConfig backend) = do
                 displayErrors errs
 
                 let toAnnotation (CompilerError{ position, message }) =
-                      unwrap position <#> \(ErrorPosition pos) ->
+                      position <#> \(ErrorPosition pos) ->
                         { row: pos.startLine - 1
                         , column: pos.startColumn - 1
                         , type: "error"
                         , text: message
                         }
-                runEffFn1 setAnnotations (mapMaybe toAnnotation errs)
+                runEffectFn1 setAnnotations (mapMaybe toAnnotation errs)
 
                 for_ errs \(CompilerError{ position }) ->
-                  for_ (unwrap position) \(ErrorPosition pos) ->
-                    runEffFn5 addMarker
+                  for_ position \(ErrorPosition pos) ->
+                    runEffectFn5 addMarker
                       "error"
                       pos.startLine
                       pos.startColumn
@@ -199,155 +186,76 @@ compile bc@(BackendConfig backend) = do
             traverse_ (error <<< renderForeignError) errs
 
 -- | Execute the compiled code in a new iframe.
-execute :: forall eff. JS -> JS -> BackendConfig -> Eff (dom :: DOM | eff) Unit
-execute js bundle bc@(BackendConfig backend) = do
-  let html = joinWith "\n"
-        [ """<!DOCTYPE html>"""
-        , """<html>"""
-        , """  <head>"""
-        , """    <meta content="text/html;charset=utf-8" http-equiv="Content-Type">"""
-        , """    <meta content="utf-8" http-equiv="encoding">"""
-        , """    <meta name="viewport" content="width=device-width, initial-scale=1.0">"""
-        , """    <title>Try PureScript!</title>"""
-        , """    <link rel="stylesheet" href="css/style.css">"""
-        , backend.extra_styling
-        , """  </head>"""
-        , """  <body>"""
-        , backend.extra_body
-        , """  </body>"""
-        , """</html>"""
-        ]
-
-      replaced = replace' (unsafeRegex """require\("[^"]*"\)""" global) (\s _ ->
-        "PS['" <> String.drop 12 (String.take (String.length s - 2) s) <> "']") (unwrap js)
-
-      wrapped = joinWith "\n"
-        [ "var module = {};"
-        , "(function(module) {"
-        , replaced
-        , "})(module);"
-        , "module.exports.main && module.exports.main();"
-        ]
-
-      scripts = joinWith "\n" [unwrap bundle, wrapped]
-
+execute :: JS -> Object JS -> Effect Unit
+execute js modules = do
+  let eventData = Object.insert "<file>" js modules
   column2 <- JQuery.select "#column2"
-  runEffFn3 setupIFrame column2 html scripts
+  runEffectFn2 setupIFrame column2 eventData
 
 -- | Setup the editor component and some event handlers.
-setupEditor
-  :: forall eff
-   . { code :: String, backend :: BackendConfig }
-  -> Eff ( alert :: ALERT
-         , console :: CONSOLE
-         , confirm :: CONFIRM
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
-setupEditor { code, backend } = do
-  loadOptions backend
-  setupBackendMenu backend
+setupEditor :: forall r. { code :: String | r } -> Effect Unit
+setupEditor { code } = do
+  loadOptions
 
   setTextAreaContent code
-  runEffFn1 setEditorContent code
+  runEffectFn1 setEditorContent code
 
-  runEffFn2 onEditorChanged (mkEffFn1 \value -> do
+  runEffectFn2 onEditorChanged (mkEffectFn1 \value -> do
     setTextAreaContent value
-    cacheCurrentCode backend
+    cacheCurrentCode
     autoCompile <- isAutoCompileChecked
     when autoCompile do
-      compile backend) 750
+      compile) 750
 
   JQuery.select "#showjs" >>= JQuery.on "change" \e _ ->
-    compile backend
+    compile
 
   JQuery.select "#compile_label" >>= JQuery.on "click" \e _ ->
-    compile backend
+    compile
 
   JQuery.select "#gist_save" >>= JQuery.on "click" \e _ ->
-    publishNewGist backend
+    publishNewGist
 
-  compile backend
-  cacheCurrentCode backend
+  compile
+  cacheCurrentCode
 
 loadFromGist
-  :: forall eff
-   . String
-  -> BackendConfig
-  -> ({ code :: String, backend :: BackendConfig }
-      -> Eff ( alert :: ALERT
-             , console :: CONSOLE
-             , dom :: DOM
-             , timer :: TIMER
-             | eff
-             ) Unit)
-  -> Eff ( alert :: ALERT
-         , console :: CONSOLE
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
-loadFromGist id_ backend k = do
+  :: String
+  -> ({ code :: String } -> Effect Unit)
+  -> Effect Unit
+loadFromGist id_ k = do
   runContT (runExceptT (getGistById id_ >>= \gi -> tryLoadFileFromGist gi "Main.purs")) $
     case _ of
       Left err -> do
         window >>= alert err
-        k { code: "", backend }
-      Right code -> k { code, backend }
+        k { code: "" }
+      Right code -> k { code }
 
 withSession
-  :: forall eff
-   . String
-  -> ({ code :: String, backend :: BackendConfig }
-      -> Eff ( alert :: ALERT
-             , confirm :: CONFIRM
-             , console :: CONSOLE
-             , dom :: DOM
-             , timer :: TIMER
-             | eff
-             ) Unit)
-  -> Eff ( alert :: ALERT
-         , confirm :: CONFIRM
-         , console :: CONSOLE
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
+  :: String
+  -> ({ code :: String } -> Effect Unit)
+  -> Effect Unit
 withSession sessionId k = do
   state <- tryRetrieveSession sessionId
   case state of
-    Just { code, backend } -> do
-      k { code, backend: API.getBackendConfigFromString backend }
+    Just state' -> k state'
     Nothing -> do
-      bc@(BackendConfig backend) <- API.getBackendConfigFromString <<< fromMaybe "core" <$> getQueryStringMaybe "backend"
-      gist <- fromMaybe backend.mainGist <$> getQueryStringMaybe "gist"
-      loadFromGist gist bc k
+      gist <- fromMaybe Config.mainGist <$> getQueryStringMaybe "gist"
+      loadFromGist gist k
 
 -- | Cache the current code in the session state
-cacheCurrentCode
-  :: forall eff
-   . BackendConfig
-  -> Eff (console :: CONSOLE, dom :: DOM | eff) Unit
-cacheCurrentCode bc@(BackendConfig backend) = do
+cacheCurrentCode :: Effect Unit
+cacheCurrentCode  = do
   sessionId <- getQueryStringMaybe "session"
   case sessionId of
     Just sessionId_ -> do
       code <- getTextAreaContent
-      storeSession sessionId_ { code, backend: backend.backend }
+      storeSession sessionId_ { code }
     Nothing -> error "No session ID"
 
 -- | Create a new Gist using the current content
-publishNewGist
-  :: forall eff
-   . BackendConfig
-  -> Eff ( alert :: ALERT
-         , confirm :: CONFIRM
-         , console :: CONSOLE
-         , dom :: DOM
-         | eff
-         ) Unit
-publishNewGist bc@(BackendConfig backend) = do
+publishNewGist :: Effect Unit
+publishNewGist = do
   ok <- window >>= confirm (intercalate "\n"
           [ "Do you really want to publish this code as an anonymous Gist?"
           , ""
@@ -361,24 +269,15 @@ publishNewGist bc@(BackendConfig backend) = do
           window >>= alert "Failed to create gist"
           error ("Failed to create gist: " <> err)
         Right gistId -> do
-          setQueryStrings (StrMap.singleton "gist" gistId <>
-                           StrMap.singleton "backend" backend.backend)
+          setQueryStrings (Object.singleton "gist" gistId)
 
 -- | Navigate to the specified URL.
-navigateTo :: forall eff. String -> Eff (dom :: DOM | eff) Unit
+navigateTo :: String -> Effect Unit
 navigateTo uri = void (window >>= location >>= setHref uri)
 
 -- | Read query string options and update the state accordingly
-loadOptions
-  :: forall eff
-   . BackendConfig
-  -> Eff ( console :: CONSOLE
-         , confirm :: CONFIRM
-         , dom :: DOM
-         , timer :: TIMER
-         | eff
-         ) Unit
-loadOptions bc = do
+loadOptions :: Effect Unit
+loadOptions = do
   viewMode <- getQueryStringMaybe "view"
   case viewMode of
     Just viewMode_
@@ -403,40 +302,10 @@ loadOptions bc = do
     Just gist_ -> JQuery.select ".view_gist" >>= JQuery.attr { href: "https://gist.github.com/" <> gist_ }
     Nothing -> JQuery.select ".view_gist_li" >>= JQuery.hide
 
--- | Setup event listeners for the backend dropdown menu.
-setupBackendMenu
-  :: forall eff
-   . BackendConfig
-  -> Eff
-       ( dom :: DOM
-       , confirm :: CONFIRM
-       , console :: CONSOLE
-       , timer :: TIMER
-       | eff
-       )
-       Unit
-setupBackendMenu bc@(BackendConfig backend) = do
-  JQuery.select ("#backend_" <> backend.backend) >>= JQuery.attr { checked: "checked" }
-  JQuery.select "input[name=backend_inputs]" >>= JQuery.on "change" \e jq -> do
-    bc_@(BackendConfig newBackend) <- getBackendConfigFromString <<< fromMaybe "core" <$> JQuery.getValueMaybe jq
-
-    ok <- window >>= confirm ("Replace your current code with the " <> newBackend.backend <> " backend sample code?")
-    if ok
-      then navigateTo ("?backend=" <> newBackend.backend)
-      else void $ setTimeout 1000 do
-             compile bc_
-             cacheCurrentCode bc_
-
-main :: Eff ( alert :: ALERT
-            , confirm :: CONFIRM
-            , console :: CONSOLE
-            , dom :: DOM
-            , random :: RANDOM
-            , timer :: TIMER
-            ) Unit
+main :: Effect Unit
 main = JQuery.ready do
   JQuery.select "input[name=view_mode]" >>= JQuery.on "change" \_ jq -> do
-    viewMode <- JQuery.filter jq ":checked" >>= JQuery.getValueMaybe
+    viewMode <- JQueryExtras.filter jq ":checked" >>= JQueryExtras.getValueMaybe
     changeViewMode viewMode
 
   runContT (do sessionId <- ContT createSessionIdIfNecessary
diff --git a/src/Try/API.purs b/src/Try/API.purs
index 41539e14..3e205921 100644
--- a/src/Try/API.purs
+++ b/src/Try/API.purs
@@ -7,36 +7,26 @@ module Try.API
   , SuccessResult(..)
   , FailedResult(..)
   , CompileResult(..)
-  , Backend(..)
-  , BackendConfig(..)
-  , getBackendConfig
-  , getBackendConfigFromString
+  , get
+  , compile
   ) where
 
 import Prelude
 
 import Control.Alt ((<|>))
 import Control.Monad.Cont.Trans (ContT(ContT))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn3, EffFn4, mkEffFn1, runEffFn3, runEffFn4)
 import Control.Monad.Except (runExcept)
 import Control.Monad.Except.Trans (ExceptT(ExceptT))
-import Control.Parallel (parTraverse)
-import DOM (DOM)
-import Data.Array (fold, intercalate)
 import Data.Either (Either(..))
-import Data.Foreign (Foreign, ForeignError)
-import Data.Foreign.Class (class Decode, decode)
-import Data.Foreign.Generic (defaultOptions, genericDecode)
-import Data.Foreign.Generic.Types (Options, SumEncoding(..))
-import Data.Foreign.NullOrUndefined (NullOrUndefined)
 import Data.Generic.Rep (class Generic)
 import Data.List.NonEmpty (NonEmptyList)
-import Data.String.Regex (replace)
-import Data.String.Regex.Flags (global)
-import Data.String.Regex.Unsafe (unsafeRegex)
-import Partial.Unsafe (unsafePartial)
-import Try.Types (JS(JS))
+import Data.Maybe (Maybe)
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, mkEffectFn1, runEffectFn3, runEffectFn4)
+import Foreign (Foreign, ForeignError)
+import Foreign.Class (class Decode, decode)
+import Foreign.Generic (defaultOptions, genericDecode)
+import Foreign.Generic.Types (Options, SumEncoding(..))
 
 decodingOptions :: Options
 decodingOptions = defaultOptions { unwrapSingleConstructors = true }
@@ -56,7 +46,7 @@ instance decodeErrorPosition :: Decode ErrorPosition where
 
 newtype CompilerError = CompilerError
   { message :: String
-  , position :: NullOrUndefined ErrorPosition
+  , position :: Maybe ErrorPosition
   }
 
 derive instance genericCompilerError :: Generic CompilerError _
@@ -78,13 +68,13 @@ instance decodeCompileError :: Decode CompileError where
           TaggedObject
             { tagFieldName: "tag"
             , contentsFieldName: "contents"
-            , constructorTagTransform: id
+            , constructorTagTransform: identity
             }
       })
 
 newtype Suggestion = Suggestion
   { replacement :: String
-  , replaceRange :: NullOrUndefined ErrorPosition
+  , replaceRange :: Maybe ErrorPosition
   }
 
 derive instance genericSuggestion :: Generic Suggestion _
@@ -95,8 +85,8 @@ instance decodeSuggestion :: Decode Suggestion where
 newtype CompileWarning = CompileWarning
   { errorCode :: String
   , message :: String
-  , position :: NullOrUndefined ErrorPosition
-  , suggestion :: NullOrUndefined Suggestion
+  , position :: Maybe ErrorPosition
+  , suggestion :: Maybe Suggestion
   }
 
 derive instance genericCompileWarning :: Generic CompileWarning _
@@ -106,7 +96,7 @@ instance decodeCompileWarning :: Decode CompileWarning where
 
 newtype SuccessResult = SuccessResult
   { js :: String
-  , warnings :: NullOrUndefined (Array CompileWarning)
+  , warnings :: Maybe (Array CompileWarning)
   }
 
 derive instance genericSuccessResult :: Generic SuccessResult _
@@ -134,164 +124,30 @@ instance decodeCompileResult :: Decode CompileResult where
     <|> CompileFailed <$> genericDecode decodingOptions f
 
 foreign import get_
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
+  :: EffectFn3
             String
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
+            (EffectFn1 String Unit)
+            (EffectFn1 String Unit)
             Unit
 
 -- | A wrapper for `get` which uses `ContT`.
-get :: forall eff. String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) String
-get uri = ExceptT (ContT \k -> runEffFn3 get_ uri (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
-
--- | Get the default bundle
-getDefaultBundle
-  :: forall eff
-   . String
-  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) JS
-getDefaultBundle endpoint = JS <$> get (endpoint <> "/bundle")
-
--- | Get the JS bundle for the Thermite backend, which includes additional dependencies
-getThermiteBundle
-  :: forall eff
-   . String
-  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) JS
-getThermiteBundle endpoint =
-  let getAll = parTraverse get
-        [ "js/console.js"
-        , "js/react.min.js"
-        , "js/react-dom.min.js"
-        , endpoint <> "/bundle"
-        ]
-
-      onComplete :: Partial
-                 => Array String
-                 -> JS
-      onComplete [consoleScript, react, react_dom, bundle] =
-        let replaced = bundle
-                         # replace (unsafeRegex """require\("react"\)""" global) "window.React"
-                         # replace (unsafeRegex """require\("react-dom"\)""" global) "window.ReactDOM"
-                         # replace (unsafeRegex """require\("react-dom\/server"\)""" global) "window.ReactDOM"
-        in JS (intercalate "\n" [consoleScript, react, react_dom, replaced])
-  in unsafePartial onComplete <$> getAll
+get :: String -> ExceptT String (ContT Unit Effect) String
+get uri = ExceptT (ContT \k -> runEffectFn3 get_ uri (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
 
 -- | POST the specified code to the Try PureScript API, and wait for
 -- | a response.
 foreign import compile_
-  :: forall eff
-   . EffFn4 (dom :: DOM | eff)
+  :: EffectFn4
             String
             String
-            (EffFn1 (dom :: DOM | eff) Foreign Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
+            (EffectFn1 Foreign Unit)
+            (EffectFn1 String Unit)
             Unit
 
 -- | A wrapper for `compileApi` which uses `ContT`.
 compile
-  :: forall eff
-   . String
+  :: String
   -> String
-  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff)))
+  -> ExceptT String (ContT Unit Effect)
        (Either (NonEmptyList ForeignError) CompileResult)
-compile endpoint code = ExceptT (ContT \k -> runEffFn4 compile_ endpoint code (mkEffFn1 (k <<< Right <<< runExcept <<< decode)) (mkEffFn1 (k <<< Left)))
-
-newtype BackendConfig = BackendConfig
-  { backend       :: String
-  , mainGist      :: String
-  , extra_styling :: String
-  , extra_body    :: String
-  , compile       :: forall eff
-                   . String
-                  -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff)))
-                       (Either (NonEmptyList ForeignError) CompileResult)
-  , getBundle     :: forall eff. ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) JS
-  }
-
-data Backend
-  = Core
-  | Thermite
-  | Slides
-  | Mathbox
-  | Behaviors
-  | Flare
-
-backendFromString :: Partial => String -> Backend
-backendFromString "core"      = Core
-backendFromString "thermite"  = Thermite
-backendFromString "slides"    = Slides
-backendFromString "mathbox"   = Mathbox
-backendFromString "behaviors" = Behaviors
-backendFromString "flare"     = Flare
-
-backendToString :: Backend -> String
-backendToString Core      = "core"
-backendToString Thermite  = "thermite"
-backendToString Slides    = "slides"
-backendToString Mathbox   = "mathbox"
-backendToString Behaviors = "behaviors"
-backendToString Flare     = "flare"
-
-derive instance eqBackend :: Eq Backend
-derive instance ordBackend :: Ord Backend
-
-getBackendConfig :: Backend -> BackendConfig
-getBackendConfig Core = BackendConfig
-  { backend: "core"
-  , mainGist: "b57a766d417e109785540d584266fc33"
-  , extra_styling: ""
-  , extra_body: ""
-  , compile: compile "https://compile.purescript.org/try"
-  , getBundle: getDefaultBundle "https://compile.purescript.org/try"
-  }
-getBackendConfig Thermite = BackendConfig
-  { backend: "thermite"
-  , mainGist: "85383bb058471109cfef379bbb6bc11c"
-  , extra_styling: """<link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">"""
-  , extra_body: """<div id="app"></div>"""
-  , compile: compile "https://compile.purescript.org/thermite"
-  , getBundle: getThermiteBundle "https://compile.purescript.org/thermite"
-  }
-getBackendConfig Slides = BackendConfig
-  { backend: "slides"
-  , mainGist: "c62b5778a6a5f2bcd32dd97b294c068a"
-  , extra_styling: """<link rel="stylesheet" href="css/slides.css">"""
-  , extra_body: """<div id="main"></div>"""
-  , compile: compile "https://compile.purescript.org/slides"
-  , getBundle: getDefaultBundle "https://compile.purescript.org/slides"
-  }
-getBackendConfig Mathbox = BackendConfig
-  { backend: "mathbox"
-  , mainGist: "81f8bb3261b9c819d677de2ea54a4d2e"
-  , extra_styling: fold
-      [ """<script src="js/mathbox-bundle.js"></script>"""
-      , """<link rel="stylesheet" href="css/mathbox.css">"""
-      ]
-  , extra_body: ""
-  , compile: compile "https://compile.purescript.org/purescript-mathbox"
-  , getBundle: getDefaultBundle "https://compile.purescript.org/purescript-mathbox"
-  }
-getBackendConfig Behaviors = BackendConfig
-  { backend: "behaviors"
-  , mainGist: "ff1e87f0872d2d891e77d209d8f7706d"
-  , extra_styling: ""
-  , extra_body: """<canvas id="canvas" width="800" height="600"></canvas>"""
-  , compile: compile "https://compile.purescript.org/behaviors"
-  , getBundle: getDefaultBundle "https://compile.purescript.org/behaviors"
-  }
-getBackendConfig Flare = BackendConfig
-  { backend: "flare"
-  , mainGist: "4f54d6dd213caa54d736ead597e17fee"
-  , extra_styling: """<link rel="stylesheet" href="css/flare.css">"""
-  , extra_body: fold
-      [ """<div id="controls"></div>"""
-      , """<div id="output"></div>"""
-      , """<div id="tests"></div>"""
-      , """<canvas id="canvas" width="800" height="600"></canvas>"""
-      ]
-  , compile: compile "https://compile.purescript.org/flare"
-  , getBundle: getDefaultBundle "https://compile.purescript.org/flare"
-  }
-
-getBackendConfigFromString :: String -> BackendConfig
-getBackendConfigFromString s = getBackendConfig (unsafePartial backendFromString s)
+compile endpoint code = ExceptT (ContT \k -> runEffectFn4 compile_ endpoint code (mkEffectFn1 (k <<< Right <<< runExcept <<< decode)) (mkEffectFn1 (k <<< Left)))
diff --git a/src/Try/Config.purs b/src/Try/Config.purs
new file mode 100644
index 00000000..483d0fe0
--- /dev/null
+++ b/src/Try/Config.purs
@@ -0,0 +1,10 @@
+module Try.Config where
+
+loaderUrl :: String
+loaderUrl = "js/output"
+
+compileUrl :: String
+compileUrl = "http://localhost:8081"
+
+mainGist :: String
+mainGist = "b57a766d417e109785540d584266fc33"
diff --git a/src/Try/Gist.purs b/src/Try/Gist.purs
index 172b40cb..6057e291 100644
--- a/src/Try/Gist.purs
+++ b/src/Try/Gist.purs
@@ -9,48 +9,41 @@ module Try.Gist
 import Prelude
 
 import Control.Monad.Cont.Trans (ContT(..))
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn3, EffFn4, mkEffFn1, runEffFn3, runEffFn4)
 import Control.Monad.Except.Trans (ExceptT(..))
-import DOM (DOM)
 import Data.Either (Either(..))
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, EffectFn3, EffectFn4, mkEffectFn1, runEffectFn3, runEffectFn4)
 
 -- | An abstract data type representing the data we get back from the GitHub API.
 data GistInfo
 
 foreign import uploadGist_
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
-            String
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Unit
+  :: EffectFn3 String
+               (EffectFn1 String Unit)
+               (EffectFn1 String Unit)
+               Unit
 
 -- | A wrapper for `uploadGist` which uses `ContT`.
-uploadGist :: forall eff. String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) String
-uploadGist content = ExceptT (ContT \k -> runEffFn3 uploadGist_ content (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+uploadGist :: String -> ExceptT String (ContT Unit Effect) String
+uploadGist content = ExceptT (ContT \k -> runEffectFn3 uploadGist_ content (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
 
 -- | Get a gist by its ID
 foreign import getGistById_
-  :: forall eff
-   . EffFn3 (dom :: DOM | eff)
-            String
-            (EffFn1 (dom :: DOM | eff) GistInfo Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Unit
+  :: EffectFn3 String
+               (EffectFn1 GistInfo Unit)
+               (EffectFn1 String Unit)
+               Unit
 
 -- | A wrapper for `getGistById` which uses `ContT`.
-getGistById :: forall eff. String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) GistInfo
-getGistById id_ = ExceptT (ContT \k -> runEffFn3 getGistById_ id_ (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+getGistById :: String -> ExceptT String (ContT Unit Effect) GistInfo
+getGistById id_ = ExceptT (ContT \k -> runEffectFn3 getGistById_ id_ (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
 
 foreign import tryLoadFileFromGist_
-  :: forall eff
-   . EffFn4 (dom :: DOM | eff)
-            GistInfo
-            String
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            (EffFn1 (dom :: DOM | eff) String Unit)
-            Unit
-
-tryLoadFileFromGist :: forall eff. GistInfo -> String -> ExceptT String (ContT Unit (Eff (dom :: DOM | eff))) String
-tryLoadFileFromGist gi filename = ExceptT (ContT \k -> runEffFn4 tryLoadFileFromGist_ gi filename (mkEffFn1 (k <<< Right)) (mkEffFn1 (k <<< Left)))
+  :: EffectFn4 GistInfo
+               String
+               (EffectFn1 String Unit)
+               (EffectFn1 String Unit)
+               Unit
+
+tryLoadFileFromGist :: GistInfo -> String -> ExceptT String (ContT Unit Effect) String
+tryLoadFileFromGist gi filename = ExceptT (ContT \k -> runEffectFn4 tryLoadFileFromGist_ gi filename (mkEffectFn1 (k <<< Right)) (mkEffectFn1 (k <<< Left)))
diff --git a/src/Try/Loader.purs b/src/Try/Loader.purs
new file mode 100644
index 00000000..e1fef7d1
--- /dev/null
+++ b/src/Try/Loader.purs
@@ -0,0 +1,135 @@
+module Try.Loader
+  ( Loader
+  , makeLoader
+  , runLoader
+  ) where
+
+import Prelude
+
+import Control.Bind (bindFlipped)
+import Control.Monad.Cont (ContT)
+import Control.Monad.Except (ExceptT)
+import Control.Parallel (parTraverse)
+import Data.Array as Array
+import Data.Array.NonEmpty as NonEmpty
+import Data.Maybe (Maybe(..), fromMaybe)
+import Data.Newtype (unwrap)
+import Data.String (Pattern(..))
+import Data.String as String
+import Data.String.Regex (Regex)
+import Data.String.Regex as Regex
+import Data.String.Regex.Flags (noFlags)
+import Data.String.Regex.Unsafe (unsafeRegex)
+import Data.Tuple (Tuple(..))
+import Effect (Effect)
+import Effect.Class (liftEffect)
+import Effect.Ref (Ref)
+import Effect.Ref as Ref
+import Effect.Unsafe (unsafePerformEffect)
+import Foreign.Object (Object)
+import Foreign.Object as Object
+import Try.API as API
+import Try.Shim (shims)
+import Try.Types (JS(..))
+
+type Module =
+  { name :: String
+  , path :: Maybe String
+  , deps :: Array Dependency
+  , src :: JS
+  }
+
+type Dependency =
+  { name :: String
+  , path :: Maybe String
+  }
+
+requireRegex :: Regex
+requireRegex = unsafeRegex """^var\s+\S+\s*=\s*require\(["']([^"']*)["']\)""" noFlags
+
+dirname :: String -> String
+dirname path = fromMaybe "" do
+  ix <- String.lastIndexOf (Pattern "/") path
+  pure $ String.take ix path
+
+resolvePath :: String -> String -> Maybe String
+resolvePath a b
+  | String.take 2 b == "./"  = Just $ dirname a <> String.drop 1 b
+  | String.take 3 b == "../" = Just $ dirname (dirname a) <> String.drop 2 b
+  | otherwise = Nothing
+
+parseDeps :: String -> JS -> Array Dependency
+parseDeps current = Array.mapMaybe go <<< String.split (Pattern "\n") <<< unwrap
+  where
+  go :: String -> Maybe Dependency
+  go line = do
+    match <- Regex.match requireRegex line
+    requirePath <- join $ NonEmpty.index match 1
+    pure $ case resolvePath current requirePath of
+      Just path ->
+        { name: path
+        , path: String.stripPrefix (Pattern "/") path
+        }
+      _ ->
+        { name: requirePath
+        , path: Nothing
+        }
+
+newtype Loader = Loader (JS -> ExceptT String (ContT Unit Effect) (Object JS))
+
+runLoader :: Loader -> JS -> ExceptT String (ContT Unit Effect) (Object JS)
+runLoader (Loader k) = k
+
+makeLoader :: String -> Loader
+makeLoader rootPath = Loader (go Object.empty <<< parseDeps "<file>")
+  where
+  moduleCache :: Ref (Object Module)
+  moduleCache = unsafePerformEffect (Ref.new Object.empty)
+
+  putModule :: String -> Module -> Effect Unit
+  putModule a b = Ref.modify_ (Object.insert a b) moduleCache
+
+  getModule :: String -> Effect (Maybe Module)
+  getModule a = Object.lookup a <$> Ref.read moduleCache
+
+  load :: Dependency -> ExceptT String (ContT Unit Effect) Module
+  load { name, path } = do
+    cached <- liftEffect $ getModule name
+    case cached of
+      Just mod -> pure mod
+      Nothing -> do
+        mod <-
+          case path of
+            Just path' -> do
+              srcStr <- API.get (rootPath <> "/" <> path')
+              let src = JS $ srcStr <> "\n//@ sourceURL=" <> path'
+              pure { name, path, deps: parseDeps name src, src }
+            Nothing -> case Object.lookup name shims of
+              Just shim -> do
+                srcStr <- API.get shim.url
+                let
+                  src = JS $ srcStr <> "\n//@ sourceURL=" <> shim.url
+                  deps = { name: _, path: Nothing } <$> shim.deps
+                pure { name, path, deps, src }
+              Nothing ->
+                pure { name, path, deps: [], src: ffiDep name }
+        liftEffect $ putModule name mod
+        pure mod
+
+  go :: Object JS -> Array Dependency -> ExceptT String (ContT Unit Effect) (Object JS)
+  go ms []   = pure ms
+  go ms deps = do
+    modules <- parTraverse load deps
+    let
+      ms' =
+        modules
+          # map (\{ name, src } -> Tuple name src)
+          # Object.fromFoldable
+          # Object.union ms
+    modules
+      # bindFlipped _.deps
+      # Array.nubBy (comparing _.name)
+      # go ms'
+
+ffiDep :: String -> JS
+ffiDep name = JS $ "throw new Error('FFI dependency not provided: " <> name <> "');"
diff --git a/src/Try/QueryString.purs b/src/Try/QueryString.purs
index fbb66a4e..8009936a 100644
--- a/src/Try/QueryString.purs
+++ b/src/Try/QueryString.purs
@@ -7,49 +7,48 @@ module Try.QueryString
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Uncurried (EffFn1, runEffFn1)
-import DOM (DOM)
 import Data.Array as Array
 import Data.Maybe (Maybe(..))
 import Data.Newtype (wrap)
-import Data.StrMap as StrMap
 import Data.String as String
 import Data.Tuple (Tuple(..))
-import Global (decodeURIComponent)
+import Effect (Effect)
+import Effect.Uncurried (EffectFn1, runEffectFn1)
+import Foreign.Object as Object
+import Global.Unsafe (unsafeDecodeURIComponent)
 
-foreign import getQueryString :: forall eff. Eff (dom :: DOM | eff) String
+foreign import getQueryString :: Effect String
 
 -- | Get all of the URL's query parameters.
-getQueryParams :: forall eff. Eff (dom :: DOM | eff) (StrMap.StrMap String)
+getQueryParams :: Effect (Object.Object String)
 getQueryParams = breakQueryString <$> getQueryString where
-  breakQueryString :: String -> StrMap.StrMap String
+  breakQueryString :: String -> Object.Object String
   breakQueryString =
     String.drop 1
     >>> String.split (wrap "&")
     >>> map (String.split (wrap "=") >>> parseQueryTerm)
     >>> Array.catMaybes
-    >>> StrMap.fromFoldable
+    >>> Object.fromFoldable
 
   parseQueryTerm :: Array String -> Maybe (Tuple String String)
-  parseQueryTerm [k, v] = Just (Tuple k (decodeURIComponent (spaces v)))
+  parseQueryTerm [k, v] = Just (Tuple k (unsafeDecodeURIComponent (spaces v)))
   parseQueryTerm _ = Nothing
 
   spaces :: String -> String
   spaces = String.replaceAll (wrap "+") (wrap " ")
 
 -- | Try to get a key from the URL's query parameters.
-getQueryStringMaybe :: forall eff. String -> Eff (dom :: DOM | eff) (Maybe String)
-getQueryStringMaybe key = StrMap.lookup key <$> getQueryParams
+getQueryStringMaybe :: String -> Effect (Maybe String)
+getQueryStringMaybe key = Object.lookup key <$> getQueryParams
 
 -- | Set the value of a query string parameter
-foreign import setQueryParameters :: forall eff. EffFn1 (dom :: DOM | eff) (StrMap.StrMap String) Unit
+foreign import setQueryParameters :: EffectFn1 (Object.Object String) Unit
 
 -- | Update the specified key in the URL's query parameters.
-setQueryString :: forall eff. String -> String -> Eff (dom :: DOM | eff) Unit
-setQueryString k v = setQueryStrings (StrMap.singleton k v)
+setQueryString :: String -> String -> Effect Unit
+setQueryString k v = setQueryStrings (Object.singleton k v)
 
-setQueryStrings :: forall eff. StrMap.StrMap String -> Eff (dom :: DOM | eff) Unit
+setQueryStrings :: Object.Object String -> Effect Unit
 setQueryStrings ss = do
   params <- getQueryParams
-  runEffFn1 setQueryParameters (StrMap.union ss params)
+  runEffectFn1 setQueryParameters (Object.union ss params)
diff --git a/src/Try/Session.purs b/src/Try/Session.purs
index 0b6d13f1..2262bf26 100644
--- a/src/Try/Session.purs
+++ b/src/Try/Session.purs
@@ -6,19 +6,18 @@ module Try.Session
 
 import Prelude
 
-import Control.Monad.Eff (Eff)
-import Control.Monad.Eff.Random (RANDOM, randomInt)
-import Control.Monad.Eff.Uncurried (EffFn1, EffFn2, runEffFn1, runEffFn2)
-import DOM (DOM)
 import Data.Functor.App (App(..))
 import Data.Int (hexadecimal, toStringAs)
 import Data.Maybe (Maybe(..))
 import Data.Newtype (unwrap)
 import Data.Nullable (Nullable, toMaybe)
 import Data.String as String
+import Effect (Effect)
+import Effect.Random (randomInt)
+import Effect.Uncurried (EffectFn1, EffectFn2, runEffectFn1, runEffectFn2)
 import Try.QueryString (getQueryStringMaybe, setQueryString)
 
-randomGuid :: forall eff. Eff (random :: RANDOM | eff) String
+randomGuid :: Effect String
 randomGuid =
     unwrap (App s4 <> App s4 <> pure "-" <>
             App s4 <> pure "-" <>
@@ -30,35 +29,29 @@ randomGuid =
     padLeft s = String.drop (String.length s - 1) ("000" <> s)
 
 foreign import storeSession_
-  :: forall eff
-   . EffFn2 (dom :: DOM | eff)
-            String
-            { code :: String, backend :: String }
-            Unit
+  :: EffectFn2 String
+               { code :: String }
+               Unit
 
 -- | Store the current session state in local storage
 storeSession
-  :: forall eff
-   . String
-  -> { code :: String, backend :: String }
-  -> Eff (dom :: DOM | eff) Unit
-storeSession sessionId values = runEffFn2 storeSession_ sessionId values
+  :: String
+  -> { code :: String }
+  -> Effect Unit
+storeSession sessionId values = runEffectFn2 storeSession_ sessionId values
 
 foreign import tryRetrieveSession_
-  :: forall eff
-   . EffFn1 (dom :: DOM | eff)
-            String
-            (Nullable { code :: String, backend :: String })
+  :: EffectFn1 String
+               (Nullable { code :: String })
 
 -- | Retrieve the session state from local storage
-tryRetrieveSession :: forall eff. String -> Eff (dom :: DOM | eff) (Maybe { code :: String, backend :: String })
-tryRetrieveSession sessionId = toMaybe <$> runEffFn1 tryRetrieveSession_ sessionId
+tryRetrieveSession :: String -> Effect (Maybe { code :: String })
+tryRetrieveSession sessionId = toMaybe <$> runEffectFn1 tryRetrieveSession_ sessionId
 
 -- | Look up the session by ID, or create a new session ID.
 createSessionIdIfNecessary
-  :: forall eff
-   . (String -> Eff (dom :: DOM, random :: RANDOM | eff) Unit)
-  -> Eff (dom :: DOM, random :: RANDOM | eff) Unit
+  :: (String -> Effect Unit)
+  -> Effect Unit
 createSessionIdIfNecessary k = do
   sessionId <- getQueryStringMaybe "session"
   case sessionId of
diff --git a/src/Try/Shim.purs b/src/Try/Shim.purs
new file mode 100644
index 00000000..8ad23461
--- /dev/null
+++ b/src/Try/Shim.purs
@@ -0,0 +1,27 @@
+module Try.Shim where
+
+import Data.Tuple (Tuple(..))
+import Foreign.Object (Object)
+import Foreign.Object as Object
+
+type Shim =
+  { url :: String
+  , deps :: Array String
+  }
+
+shims :: Object Shim
+shims = Object.fromFoldable
+  [ Tuple "react"
+      { url: "https://unpkg.com/react@16.6.3/umd/react.development.js"
+      , deps: []
+      }
+  , Tuple "react-dom"
+      { url: "https://unpkg.com/react-dom@16.6.3/umd/react-dom.development.js"
+      , deps: [ "react" ]
+      }
+  , Tuple "react-dom/server"
+      { url: "https://unpkg.com/react-dom@16.6.3/umd/react-dom-server.browser.development.js"
+      , deps: [ "react" ]
+      }
+  ]
+
diff --git a/src/Try/Types.purs b/src/Try/Types.purs
index 35f01789..a85d2e8b 100644
--- a/src/Try/Types.purs
+++ b/src/Try/Types.purs
@@ -3,7 +3,10 @@ module Try.Types
   ) where
 
 import Data.Newtype (class Newtype)
+import Foreign.Class (class Encode)
 
 newtype JS = JS String
 
 derive instance newtypeJS :: Newtype JS _
+
+derive newtype instance encodeJS :: Encode JS