From 77c8d55a3152ca996bbd5023d0faa4016d676887 Mon Sep 17 00:00:00 2001
From: Nicholas Kariniemi <nicholas.kariniemi@gmail.com>
Date: Wed, 24 Jul 2013 20:39:02 +0300
Subject: [PATCH] Initial commit

---
 .gitignore                     |    12 +
 README.md                      |    13 +
 doc/intro.md                   |     3 +
 project.clj                    |    24 +
 public/js/main.js              | 21688 +++++++++++++++++++++++++++++++
 src-clj/grub/core.clj          |    31 +
 src-cljs/grub_client/core.cljs |     3 +
 test/grub/core_test.clj        |     7 +
 8 files changed, 21781 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 README.md
 create mode 100644 doc/intro.md
 create mode 100644 project.clj
 create mode 100644 public/js/main.js
 create mode 100644 src-clj/grub/core.clj
 create mode 100644 src-cljs/grub_client/core.cljs
 create mode 100644 test/grub/core_test.clj

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..cc2ff39
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,12 @@
+/target
+/lib
+/classes
+/checkouts
+pom.xml
+pom.xml.asc
+*.jar
+*.class
+.lein-deps-sum
+.lein-failures
+.lein-plugins
+.lein-repl-history
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..ddcf6f9
--- /dev/null
+++ b/README.md
@@ -0,0 +1,13 @@
+# grub
+
+A Clojure library designed to ... well, that part is up to you.
+
+## Usage
+
+FIXME
+
+## License
+
+Copyright © 2013 FIXME
+
+Distributed under the Eclipse Public License, the same as Clojure.
diff --git a/doc/intro.md b/doc/intro.md
new file mode 100644
index 0000000..c16e801
--- /dev/null
+++ b/doc/intro.md
@@ -0,0 +1,3 @@
+# Introduction to grub
+
+TODO: write [great documentation](http://jacobian.org/writing/great-documentation/what-to-write/)
diff --git a/project.clj b/project.clj
new file mode 100644
index 0000000..1bb27e8
--- /dev/null
+++ b/project.clj
@@ -0,0 +1,24 @@
+(defproject grub "0.1.0-SNAPSHOT"
+  :description "FIXME: write description"
+  :url "http://example.com/FIXME"
+  :license {:name "Eclipse Public License"
+            :url "http://www.eclipse.org/legal/epl-v10.html"}
+  :source-paths ["src-clj"]
+  :dependencies [[org.clojure/clojure "1.5.1"]
+                 [http-kit "2.1.5"]
+                 [compojure "1.1.5"]
+                 [ring/ring-devel "1.2.0"]
+                 [ring/ring-core "1.2.0"]]
+  :plugins [[lein-cljsbuild "0.3.2"]
+            [lein-ring "0.8.6"]]
+  :cljsbuild {
+    :builds [{
+        ; The path to the top-level ClojureScript source directory:
+        :source-paths ["src-cljs"]
+        ; The standard ClojureScript compiler options:
+        ; (See the ClojureScript compiler documentation for details.)
+        :compiler {
+          :output-to "public/js/main.js"  ; default: target/cljsbuild-main.js
+          :optimizations :whitespace
+          :pretty-print true}}]}
+  :ring {:handler grub.core/async-handler})
diff --git a/public/js/main.js b/public/js/main.js
new file mode 100644
index 0000000..8263d84
--- /dev/null
+++ b/public/js/main.js
@@ -0,0 +1,21688 @@
+var CLOSURE_NO_DEPS = true;
+var COMPILED = false;
+var goog = goog || {};
+goog.global = this;
+goog.DEBUG = true;
+goog.LOCALE = "en";
+goog.provide = function(name) {
+  if(!COMPILED) {
+    if(goog.isProvided_(name)) {
+      throw Error('Namespace "' + name + '" already declared.');
+    }
+    delete goog.implicitNamespaces_[name];
+    var namespace = name;
+    while(namespace = namespace.substring(0, namespace.lastIndexOf("."))) {
+      if(goog.getObjectByName(namespace)) {
+        break
+      }
+      goog.implicitNamespaces_[namespace] = true
+    }
+  }
+  goog.exportPath_(name)
+};
+goog.setTestOnly = function(opt_message) {
+  if(COMPILED && !goog.DEBUG) {
+    opt_message = opt_message || "";
+    throw Error("Importing test-only code into non-debug environment" + opt_message ? ": " + opt_message : ".");
+  }
+};
+if(!COMPILED) {
+  goog.isProvided_ = function(name) {
+    return!goog.implicitNamespaces_[name] && !!goog.getObjectByName(name)
+  };
+  goog.implicitNamespaces_ = {}
+}
+goog.exportPath_ = function(name, opt_object, opt_objectToExportTo) {
+  var parts = name.split(".");
+  var cur = opt_objectToExportTo || goog.global;
+  if(!(parts[0] in cur) && cur.execScript) {
+    cur.execScript("var " + parts[0])
+  }
+  for(var part;parts.length && (part = parts.shift());) {
+    if(!parts.length && goog.isDef(opt_object)) {
+      cur[part] = opt_object
+    }else {
+      if(cur[part]) {
+        cur = cur[part]
+      }else {
+        cur = cur[part] = {}
+      }
+    }
+  }
+};
+goog.getObjectByName = function(name, opt_obj) {
+  var parts = name.split(".");
+  var cur = opt_obj || goog.global;
+  for(var part;part = parts.shift();) {
+    if(goog.isDefAndNotNull(cur[part])) {
+      cur = cur[part]
+    }else {
+      return null
+    }
+  }
+  return cur
+};
+goog.globalize = function(obj, opt_global) {
+  var global = opt_global || goog.global;
+  for(var x in obj) {
+    global[x] = obj[x]
+  }
+};
+goog.addDependency = function(relPath, provides, requires) {
+  if(!COMPILED) {
+    var provide, require;
+    var path = relPath.replace(/\\/g, "/");
+    var deps = goog.dependencies_;
+    for(var i = 0;provide = provides[i];i++) {
+      deps.nameToPath[provide] = path;
+      if(!(path in deps.pathToNames)) {
+        deps.pathToNames[path] = {}
+      }
+      deps.pathToNames[path][provide] = true
+    }
+    for(var j = 0;require = requires[j];j++) {
+      if(!(path in deps.requires)) {
+        deps.requires[path] = {}
+      }
+      deps.requires[path][require] = true
+    }
+  }
+};
+goog.ENABLE_DEBUG_LOADER = true;
+goog.require = function(name) {
+  if(!COMPILED) {
+    if(goog.isProvided_(name)) {
+      return
+    }
+    if(goog.ENABLE_DEBUG_LOADER) {
+      var path = goog.getPathFromDeps_(name);
+      if(path) {
+        goog.included_[path] = true;
+        goog.writeScripts_();
+        return
+      }
+    }
+    var errorMessage = "goog.require could not find: " + name;
+    if(goog.global.console) {
+      goog.global.console["error"](errorMessage)
+    }
+    throw Error(errorMessage);
+  }
+};
+goog.basePath = "";
+goog.global.CLOSURE_BASE_PATH;
+goog.global.CLOSURE_NO_DEPS;
+goog.global.CLOSURE_IMPORT_SCRIPT;
+goog.nullFunction = function() {
+};
+goog.identityFunction = function(opt_returnValue, var_args) {
+  return opt_returnValue
+};
+goog.abstractMethod = function() {
+  throw Error("unimplemented abstract method");
+};
+goog.addSingletonGetter = function(ctor) {
+  ctor.getInstance = function() {
+    if(ctor.instance_) {
+      return ctor.instance_
+    }
+    if(goog.DEBUG) {
+      goog.instantiatedSingletons_[goog.instantiatedSingletons_.length] = ctor
+    }
+    return ctor.instance_ = new ctor
+  }
+};
+goog.instantiatedSingletons_ = [];
+if(!COMPILED && goog.ENABLE_DEBUG_LOADER) {
+  goog.included_ = {};
+  goog.dependencies_ = {pathToNames:{}, nameToPath:{}, requires:{}, visited:{}, written:{}};
+  goog.inHtmlDocument_ = function() {
+    var doc = goog.global.document;
+    return typeof doc != "undefined" && "write" in doc
+  };
+  goog.findBasePath_ = function() {
+    if(goog.global.CLOSURE_BASE_PATH) {
+      goog.basePath = goog.global.CLOSURE_BASE_PATH;
+      return
+    }else {
+      if(!goog.inHtmlDocument_()) {
+        return
+      }
+    }
+    var doc = goog.global.document;
+    var scripts = doc.getElementsByTagName("script");
+    for(var i = scripts.length - 1;i >= 0;--i) {
+      var src = scripts[i].src;
+      var qmark = src.lastIndexOf("?");
+      var l = qmark == -1 ? src.length : qmark;
+      if(src.substr(l - 7, 7) == "base.js") {
+        goog.basePath = src.substr(0, l - 7);
+        return
+      }
+    }
+  };
+  goog.importScript_ = function(src) {
+    var importScript = goog.global.CLOSURE_IMPORT_SCRIPT || goog.writeScriptTag_;
+    if(!goog.dependencies_.written[src] && importScript(src)) {
+      goog.dependencies_.written[src] = true
+    }
+  };
+  goog.writeScriptTag_ = function(src) {
+    if(goog.inHtmlDocument_()) {
+      var doc = goog.global.document;
+      doc.write('<script type="text/javascript" src="' + src + '"></' + "script>");
+      return true
+    }else {
+      return false
+    }
+  };
+  goog.writeScripts_ = function() {
+    var scripts = [];
+    var seenScript = {};
+    var deps = goog.dependencies_;
+    function visitNode(path) {
+      if(path in deps.written) {
+        return
+      }
+      if(path in deps.visited) {
+        if(!(path in seenScript)) {
+          seenScript[path] = true;
+          scripts.push(path)
+        }
+        return
+      }
+      deps.visited[path] = true;
+      if(path in deps.requires) {
+        for(var requireName in deps.requires[path]) {
+          if(!goog.isProvided_(requireName)) {
+            if(requireName in deps.nameToPath) {
+              visitNode(deps.nameToPath[requireName])
+            }else {
+              throw Error("Undefined nameToPath for " + requireName);
+            }
+          }
+        }
+      }
+      if(!(path in seenScript)) {
+        seenScript[path] = true;
+        scripts.push(path)
+      }
+    }
+    for(var path in goog.included_) {
+      if(!deps.written[path]) {
+        visitNode(path)
+      }
+    }
+    for(var i = 0;i < scripts.length;i++) {
+      if(scripts[i]) {
+        goog.importScript_(goog.basePath + scripts[i])
+      }else {
+        throw Error("Undefined script input");
+      }
+    }
+  };
+  goog.getPathFromDeps_ = function(rule) {
+    if(rule in goog.dependencies_.nameToPath) {
+      return goog.dependencies_.nameToPath[rule]
+    }else {
+      return null
+    }
+  };
+  goog.findBasePath_();
+  if(!goog.global.CLOSURE_NO_DEPS) {
+    goog.importScript_(goog.basePath + "deps.js")
+  }
+}
+goog.typeOf = function(value) {
+  var s = typeof value;
+  if(s == "object") {
+    if(value) {
+      if(value instanceof Array) {
+        return"array"
+      }else {
+        if(value instanceof Object) {
+          return s
+        }
+      }
+      var className = Object.prototype.toString.call(value);
+      if(className == "[object Window]") {
+        return"object"
+      }
+      if(className == "[object Array]" || typeof value.length == "number" && typeof value.splice != "undefined" && typeof value.propertyIsEnumerable != "undefined" && !value.propertyIsEnumerable("splice")) {
+        return"array"
+      }
+      if(className == "[object Function]" || typeof value.call != "undefined" && typeof value.propertyIsEnumerable != "undefined" && !value.propertyIsEnumerable("call")) {
+        return"function"
+      }
+    }else {
+      return"null"
+    }
+  }else {
+    if(s == "function" && typeof value.call == "undefined") {
+      return"object"
+    }
+  }
+  return s
+};
+goog.isDef = function(val) {
+  return val !== undefined
+};
+goog.isNull = function(val) {
+  return val === null
+};
+goog.isDefAndNotNull = function(val) {
+  return val != null
+};
+goog.isArray = function(val) {
+  return goog.typeOf(val) == "array"
+};
+goog.isArrayLike = function(val) {
+  var type = goog.typeOf(val);
+  return type == "array" || type == "object" && typeof val.length == "number"
+};
+goog.isDateLike = function(val) {
+  return goog.isObject(val) && typeof val.getFullYear == "function"
+};
+goog.isString = function(val) {
+  return typeof val == "string"
+};
+goog.isBoolean = function(val) {
+  return typeof val == "boolean"
+};
+goog.isNumber = function(val) {
+  return typeof val == "number"
+};
+goog.isFunction = function(val) {
+  return goog.typeOf(val) == "function"
+};
+goog.isObject = function(val) {
+  var type = typeof val;
+  return type == "object" && val != null || type == "function"
+};
+goog.getUid = function(obj) {
+  return obj[goog.UID_PROPERTY_] || (obj[goog.UID_PROPERTY_] = ++goog.uidCounter_)
+};
+goog.removeUid = function(obj) {
+  if("removeAttribute" in obj) {
+    obj.removeAttribute(goog.UID_PROPERTY_)
+  }
+  try {
+    delete obj[goog.UID_PROPERTY_]
+  }catch(ex) {
+  }
+};
+goog.UID_PROPERTY_ = "closure_uid_" + Math.floor(Math.random() * 2147483648).toString(36);
+goog.uidCounter_ = 0;
+goog.getHashCode = goog.getUid;
+goog.removeHashCode = goog.removeUid;
+goog.cloneObject = function(obj) {
+  var type = goog.typeOf(obj);
+  if(type == "object" || type == "array") {
+    if(obj.clone) {
+      return obj.clone()
+    }
+    var clone = type == "array" ? [] : {};
+    for(var key in obj) {
+      clone[key] = goog.cloneObject(obj[key])
+    }
+    return clone
+  }
+  return obj
+};
+goog.bindNative_ = function(fn, selfObj, var_args) {
+  return fn.call.apply(fn.bind, arguments)
+};
+goog.bindJs_ = function(fn, selfObj, var_args) {
+  if(!fn) {
+    throw new Error;
+  }
+  if(arguments.length > 2) {
+    var boundArgs = Array.prototype.slice.call(arguments, 2);
+    return function() {
+      var newArgs = Array.prototype.slice.call(arguments);
+      Array.prototype.unshift.apply(newArgs, boundArgs);
+      return fn.apply(selfObj, newArgs)
+    }
+  }else {
+    return function() {
+      return fn.apply(selfObj, arguments)
+    }
+  }
+};
+goog.bind = function(fn, selfObj, var_args) {
+  if(Function.prototype.bind && Function.prototype.bind.toString().indexOf("native code") != -1) {
+    goog.bind = goog.bindNative_
+  }else {
+    goog.bind = goog.bindJs_
+  }
+  return goog.bind.apply(null, arguments)
+};
+goog.partial = function(fn, var_args) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  return function() {
+    var newArgs = Array.prototype.slice.call(arguments);
+    newArgs.unshift.apply(newArgs, args);
+    return fn.apply(this, newArgs)
+  }
+};
+goog.mixin = function(target, source) {
+  for(var x in source) {
+    target[x] = source[x]
+  }
+};
+goog.now = Date.now || function() {
+  return+new Date
+};
+goog.globalEval = function(script) {
+  if(goog.global.execScript) {
+    goog.global.execScript(script, "JavaScript")
+  }else {
+    if(goog.global.eval) {
+      if(goog.evalWorksForGlobals_ == null) {
+        goog.global.eval("var _et_ = 1;");
+        if(typeof goog.global["_et_"] != "undefined") {
+          delete goog.global["_et_"];
+          goog.evalWorksForGlobals_ = true
+        }else {
+          goog.evalWorksForGlobals_ = false
+        }
+      }
+      if(goog.evalWorksForGlobals_) {
+        goog.global.eval(script)
+      }else {
+        var doc = goog.global.document;
+        var scriptElt = doc.createElement("script");
+        scriptElt.type = "text/javascript";
+        scriptElt.defer = false;
+        scriptElt.appendChild(doc.createTextNode(script));
+        doc.body.appendChild(scriptElt);
+        doc.body.removeChild(scriptElt)
+      }
+    }else {
+      throw Error("goog.globalEval not available");
+    }
+  }
+};
+goog.evalWorksForGlobals_ = null;
+goog.cssNameMapping_;
+goog.cssNameMappingStyle_;
+goog.getCssName = function(className, opt_modifier) {
+  var getMapping = function(cssName) {
+    return goog.cssNameMapping_[cssName] || cssName
+  };
+  var renameByParts = function(cssName) {
+    var parts = cssName.split("-");
+    var mapped = [];
+    for(var i = 0;i < parts.length;i++) {
+      mapped.push(getMapping(parts[i]))
+    }
+    return mapped.join("-")
+  };
+  var rename;
+  if(goog.cssNameMapping_) {
+    rename = goog.cssNameMappingStyle_ == "BY_WHOLE" ? getMapping : renameByParts
+  }else {
+    rename = function(a) {
+      return a
+    }
+  }
+  if(opt_modifier) {
+    return className + "-" + rename(opt_modifier)
+  }else {
+    return rename(className)
+  }
+};
+goog.setCssNameMapping = function(mapping, opt_style) {
+  goog.cssNameMapping_ = mapping;
+  goog.cssNameMappingStyle_ = opt_style
+};
+goog.global.CLOSURE_CSS_NAME_MAPPING;
+if(!COMPILED && goog.global.CLOSURE_CSS_NAME_MAPPING) {
+  goog.cssNameMapping_ = goog.global.CLOSURE_CSS_NAME_MAPPING
+}
+goog.getMsg = function(str, opt_values) {
+  var values = opt_values || {};
+  for(var key in values) {
+    var value = ("" + values[key]).replace(/\$/g, "$$$$");
+    str = str.replace(new RegExp("\\{\\$" + key + "\\}", "gi"), value)
+  }
+  return str
+};
+goog.exportSymbol = function(publicPath, object, opt_objectToExportTo) {
+  goog.exportPath_(publicPath, object, opt_objectToExportTo)
+};
+goog.exportProperty = function(object, publicName, symbol) {
+  object[publicName] = symbol
+};
+goog.inherits = function(childCtor, parentCtor) {
+  function tempCtor() {
+  }
+  tempCtor.prototype = parentCtor.prototype;
+  childCtor.superClass_ = parentCtor.prototype;
+  childCtor.prototype = new tempCtor;
+  childCtor.prototype.constructor = childCtor
+};
+goog.base = function(me, opt_methodName, var_args) {
+  var caller = arguments.callee.caller;
+  if(caller.superClass_) {
+    return caller.superClass_.constructor.apply(me, Array.prototype.slice.call(arguments, 1))
+  }
+  var args = Array.prototype.slice.call(arguments, 2);
+  var foundCaller = false;
+  for(var ctor = me.constructor;ctor;ctor = ctor.superClass_ && ctor.superClass_.constructor) {
+    if(ctor.prototype[opt_methodName] === caller) {
+      foundCaller = true
+    }else {
+      if(foundCaller) {
+        return ctor.prototype[opt_methodName].apply(me, args)
+      }
+    }
+  }
+  if(me[opt_methodName] === caller) {
+    return me.constructor.prototype[opt_methodName].apply(me, args)
+  }else {
+    throw Error("goog.base called from a method of one name " + "to a method of a different name");
+  }
+};
+goog.scope = function(fn) {
+  fn.call(goog.global)
+};
+goog.provide("goog.string");
+goog.provide("goog.string.Unicode");
+goog.string.Unicode = {NBSP:"\u00a0"};
+goog.string.startsWith = function(str, prefix) {
+  return str.lastIndexOf(prefix, 0) == 0
+};
+goog.string.endsWith = function(str, suffix) {
+  var l = str.length - suffix.length;
+  return l >= 0 && str.indexOf(suffix, l) == l
+};
+goog.string.caseInsensitiveStartsWith = function(str, prefix) {
+  return goog.string.caseInsensitiveCompare(prefix, str.substr(0, prefix.length)) == 0
+};
+goog.string.caseInsensitiveEndsWith = function(str, suffix) {
+  return goog.string.caseInsensitiveCompare(suffix, str.substr(str.length - suffix.length, suffix.length)) == 0
+};
+goog.string.subs = function(str, var_args) {
+  for(var i = 1;i < arguments.length;i++) {
+    var replacement = String(arguments[i]).replace(/\$/g, "$$$$");
+    str = str.replace(/\%s/, replacement)
+  }
+  return str
+};
+goog.string.collapseWhitespace = function(str) {
+  return str.replace(/[\s\xa0]+/g, " ").replace(/^\s+|\s+$/g, "")
+};
+goog.string.isEmpty = function(str) {
+  return/^[\s\xa0]*$/.test(str)
+};
+goog.string.isEmptySafe = function(str) {
+  return goog.string.isEmpty(goog.string.makeSafe(str))
+};
+goog.string.isBreakingWhitespace = function(str) {
+  return!/[^\t\n\r ]/.test(str)
+};
+goog.string.isAlpha = function(str) {
+  return!/[^a-zA-Z]/.test(str)
+};
+goog.string.isNumeric = function(str) {
+  return!/[^0-9]/.test(str)
+};
+goog.string.isAlphaNumeric = function(str) {
+  return!/[^a-zA-Z0-9]/.test(str)
+};
+goog.string.isSpace = function(ch) {
+  return ch == " "
+};
+goog.string.isUnicodeChar = function(ch) {
+  return ch.length == 1 && ch >= " " && ch <= "~" || ch >= "\u0080" && ch <= "\ufffd"
+};
+goog.string.stripNewlines = function(str) {
+  return str.replace(/(\r\n|\r|\n)+/g, " ")
+};
+goog.string.canonicalizeNewlines = function(str) {
+  return str.replace(/(\r\n|\r|\n)/g, "\n")
+};
+goog.string.normalizeWhitespace = function(str) {
+  return str.replace(/\xa0|\s/g, " ")
+};
+goog.string.normalizeSpaces = function(str) {
+  return str.replace(/\xa0|[ \t]+/g, " ")
+};
+goog.string.collapseBreakingSpaces = function(str) {
+  return str.replace(/[\t\r\n ]+/g, " ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g, "")
+};
+goog.string.trim = function(str) {
+  return str.replace(/^[\s\xa0]+|[\s\xa0]+$/g, "")
+};
+goog.string.trimLeft = function(str) {
+  return str.replace(/^[\s\xa0]+/, "")
+};
+goog.string.trimRight = function(str) {
+  return str.replace(/[\s\xa0]+$/, "")
+};
+goog.string.caseInsensitiveCompare = function(str1, str2) {
+  var test1 = String(str1).toLowerCase();
+  var test2 = String(str2).toLowerCase();
+  if(test1 < test2) {
+    return-1
+  }else {
+    if(test1 == test2) {
+      return 0
+    }else {
+      return 1
+    }
+  }
+};
+goog.string.numerateCompareRegExp_ = /(\.\d+)|(\d+)|(\D+)/g;
+goog.string.numerateCompare = function(str1, str2) {
+  if(str1 == str2) {
+    return 0
+  }
+  if(!str1) {
+    return-1
+  }
+  if(!str2) {
+    return 1
+  }
+  var tokens1 = str1.toLowerCase().match(goog.string.numerateCompareRegExp_);
+  var tokens2 = str2.toLowerCase().match(goog.string.numerateCompareRegExp_);
+  var count = Math.min(tokens1.length, tokens2.length);
+  for(var i = 0;i < count;i++) {
+    var a = tokens1[i];
+    var b = tokens2[i];
+    if(a != b) {
+      var num1 = parseInt(a, 10);
+      if(!isNaN(num1)) {
+        var num2 = parseInt(b, 10);
+        if(!isNaN(num2) && num1 - num2) {
+          return num1 - num2
+        }
+      }
+      return a < b ? -1 : 1
+    }
+  }
+  if(tokens1.length != tokens2.length) {
+    return tokens1.length - tokens2.length
+  }
+  return str1 < str2 ? -1 : 1
+};
+goog.string.urlEncode = function(str) {
+  return encodeURIComponent(String(str))
+};
+goog.string.urlDecode = function(str) {
+  return decodeURIComponent(str.replace(/\+/g, " "))
+};
+goog.string.newLineToBr = function(str, opt_xml) {
+  return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "<br />" : "<br>")
+};
+goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
+  if(opt_isLikelyToContainHtmlChars) {
+    return str.replace(goog.string.amperRe_, "&amp;").replace(goog.string.ltRe_, "&lt;").replace(goog.string.gtRe_, "&gt;").replace(goog.string.quotRe_, "&quot;")
+  }else {
+    if(!goog.string.allRe_.test(str)) {
+      return str
+    }
+    if(str.indexOf("&") != -1) {
+      str = str.replace(goog.string.amperRe_, "&amp;")
+    }
+    if(str.indexOf("<") != -1) {
+      str = str.replace(goog.string.ltRe_, "&lt;")
+    }
+    if(str.indexOf(">") != -1) {
+      str = str.replace(goog.string.gtRe_, "&gt;")
+    }
+    if(str.indexOf('"') != -1) {
+      str = str.replace(goog.string.quotRe_, "&quot;")
+    }
+    return str
+  }
+};
+goog.string.amperRe_ = /&/g;
+goog.string.ltRe_ = /</g;
+goog.string.gtRe_ = />/g;
+goog.string.quotRe_ = /\"/g;
+goog.string.allRe_ = /[&<>\"]/;
+goog.string.unescapeEntities = function(str) {
+  if(goog.string.contains(str, "&")) {
+    if("document" in goog.global) {
+      return goog.string.unescapeEntitiesUsingDom_(str)
+    }else {
+      return goog.string.unescapePureXmlEntities_(str)
+    }
+  }
+  return str
+};
+goog.string.unescapeEntitiesUsingDom_ = function(str) {
+  var seen = {"&amp;":"&", "&lt;":"<", "&gt;":">", "&quot;":'"'};
+  var div = document.createElement("div");
+  return str.replace(goog.string.HTML_ENTITY_PATTERN_, function(s, entity) {
+    var value = seen[s];
+    if(value) {
+      return value
+    }
+    if(entity.charAt(0) == "#") {
+      var n = Number("0" + entity.substr(1));
+      if(!isNaN(n)) {
+        value = String.fromCharCode(n)
+      }
+    }
+    if(!value) {
+      div.innerHTML = s + " ";
+      value = div.firstChild.nodeValue.slice(0, -1)
+    }
+    return seen[s] = value
+  })
+};
+goog.string.unescapePureXmlEntities_ = function(str) {
+  return str.replace(/&([^;]+);/g, function(s, entity) {
+    switch(entity) {
+      case "amp":
+        return"&";
+      case "lt":
+        return"<";
+      case "gt":
+        return">";
+      case "quot":
+        return'"';
+      default:
+        if(entity.charAt(0) == "#") {
+          var n = Number("0" + entity.substr(1));
+          if(!isNaN(n)) {
+            return String.fromCharCode(n)
+          }
+        }
+        return s
+    }
+  })
+};
+goog.string.HTML_ENTITY_PATTERN_ = /&([^;\s<&]+);?/g;
+goog.string.whitespaceEscape = function(str, opt_xml) {
+  return goog.string.newLineToBr(str.replace(/  /g, " &#160;"), opt_xml)
+};
+goog.string.stripQuotes = function(str, quoteChars) {
+  var length = quoteChars.length;
+  for(var i = 0;i < length;i++) {
+    var quoteChar = length == 1 ? quoteChars : quoteChars.charAt(i);
+    if(str.charAt(0) == quoteChar && str.charAt(str.length - 1) == quoteChar) {
+      return str.substring(1, str.length - 1)
+    }
+  }
+  return str
+};
+goog.string.truncate = function(str, chars, opt_protectEscapedCharacters) {
+  if(opt_protectEscapedCharacters) {
+    str = goog.string.unescapeEntities(str)
+  }
+  if(str.length > chars) {
+    str = str.substring(0, chars - 3) + "..."
+  }
+  if(opt_protectEscapedCharacters) {
+    str = goog.string.htmlEscape(str)
+  }
+  return str
+};
+goog.string.truncateMiddle = function(str, chars, opt_protectEscapedCharacters, opt_trailingChars) {
+  if(opt_protectEscapedCharacters) {
+    str = goog.string.unescapeEntities(str)
+  }
+  if(opt_trailingChars && str.length > chars) {
+    if(opt_trailingChars > chars) {
+      opt_trailingChars = chars
+    }
+    var endPoint = str.length - opt_trailingChars;
+    var startPoint = chars - opt_trailingChars;
+    str = str.substring(0, startPoint) + "..." + str.substring(endPoint)
+  }else {
+    if(str.length > chars) {
+      var half = Math.floor(chars / 2);
+      var endPos = str.length - half;
+      half += chars % 2;
+      str = str.substring(0, half) + "..." + str.substring(endPos)
+    }
+  }
+  if(opt_protectEscapedCharacters) {
+    str = goog.string.htmlEscape(str)
+  }
+  return str
+};
+goog.string.specialEscapeChars_ = {"\x00":"\\0", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\x0B", '"':'\\"', "\\":"\\\\"};
+goog.string.jsEscapeCache_ = {"'":"\\'"};
+goog.string.quote = function(s) {
+  s = String(s);
+  if(s.quote) {
+    return s.quote()
+  }else {
+    var sb = ['"'];
+    for(var i = 0;i < s.length;i++) {
+      var ch = s.charAt(i);
+      var cc = ch.charCodeAt(0);
+      sb[i + 1] = goog.string.specialEscapeChars_[ch] || (cc > 31 && cc < 127 ? ch : goog.string.escapeChar(ch))
+    }
+    sb.push('"');
+    return sb.join("")
+  }
+};
+goog.string.escapeString = function(str) {
+  var sb = [];
+  for(var i = 0;i < str.length;i++) {
+    sb[i] = goog.string.escapeChar(str.charAt(i))
+  }
+  return sb.join("")
+};
+goog.string.escapeChar = function(c) {
+  if(c in goog.string.jsEscapeCache_) {
+    return goog.string.jsEscapeCache_[c]
+  }
+  if(c in goog.string.specialEscapeChars_) {
+    return goog.string.jsEscapeCache_[c] = goog.string.specialEscapeChars_[c]
+  }
+  var rv = c;
+  var cc = c.charCodeAt(0);
+  if(cc > 31 && cc < 127) {
+    rv = c
+  }else {
+    if(cc < 256) {
+      rv = "\\x";
+      if(cc < 16 || cc > 256) {
+        rv += "0"
+      }
+    }else {
+      rv = "\\u";
+      if(cc < 4096) {
+        rv += "0"
+      }
+    }
+    rv += cc.toString(16).toUpperCase()
+  }
+  return goog.string.jsEscapeCache_[c] = rv
+};
+goog.string.toMap = function(s) {
+  var rv = {};
+  for(var i = 0;i < s.length;i++) {
+    rv[s.charAt(i)] = true
+  }
+  return rv
+};
+goog.string.contains = function(s, ss) {
+  return s.indexOf(ss) != -1
+};
+goog.string.countOf = function(s, ss) {
+  return s && ss ? s.split(ss).length - 1 : 0
+};
+goog.string.removeAt = function(s, index, stringLength) {
+  var resultStr = s;
+  if(index >= 0 && index < s.length && stringLength > 0) {
+    resultStr = s.substr(0, index) + s.substr(index + stringLength, s.length - index - stringLength)
+  }
+  return resultStr
+};
+goog.string.remove = function(s, ss) {
+  var re = new RegExp(goog.string.regExpEscape(ss), "");
+  return s.replace(re, "")
+};
+goog.string.removeAll = function(s, ss) {
+  var re = new RegExp(goog.string.regExpEscape(ss), "g");
+  return s.replace(re, "")
+};
+goog.string.regExpEscape = function(s) {
+  return String(s).replace(/([-()\[\]{}+?*.$\^|,:#<!\\])/g, "\\$1").replace(/\x08/g, "\\x08")
+};
+goog.string.repeat = function(string, length) {
+  return(new Array(length + 1)).join(string)
+};
+goog.string.padNumber = function(num, length, opt_precision) {
+  var s = goog.isDef(opt_precision) ? num.toFixed(opt_precision) : String(num);
+  var index = s.indexOf(".");
+  if(index == -1) {
+    index = s.length
+  }
+  return goog.string.repeat("0", Math.max(0, length - index)) + s
+};
+goog.string.makeSafe = function(obj) {
+  return obj == null ? "" : String(obj)
+};
+goog.string.buildString = function(var_args) {
+  return Array.prototype.join.call(arguments, "")
+};
+goog.string.getRandomString = function() {
+  var x = 2147483648;
+  return Math.floor(Math.random() * x).toString(36) + Math.abs(Math.floor(Math.random() * x) ^ goog.now()).toString(36)
+};
+goog.string.compareVersions = function(version1, version2) {
+  var order = 0;
+  var v1Subs = goog.string.trim(String(version1)).split(".");
+  var v2Subs = goog.string.trim(String(version2)).split(".");
+  var subCount = Math.max(v1Subs.length, v2Subs.length);
+  for(var subIdx = 0;order == 0 && subIdx < subCount;subIdx++) {
+    var v1Sub = v1Subs[subIdx] || "";
+    var v2Sub = v2Subs[subIdx] || "";
+    var v1CompParser = new RegExp("(\\d*)(\\D*)", "g");
+    var v2CompParser = new RegExp("(\\d*)(\\D*)", "g");
+    do {
+      var v1Comp = v1CompParser.exec(v1Sub) || ["", "", ""];
+      var v2Comp = v2CompParser.exec(v2Sub) || ["", "", ""];
+      if(v1Comp[0].length == 0 && v2Comp[0].length == 0) {
+        break
+      }
+      var v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);
+      var v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);
+      order = goog.string.compareElements_(v1CompNum, v2CompNum) || goog.string.compareElements_(v1Comp[2].length == 0, v2Comp[2].length == 0) || goog.string.compareElements_(v1Comp[2], v2Comp[2])
+    }while(order == 0)
+  }
+  return order
+};
+goog.string.compareElements_ = function(left, right) {
+  if(left < right) {
+    return-1
+  }else {
+    if(left > right) {
+      return 1
+    }
+  }
+  return 0
+};
+goog.string.HASHCODE_MAX_ = 4294967296;
+goog.string.hashCode = function(str) {
+  var result = 0;
+  for(var i = 0;i < str.length;++i) {
+    result = 31 * result + str.charCodeAt(i);
+    result %= goog.string.HASHCODE_MAX_
+  }
+  return result
+};
+goog.string.uniqueStringCounter_ = Math.random() * 2147483648 | 0;
+goog.string.createUniqueString = function() {
+  return"goog_" + goog.string.uniqueStringCounter_++
+};
+goog.string.toNumber = function(str) {
+  var num = Number(str);
+  if(num == 0 && goog.string.isEmpty(str)) {
+    return NaN
+  }
+  return num
+};
+goog.string.toCamelCase = function(str) {
+  return String(str).replace(/\-([a-z])/g, function(all, match) {
+    return match.toUpperCase()
+  })
+};
+goog.string.toSelectorCase = function(str) {
+  return String(str).replace(/([A-Z])/g, "-$1").toLowerCase()
+};
+goog.string.toTitleCase = function(str, opt_delimiters) {
+  var delimiters = goog.isString(opt_delimiters) ? goog.string.regExpEscape(opt_delimiters) : "\\s";
+  delimiters = delimiters ? "|[" + delimiters + "]+" : "";
+  var regexp = new RegExp("(^" + delimiters + ")([a-z])", "g");
+  return str.replace(regexp, function(all, p1, p2) {
+    return p1 + p2.toUpperCase()
+  })
+};
+goog.string.parseInt = function(value) {
+  if(isFinite(value)) {
+    value = String(value)
+  }
+  if(goog.isString(value)) {
+    return/^\s*-?0x/i.test(value) ? parseInt(value, 16) : parseInt(value, 10)
+  }
+  return NaN
+};
+goog.provide("goog.debug.Error");
+goog.debug.Error = function(opt_msg) {
+  if(Error.captureStackTrace) {
+    Error.captureStackTrace(this, goog.debug.Error)
+  }else {
+    this.stack = (new Error).stack || ""
+  }
+  if(opt_msg) {
+    this.message = String(opt_msg)
+  }
+};
+goog.inherits(goog.debug.Error, Error);
+goog.debug.Error.prototype.name = "CustomError";
+goog.provide("goog.asserts");
+goog.provide("goog.asserts.AssertionError");
+goog.require("goog.debug.Error");
+goog.require("goog.string");
+goog.asserts.ENABLE_ASSERTS = goog.DEBUG;
+goog.asserts.AssertionError = function(messagePattern, messageArgs) {
+  messageArgs.unshift(messagePattern);
+  goog.debug.Error.call(this, goog.string.subs.apply(null, messageArgs));
+  messageArgs.shift();
+  this.messagePattern = messagePattern
+};
+goog.inherits(goog.asserts.AssertionError, goog.debug.Error);
+goog.asserts.AssertionError.prototype.name = "AssertionError";
+goog.asserts.doAssertFailure_ = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
+  var message = "Assertion failed";
+  if(givenMessage) {
+    message += ": " + givenMessage;
+    var args = givenArgs
+  }else {
+    if(defaultMessage) {
+      message += ": " + defaultMessage;
+      args = defaultArgs
+    }
+  }
+  throw new goog.asserts.AssertionError("" + message, args || []);
+};
+goog.asserts.assert = function(condition, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !condition) {
+    goog.asserts.doAssertFailure_("", null, opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return condition
+};
+goog.asserts.fail = function(opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS) {
+    throw new goog.asserts.AssertionError("Failure" + (opt_message ? ": " + opt_message : ""), Array.prototype.slice.call(arguments, 1));
+  }
+};
+goog.asserts.assertNumber = function(value, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !goog.isNumber(value)) {
+    goog.asserts.doAssertFailure_("Expected number but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return value
+};
+goog.asserts.assertString = function(value, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !goog.isString(value)) {
+    goog.asserts.doAssertFailure_("Expected string but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return value
+};
+goog.asserts.assertFunction = function(value, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !goog.isFunction(value)) {
+    goog.asserts.doAssertFailure_("Expected function but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return value
+};
+goog.asserts.assertObject = function(value, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !goog.isObject(value)) {
+    goog.asserts.doAssertFailure_("Expected object but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return value
+};
+goog.asserts.assertArray = function(value, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !goog.isArray(value)) {
+    goog.asserts.doAssertFailure_("Expected array but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return value
+};
+goog.asserts.assertBoolean = function(value, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !goog.isBoolean(value)) {
+    goog.asserts.doAssertFailure_("Expected boolean but got %s: %s.", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2))
+  }
+  return value
+};
+goog.asserts.assertInstanceof = function(value, type, opt_message, var_args) {
+  if(goog.asserts.ENABLE_ASSERTS && !(value instanceof type)) {
+    goog.asserts.doAssertFailure_("instanceof check failed.", null, opt_message, Array.prototype.slice.call(arguments, 3))
+  }
+  return value
+};
+goog.provide("goog.array");
+goog.provide("goog.array.ArrayLike");
+goog.require("goog.asserts");
+goog.NATIVE_ARRAY_PROTOTYPES = true;
+goog.array.ArrayLike;
+goog.array.peek = function(array) {
+  return array[array.length - 1]
+};
+goog.array.ARRAY_PROTOTYPE_ = Array.prototype;
+goog.array.indexOf = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.indexOf ? function(arr, obj, opt_fromIndex) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.indexOf.call(arr, obj, opt_fromIndex)
+} : function(arr, obj, opt_fromIndex) {
+  var fromIndex = opt_fromIndex == null ? 0 : opt_fromIndex < 0 ? Math.max(0, arr.length + opt_fromIndex) : opt_fromIndex;
+  if(goog.isString(arr)) {
+    if(!goog.isString(obj) || obj.length != 1) {
+      return-1
+    }
+    return arr.indexOf(obj, fromIndex)
+  }
+  for(var i = fromIndex;i < arr.length;i++) {
+    if(i in arr && arr[i] === obj) {
+      return i
+    }
+  }
+  return-1
+};
+goog.array.lastIndexOf = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.lastIndexOf ? function(arr, obj, opt_fromIndex) {
+  goog.asserts.assert(arr.length != null);
+  var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
+  return goog.array.ARRAY_PROTOTYPE_.lastIndexOf.call(arr, obj, fromIndex)
+} : function(arr, obj, opt_fromIndex) {
+  var fromIndex = opt_fromIndex == null ? arr.length - 1 : opt_fromIndex;
+  if(fromIndex < 0) {
+    fromIndex = Math.max(0, arr.length + fromIndex)
+  }
+  if(goog.isString(arr)) {
+    if(!goog.isString(obj) || obj.length != 1) {
+      return-1
+    }
+    return arr.lastIndexOf(obj, fromIndex)
+  }
+  for(var i = fromIndex;i >= 0;i--) {
+    if(i in arr && arr[i] === obj) {
+      return i
+    }
+  }
+  return-1
+};
+goog.array.forEach = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.forEach ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  goog.array.ARRAY_PROTOTYPE_.forEach.call(arr, f, opt_obj)
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = 0;i < l;i++) {
+    if(i in arr2) {
+      f.call(opt_obj, arr2[i], i, arr)
+    }
+  }
+};
+goog.array.forEachRight = function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = l - 1;i >= 0;--i) {
+    if(i in arr2) {
+      f.call(opt_obj, arr2[i], i, arr)
+    }
+  }
+};
+goog.array.filter = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.filter ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.filter.call(arr, f, opt_obj)
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var res = [];
+  var resLength = 0;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = 0;i < l;i++) {
+    if(i in arr2) {
+      var val = arr2[i];
+      if(f.call(opt_obj, val, i, arr)) {
+        res[resLength++] = val
+      }
+    }
+  }
+  return res
+};
+goog.array.map = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.map ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.map.call(arr, f, opt_obj)
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var res = new Array(l);
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = 0;i < l;i++) {
+    if(i in arr2) {
+      res[i] = f.call(opt_obj, arr2[i], i, arr)
+    }
+  }
+  return res
+};
+goog.array.reduce = function(arr, f, val, opt_obj) {
+  if(arr.reduce) {
+    if(opt_obj) {
+      return arr.reduce(goog.bind(f, opt_obj), val)
+    }else {
+      return arr.reduce(f, val)
+    }
+  }
+  var rval = val;
+  goog.array.forEach(arr, function(val, index) {
+    rval = f.call(opt_obj, rval, val, index, arr)
+  });
+  return rval
+};
+goog.array.reduceRight = function(arr, f, val, opt_obj) {
+  if(arr.reduceRight) {
+    if(opt_obj) {
+      return arr.reduceRight(goog.bind(f, opt_obj), val)
+    }else {
+      return arr.reduceRight(f, val)
+    }
+  }
+  var rval = val;
+  goog.array.forEachRight(arr, function(val, index) {
+    rval = f.call(opt_obj, rval, val, index, arr)
+  });
+  return rval
+};
+goog.array.some = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.some ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.some.call(arr, f, opt_obj)
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = 0;i < l;i++) {
+    if(i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+      return true
+    }
+  }
+  return false
+};
+goog.array.every = goog.NATIVE_ARRAY_PROTOTYPES && goog.array.ARRAY_PROTOTYPE_.every ? function(arr, f, opt_obj) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.every.call(arr, f, opt_obj)
+} : function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = 0;i < l;i++) {
+    if(i in arr2 && !f.call(opt_obj, arr2[i], i, arr)) {
+      return false
+    }
+  }
+  return true
+};
+goog.array.find = function(arr, f, opt_obj) {
+  var i = goog.array.findIndex(arr, f, opt_obj);
+  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i]
+};
+goog.array.findIndex = function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = 0;i < l;i++) {
+    if(i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+      return i
+    }
+  }
+  return-1
+};
+goog.array.findRight = function(arr, f, opt_obj) {
+  var i = goog.array.findIndexRight(arr, f, opt_obj);
+  return i < 0 ? null : goog.isString(arr) ? arr.charAt(i) : arr[i]
+};
+goog.array.findIndexRight = function(arr, f, opt_obj) {
+  var l = arr.length;
+  var arr2 = goog.isString(arr) ? arr.split("") : arr;
+  for(var i = l - 1;i >= 0;i--) {
+    if(i in arr2 && f.call(opt_obj, arr2[i], i, arr)) {
+      return i
+    }
+  }
+  return-1
+};
+goog.array.contains = function(arr, obj) {
+  return goog.array.indexOf(arr, obj) >= 0
+};
+goog.array.isEmpty = function(arr) {
+  return arr.length == 0
+};
+goog.array.clear = function(arr) {
+  if(!goog.isArray(arr)) {
+    for(var i = arr.length - 1;i >= 0;i--) {
+      delete arr[i]
+    }
+  }
+  arr.length = 0
+};
+goog.array.insert = function(arr, obj) {
+  if(!goog.array.contains(arr, obj)) {
+    arr.push(obj)
+  }
+};
+goog.array.insertAt = function(arr, obj, opt_i) {
+  goog.array.splice(arr, opt_i, 0, obj)
+};
+goog.array.insertArrayAt = function(arr, elementsToAdd, opt_i) {
+  goog.partial(goog.array.splice, arr, opt_i, 0).apply(null, elementsToAdd)
+};
+goog.array.insertBefore = function(arr, obj, opt_obj2) {
+  var i;
+  if(arguments.length == 2 || (i = goog.array.indexOf(arr, opt_obj2)) < 0) {
+    arr.push(obj)
+  }else {
+    goog.array.insertAt(arr, obj, i)
+  }
+};
+goog.array.remove = function(arr, obj) {
+  var i = goog.array.indexOf(arr, obj);
+  var rv;
+  if(rv = i >= 0) {
+    goog.array.removeAt(arr, i)
+  }
+  return rv
+};
+goog.array.removeAt = function(arr, i) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.splice.call(arr, i, 1).length == 1
+};
+goog.array.removeIf = function(arr, f, opt_obj) {
+  var i = goog.array.findIndex(arr, f, opt_obj);
+  if(i >= 0) {
+    goog.array.removeAt(arr, i);
+    return true
+  }
+  return false
+};
+goog.array.concat = function(var_args) {
+  return goog.array.ARRAY_PROTOTYPE_.concat.apply(goog.array.ARRAY_PROTOTYPE_, arguments)
+};
+goog.array.toArray = function(object) {
+  var length = object.length;
+  if(length > 0) {
+    var rv = new Array(length);
+    for(var i = 0;i < length;i++) {
+      rv[i] = object[i]
+    }
+    return rv
+  }
+  return[]
+};
+goog.array.clone = goog.array.toArray;
+goog.array.extend = function(arr1, var_args) {
+  for(var i = 1;i < arguments.length;i++) {
+    var arr2 = arguments[i];
+    var isArrayLike;
+    if(goog.isArray(arr2) || (isArrayLike = goog.isArrayLike(arr2)) && arr2.hasOwnProperty("callee")) {
+      arr1.push.apply(arr1, arr2)
+    }else {
+      if(isArrayLike) {
+        var len1 = arr1.length;
+        var len2 = arr2.length;
+        for(var j = 0;j < len2;j++) {
+          arr1[len1 + j] = arr2[j]
+        }
+      }else {
+        arr1.push(arr2)
+      }
+    }
+  }
+};
+goog.array.splice = function(arr, index, howMany, var_args) {
+  goog.asserts.assert(arr.length != null);
+  return goog.array.ARRAY_PROTOTYPE_.splice.apply(arr, goog.array.slice(arguments, 1))
+};
+goog.array.slice = function(arr, start, opt_end) {
+  goog.asserts.assert(arr.length != null);
+  if(arguments.length <= 2) {
+    return goog.array.ARRAY_PROTOTYPE_.slice.call(arr, start)
+  }else {
+    return goog.array.ARRAY_PROTOTYPE_.slice.call(arr, start, opt_end)
+  }
+};
+goog.array.removeDuplicates = function(arr, opt_rv) {
+  var returnArray = opt_rv || arr;
+  var seen = {}, cursorInsert = 0, cursorRead = 0;
+  while(cursorRead < arr.length) {
+    var current = arr[cursorRead++];
+    var key = goog.isObject(current) ? "o" + goog.getUid(current) : (typeof current).charAt(0) + current;
+    if(!Object.prototype.hasOwnProperty.call(seen, key)) {
+      seen[key] = true;
+      returnArray[cursorInsert++] = current
+    }
+  }
+  returnArray.length = cursorInsert
+};
+goog.array.binarySearch = function(arr, target, opt_compareFn) {
+  return goog.array.binarySearch_(arr, opt_compareFn || goog.array.defaultCompare, false, target)
+};
+goog.array.binarySelect = function(arr, evaluator, opt_obj) {
+  return goog.array.binarySearch_(arr, evaluator, true, undefined, opt_obj)
+};
+goog.array.binarySearch_ = function(arr, compareFn, isEvaluator, opt_target, opt_selfObj) {
+  var left = 0;
+  var right = arr.length;
+  var found;
+  while(left < right) {
+    var middle = left + right >> 1;
+    var compareResult;
+    if(isEvaluator) {
+      compareResult = compareFn.call(opt_selfObj, arr[middle], middle, arr)
+    }else {
+      compareResult = compareFn(opt_target, arr[middle])
+    }
+    if(compareResult > 0) {
+      left = middle + 1
+    }else {
+      right = middle;
+      found = !compareResult
+    }
+  }
+  return found ? left : ~left
+};
+goog.array.sort = function(arr, opt_compareFn) {
+  goog.asserts.assert(arr.length != null);
+  goog.array.ARRAY_PROTOTYPE_.sort.call(arr, opt_compareFn || goog.array.defaultCompare)
+};
+goog.array.stableSort = function(arr, opt_compareFn) {
+  for(var i = 0;i < arr.length;i++) {
+    arr[i] = {index:i, value:arr[i]}
+  }
+  var valueCompareFn = opt_compareFn || goog.array.defaultCompare;
+  function stableCompareFn(obj1, obj2) {
+    return valueCompareFn(obj1.value, obj2.value) || obj1.index - obj2.index
+  }
+  goog.array.sort(arr, stableCompareFn);
+  for(var i = 0;i < arr.length;i++) {
+    arr[i] = arr[i].value
+  }
+};
+goog.array.sortObjectsByKey = function(arr, key, opt_compareFn) {
+  var compare = opt_compareFn || goog.array.defaultCompare;
+  goog.array.sort(arr, function(a, b) {
+    return compare(a[key], b[key])
+  })
+};
+goog.array.isSorted = function(arr, opt_compareFn, opt_strict) {
+  var compare = opt_compareFn || goog.array.defaultCompare;
+  for(var i = 1;i < arr.length;i++) {
+    var compareResult = compare(arr[i - 1], arr[i]);
+    if(compareResult > 0 || compareResult == 0 && opt_strict) {
+      return false
+    }
+  }
+  return true
+};
+goog.array.equals = function(arr1, arr2, opt_equalsFn) {
+  if(!goog.isArrayLike(arr1) || !goog.isArrayLike(arr2) || arr1.length != arr2.length) {
+    return false
+  }
+  var l = arr1.length;
+  var equalsFn = opt_equalsFn || goog.array.defaultCompareEquality;
+  for(var i = 0;i < l;i++) {
+    if(!equalsFn(arr1[i], arr2[i])) {
+      return false
+    }
+  }
+  return true
+};
+goog.array.compare = function(arr1, arr2, opt_equalsFn) {
+  return goog.array.equals(arr1, arr2, opt_equalsFn)
+};
+goog.array.compare3 = function(arr1, arr2, opt_compareFn) {
+  var compare = opt_compareFn || goog.array.defaultCompare;
+  var l = Math.min(arr1.length, arr2.length);
+  for(var i = 0;i < l;i++) {
+    var result = compare(arr1[i], arr2[i]);
+    if(result != 0) {
+      return result
+    }
+  }
+  return goog.array.defaultCompare(arr1.length, arr2.length)
+};
+goog.array.defaultCompare = function(a, b) {
+  return a > b ? 1 : a < b ? -1 : 0
+};
+goog.array.defaultCompareEquality = function(a, b) {
+  return a === b
+};
+goog.array.binaryInsert = function(array, value, opt_compareFn) {
+  var index = goog.array.binarySearch(array, value, opt_compareFn);
+  if(index < 0) {
+    goog.array.insertAt(array, value, -(index + 1));
+    return true
+  }
+  return false
+};
+goog.array.binaryRemove = function(array, value, opt_compareFn) {
+  var index = goog.array.binarySearch(array, value, opt_compareFn);
+  return index >= 0 ? goog.array.removeAt(array, index) : false
+};
+goog.array.bucket = function(array, sorter) {
+  var buckets = {};
+  for(var i = 0;i < array.length;i++) {
+    var value = array[i];
+    var key = sorter(value, i, array);
+    if(goog.isDef(key)) {
+      var bucket = buckets[key] || (buckets[key] = []);
+      bucket.push(value)
+    }
+  }
+  return buckets
+};
+goog.array.repeat = function(value, n) {
+  var array = [];
+  for(var i = 0;i < n;i++) {
+    array[i] = value
+  }
+  return array
+};
+goog.array.flatten = function(var_args) {
+  var result = [];
+  for(var i = 0;i < arguments.length;i++) {
+    var element = arguments[i];
+    if(goog.isArray(element)) {
+      result.push.apply(result, goog.array.flatten.apply(null, element))
+    }else {
+      result.push(element)
+    }
+  }
+  return result
+};
+goog.array.rotate = function(array, n) {
+  goog.asserts.assert(array.length != null);
+  if(array.length) {
+    n %= array.length;
+    if(n > 0) {
+      goog.array.ARRAY_PROTOTYPE_.unshift.apply(array, array.splice(-n, n))
+    }else {
+      if(n < 0) {
+        goog.array.ARRAY_PROTOTYPE_.push.apply(array, array.splice(0, -n))
+      }
+    }
+  }
+  return array
+};
+goog.array.zip = function(var_args) {
+  if(!arguments.length) {
+    return[]
+  }
+  var result = [];
+  for(var i = 0;true;i++) {
+    var value = [];
+    for(var j = 0;j < arguments.length;j++) {
+      var arr = arguments[j];
+      if(i >= arr.length) {
+        return result
+      }
+      value.push(arr[i])
+    }
+    result.push(value)
+  }
+};
+goog.array.shuffle = function(arr, opt_randFn) {
+  var randFn = opt_randFn || Math.random;
+  for(var i = arr.length - 1;i > 0;i--) {
+    var j = Math.floor(randFn() * (i + 1));
+    var tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp
+  }
+};
+goog.provide("goog.object");
+goog.object.forEach = function(obj, f, opt_obj) {
+  for(var key in obj) {
+    f.call(opt_obj, obj[key], key, obj)
+  }
+};
+goog.object.filter = function(obj, f, opt_obj) {
+  var res = {};
+  for(var key in obj) {
+    if(f.call(opt_obj, obj[key], key, obj)) {
+      res[key] = obj[key]
+    }
+  }
+  return res
+};
+goog.object.map = function(obj, f, opt_obj) {
+  var res = {};
+  for(var key in obj) {
+    res[key] = f.call(opt_obj, obj[key], key, obj)
+  }
+  return res
+};
+goog.object.some = function(obj, f, opt_obj) {
+  for(var key in obj) {
+    if(f.call(opt_obj, obj[key], key, obj)) {
+      return true
+    }
+  }
+  return false
+};
+goog.object.every = function(obj, f, opt_obj) {
+  for(var key in obj) {
+    if(!f.call(opt_obj, obj[key], key, obj)) {
+      return false
+    }
+  }
+  return true
+};
+goog.object.getCount = function(obj) {
+  var rv = 0;
+  for(var key in obj) {
+    rv++
+  }
+  return rv
+};
+goog.object.getAnyKey = function(obj) {
+  for(var key in obj) {
+    return key
+  }
+};
+goog.object.getAnyValue = function(obj) {
+  for(var key in obj) {
+    return obj[key]
+  }
+};
+goog.object.contains = function(obj, val) {
+  return goog.object.containsValue(obj, val)
+};
+goog.object.getValues = function(obj) {
+  var res = [];
+  var i = 0;
+  for(var key in obj) {
+    res[i++] = obj[key]
+  }
+  return res
+};
+goog.object.getKeys = function(obj) {
+  var res = [];
+  var i = 0;
+  for(var key in obj) {
+    res[i++] = key
+  }
+  return res
+};
+goog.object.getValueByKeys = function(obj, var_args) {
+  var isArrayLike = goog.isArrayLike(var_args);
+  var keys = isArrayLike ? var_args : arguments;
+  for(var i = isArrayLike ? 0 : 1;i < keys.length;i++) {
+    obj = obj[keys[i]];
+    if(!goog.isDef(obj)) {
+      break
+    }
+  }
+  return obj
+};
+goog.object.containsKey = function(obj, key) {
+  return key in obj
+};
+goog.object.containsValue = function(obj, val) {
+  for(var key in obj) {
+    if(obj[key] == val) {
+      return true
+    }
+  }
+  return false
+};
+goog.object.findKey = function(obj, f, opt_this) {
+  for(var key in obj) {
+    if(f.call(opt_this, obj[key], key, obj)) {
+      return key
+    }
+  }
+  return undefined
+};
+goog.object.findValue = function(obj, f, opt_this) {
+  var key = goog.object.findKey(obj, f, opt_this);
+  return key && obj[key]
+};
+goog.object.isEmpty = function(obj) {
+  for(var key in obj) {
+    return false
+  }
+  return true
+};
+goog.object.clear = function(obj) {
+  for(var i in obj) {
+    delete obj[i]
+  }
+};
+goog.object.remove = function(obj, key) {
+  var rv;
+  if(rv = key in obj) {
+    delete obj[key]
+  }
+  return rv
+};
+goog.object.add = function(obj, key, val) {
+  if(key in obj) {
+    throw Error('The object already contains the key "' + key + '"');
+  }
+  goog.object.set(obj, key, val)
+};
+goog.object.get = function(obj, key, opt_val) {
+  if(key in obj) {
+    return obj[key]
+  }
+  return opt_val
+};
+goog.object.set = function(obj, key, value) {
+  obj[key] = value
+};
+goog.object.setIfUndefined = function(obj, key, value) {
+  return key in obj ? obj[key] : obj[key] = value
+};
+goog.object.clone = function(obj) {
+  var res = {};
+  for(var key in obj) {
+    res[key] = obj[key]
+  }
+  return res
+};
+goog.object.unsafeClone = function(obj) {
+  var type = goog.typeOf(obj);
+  if(type == "object" || type == "array") {
+    if(obj.clone) {
+      return obj.clone()
+    }
+    var clone = type == "array" ? [] : {};
+    for(var key in obj) {
+      clone[key] = goog.object.unsafeClone(obj[key])
+    }
+    return clone
+  }
+  return obj
+};
+goog.object.transpose = function(obj) {
+  var transposed = {};
+  for(var key in obj) {
+    transposed[obj[key]] = key
+  }
+  return transposed
+};
+goog.object.PROTOTYPE_FIELDS_ = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+goog.object.extend = function(target, var_args) {
+  var key, source;
+  for(var i = 1;i < arguments.length;i++) {
+    source = arguments[i];
+    for(key in source) {
+      target[key] = source[key]
+    }
+    for(var j = 0;j < goog.object.PROTOTYPE_FIELDS_.length;j++) {
+      key = goog.object.PROTOTYPE_FIELDS_[j];
+      if(Object.prototype.hasOwnProperty.call(source, key)) {
+        target[key] = source[key]
+      }
+    }
+  }
+};
+goog.object.create = function(var_args) {
+  var argLength = arguments.length;
+  if(argLength == 1 && goog.isArray(arguments[0])) {
+    return goog.object.create.apply(null, arguments[0])
+  }
+  if(argLength % 2) {
+    throw Error("Uneven number of arguments");
+  }
+  var rv = {};
+  for(var i = 0;i < argLength;i += 2) {
+    rv[arguments[i]] = arguments[i + 1]
+  }
+  return rv
+};
+goog.object.createSet = function(var_args) {
+  var argLength = arguments.length;
+  if(argLength == 1 && goog.isArray(arguments[0])) {
+    return goog.object.createSet.apply(null, arguments[0])
+  }
+  var rv = {};
+  for(var i = 0;i < argLength;i++) {
+    rv[arguments[i]] = true
+  }
+  return rv
+};
+goog.provide("goog.string.format");
+goog.require("goog.string");
+goog.string.format = function(formatString, var_args) {
+  var args = Array.prototype.slice.call(arguments);
+  var template = args.shift();
+  if(typeof template == "undefined") {
+    throw Error("[goog.string.format] Template required");
+  }
+  var formatRe = /%([0\-\ \+]*)(\d+)?(\.(\d+))?([%sfdiu])/g;
+  function replacerDemuxer(match, flags, width, dotp, precision, type, offset, wholeString) {
+    if(type == "%") {
+      return"%"
+    }
+    var value = args.shift();
+    if(typeof value == "undefined") {
+      throw Error("[goog.string.format] Not enough arguments");
+    }
+    arguments[0] = value;
+    return goog.string.format.demuxes_[type].apply(null, arguments)
+  }
+  return template.replace(formatRe, replacerDemuxer)
+};
+goog.string.format.demuxes_ = {};
+goog.string.format.demuxes_["s"] = function(value, flags, width, dotp, precision, type, offset, wholeString) {
+  var replacement = value;
+  if(isNaN(width) || width == "" || replacement.length >= width) {
+    return replacement
+  }
+  if(flags.indexOf("-", 0) > -1) {
+    replacement = replacement + goog.string.repeat(" ", width - replacement.length)
+  }else {
+    replacement = goog.string.repeat(" ", width - replacement.length) + replacement
+  }
+  return replacement
+};
+goog.string.format.demuxes_["f"] = function(value, flags, width, dotp, precision, type, offset, wholeString) {
+  var replacement = value.toString();
+  if(!(isNaN(precision) || precision == "")) {
+    replacement = value.toFixed(precision)
+  }
+  var sign;
+  if(value < 0) {
+    sign = "-"
+  }else {
+    if(flags.indexOf("+") >= 0) {
+      sign = "+"
+    }else {
+      if(flags.indexOf(" ") >= 0) {
+        sign = " "
+      }else {
+        sign = ""
+      }
+    }
+  }
+  if(value >= 0) {
+    replacement = sign + replacement
+  }
+  if(isNaN(width) || replacement.length >= width) {
+    return replacement
+  }
+  replacement = isNaN(precision) ? Math.abs(value).toString() : Math.abs(value).toFixed(precision);
+  var padCount = width - replacement.length - sign.length;
+  if(flags.indexOf("-", 0) >= 0) {
+    replacement = sign + replacement + goog.string.repeat(" ", padCount)
+  }else {
+    var paddingChar = flags.indexOf("0", 0) >= 0 ? "0" : " ";
+    replacement = sign + goog.string.repeat(paddingChar, padCount) + replacement
+  }
+  return replacement
+};
+goog.string.format.demuxes_["d"] = function(value, flags, width, dotp, precision, type, offset, wholeString) {
+  return goog.string.format.demuxes_["f"](parseInt(value, 10), flags, width, dotp, 0, type, offset, wholeString)
+};
+goog.string.format.demuxes_["i"] = goog.string.format.demuxes_["d"];
+goog.string.format.demuxes_["u"] = goog.string.format.demuxes_["d"];
+goog.provide("goog.string.StringBuffer");
+goog.string.StringBuffer = function(opt_a1, var_args) {
+  if(opt_a1 != null) {
+    this.append.apply(this, arguments)
+  }
+};
+goog.string.StringBuffer.prototype.buffer_ = "";
+goog.string.StringBuffer.prototype.set = function(s) {
+  this.buffer_ = "" + s
+};
+goog.string.StringBuffer.prototype.append = function(a1, opt_a2, var_args) {
+  this.buffer_ += a1;
+  if(opt_a2 != null) {
+    for(var i = 1;i < arguments.length;i++) {
+      this.buffer_ += arguments[i]
+    }
+  }
+  return this
+};
+goog.string.StringBuffer.prototype.clear = function() {
+  this.buffer_ = ""
+};
+goog.string.StringBuffer.prototype.getLength = function() {
+  return this.buffer_.length
+};
+goog.string.StringBuffer.prototype.toString = function() {
+  return this.buffer_
+};
+goog.provide("cljs.core");
+goog.require("goog.array");
+goog.require("goog.object");
+goog.require("goog.string.format");
+goog.require("goog.string.StringBuffer");
+goog.require("goog.string");
+cljs.core._STAR_unchecked_if_STAR_ = false;
+cljs.core._STAR_print_fn_STAR_ = function _STAR_print_fn_STAR_(_) {
+  throw new Error("No *print-fn* fn set for evaluation environment");
+};
+cljs.core.set_print_fn_BANG_ = function set_print_fn_BANG_(f) {
+  return cljs.core._STAR_print_fn_STAR_ = f
+};
+goog.exportSymbol("cljs.core.set_print_fn_BANG_", cljs.core.set_print_fn_BANG_);
+cljs.core._STAR_flush_on_newline_STAR_ = true;
+cljs.core._STAR_print_readably_STAR_ = true;
+cljs.core._STAR_print_meta_STAR_ = false;
+cljs.core._STAR_print_dup_STAR_ = false;
+cljs.core.pr_opts = function pr_opts() {
+  return cljs.core.PersistentArrayMap.fromArray(["\ufdd0:flush-on-newline", cljs.core._STAR_flush_on_newline_STAR_, "\ufdd0:readably", cljs.core._STAR_print_readably_STAR_, "\ufdd0:meta", cljs.core._STAR_print_meta_STAR_, "\ufdd0:dup", cljs.core._STAR_print_dup_STAR_], true)
+};
+cljs.core.truth_ = function truth_(x) {
+  return x != null && x !== false
+};
+cljs.core.not_native = null;
+cljs.core.identical_QMARK_ = function identical_QMARK_(x, y) {
+  return x === y
+};
+cljs.core.nil_QMARK_ = function nil_QMARK_(x) {
+  return x == null
+};
+cljs.core.array_QMARK_ = function array_QMARK_(x) {
+  return x instanceof Array
+};
+cljs.core.number_QMARK_ = function number_QMARK_(n) {
+  return typeof n === "number"
+};
+cljs.core.not = function not(x) {
+  if(cljs.core.truth_(x)) {
+    return false
+  }else {
+    return true
+  }
+};
+cljs.core.string_QMARK_ = function string_QMARK_(x) {
+  var and__3941__auto__ = goog.isString(x);
+  if(and__3941__auto__) {
+    return!(x.charAt(0) === "\ufdd0")
+  }else {
+    return and__3941__auto__
+  }
+};
+cljs.core.type_satisfies_ = function type_satisfies_(p, x) {
+  var x__$1 = x == null ? null : x;
+  if(p[goog.typeOf(x__$1)]) {
+    return true
+  }else {
+    if(p["_"]) {
+      return true
+    }else {
+      if("\ufdd0:else") {
+        return false
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.is_proto_ = function is_proto_(x) {
+  return x.constructor.prototype === x
+};
+cljs.core._STAR_main_cli_fn_STAR_ = null;
+cljs.core.type = function type(x) {
+  if(x == null) {
+    return null
+  }else {
+    return x.constructor
+  }
+};
+cljs.core.missing_protocol = function missing_protocol(proto, obj) {
+  var ty = cljs.core.type.call(null, obj);
+  var ty__$1 = cljs.core.truth_(function() {
+    var and__3941__auto__ = ty;
+    if(cljs.core.truth_(and__3941__auto__)) {
+      return ty.cljs$lang$type
+    }else {
+      return and__3941__auto__
+    }
+  }()) ? ty.cljs$lang$ctorStr : goog.typeOf(obj);
+  return new Error(["No protocol method ", proto, " defined for type ", ty__$1, ": ", obj].join(""))
+};
+cljs.core.aclone = function aclone(array_like) {
+  return array_like.slice()
+};
+cljs.core.array = function array(var_args) {
+  return Array.prototype.slice.call(arguments)
+};
+cljs.core.make_array = function() {
+  var make_array = null;
+  var make_array__1 = function(size) {
+    return new Array(size)
+  };
+  var make_array__2 = function(type, size) {
+    return make_array.call(null, size)
+  };
+  make_array = function(type, size) {
+    switch(arguments.length) {
+      case 1:
+        return make_array__1.call(this, type);
+      case 2:
+        return make_array__2.call(this, type, size)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  make_array.cljs$core$IFn$_invoke$arity$1 = make_array__1;
+  make_array.cljs$core$IFn$_invoke$arity$2 = make_array__2;
+  return make_array
+}();
+cljs.core.aget = function() {
+  var aget = null;
+  var aget__2 = function(array, i) {
+    return array[i]
+  };
+  var aget__3 = function() {
+    var G__3451__delegate = function(array, i, idxs) {
+      return cljs.core.apply.call(null, aget, aget.call(null, array, i), idxs)
+    };
+    var G__3451 = function(array, i, var_args) {
+      var idxs = null;
+      if(arguments.length > 2) {
+        idxs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3451__delegate.call(this, array, i, idxs)
+    };
+    G__3451.cljs$lang$maxFixedArity = 2;
+    G__3451.cljs$lang$applyTo = function(arglist__3452) {
+      var array = cljs.core.first(arglist__3452);
+      arglist__3452 = cljs.core.next(arglist__3452);
+      var i = cljs.core.first(arglist__3452);
+      var idxs = cljs.core.rest(arglist__3452);
+      return G__3451__delegate(array, i, idxs)
+    };
+    G__3451.cljs$core$IFn$_invoke$arity$variadic = G__3451__delegate;
+    return G__3451
+  }();
+  aget = function(array, i, var_args) {
+    var idxs = var_args;
+    switch(arguments.length) {
+      case 2:
+        return aget__2.call(this, array, i);
+      default:
+        return aget__3.cljs$core$IFn$_invoke$arity$variadic(array, i, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  aget.cljs$lang$maxFixedArity = 2;
+  aget.cljs$lang$applyTo = aget__3.cljs$lang$applyTo;
+  aget.cljs$core$IFn$_invoke$arity$2 = aget__2;
+  aget.cljs$core$IFn$_invoke$arity$variadic = aget__3.cljs$core$IFn$_invoke$arity$variadic;
+  return aget
+}();
+cljs.core.aset = function aset(array, i, val) {
+  return array[i] = val
+};
+cljs.core.alength = function alength(array) {
+  return array.length
+};
+cljs.core.into_array = function() {
+  var into_array = null;
+  var into_array__1 = function(aseq) {
+    return into_array.call(null, null, aseq)
+  };
+  var into_array__2 = function(type, aseq) {
+    return cljs.core.reduce.call(null, function(a, x) {
+      a.push(x);
+      return a
+    }, [], aseq)
+  };
+  into_array = function(type, aseq) {
+    switch(arguments.length) {
+      case 1:
+        return into_array__1.call(this, type);
+      case 2:
+        return into_array__2.call(this, type, aseq)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  into_array.cljs$core$IFn$_invoke$arity$1 = into_array__1;
+  into_array.cljs$core$IFn$_invoke$arity$2 = into_array__2;
+  return into_array
+}();
+cljs.core.Fn = {};
+cljs.core.IFn = {};
+cljs.core._invoke = function() {
+  var _invoke = null;
+  var _invoke__1 = function(this$) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$1
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$1(this$)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$)
+    }
+  };
+  var _invoke__2 = function(this$, a) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$2
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$2(this$, a)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a)
+    }
+  };
+  var _invoke__3 = function(this$, a, b) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$3
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$3(this$, a, b)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b)
+    }
+  };
+  var _invoke__4 = function(this$, a, b, c) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$4
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$4(this$, a, b, c)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c)
+    }
+  };
+  var _invoke__5 = function(this$, a, b, c, d) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$5
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d)
+    }
+  };
+  var _invoke__6 = function(this$, a, b, c, d, e) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$6
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$6(this$, a, b, c, d, e)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e)
+    }
+  };
+  var _invoke__7 = function(this$, a, b, c, d, e, f) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$7
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$7(this$, a, b, c, d, e, f)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f)
+    }
+  };
+  var _invoke__8 = function(this$, a, b, c, d, e, f, g) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$8
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$8(this$, a, b, c, d, e, f, g)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g)
+    }
+  };
+  var _invoke__9 = function(this$, a, b, c, d, e, f, g, h) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$9
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$9(this$, a, b, c, d, e, f, g, h)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h)
+    }
+  };
+  var _invoke__10 = function(this$, a, b, c, d, e, f, g, h, i) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$10
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$10(this$, a, b, c, d, e, f, g, h, i)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i)
+    }
+  };
+  var _invoke__11 = function(this$, a, b, c, d, e, f, g, h, i, j) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$11
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$11(this$, a, b, c, d, e, f, g, h, i, j)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j)
+    }
+  };
+  var _invoke__12 = function(this$, a, b, c, d, e, f, g, h, i, j, k) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$12
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$12(this$, a, b, c, d, e, f, g, h, i, j, k)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k)
+    }
+  };
+  var _invoke__13 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$13
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$13(this$, a, b, c, d, e, f, g, h, i, j, k, l)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l)
+    }
+  };
+  var _invoke__14 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$14
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$14(this$, a, b, c, d, e, f, g, h, i, j, k, l, m)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m)
+    }
+  };
+  var _invoke__15 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$15
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$15(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+    }
+  };
+  var _invoke__16 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$16
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$16(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
+    }
+  };
+  var _invoke__17 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$17
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$17(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
+    }
+  };
+  var _invoke__18 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$18
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$18(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
+    }
+  };
+  var _invoke__19 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$19
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$19(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s)
+    }
+  };
+  var _invoke__20 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$20
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$20(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t)
+    }
+  };
+  var _invoke__21 = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t, rest) {
+    if(function() {
+      var and__3941__auto__ = this$;
+      if(and__3941__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$21
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$21(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t, rest)
+    }else {
+      var x__2942__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3943__auto__ = cljs.core._invoke[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._invoke["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IFn.-invoke", this$);
+          }
+        }
+      }().call(null, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t, rest)
+    }
+  };
+  _invoke = function(this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t, rest) {
+    switch(arguments.length) {
+      case 1:
+        return _invoke__1.call(this, this$);
+      case 2:
+        return _invoke__2.call(this, this$, a);
+      case 3:
+        return _invoke__3.call(this, this$, a, b);
+      case 4:
+        return _invoke__4.call(this, this$, a, b, c);
+      case 5:
+        return _invoke__5.call(this, this$, a, b, c, d);
+      case 6:
+        return _invoke__6.call(this, this$, a, b, c, d, e);
+      case 7:
+        return _invoke__7.call(this, this$, a, b, c, d, e, f);
+      case 8:
+        return _invoke__8.call(this, this$, a, b, c, d, e, f, g);
+      case 9:
+        return _invoke__9.call(this, this$, a, b, c, d, e, f, g, h);
+      case 10:
+        return _invoke__10.call(this, this$, a, b, c, d, e, f, g, h, i);
+      case 11:
+        return _invoke__11.call(this, this$, a, b, c, d, e, f, g, h, i, j);
+      case 12:
+        return _invoke__12.call(this, this$, a, b, c, d, e, f, g, h, i, j, k);
+      case 13:
+        return _invoke__13.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l);
+      case 14:
+        return _invoke__14.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m);
+      case 15:
+        return _invoke__15.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n);
+      case 16:
+        return _invoke__16.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
+      case 17:
+        return _invoke__17.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p);
+      case 18:
+        return _invoke__18.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q);
+      case 19:
+        return _invoke__19.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s);
+      case 20:
+        return _invoke__20.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t);
+      case 21:
+        return _invoke__21.call(this, this$, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, s, t, rest)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _invoke.cljs$core$IFn$_invoke$arity$1 = _invoke__1;
+  _invoke.cljs$core$IFn$_invoke$arity$2 = _invoke__2;
+  _invoke.cljs$core$IFn$_invoke$arity$3 = _invoke__3;
+  _invoke.cljs$core$IFn$_invoke$arity$4 = _invoke__4;
+  _invoke.cljs$core$IFn$_invoke$arity$5 = _invoke__5;
+  _invoke.cljs$core$IFn$_invoke$arity$6 = _invoke__6;
+  _invoke.cljs$core$IFn$_invoke$arity$7 = _invoke__7;
+  _invoke.cljs$core$IFn$_invoke$arity$8 = _invoke__8;
+  _invoke.cljs$core$IFn$_invoke$arity$9 = _invoke__9;
+  _invoke.cljs$core$IFn$_invoke$arity$10 = _invoke__10;
+  _invoke.cljs$core$IFn$_invoke$arity$11 = _invoke__11;
+  _invoke.cljs$core$IFn$_invoke$arity$12 = _invoke__12;
+  _invoke.cljs$core$IFn$_invoke$arity$13 = _invoke__13;
+  _invoke.cljs$core$IFn$_invoke$arity$14 = _invoke__14;
+  _invoke.cljs$core$IFn$_invoke$arity$15 = _invoke__15;
+  _invoke.cljs$core$IFn$_invoke$arity$16 = _invoke__16;
+  _invoke.cljs$core$IFn$_invoke$arity$17 = _invoke__17;
+  _invoke.cljs$core$IFn$_invoke$arity$18 = _invoke__18;
+  _invoke.cljs$core$IFn$_invoke$arity$19 = _invoke__19;
+  _invoke.cljs$core$IFn$_invoke$arity$20 = _invoke__20;
+  _invoke.cljs$core$IFn$_invoke$arity$21 = _invoke__21;
+  return _invoke
+}();
+cljs.core.ICounted = {};
+cljs.core._count = function _count(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ICounted$_count$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ICounted$_count$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._count[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._count["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ICounted.-count", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.IEmptyableCollection = {};
+cljs.core._empty = function _empty(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IEmptyableCollection$_empty$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._empty[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._empty["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IEmptyableCollection.-empty", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.ICollection = {};
+cljs.core._conj = function _conj(coll, o) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ICollection$_conj$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ICollection$_conj$arity$2(coll, o)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._conj[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._conj["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ICollection.-conj", coll);
+        }
+      }
+    }().call(null, coll, o)
+  }
+};
+cljs.core.IIndexed = {};
+cljs.core._nth = function() {
+  var _nth = null;
+  var _nth__2 = function(coll, n) {
+    if(function() {
+      var and__3941__auto__ = coll;
+      if(and__3941__auto__) {
+        return coll.cljs$core$IIndexed$_nth$arity$2
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return coll.cljs$core$IIndexed$_nth$arity$2(coll, n)
+    }else {
+      var x__2942__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3943__auto__ = cljs.core._nth[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._nth["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IIndexed.-nth", coll);
+          }
+        }
+      }().call(null, coll, n)
+    }
+  };
+  var _nth__3 = function(coll, n, not_found) {
+    if(function() {
+      var and__3941__auto__ = coll;
+      if(and__3941__auto__) {
+        return coll.cljs$core$IIndexed$_nth$arity$3
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return coll.cljs$core$IIndexed$_nth$arity$3(coll, n, not_found)
+    }else {
+      var x__2942__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3943__auto__ = cljs.core._nth[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._nth["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IIndexed.-nth", coll);
+          }
+        }
+      }().call(null, coll, n, not_found)
+    }
+  };
+  _nth = function(coll, n, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return _nth__2.call(this, coll, n);
+      case 3:
+        return _nth__3.call(this, coll, n, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _nth.cljs$core$IFn$_invoke$arity$2 = _nth__2;
+  _nth.cljs$core$IFn$_invoke$arity$3 = _nth__3;
+  return _nth
+}();
+cljs.core.ASeq = {};
+cljs.core.ISeq = {};
+cljs.core._first = function _first(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISeq$_first$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISeq$_first$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._first[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._first["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISeq.-first", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core._rest = function _rest(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISeq$_rest$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISeq$_rest$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._rest[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._rest["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISeq.-rest", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.INext = {};
+cljs.core._next = function _next(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$INext$_next$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$INext$_next$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._next[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._next["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "INext.-next", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.ILookup = {};
+cljs.core._lookup = function() {
+  var _lookup = null;
+  var _lookup__2 = function(o, k) {
+    if(function() {
+      var and__3941__auto__ = o;
+      if(and__3941__auto__) {
+        return o.cljs$core$ILookup$_lookup$arity$2
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return o.cljs$core$ILookup$_lookup$arity$2(o, k)
+    }else {
+      var x__2942__auto__ = o == null ? null : o;
+      return function() {
+        var or__3943__auto__ = cljs.core._lookup[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._lookup["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "ILookup.-lookup", o);
+          }
+        }
+      }().call(null, o, k)
+    }
+  };
+  var _lookup__3 = function(o, k, not_found) {
+    if(function() {
+      var and__3941__auto__ = o;
+      if(and__3941__auto__) {
+        return o.cljs$core$ILookup$_lookup$arity$3
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return o.cljs$core$ILookup$_lookup$arity$3(o, k, not_found)
+    }else {
+      var x__2942__auto__ = o == null ? null : o;
+      return function() {
+        var or__3943__auto__ = cljs.core._lookup[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._lookup["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "ILookup.-lookup", o);
+          }
+        }
+      }().call(null, o, k, not_found)
+    }
+  };
+  _lookup = function(o, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return _lookup__2.call(this, o, k);
+      case 3:
+        return _lookup__3.call(this, o, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _lookup.cljs$core$IFn$_invoke$arity$2 = _lookup__2;
+  _lookup.cljs$core$IFn$_invoke$arity$3 = _lookup__3;
+  return _lookup
+}();
+cljs.core.IAssociative = {};
+cljs.core._contains_key_QMARK_ = function _contains_key_QMARK_(coll, k) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll, k)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._contains_key_QMARK_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._contains_key_QMARK_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IAssociative.-contains-key?", coll);
+        }
+      }
+    }().call(null, coll, k)
+  }
+};
+cljs.core._assoc = function _assoc(coll, k, v) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IAssociative$_assoc$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, k, v)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._assoc[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._assoc["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IAssociative.-assoc", coll);
+        }
+      }
+    }().call(null, coll, k, v)
+  }
+};
+cljs.core.IMap = {};
+cljs.core._dissoc = function _dissoc(coll, k) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IMap$_dissoc$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IMap$_dissoc$arity$2(coll, k)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._dissoc[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._dissoc["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMap.-dissoc", coll);
+        }
+      }
+    }().call(null, coll, k)
+  }
+};
+cljs.core.IMapEntry = {};
+cljs.core._key = function _key(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IMapEntry$_key$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IMapEntry$_key$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._key[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._key["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMapEntry.-key", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core._val = function _val(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IMapEntry$_val$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IMapEntry$_val$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._val[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._val["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMapEntry.-val", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.ISet = {};
+cljs.core._disjoin = function _disjoin(coll, v) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISet$_disjoin$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISet$_disjoin$arity$2(coll, v)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._disjoin[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._disjoin["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISet.-disjoin", coll);
+        }
+      }
+    }().call(null, coll, v)
+  }
+};
+cljs.core.IStack = {};
+cljs.core._peek = function _peek(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IStack$_peek$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IStack$_peek$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._peek[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._peek["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IStack.-peek", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core._pop = function _pop(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IStack$_pop$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IStack$_pop$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._pop[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._pop["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IStack.-pop", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.IVector = {};
+cljs.core._assoc_n = function _assoc_n(coll, n, val) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IVector$_assoc_n$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IVector$_assoc_n$arity$3(coll, n, val)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._assoc_n[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._assoc_n["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IVector.-assoc-n", coll);
+        }
+      }
+    }().call(null, coll, n, val)
+  }
+};
+cljs.core.IDeref = {};
+cljs.core._deref = function _deref(o) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IDeref$_deref$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IDeref$_deref$arity$1(o)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._deref[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._deref["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IDeref.-deref", o);
+        }
+      }
+    }().call(null, o)
+  }
+};
+cljs.core.IDerefWithTimeout = {};
+cljs.core._deref_with_timeout = function _deref_with_timeout(o, msec, timeout_val) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o, msec, timeout_val)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._deref_with_timeout[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._deref_with_timeout["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IDerefWithTimeout.-deref-with-timeout", o);
+        }
+      }
+    }().call(null, o, msec, timeout_val)
+  }
+};
+cljs.core.IMeta = {};
+cljs.core._meta = function _meta(o) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IMeta$_meta$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IMeta$_meta$arity$1(o)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._meta[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._meta["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMeta.-meta", o);
+        }
+      }
+    }().call(null, o)
+  }
+};
+cljs.core.IWithMeta = {};
+cljs.core._with_meta = function _with_meta(o, meta) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IWithMeta$_with_meta$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IWithMeta$_with_meta$arity$2(o, meta)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._with_meta[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._with_meta["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IWithMeta.-with-meta", o);
+        }
+      }
+    }().call(null, o, meta)
+  }
+};
+cljs.core.IReduce = {};
+cljs.core._reduce = function() {
+  var _reduce = null;
+  var _reduce__2 = function(coll, f) {
+    if(function() {
+      var and__3941__auto__ = coll;
+      if(and__3941__auto__) {
+        return coll.cljs$core$IReduce$_reduce$arity$2
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return coll.cljs$core$IReduce$_reduce$arity$2(coll, f)
+    }else {
+      var x__2942__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3943__auto__ = cljs.core._reduce[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._reduce["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IReduce.-reduce", coll);
+          }
+        }
+      }().call(null, coll, f)
+    }
+  };
+  var _reduce__3 = function(coll, f, start) {
+    if(function() {
+      var and__3941__auto__ = coll;
+      if(and__3941__auto__) {
+        return coll.cljs$core$IReduce$_reduce$arity$3
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return coll.cljs$core$IReduce$_reduce$arity$3(coll, f, start)
+    }else {
+      var x__2942__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3943__auto__ = cljs.core._reduce[goog.typeOf(x__2942__auto__)];
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = cljs.core._reduce["_"];
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            throw cljs.core.missing_protocol.call(null, "IReduce.-reduce", coll);
+          }
+        }
+      }().call(null, coll, f, start)
+    }
+  };
+  _reduce = function(coll, f, start) {
+    switch(arguments.length) {
+      case 2:
+        return _reduce__2.call(this, coll, f);
+      case 3:
+        return _reduce__3.call(this, coll, f, start)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _reduce.cljs$core$IFn$_invoke$arity$2 = _reduce__2;
+  _reduce.cljs$core$IFn$_invoke$arity$3 = _reduce__3;
+  return _reduce
+}();
+cljs.core.IKVReduce = {};
+cljs.core._kv_reduce = function _kv_reduce(coll, f, init) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IKVReduce$_kv_reduce$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll, f, init)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._kv_reduce[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._kv_reduce["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IKVReduce.-kv-reduce", coll);
+        }
+      }
+    }().call(null, coll, f, init)
+  }
+};
+cljs.core.IEquiv = {};
+cljs.core._equiv = function _equiv(o, other) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IEquiv$_equiv$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IEquiv$_equiv$arity$2(o, other)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._equiv[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._equiv["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IEquiv.-equiv", o);
+        }
+      }
+    }().call(null, o, other)
+  }
+};
+cljs.core.IHash = {};
+cljs.core._hash = function _hash(o) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IHash$_hash$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IHash$_hash$arity$1(o)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._hash[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._hash["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IHash.-hash", o);
+        }
+      }
+    }().call(null, o)
+  }
+};
+cljs.core.ISeqable = {};
+cljs.core._seq = function _seq(o) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$ISeqable$_seq$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$ISeqable$_seq$arity$1(o)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._seq[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._seq["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISeqable.-seq", o);
+        }
+      }
+    }().call(null, o)
+  }
+};
+cljs.core.ISequential = {};
+cljs.core.IList = {};
+cljs.core.IRecord = {};
+cljs.core.IReversible = {};
+cljs.core._rseq = function _rseq(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IReversible$_rseq$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IReversible$_rseq$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._rseq[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._rseq["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IReversible.-rseq", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.ISorted = {};
+cljs.core._sorted_seq = function _sorted_seq(coll, ascending_QMARK_) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISorted$_sorted_seq$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll, ascending_QMARK_)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._sorted_seq[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._sorted_seq["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISorted.-sorted-seq", coll);
+        }
+      }
+    }().call(null, coll, ascending_QMARK_)
+  }
+};
+cljs.core._sorted_seq_from = function _sorted_seq_from(coll, k, ascending_QMARK_) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISorted$_sorted_seq_from$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll, k, ascending_QMARK_)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._sorted_seq_from[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._sorted_seq_from["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISorted.-sorted-seq-from", coll);
+        }
+      }
+    }().call(null, coll, k, ascending_QMARK_)
+  }
+};
+cljs.core._entry_key = function _entry_key(coll, entry) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISorted$_entry_key$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_entry_key$arity$2(coll, entry)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._entry_key[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._entry_key["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISorted.-entry-key", coll);
+        }
+      }
+    }().call(null, coll, entry)
+  }
+};
+cljs.core._comparator = function _comparator(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$ISorted$_comparator$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_comparator$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._comparator[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._comparator["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ISorted.-comparator", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.IWriter = {};
+cljs.core._write = function _write(writer, s) {
+  if(function() {
+    var and__3941__auto__ = writer;
+    if(and__3941__auto__) {
+      return writer.cljs$core$IWriter$_write$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return writer.cljs$core$IWriter$_write$arity$2(writer, s)
+  }else {
+    var x__2942__auto__ = writer == null ? null : writer;
+    return function() {
+      var or__3943__auto__ = cljs.core._write[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._write["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IWriter.-write", writer);
+        }
+      }
+    }().call(null, writer, s)
+  }
+};
+cljs.core._flush = function _flush(writer) {
+  if(function() {
+    var and__3941__auto__ = writer;
+    if(and__3941__auto__) {
+      return writer.cljs$core$IWriter$_flush$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return writer.cljs$core$IWriter$_flush$arity$1(writer)
+  }else {
+    var x__2942__auto__ = writer == null ? null : writer;
+    return function() {
+      var or__3943__auto__ = cljs.core._flush[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._flush["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IWriter.-flush", writer);
+        }
+      }
+    }().call(null, writer)
+  }
+};
+cljs.core.IPrintWithWriter = {};
+cljs.core._pr_writer = function _pr_writer(o, writer, opts) {
+  if(function() {
+    var and__3941__auto__ = o;
+    if(and__3941__auto__) {
+      return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o, writer, opts)
+  }else {
+    var x__2942__auto__ = o == null ? null : o;
+    return function() {
+      var or__3943__auto__ = cljs.core._pr_writer[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._pr_writer["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IPrintWithWriter.-pr-writer", o);
+        }
+      }
+    }().call(null, o, writer, opts)
+  }
+};
+cljs.core.IPending = {};
+cljs.core._realized_QMARK_ = function _realized_QMARK_(d) {
+  if(function() {
+    var and__3941__auto__ = d;
+    if(and__3941__auto__) {
+      return d.cljs$core$IPending$_realized_QMARK_$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return d.cljs$core$IPending$_realized_QMARK_$arity$1(d)
+  }else {
+    var x__2942__auto__ = d == null ? null : d;
+    return function() {
+      var or__3943__auto__ = cljs.core._realized_QMARK_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._realized_QMARK_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IPending.-realized?", d);
+        }
+      }
+    }().call(null, d)
+  }
+};
+cljs.core.IWatchable = {};
+cljs.core._notify_watches = function _notify_watches(this$, oldval, newval) {
+  if(function() {
+    var and__3941__auto__ = this$;
+    if(and__3941__auto__) {
+      return this$.cljs$core$IWatchable$_notify_watches$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$, oldval, newval)
+  }else {
+    var x__2942__auto__ = this$ == null ? null : this$;
+    return function() {
+      var or__3943__auto__ = cljs.core._notify_watches[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._notify_watches["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IWatchable.-notify-watches", this$);
+        }
+      }
+    }().call(null, this$, oldval, newval)
+  }
+};
+cljs.core._add_watch = function _add_watch(this$, key, f) {
+  if(function() {
+    var and__3941__auto__ = this$;
+    if(and__3941__auto__) {
+      return this$.cljs$core$IWatchable$_add_watch$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return this$.cljs$core$IWatchable$_add_watch$arity$3(this$, key, f)
+  }else {
+    var x__2942__auto__ = this$ == null ? null : this$;
+    return function() {
+      var or__3943__auto__ = cljs.core._add_watch[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._add_watch["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IWatchable.-add-watch", this$);
+        }
+      }
+    }().call(null, this$, key, f)
+  }
+};
+cljs.core._remove_watch = function _remove_watch(this$, key) {
+  if(function() {
+    var and__3941__auto__ = this$;
+    if(and__3941__auto__) {
+      return this$.cljs$core$IWatchable$_remove_watch$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$, key)
+  }else {
+    var x__2942__auto__ = this$ == null ? null : this$;
+    return function() {
+      var or__3943__auto__ = cljs.core._remove_watch[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._remove_watch["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IWatchable.-remove-watch", this$);
+        }
+      }
+    }().call(null, this$, key)
+  }
+};
+cljs.core.IEditableCollection = {};
+cljs.core._as_transient = function _as_transient(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IEditableCollection$_as_transient$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._as_transient[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._as_transient["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IEditableCollection.-as-transient", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.ITransientCollection = {};
+cljs.core._conj_BANG_ = function _conj_BANG_(tcoll, val) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll, val)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._conj_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._conj_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientCollection.-conj!", tcoll);
+        }
+      }
+    }().call(null, tcoll, val)
+  }
+};
+cljs.core._persistent_BANG_ = function _persistent_BANG_(tcoll) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._persistent_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._persistent_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientCollection.-persistent!", tcoll);
+        }
+      }
+    }().call(null, tcoll)
+  }
+};
+cljs.core.ITransientAssociative = {};
+cljs.core._assoc_BANG_ = function _assoc_BANG_(tcoll, key, val) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll, key, val)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._assoc_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._assoc_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientAssociative.-assoc!", tcoll);
+        }
+      }
+    }().call(null, tcoll, key, val)
+  }
+};
+cljs.core.ITransientMap = {};
+cljs.core._dissoc_BANG_ = function _dissoc_BANG_(tcoll, key) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll, key)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._dissoc_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._dissoc_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientMap.-dissoc!", tcoll);
+        }
+      }
+    }().call(null, tcoll, key)
+  }
+};
+cljs.core.ITransientVector = {};
+cljs.core._assoc_n_BANG_ = function _assoc_n_BANG_(tcoll, n, val) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll, n, val)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._assoc_n_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._assoc_n_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientVector.-assoc-n!", tcoll);
+        }
+      }
+    }().call(null, tcoll, n, val)
+  }
+};
+cljs.core._pop_BANG_ = function _pop_BANG_(tcoll) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._pop_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._pop_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientVector.-pop!", tcoll);
+        }
+      }
+    }().call(null, tcoll)
+  }
+};
+cljs.core.ITransientSet = {};
+cljs.core._disjoin_BANG_ = function _disjoin_BANG_(tcoll, v) {
+  if(function() {
+    var and__3941__auto__ = tcoll;
+    if(and__3941__auto__) {
+      return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll, v)
+  }else {
+    var x__2942__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3943__auto__ = cljs.core._disjoin_BANG_[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._disjoin_BANG_["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "ITransientSet.-disjoin!", tcoll);
+        }
+      }
+    }().call(null, tcoll, v)
+  }
+};
+cljs.core.IComparable = {};
+cljs.core._compare = function _compare(x, y) {
+  if(function() {
+    var and__3941__auto__ = x;
+    if(and__3941__auto__) {
+      return x.cljs$core$IComparable$_compare$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return x.cljs$core$IComparable$_compare$arity$2(x, y)
+  }else {
+    var x__2942__auto__ = x == null ? null : x;
+    return function() {
+      var or__3943__auto__ = cljs.core._compare[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._compare["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IComparable.-compare", x);
+        }
+      }
+    }().call(null, x, y)
+  }
+};
+cljs.core.IChunk = {};
+cljs.core._drop_first = function _drop_first(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IChunk$_drop_first$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IChunk$_drop_first$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._drop_first[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._drop_first["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IChunk.-drop-first", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.IChunkedSeq = {};
+cljs.core._chunked_first = function _chunked_first(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._chunked_first[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._chunked_first["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IChunkedSeq.-chunked-first", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core._chunked_rest = function _chunked_rest(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._chunked_rest[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._chunked_rest["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IChunkedSeq.-chunked-rest", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.IChunkedNext = {};
+cljs.core._chunked_next = function _chunked_next(coll) {
+  if(function() {
+    var and__3941__auto__ = coll;
+    if(and__3941__auto__) {
+      return coll.cljs$core$IChunkedNext$_chunked_next$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll)
+  }else {
+    var x__2942__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3943__auto__ = cljs.core._chunked_next[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._chunked_next["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IChunkedNext.-chunked-next", coll);
+        }
+      }
+    }().call(null, coll)
+  }
+};
+cljs.core.INamed = {};
+cljs.core._name = function _name(x) {
+  if(function() {
+    var and__3941__auto__ = x;
+    if(and__3941__auto__) {
+      return x.cljs$core$INamed$_name$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return x.cljs$core$INamed$_name$arity$1(x)
+  }else {
+    var x__2942__auto__ = x == null ? null : x;
+    return function() {
+      var or__3943__auto__ = cljs.core._name[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._name["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "INamed.-name", x);
+        }
+      }
+    }().call(null, x)
+  }
+};
+cljs.core._namespace = function _namespace(x) {
+  if(function() {
+    var and__3941__auto__ = x;
+    if(and__3941__auto__) {
+      return x.cljs$core$INamed$_namespace$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return x.cljs$core$INamed$_namespace$arity$1(x)
+  }else {
+    var x__2942__auto__ = x == null ? null : x;
+    return function() {
+      var or__3943__auto__ = cljs.core._namespace[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._namespace["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "INamed.-namespace", x);
+        }
+      }
+    }().call(null, x)
+  }
+};
+goog.provide("cljs.core.StringBufferWriter");
+cljs.core.StringBufferWriter = function(sb) {
+  this.sb = sb;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 1073741824
+};
+cljs.core.StringBufferWriter.cljs$lang$type = true;
+cljs.core.StringBufferWriter.cljs$lang$ctorStr = "cljs.core/StringBufferWriter";
+cljs.core.StringBufferWriter.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/StringBufferWriter")
+};
+cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_write$arity$2 = function(_, s) {
+  var self__ = this;
+  return self__.sb.append(s)
+};
+cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_flush$arity$1 = function(_) {
+  var self__ = this;
+  return null
+};
+cljs.core.pr_str_STAR_ = function pr_str_STAR_(obj) {
+  var sb = new goog.string.StringBuffer;
+  var writer = new cljs.core.StringBufferWriter(sb);
+  cljs.core._pr_writer.call(null, obj, writer, cljs.core.pr_opts.call(null));
+  cljs.core._flush.call(null, writer);
+  return[cljs.core.str(sb)].join("")
+};
+cljs.core.instance_QMARK_ = function instance_QMARK_(t, o) {
+  return o instanceof t
+};
+cljs.core.symbol_QMARK_ = function symbol_QMARK_(x) {
+  return x instanceof cljs.core.Symbol
+};
+goog.provide("cljs.core.Symbol");
+cljs.core.Symbol = function(ns, name, str, _hash, _meta) {
+  this.ns = ns;
+  this.name = name;
+  this.str = str;
+  this._hash = _hash;
+  this._meta = _meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 2154168321
+};
+cljs.core.Symbol.cljs$lang$type = true;
+cljs.core.Symbol.cljs$lang$ctorStr = "cljs.core/Symbol";
+cljs.core.Symbol.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Symbol")
+};
+cljs.core.Symbol.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(o, writer, _) {
+  var self__ = this;
+  return cljs.core._write.call(null, writer, self__.str)
+};
+cljs.core.Symbol.prototype.cljs$core$INamed$ = true;
+cljs.core.Symbol.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
+  var self__ = this;
+  return self__.name
+};
+cljs.core.Symbol.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
+  var self__ = this;
+  return self__.ns
+};
+cljs.core.Symbol.prototype.cljs$core$IHash$_hash$arity$1 = function(_) {
+  var self__ = this;
+  if(self__._hash === -1) {
+    self__._hash = cljs.core.hash_combine.call(null, cljs.core.hash.call(null, self__.ns), cljs.core.hash.call(null, self__.name));
+    return self__._hash
+  }else {
+    return self__._hash
+  }
+};
+cljs.core.Symbol.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_, new_meta) {
+  var self__ = this;
+  return new cljs.core.Symbol(self__.ns, self__.name, self__.str, self__._hash, new_meta)
+};
+cljs.core.Symbol.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
+  var self__ = this;
+  return self__._meta
+};
+cljs.core.Symbol.prototype.call = function() {
+  var G__3454 = null;
+  var G__3454__2 = function(self__, coll) {
+    var self__ = this;
+    var self____$1 = this;
+    var sym = self____$1;
+    return cljs.core._lookup.call(null, coll, sym, null)
+  };
+  var G__3454__3 = function(self__, coll, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var sym = self____$1;
+    return cljs.core._lookup.call(null, coll, sym, not_found)
+  };
+  G__3454 = function(self__, coll, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3454__2.call(this, self__, coll);
+      case 3:
+        return G__3454__3.call(this, self__, coll, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3454
+}();
+cljs.core.Symbol.prototype.apply = function(self__, args3453) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3453.slice()))
+};
+cljs.core.Symbol.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(_, other) {
+  var self__ = this;
+  if(other instanceof cljs.core.Symbol) {
+    return self__.str === other.str
+  }else {
+    return false
+  }
+};
+cljs.core.Symbol.prototype.toString = function() {
+  var self__ = this;
+  var _ = this;
+  return self__.str
+};
+cljs.core.symbol = function() {
+  var symbol = null;
+  var symbol__1 = function(name) {
+    if(name instanceof cljs.core.Symbol) {
+      return name
+    }else {
+      return symbol.call(null, null, name)
+    }
+  };
+  var symbol__2 = function(ns, name) {
+    var sym_str = !(ns == null) ? [cljs.core.str(ns), cljs.core.str("/"), cljs.core.str(name)].join("") : name;
+    return new cljs.core.Symbol(ns, name, sym_str, -1, null)
+  };
+  symbol = function(ns, name) {
+    switch(arguments.length) {
+      case 1:
+        return symbol__1.call(this, ns);
+      case 2:
+        return symbol__2.call(this, ns, name)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  symbol.cljs$core$IFn$_invoke$arity$1 = symbol__1;
+  symbol.cljs$core$IFn$_invoke$arity$2 = symbol__2;
+  return symbol
+}();
+cljs.core.seq = function seq(coll) {
+  if(coll == null) {
+    return null
+  }else {
+    if(function() {
+      var G__3456 = coll;
+      if(G__3456) {
+        if(function() {
+          var or__3943__auto__ = G__3456.cljs$lang$protocol_mask$partition0$ & 8388608;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3456.cljs$core$ISeqable$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core._seq.call(null, coll)
+    }else {
+      if(coll instanceof Array) {
+        if(coll.length === 0) {
+          return null
+        }else {
+          return new cljs.core.IndexedSeq(coll, 0)
+        }
+      }else {
+        if(cljs.core.string_QMARK_.call(null, coll)) {
+          if(coll.length === 0) {
+            return null
+          }else {
+            return new cljs.core.IndexedSeq(coll, 0)
+          }
+        }else {
+          if(cljs.core.type_satisfies_.call(null, cljs.core.ILookup, coll)) {
+            return cljs.core._seq.call(null, coll)
+          }else {
+            if("\ufdd0:else") {
+              throw new Error([cljs.core.str(coll), cljs.core.str("is not ISeqable")].join(""));
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.first = function first(coll) {
+  if(coll == null) {
+    return null
+  }else {
+    if(function() {
+      var G__3458 = coll;
+      if(G__3458) {
+        if(function() {
+          var or__3943__auto__ = G__3458.cljs$lang$protocol_mask$partition0$ & 64;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3458.cljs$core$ISeq$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core._first.call(null, coll)
+    }else {
+      var s = cljs.core.seq.call(null, coll);
+      if(s == null) {
+        return null
+      }else {
+        return cljs.core._first.call(null, s)
+      }
+    }
+  }
+};
+cljs.core.rest = function rest(coll) {
+  if(!(coll == null)) {
+    if(function() {
+      var G__3460 = coll;
+      if(G__3460) {
+        if(function() {
+          var or__3943__auto__ = G__3460.cljs$lang$protocol_mask$partition0$ & 64;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3460.cljs$core$ISeq$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core._rest.call(null, coll)
+    }else {
+      var s = cljs.core.seq.call(null, coll);
+      if(!(s == null)) {
+        return cljs.core._rest.call(null, s)
+      }else {
+        return cljs.core.List.EMPTY
+      }
+    }
+  }else {
+    return cljs.core.List.EMPTY
+  }
+};
+cljs.core.next = function next(coll) {
+  if(coll == null) {
+    return null
+  }else {
+    if(function() {
+      var G__3462 = coll;
+      if(G__3462) {
+        if(function() {
+          var or__3943__auto__ = G__3462.cljs$lang$protocol_mask$partition0$ & 128;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3462.cljs$core$INext$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core._next.call(null, coll)
+    }else {
+      return cljs.core.seq.call(null, cljs.core.rest.call(null, coll))
+    }
+  }
+};
+cljs.core._EQ_ = function() {
+  var _EQ_ = null;
+  var _EQ___1 = function(x) {
+    return true
+  };
+  var _EQ___2 = function(x, y) {
+    var or__3943__auto__ = x === y;
+    if(or__3943__auto__) {
+      return or__3943__auto__
+    }else {
+      return cljs.core._equiv.call(null, x, y)
+    }
+  };
+  var _EQ___3 = function() {
+    var G__3463__delegate = function(x, y, more) {
+      while(true) {
+        if(cljs.core.truth_(_EQ_.call(null, x, y))) {
+          if(cljs.core.next.call(null, more)) {
+            var G__3464 = y;
+            var G__3465 = cljs.core.first.call(null, more);
+            var G__3466 = cljs.core.next.call(null, more);
+            x = G__3464;
+            y = G__3465;
+            more = G__3466;
+            continue
+          }else {
+            return _EQ_.call(null, y, cljs.core.first.call(null, more))
+          }
+        }else {
+          return false
+        }
+        break
+      }
+    };
+    var G__3463 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3463__delegate.call(this, x, y, more)
+    };
+    G__3463.cljs$lang$maxFixedArity = 2;
+    G__3463.cljs$lang$applyTo = function(arglist__3467) {
+      var x = cljs.core.first(arglist__3467);
+      arglist__3467 = cljs.core.next(arglist__3467);
+      var y = cljs.core.first(arglist__3467);
+      var more = cljs.core.rest(arglist__3467);
+      return G__3463__delegate(x, y, more)
+    };
+    G__3463.cljs$core$IFn$_invoke$arity$variadic = G__3463__delegate;
+    return G__3463
+  }();
+  _EQ_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _EQ___1.call(this, x);
+      case 2:
+        return _EQ___2.call(this, x, y);
+      default:
+        return _EQ___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _EQ_.cljs$lang$maxFixedArity = 2;
+  _EQ_.cljs$lang$applyTo = _EQ___3.cljs$lang$applyTo;
+  _EQ_.cljs$core$IFn$_invoke$arity$1 = _EQ___1;
+  _EQ_.cljs$core$IFn$_invoke$arity$2 = _EQ___2;
+  _EQ_.cljs$core$IFn$_invoke$arity$variadic = _EQ___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _EQ_
+}();
+cljs.core.IHash["null"] = true;
+cljs.core._hash["null"] = function(o) {
+  return 0
+};
+cljs.core.INext["null"] = true;
+cljs.core._next["null"] = function(_) {
+  return null
+};
+cljs.core.IKVReduce["null"] = true;
+cljs.core._kv_reduce["null"] = function(_, f, init) {
+  return init
+};
+cljs.core.ISet["null"] = true;
+cljs.core._disjoin["null"] = function(_, v) {
+  return null
+};
+cljs.core.ICounted["null"] = true;
+cljs.core._count["null"] = function(_) {
+  return 0
+};
+cljs.core.IStack["null"] = true;
+cljs.core._peek["null"] = function(_) {
+  return null
+};
+cljs.core._pop["null"] = function(_) {
+  return null
+};
+cljs.core.IEquiv["null"] = true;
+cljs.core._equiv["null"] = function(_, o) {
+  return o == null
+};
+cljs.core.IWithMeta["null"] = true;
+cljs.core._with_meta["null"] = function(_, meta) {
+  return null
+};
+cljs.core.IMeta["null"] = true;
+cljs.core._meta["null"] = function(_) {
+  return null
+};
+cljs.core.IEmptyableCollection["null"] = true;
+cljs.core._empty["null"] = function(_) {
+  return null
+};
+cljs.core.IMap["null"] = true;
+cljs.core._dissoc["null"] = function(_, k) {
+  return null
+};
+Date.prototype.cljs$core$IEquiv$ = true;
+Date.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
+  var and__3941__auto__ = other instanceof Date;
+  if(and__3941__auto__) {
+    return o.toString() === other.toString()
+  }else {
+    return and__3941__auto__
+  }
+};
+cljs.core.IHash["number"] = true;
+cljs.core._hash["number"] = function(o) {
+  return Math.floor(o) % 2147483647
+};
+cljs.core.IEquiv["number"] = true;
+cljs.core._equiv["number"] = function(x, o) {
+  return x === o
+};
+cljs.core.IHash["boolean"] = true;
+cljs.core._hash["boolean"] = function(o) {
+  if(o === true) {
+    return 1
+  }else {
+    return 0
+  }
+};
+cljs.core.IMeta["function"] = true;
+cljs.core._meta["function"] = function(_) {
+  return null
+};
+cljs.core.Fn["function"] = true;
+cljs.core.IHash["_"] = true;
+cljs.core._hash["_"] = function(o) {
+  return goog.getUid(o)
+};
+cljs.core.inc = function inc(x) {
+  return x + 1
+};
+goog.provide("cljs.core.Reduced");
+cljs.core.Reduced = function(val) {
+  this.val = val;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32768
+};
+cljs.core.Reduced.cljs$lang$type = true;
+cljs.core.Reduced.cljs$lang$ctorStr = "cljs.core/Reduced";
+cljs.core.Reduced.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Reduced")
+};
+cljs.core.Reduced.prototype.cljs$core$IDeref$_deref$arity$1 = function(o) {
+  var self__ = this;
+  return self__.val
+};
+cljs.core.reduced = function reduced(x) {
+  return new cljs.core.Reduced(x)
+};
+cljs.core.reduced_QMARK_ = function reduced_QMARK_(r) {
+  return r instanceof cljs.core.Reduced
+};
+cljs.core.ci_reduce = function() {
+  var ci_reduce = null;
+  var ci_reduce__2 = function(cicoll, f) {
+    var cnt = cljs.core._count.call(null, cicoll);
+    if(cnt === 0) {
+      return f.call(null)
+    }else {
+      var val = cljs.core._nth.call(null, cicoll, 0);
+      var n = 1;
+      while(true) {
+        if(n < cnt) {
+          var nval = f.call(null, val, cljs.core._nth.call(null, cicoll, n));
+          if(cljs.core.reduced_QMARK_.call(null, nval)) {
+            return cljs.core.deref.call(null, nval)
+          }else {
+            var G__3468 = nval;
+            var G__3469 = n + 1;
+            val = G__3468;
+            n = G__3469;
+            continue
+          }
+        }else {
+          return val
+        }
+        break
+      }
+    }
+  };
+  var ci_reduce__3 = function(cicoll, f, val) {
+    var cnt = cljs.core._count.call(null, cicoll);
+    var val__$1 = val;
+    var n = 0;
+    while(true) {
+      if(n < cnt) {
+        var nval = f.call(null, val__$1, cljs.core._nth.call(null, cicoll, n));
+        if(cljs.core.reduced_QMARK_.call(null, nval)) {
+          return cljs.core.deref.call(null, nval)
+        }else {
+          var G__3470 = nval;
+          var G__3471 = n + 1;
+          val__$1 = G__3470;
+          n = G__3471;
+          continue
+        }
+      }else {
+        return val__$1
+      }
+      break
+    }
+  };
+  var ci_reduce__4 = function(cicoll, f, val, idx) {
+    var cnt = cljs.core._count.call(null, cicoll);
+    var val__$1 = val;
+    var n = idx;
+    while(true) {
+      if(n < cnt) {
+        var nval = f.call(null, val__$1, cljs.core._nth.call(null, cicoll, n));
+        if(cljs.core.reduced_QMARK_.call(null, nval)) {
+          return cljs.core.deref.call(null, nval)
+        }else {
+          var G__3472 = nval;
+          var G__3473 = n + 1;
+          val__$1 = G__3472;
+          n = G__3473;
+          continue
+        }
+      }else {
+        return val__$1
+      }
+      break
+    }
+  };
+  ci_reduce = function(cicoll, f, val, idx) {
+    switch(arguments.length) {
+      case 2:
+        return ci_reduce__2.call(this, cicoll, f);
+      case 3:
+        return ci_reduce__3.call(this, cicoll, f, val);
+      case 4:
+        return ci_reduce__4.call(this, cicoll, f, val, idx)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  ci_reduce.cljs$core$IFn$_invoke$arity$2 = ci_reduce__2;
+  ci_reduce.cljs$core$IFn$_invoke$arity$3 = ci_reduce__3;
+  ci_reduce.cljs$core$IFn$_invoke$arity$4 = ci_reduce__4;
+  return ci_reduce
+}();
+cljs.core.array_reduce = function() {
+  var array_reduce = null;
+  var array_reduce__2 = function(arr, f) {
+    var cnt = arr.length;
+    if(arr.length === 0) {
+      return f.call(null)
+    }else {
+      var val = arr[0];
+      var n = 1;
+      while(true) {
+        if(n < cnt) {
+          var nval = f.call(null, val, arr[n]);
+          if(cljs.core.reduced_QMARK_.call(null, nval)) {
+            return cljs.core.deref.call(null, nval)
+          }else {
+            var G__3474 = nval;
+            var G__3475 = n + 1;
+            val = G__3474;
+            n = G__3475;
+            continue
+          }
+        }else {
+          return val
+        }
+        break
+      }
+    }
+  };
+  var array_reduce__3 = function(arr, f, val) {
+    var cnt = arr.length;
+    var val__$1 = val;
+    var n = 0;
+    while(true) {
+      if(n < cnt) {
+        var nval = f.call(null, val__$1, arr[n]);
+        if(cljs.core.reduced_QMARK_.call(null, nval)) {
+          return cljs.core.deref.call(null, nval)
+        }else {
+          var G__3476 = nval;
+          var G__3477 = n + 1;
+          val__$1 = G__3476;
+          n = G__3477;
+          continue
+        }
+      }else {
+        return val__$1
+      }
+      break
+    }
+  };
+  var array_reduce__4 = function(arr, f, val, idx) {
+    var cnt = arr.length;
+    var val__$1 = val;
+    var n = idx;
+    while(true) {
+      if(n < cnt) {
+        var nval = f.call(null, val__$1, arr[n]);
+        if(cljs.core.reduced_QMARK_.call(null, nval)) {
+          return cljs.core.deref.call(null, nval)
+        }else {
+          var G__3478 = nval;
+          var G__3479 = n + 1;
+          val__$1 = G__3478;
+          n = G__3479;
+          continue
+        }
+      }else {
+        return val__$1
+      }
+      break
+    }
+  };
+  array_reduce = function(arr, f, val, idx) {
+    switch(arguments.length) {
+      case 2:
+        return array_reduce__2.call(this, arr, f);
+      case 3:
+        return array_reduce__3.call(this, arr, f, val);
+      case 4:
+        return array_reduce__4.call(this, arr, f, val, idx)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  array_reduce.cljs$core$IFn$_invoke$arity$2 = array_reduce__2;
+  array_reduce.cljs$core$IFn$_invoke$arity$3 = array_reduce__3;
+  array_reduce.cljs$core$IFn$_invoke$arity$4 = array_reduce__4;
+  return array_reduce
+}();
+cljs.core.counted_QMARK_ = function counted_QMARK_(x) {
+  var G__3481 = x;
+  if(G__3481) {
+    if(function() {
+      var or__3943__auto__ = G__3481.cljs$lang$protocol_mask$partition0$ & 2;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3481.cljs$core$ICounted$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3481.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.ICounted, G__3481)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.ICounted, G__3481)
+  }
+};
+cljs.core.indexed_QMARK_ = function indexed_QMARK_(x) {
+  var G__3483 = x;
+  if(G__3483) {
+    if(function() {
+      var or__3943__auto__ = G__3483.cljs$lang$protocol_mask$partition0$ & 16;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3483.cljs$core$IIndexed$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3483.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IIndexed, G__3483)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.IIndexed, G__3483)
+  }
+};
+goog.provide("cljs.core.IndexedSeq");
+cljs.core.IndexedSeq = function(arr, i) {
+  this.arr = arr;
+  this.i = i;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 166199550
+};
+cljs.core.IndexedSeq.cljs$lang$type = true;
+cljs.core.IndexedSeq.cljs$lang$ctorStr = "cljs.core/IndexedSeq";
+cljs.core.IndexedSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/IndexedSeq")
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.hash_coll.call(null, coll)
+};
+cljs.core.IndexedSeq.prototype.cljs$core$INext$_next$arity$1 = function(_) {
+  var self__ = this;
+  if(self__.i + 1 < self__.arr.length) {
+    return new cljs.core.IndexedSeq(self__.arr, self__.i + 1)
+  }else {
+    return null
+  }
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
+  var self__ = this;
+  var c = coll.cljs$core$ICounted$_count$arity$1(coll);
+  if(c > 0) {
+    return new cljs.core.RSeq(coll, c - 1, null)
+  }else {
+    return cljs.core.List.EMPTY
+  }
+};
+cljs.core.IndexedSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  return cljs.core.array_reduce.call(null, self__.arr, f, self__.arr[self__.i], self__.i + 1)
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  return cljs.core.array_reduce.call(null, self__.arr, f, start, self__.i)
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  return this$
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
+  var self__ = this;
+  return self__.arr.length - self__.i
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(_) {
+  var self__ = this;
+  return self__.arr[self__.i]
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(_) {
+  var self__ = this;
+  if(self__.i + 1 < self__.arr.length) {
+    return new cljs.core.IndexedSeq(self__.arr, self__.i + 1)
+  }else {
+    return cljs.core.list.call(null)
+  }
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  var i__$1 = n + self__.i;
+  if(i__$1 < self__.arr.length) {
+    return self__.arr[i__$1]
+  }else {
+    return null
+  }
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) {
+  var self__ = this;
+  var i__$1 = n + self__.i;
+  if(i__$1 < self__.arr.length) {
+    return self__.arr[i__$1]
+  }else {
+    return not_found
+  }
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.List.EMPTY
+};
+cljs.core.prim_seq = function() {
+  var prim_seq = null;
+  var prim_seq__1 = function(prim) {
+    return prim_seq.call(null, prim, 0)
+  };
+  var prim_seq__2 = function(prim, i) {
+    if(i < prim.length) {
+      return new cljs.core.IndexedSeq(prim, i)
+    }else {
+      return null
+    }
+  };
+  prim_seq = function(prim, i) {
+    switch(arguments.length) {
+      case 1:
+        return prim_seq__1.call(this, prim);
+      case 2:
+        return prim_seq__2.call(this, prim, i)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  prim_seq.cljs$core$IFn$_invoke$arity$1 = prim_seq__1;
+  prim_seq.cljs$core$IFn$_invoke$arity$2 = prim_seq__2;
+  return prim_seq
+}();
+cljs.core.array_seq = function() {
+  var array_seq = null;
+  var array_seq__1 = function(array) {
+    return cljs.core.prim_seq.call(null, array, 0)
+  };
+  var array_seq__2 = function(array, i) {
+    return cljs.core.prim_seq.call(null, array, i)
+  };
+  array_seq = function(array, i) {
+    switch(arguments.length) {
+      case 1:
+        return array_seq__1.call(this, array);
+      case 2:
+        return array_seq__2.call(this, array, i)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  array_seq.cljs$core$IFn$_invoke$arity$1 = array_seq__1;
+  array_seq.cljs$core$IFn$_invoke$arity$2 = array_seq__2;
+  return array_seq
+}();
+cljs.core.ICounted["array"] = true;
+cljs.core._count["array"] = function(a) {
+  return a.length
+};
+goog.provide("cljs.core.RSeq");
+cljs.core.RSeq = function(ci, i, meta) {
+  this.ci = ci;
+  this.i = i;
+  this.meta = meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31850574
+};
+cljs.core.RSeq.cljs$lang$type = true;
+cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq";
+cljs.core.RSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/RSeq")
+};
+cljs.core.RSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.hash_coll.call(null, coll)
+};
+cljs.core.RSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.RSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.RSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.RSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.i + 1
+};
+cljs.core.RSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._nth.call(null, self__.ci, self__.i)
+};
+cljs.core.RSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.i > 0) {
+    return new cljs.core.RSeq(self__.ci, self__.i - 1, null)
+  }else {
+    return cljs.core.List.EMPTY
+  }
+};
+cljs.core.RSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.RSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
+  var self__ = this;
+  return new cljs.core.RSeq(self__.ci, self__.i, new_meta)
+};
+cljs.core.RSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.RSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.second = function second(coll) {
+  return cljs.core.first.call(null, cljs.core.next.call(null, coll))
+};
+cljs.core.ffirst = function ffirst(coll) {
+  return cljs.core.first.call(null, cljs.core.first.call(null, coll))
+};
+cljs.core.nfirst = function nfirst(coll) {
+  return cljs.core.next.call(null, cljs.core.first.call(null, coll))
+};
+cljs.core.fnext = function fnext(coll) {
+  return cljs.core.first.call(null, cljs.core.next.call(null, coll))
+};
+cljs.core.nnext = function nnext(coll) {
+  return cljs.core.next.call(null, cljs.core.next.call(null, coll))
+};
+cljs.core.last = function last(s) {
+  while(true) {
+    var sn = cljs.core.next.call(null, s);
+    if(!(sn == null)) {
+      var G__3484 = sn;
+      s = G__3484;
+      continue
+    }else {
+      return cljs.core.first.call(null, s)
+    }
+    break
+  }
+};
+cljs.core.IEquiv["_"] = true;
+cljs.core._equiv["_"] = function(x, o) {
+  return x === o
+};
+cljs.core.conj = function() {
+  var conj = null;
+  var conj__2 = function(coll, x) {
+    if(!(coll == null)) {
+      return cljs.core._conj.call(null, coll, x)
+    }else {
+      return cljs.core.list.call(null, x)
+    }
+  };
+  var conj__3 = function() {
+    var G__3485__delegate = function(coll, x, xs) {
+      while(true) {
+        if(cljs.core.truth_(xs)) {
+          var G__3486 = conj.call(null, coll, x);
+          var G__3487 = cljs.core.first.call(null, xs);
+          var G__3488 = cljs.core.next.call(null, xs);
+          coll = G__3486;
+          x = G__3487;
+          xs = G__3488;
+          continue
+        }else {
+          return conj.call(null, coll, x)
+        }
+        break
+      }
+    };
+    var G__3485 = function(coll, x, var_args) {
+      var xs = null;
+      if(arguments.length > 2) {
+        xs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3485__delegate.call(this, coll, x, xs)
+    };
+    G__3485.cljs$lang$maxFixedArity = 2;
+    G__3485.cljs$lang$applyTo = function(arglist__3489) {
+      var coll = cljs.core.first(arglist__3489);
+      arglist__3489 = cljs.core.next(arglist__3489);
+      var x = cljs.core.first(arglist__3489);
+      var xs = cljs.core.rest(arglist__3489);
+      return G__3485__delegate(coll, x, xs)
+    };
+    G__3485.cljs$core$IFn$_invoke$arity$variadic = G__3485__delegate;
+    return G__3485
+  }();
+  conj = function(coll, x, var_args) {
+    var xs = var_args;
+    switch(arguments.length) {
+      case 2:
+        return conj__2.call(this, coll, x);
+      default:
+        return conj__3.cljs$core$IFn$_invoke$arity$variadic(coll, x, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  conj.cljs$lang$maxFixedArity = 2;
+  conj.cljs$lang$applyTo = conj__3.cljs$lang$applyTo;
+  conj.cljs$core$IFn$_invoke$arity$2 = conj__2;
+  conj.cljs$core$IFn$_invoke$arity$variadic = conj__3.cljs$core$IFn$_invoke$arity$variadic;
+  return conj
+}();
+cljs.core.empty = function empty(coll) {
+  return cljs.core._empty.call(null, coll)
+};
+cljs.core.accumulating_seq_count = function accumulating_seq_count(coll) {
+  var s = cljs.core.seq.call(null, coll);
+  var acc = 0;
+  while(true) {
+    if(cljs.core.counted_QMARK_.call(null, s)) {
+      return acc + cljs.core._count.call(null, s)
+    }else {
+      var G__3490 = cljs.core.next.call(null, s);
+      var G__3491 = acc + 1;
+      s = G__3490;
+      acc = G__3491;
+      continue
+    }
+    break
+  }
+};
+cljs.core.count = function count(coll) {
+  if(cljs.core.counted_QMARK_.call(null, coll)) {
+    return cljs.core._count.call(null, coll)
+  }else {
+    return cljs.core.accumulating_seq_count.call(null, coll)
+  }
+};
+cljs.core.linear_traversal_nth = function() {
+  var linear_traversal_nth = null;
+  var linear_traversal_nth__2 = function(coll, n) {
+    while(true) {
+      if(coll == null) {
+        throw new Error("Index out of bounds");
+      }else {
+        if(n === 0) {
+          if(cljs.core.seq.call(null, coll)) {
+            return cljs.core.first.call(null, coll)
+          }else {
+            throw new Error("Index out of bounds");
+          }
+        }else {
+          if(cljs.core.indexed_QMARK_.call(null, coll)) {
+            return cljs.core._nth.call(null, coll, n)
+          }else {
+            if(cljs.core.seq.call(null, coll)) {
+              var G__3492 = cljs.core.next.call(null, coll);
+              var G__3493 = n - 1;
+              coll = G__3492;
+              n = G__3493;
+              continue
+            }else {
+              if("\ufdd0:else") {
+                throw new Error("Index out of bounds");
+              }else {
+                return null
+              }
+            }
+          }
+        }
+      }
+      break
+    }
+  };
+  var linear_traversal_nth__3 = function(coll, n, not_found) {
+    while(true) {
+      if(coll == null) {
+        return not_found
+      }else {
+        if(n === 0) {
+          if(cljs.core.seq.call(null, coll)) {
+            return cljs.core.first.call(null, coll)
+          }else {
+            return not_found
+          }
+        }else {
+          if(cljs.core.indexed_QMARK_.call(null, coll)) {
+            return cljs.core._nth.call(null, coll, n, not_found)
+          }else {
+            if(cljs.core.seq.call(null, coll)) {
+              var G__3494 = cljs.core.next.call(null, coll);
+              var G__3495 = n - 1;
+              var G__3496 = not_found;
+              coll = G__3494;
+              n = G__3495;
+              not_found = G__3496;
+              continue
+            }else {
+              if("\ufdd0:else") {
+                return not_found
+              }else {
+                return null
+              }
+            }
+          }
+        }
+      }
+      break
+    }
+  };
+  linear_traversal_nth = function(coll, n, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return linear_traversal_nth__2.call(this, coll, n);
+      case 3:
+        return linear_traversal_nth__3.call(this, coll, n, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  linear_traversal_nth.cljs$core$IFn$_invoke$arity$2 = linear_traversal_nth__2;
+  linear_traversal_nth.cljs$core$IFn$_invoke$arity$3 = linear_traversal_nth__3;
+  return linear_traversal_nth
+}();
+cljs.core.nth = function() {
+  var nth = null;
+  var nth__2 = function(coll, n) {
+    if(coll == null) {
+      return null
+    }else {
+      if(function() {
+        var G__3499 = coll;
+        if(G__3499) {
+          if(function() {
+            var or__3943__auto__ = G__3499.cljs$lang$protocol_mask$partition0$ & 16;
+            if(or__3943__auto__) {
+              return or__3943__auto__
+            }else {
+              return G__3499.cljs$core$IIndexed$
+            }
+          }()) {
+            return true
+          }else {
+            return false
+          }
+        }else {
+          return false
+        }
+      }()) {
+        return cljs.core._nth.call(null, coll, Math.floor(n))
+      }else {
+        if(coll instanceof Array) {
+          if(n < coll.length) {
+            return coll[n]
+          }else {
+            return null
+          }
+        }else {
+          if(cljs.core.string_QMARK_.call(null, coll)) {
+            if(n < coll.length) {
+              return coll[n]
+            }else {
+              return null
+            }
+          }else {
+            if("\ufdd0:else") {
+              return cljs.core.linear_traversal_nth.call(null, coll, Math.floor(n))
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }
+  };
+  var nth__3 = function(coll, n, not_found) {
+    if(!(coll == null)) {
+      if(function() {
+        var G__3500 = coll;
+        if(G__3500) {
+          if(function() {
+            var or__3943__auto__ = G__3500.cljs$lang$protocol_mask$partition0$ & 16;
+            if(or__3943__auto__) {
+              return or__3943__auto__
+            }else {
+              return G__3500.cljs$core$IIndexed$
+            }
+          }()) {
+            return true
+          }else {
+            return false
+          }
+        }else {
+          return false
+        }
+      }()) {
+        return cljs.core._nth.call(null, coll, Math.floor(n), not_found)
+      }else {
+        if(coll instanceof Array) {
+          if(n < coll.length) {
+            return coll[n]
+          }else {
+            return not_found
+          }
+        }else {
+          if(cljs.core.string_QMARK_.call(null, coll)) {
+            if(n < coll.length) {
+              return coll[n]
+            }else {
+              return not_found
+            }
+          }else {
+            if("\ufdd0:else") {
+              return cljs.core.linear_traversal_nth.call(null, coll, Math.floor(n), not_found)
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }else {
+      return not_found
+    }
+  };
+  nth = function(coll, n, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return nth__2.call(this, coll, n);
+      case 3:
+        return nth__3.call(this, coll, n, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  nth.cljs$core$IFn$_invoke$arity$2 = nth__2;
+  nth.cljs$core$IFn$_invoke$arity$3 = nth__3;
+  return nth
+}();
+cljs.core.get = function() {
+  var get = null;
+  var get__2 = function(o, k) {
+    if(o == null) {
+      return null
+    }else {
+      if(function() {
+        var G__3503 = o;
+        if(G__3503) {
+          if(function() {
+            var or__3943__auto__ = G__3503.cljs$lang$protocol_mask$partition0$ & 256;
+            if(or__3943__auto__) {
+              return or__3943__auto__
+            }else {
+              return G__3503.cljs$core$ILookup$
+            }
+          }()) {
+            return true
+          }else {
+            return false
+          }
+        }else {
+          return false
+        }
+      }()) {
+        return cljs.core._lookup.call(null, o, k)
+      }else {
+        if(o instanceof Array) {
+          if(k < o.length) {
+            return o[k]
+          }else {
+            return null
+          }
+        }else {
+          if(cljs.core.string_QMARK_.call(null, o)) {
+            if(k < o.length) {
+              return o[k]
+            }else {
+              return null
+            }
+          }else {
+            if(cljs.core.type_satisfies_.call(null, cljs.core.ILookup, o)) {
+              return cljs.core._lookup.call(null, o, k)
+            }else {
+              if("\ufdd0:else") {
+                return null
+              }else {
+                return null
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  var get__3 = function(o, k, not_found) {
+    if(!(o == null)) {
+      if(function() {
+        var G__3504 = o;
+        if(G__3504) {
+          if(function() {
+            var or__3943__auto__ = G__3504.cljs$lang$protocol_mask$partition0$ & 256;
+            if(or__3943__auto__) {
+              return or__3943__auto__
+            }else {
+              return G__3504.cljs$core$ILookup$
+            }
+          }()) {
+            return true
+          }else {
+            return false
+          }
+        }else {
+          return false
+        }
+      }()) {
+        return cljs.core._lookup.call(null, o, k, not_found)
+      }else {
+        if(o instanceof Array) {
+          if(k < o.length) {
+            return o[k]
+          }else {
+            return not_found
+          }
+        }else {
+          if(cljs.core.string_QMARK_.call(null, o)) {
+            if(k < o.length) {
+              return o[k]
+            }else {
+              return not_found
+            }
+          }else {
+            if(cljs.core.type_satisfies_.call(null, cljs.core.ILookup, o)) {
+              return cljs.core._lookup.call(null, o, k, not_found)
+            }else {
+              if("\ufdd0:else") {
+                return not_found
+              }else {
+                return null
+              }
+            }
+          }
+        }
+      }
+    }else {
+      return not_found
+    }
+  };
+  get = function(o, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return get__2.call(this, o, k);
+      case 3:
+        return get__3.call(this, o, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  get.cljs$core$IFn$_invoke$arity$2 = get__2;
+  get.cljs$core$IFn$_invoke$arity$3 = get__3;
+  return get
+}();
+cljs.core.assoc = function() {
+  var assoc = null;
+  var assoc__3 = function(coll, k, v) {
+    if(!(coll == null)) {
+      return cljs.core._assoc.call(null, coll, k, v)
+    }else {
+      return cljs.core.hash_map.call(null, k, v)
+    }
+  };
+  var assoc__4 = function() {
+    var G__3505__delegate = function(coll, k, v, kvs) {
+      while(true) {
+        var ret = assoc.call(null, coll, k, v);
+        if(cljs.core.truth_(kvs)) {
+          var G__3506 = ret;
+          var G__3507 = cljs.core.first.call(null, kvs);
+          var G__3508 = cljs.core.second.call(null, kvs);
+          var G__3509 = cljs.core.nnext.call(null, kvs);
+          coll = G__3506;
+          k = G__3507;
+          v = G__3508;
+          kvs = G__3509;
+          continue
+        }else {
+          return ret
+        }
+        break
+      }
+    };
+    var G__3505 = function(coll, k, v, var_args) {
+      var kvs = null;
+      if(arguments.length > 3) {
+        kvs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__3505__delegate.call(this, coll, k, v, kvs)
+    };
+    G__3505.cljs$lang$maxFixedArity = 3;
+    G__3505.cljs$lang$applyTo = function(arglist__3510) {
+      var coll = cljs.core.first(arglist__3510);
+      arglist__3510 = cljs.core.next(arglist__3510);
+      var k = cljs.core.first(arglist__3510);
+      arglist__3510 = cljs.core.next(arglist__3510);
+      var v = cljs.core.first(arglist__3510);
+      var kvs = cljs.core.rest(arglist__3510);
+      return G__3505__delegate(coll, k, v, kvs)
+    };
+    G__3505.cljs$core$IFn$_invoke$arity$variadic = G__3505__delegate;
+    return G__3505
+  }();
+  assoc = function(coll, k, v, var_args) {
+    var kvs = var_args;
+    switch(arguments.length) {
+      case 3:
+        return assoc__3.call(this, coll, k, v);
+      default:
+        return assoc__4.cljs$core$IFn$_invoke$arity$variadic(coll, k, v, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  assoc.cljs$lang$maxFixedArity = 3;
+  assoc.cljs$lang$applyTo = assoc__4.cljs$lang$applyTo;
+  assoc.cljs$core$IFn$_invoke$arity$3 = assoc__3;
+  assoc.cljs$core$IFn$_invoke$arity$variadic = assoc__4.cljs$core$IFn$_invoke$arity$variadic;
+  return assoc
+}();
+cljs.core.dissoc = function() {
+  var dissoc = null;
+  var dissoc__1 = function(coll) {
+    return coll
+  };
+  var dissoc__2 = function(coll, k) {
+    return cljs.core._dissoc.call(null, coll, k)
+  };
+  var dissoc__3 = function() {
+    var G__3511__delegate = function(coll, k, ks) {
+      while(true) {
+        var ret = dissoc.call(null, coll, k);
+        if(cljs.core.truth_(ks)) {
+          var G__3512 = ret;
+          var G__3513 = cljs.core.first.call(null, ks);
+          var G__3514 = cljs.core.next.call(null, ks);
+          coll = G__3512;
+          k = G__3513;
+          ks = G__3514;
+          continue
+        }else {
+          return ret
+        }
+        break
+      }
+    };
+    var G__3511 = function(coll, k, var_args) {
+      var ks = null;
+      if(arguments.length > 2) {
+        ks = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3511__delegate.call(this, coll, k, ks)
+    };
+    G__3511.cljs$lang$maxFixedArity = 2;
+    G__3511.cljs$lang$applyTo = function(arglist__3515) {
+      var coll = cljs.core.first(arglist__3515);
+      arglist__3515 = cljs.core.next(arglist__3515);
+      var k = cljs.core.first(arglist__3515);
+      var ks = cljs.core.rest(arglist__3515);
+      return G__3511__delegate(coll, k, ks)
+    };
+    G__3511.cljs$core$IFn$_invoke$arity$variadic = G__3511__delegate;
+    return G__3511
+  }();
+  dissoc = function(coll, k, var_args) {
+    var ks = var_args;
+    switch(arguments.length) {
+      case 1:
+        return dissoc__1.call(this, coll);
+      case 2:
+        return dissoc__2.call(this, coll, k);
+      default:
+        return dissoc__3.cljs$core$IFn$_invoke$arity$variadic(coll, k, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  dissoc.cljs$lang$maxFixedArity = 2;
+  dissoc.cljs$lang$applyTo = dissoc__3.cljs$lang$applyTo;
+  dissoc.cljs$core$IFn$_invoke$arity$1 = dissoc__1;
+  dissoc.cljs$core$IFn$_invoke$arity$2 = dissoc__2;
+  dissoc.cljs$core$IFn$_invoke$arity$variadic = dissoc__3.cljs$core$IFn$_invoke$arity$variadic;
+  return dissoc
+}();
+cljs.core.fn_QMARK_ = function fn_QMARK_(f) {
+  var or__3943__auto__ = goog.isFunction(f);
+  if(or__3943__auto__) {
+    return or__3943__auto__
+  }else {
+    var G__3517 = f;
+    if(G__3517) {
+      if(cljs.core.truth_(function() {
+        var or__3943__auto____$1 = null;
+        if(cljs.core.truth_(or__3943__auto____$1)) {
+          return or__3943__auto____$1
+        }else {
+          return G__3517.cljs$core$Fn$
+        }
+      }())) {
+        return true
+      }else {
+        if(!G__3517.cljs$lang$protocol_mask$partition$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.Fn, G__3517)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.Fn, G__3517)
+    }
+  }
+};
+cljs.core.with_meta = function with_meta(o, meta) {
+  if(function() {
+    var and__3941__auto__ = cljs.core.fn_QMARK_.call(null, o);
+    if(and__3941__auto__) {
+      return!function() {
+        var G__3523 = o;
+        if(G__3523) {
+          if(function() {
+            var or__3943__auto__ = G__3523.cljs$lang$protocol_mask$partition0$ & 262144;
+            if(or__3943__auto__) {
+              return or__3943__auto__
+            }else {
+              return G__3523.cljs$core$IWithMeta$
+            }
+          }()) {
+            return true
+          }else {
+            if(!G__3523.cljs$lang$protocol_mask$partition0$) {
+              return cljs.core.type_satisfies_.call(null, cljs.core.IWithMeta, G__3523)
+            }else {
+              return false
+            }
+          }
+        }else {
+          return cljs.core.type_satisfies_.call(null, cljs.core.IWithMeta, G__3523)
+        }
+      }()
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return with_meta.call(null, function() {
+      if(void 0 === cljs.core.t3524) {
+        goog.provide("cljs.core.t3524");
+        cljs.core.t3524 = function(meta, o, with_meta, meta3525) {
+          this.meta = meta;
+          this.o = o;
+          this.with_meta = with_meta;
+          this.meta3525 = meta3525;
+          this.cljs$lang$protocol_mask$partition1$ = 0;
+          this.cljs$lang$protocol_mask$partition0$ = 393217
+        };
+        cljs.core.t3524.cljs$lang$type = true;
+        cljs.core.t3524.cljs$lang$ctorStr = "cljs.core/t3524";
+        cljs.core.t3524.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+          return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/t3524")
+        };
+        cljs.core.t3524.prototype.call = function() {
+          var G__3528__delegate = function(self__, args) {
+            var self____$1 = this;
+            var _ = self____$1;
+            return cljs.core.apply.call(null, self__.o, args)
+          };
+          var G__3528 = function(self__, var_args) {
+            var self__ = this;
+            var args = null;
+            if(arguments.length > 1) {
+              args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+            }
+            return G__3528__delegate.call(this, self__, args)
+          };
+          G__3528.cljs$lang$maxFixedArity = 1;
+          G__3528.cljs$lang$applyTo = function(arglist__3529) {
+            var self__ = cljs.core.first(arglist__3529);
+            var args = cljs.core.rest(arglist__3529);
+            return G__3528__delegate(self__, args)
+          };
+          G__3528.cljs$core$IFn$_invoke$arity$variadic = G__3528__delegate;
+          return G__3528
+        }();
+        cljs.core.t3524.prototype.apply = function(self__, args3527) {
+          var self__ = this;
+          return self__.call.apply(self__, [self__].concat(args3527.slice()))
+        };
+        cljs.core.t3524.prototype.cljs$core$Fn$ = true;
+        cljs.core.t3524.prototype.cljs$core$IMeta$_meta$arity$1 = function(_3526) {
+          var self__ = this;
+          return self__.meta3525
+        };
+        cljs.core.t3524.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_3526, meta3525__$1) {
+          var self__ = this;
+          return new cljs.core.t3524(self__.meta, self__.o, self__.with_meta, meta3525__$1)
+        }
+      }else {
+      }
+      return new cljs.core.t3524(meta, o, with_meta, null)
+    }(), meta)
+  }else {
+    return cljs.core._with_meta.call(null, o, meta)
+  }
+};
+cljs.core.meta = function meta(o) {
+  if(function() {
+    var G__3531 = o;
+    if(G__3531) {
+      if(function() {
+        var or__3943__auto__ = G__3531.cljs$lang$protocol_mask$partition0$ & 131072;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return G__3531.cljs$core$IMeta$
+        }
+      }()) {
+        return true
+      }else {
+        if(!G__3531.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.IMeta, G__3531)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.IMeta, G__3531)
+    }
+  }()) {
+    return cljs.core._meta.call(null, o)
+  }else {
+    return null
+  }
+};
+cljs.core.peek = function peek(coll) {
+  return cljs.core._peek.call(null, coll)
+};
+cljs.core.pop = function pop(coll) {
+  return cljs.core._pop.call(null, coll)
+};
+cljs.core.disj = function() {
+  var disj = null;
+  var disj__1 = function(coll) {
+    return coll
+  };
+  var disj__2 = function(coll, k) {
+    return cljs.core._disjoin.call(null, coll, k)
+  };
+  var disj__3 = function() {
+    var G__3532__delegate = function(coll, k, ks) {
+      while(true) {
+        var ret = disj.call(null, coll, k);
+        if(cljs.core.truth_(ks)) {
+          var G__3533 = ret;
+          var G__3534 = cljs.core.first.call(null, ks);
+          var G__3535 = cljs.core.next.call(null, ks);
+          coll = G__3533;
+          k = G__3534;
+          ks = G__3535;
+          continue
+        }else {
+          return ret
+        }
+        break
+      }
+    };
+    var G__3532 = function(coll, k, var_args) {
+      var ks = null;
+      if(arguments.length > 2) {
+        ks = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3532__delegate.call(this, coll, k, ks)
+    };
+    G__3532.cljs$lang$maxFixedArity = 2;
+    G__3532.cljs$lang$applyTo = function(arglist__3536) {
+      var coll = cljs.core.first(arglist__3536);
+      arglist__3536 = cljs.core.next(arglist__3536);
+      var k = cljs.core.first(arglist__3536);
+      var ks = cljs.core.rest(arglist__3536);
+      return G__3532__delegate(coll, k, ks)
+    };
+    G__3532.cljs$core$IFn$_invoke$arity$variadic = G__3532__delegate;
+    return G__3532
+  }();
+  disj = function(coll, k, var_args) {
+    var ks = var_args;
+    switch(arguments.length) {
+      case 1:
+        return disj__1.call(this, coll);
+      case 2:
+        return disj__2.call(this, coll, k);
+      default:
+        return disj__3.cljs$core$IFn$_invoke$arity$variadic(coll, k, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  disj.cljs$lang$maxFixedArity = 2;
+  disj.cljs$lang$applyTo = disj__3.cljs$lang$applyTo;
+  disj.cljs$core$IFn$_invoke$arity$1 = disj__1;
+  disj.cljs$core$IFn$_invoke$arity$2 = disj__2;
+  disj.cljs$core$IFn$_invoke$arity$variadic = disj__3.cljs$core$IFn$_invoke$arity$variadic;
+  return disj
+}();
+cljs.core.string_hash_cache = {};
+cljs.core.string_hash_cache_count = 0;
+cljs.core.add_to_string_hash_cache = function add_to_string_hash_cache(k) {
+  var h = goog.string.hashCode(k);
+  cljs.core.string_hash_cache[k] = h;
+  cljs.core.string_hash_cache_count = cljs.core.string_hash_cache_count + 1;
+  return h
+};
+cljs.core.check_string_hash_cache = function check_string_hash_cache(k) {
+  if(cljs.core.string_hash_cache_count > 255) {
+    cljs.core.string_hash_cache = {};
+    cljs.core.string_hash_cache_count = 0
+  }else {
+  }
+  var h = cljs.core.string_hash_cache[k];
+  if(typeof h === "number") {
+    return h
+  }else {
+    return cljs.core.add_to_string_hash_cache.call(null, k)
+  }
+};
+cljs.core.hash = function() {
+  var hash = null;
+  var hash__1 = function(o) {
+    return hash.call(null, o, true)
+  };
+  var hash__2 = function(o, check_cache) {
+    if(function() {
+      var and__3941__auto__ = goog.isString(o);
+      if(and__3941__auto__) {
+        return check_cache
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return cljs.core.check_string_hash_cache.call(null, o)
+    }else {
+      return cljs.core._hash.call(null, o)
+    }
+  };
+  hash = function(o, check_cache) {
+    switch(arguments.length) {
+      case 1:
+        return hash__1.call(this, o);
+      case 2:
+        return hash__2.call(this, o, check_cache)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  hash.cljs$core$IFn$_invoke$arity$1 = hash__1;
+  hash.cljs$core$IFn$_invoke$arity$2 = hash__2;
+  return hash
+}();
+cljs.core.empty_QMARK_ = function empty_QMARK_(coll) {
+  var or__3943__auto__ = coll == null;
+  if(or__3943__auto__) {
+    return or__3943__auto__
+  }else {
+    return cljs.core.not.call(null, cljs.core.seq.call(null, coll))
+  }
+};
+cljs.core.coll_QMARK_ = function coll_QMARK_(x) {
+  if(x == null) {
+    return false
+  }else {
+    var G__3538 = x;
+    if(G__3538) {
+      if(function() {
+        var or__3943__auto__ = G__3538.cljs$lang$protocol_mask$partition0$ & 8;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return G__3538.cljs$core$ICollection$
+        }
+      }()) {
+        return true
+      }else {
+        if(!G__3538.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.ICollection, G__3538)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.ICollection, G__3538)
+    }
+  }
+};
+cljs.core.set_QMARK_ = function set_QMARK_(x) {
+  if(x == null) {
+    return false
+  }else {
+    var G__3540 = x;
+    if(G__3540) {
+      if(function() {
+        var or__3943__auto__ = G__3540.cljs$lang$protocol_mask$partition0$ & 4096;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return G__3540.cljs$core$ISet$
+        }
+      }()) {
+        return true
+      }else {
+        if(!G__3540.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.ISet, G__3540)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.ISet, G__3540)
+    }
+  }
+};
+cljs.core.associative_QMARK_ = function associative_QMARK_(x) {
+  var G__3542 = x;
+  if(G__3542) {
+    if(function() {
+      var or__3943__auto__ = G__3542.cljs$lang$protocol_mask$partition0$ & 512;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3542.cljs$core$IAssociative$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3542.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IAssociative, G__3542)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.IAssociative, G__3542)
+  }
+};
+cljs.core.sequential_QMARK_ = function sequential_QMARK_(x) {
+  var G__3544 = x;
+  if(G__3544) {
+    if(function() {
+      var or__3943__auto__ = G__3544.cljs$lang$protocol_mask$partition0$ & 16777216;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3544.cljs$core$ISequential$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3544.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.ISequential, G__3544)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.ISequential, G__3544)
+  }
+};
+cljs.core.reduceable_QMARK_ = function reduceable_QMARK_(x) {
+  var G__3546 = x;
+  if(G__3546) {
+    if(function() {
+      var or__3943__auto__ = G__3546.cljs$lang$protocol_mask$partition0$ & 524288;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3546.cljs$core$IReduce$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3546.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IReduce, G__3546)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.IReduce, G__3546)
+  }
+};
+cljs.core.map_QMARK_ = function map_QMARK_(x) {
+  if(x == null) {
+    return false
+  }else {
+    var G__3548 = x;
+    if(G__3548) {
+      if(function() {
+        var or__3943__auto__ = G__3548.cljs$lang$protocol_mask$partition0$ & 1024;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return G__3548.cljs$core$IMap$
+        }
+      }()) {
+        return true
+      }else {
+        if(!G__3548.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.IMap, G__3548)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.IMap, G__3548)
+    }
+  }
+};
+cljs.core.vector_QMARK_ = function vector_QMARK_(x) {
+  var G__3550 = x;
+  if(G__3550) {
+    if(function() {
+      var or__3943__auto__ = G__3550.cljs$lang$protocol_mask$partition0$ & 16384;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3550.cljs$core$IVector$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3550.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IVector, G__3550)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.IVector, G__3550)
+  }
+};
+cljs.core.chunked_seq_QMARK_ = function chunked_seq_QMARK_(x) {
+  var or__3943__auto__ = x instanceof cljs.core.ChunkedCons;
+  if(or__3943__auto__) {
+    return or__3943__auto__
+  }else {
+    return x instanceof cljs.core.ChunkedSeq
+  }
+};
+cljs.core.js_obj = function() {
+  var js_obj = null;
+  var js_obj__0 = function() {
+    return{}
+  };
+  var js_obj__1 = function() {
+    var G__3551__delegate = function(keyvals) {
+      return cljs.core.apply.call(null, goog.object.create, keyvals)
+    };
+    var G__3551 = function(var_args) {
+      var keyvals = null;
+      if(arguments.length > 0) {
+        keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+      }
+      return G__3551__delegate.call(this, keyvals)
+    };
+    G__3551.cljs$lang$maxFixedArity = 0;
+    G__3551.cljs$lang$applyTo = function(arglist__3552) {
+      var keyvals = cljs.core.seq(arglist__3552);
+      return G__3551__delegate(keyvals)
+    };
+    G__3551.cljs$core$IFn$_invoke$arity$variadic = G__3551__delegate;
+    return G__3551
+  }();
+  js_obj = function(var_args) {
+    var keyvals = var_args;
+    switch(arguments.length) {
+      case 0:
+        return js_obj__0.call(this);
+      default:
+        return js_obj__1.cljs$core$IFn$_invoke$arity$variadic(cljs.core.array_seq(arguments, 0))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  js_obj.cljs$lang$maxFixedArity = 0;
+  js_obj.cljs$lang$applyTo = js_obj__1.cljs$lang$applyTo;
+  js_obj.cljs$core$IFn$_invoke$arity$0 = js_obj__0;
+  js_obj.cljs$core$IFn$_invoke$arity$variadic = js_obj__1.cljs$core$IFn$_invoke$arity$variadic;
+  return js_obj
+}();
+cljs.core.js_keys = function js_keys(obj) {
+  var keys = [];
+  goog.object.forEach(obj, function(val, key, obj__$1) {
+    return keys.push(key)
+  });
+  return keys
+};
+cljs.core.js_delete = function js_delete(obj, key) {
+  return delete obj[key]
+};
+cljs.core.array_copy = function array_copy(from, i, to, j, len) {
+  var i__$1 = i;
+  var j__$1 = j;
+  var len__$1 = len;
+  while(true) {
+    if(len__$1 === 0) {
+      return to
+    }else {
+      to[j__$1] = from[i__$1];
+      var G__3553 = i__$1 + 1;
+      var G__3554 = j__$1 + 1;
+      var G__3555 = len__$1 - 1;
+      i__$1 = G__3553;
+      j__$1 = G__3554;
+      len__$1 = G__3555;
+      continue
+    }
+    break
+  }
+};
+cljs.core.array_copy_downward = function array_copy_downward(from, i, to, j, len) {
+  var i__$1 = i + (len - 1);
+  var j__$1 = j + (len - 1);
+  var len__$1 = len;
+  while(true) {
+    if(len__$1 === 0) {
+      return to
+    }else {
+      to[j__$1] = from[i__$1];
+      var G__3556 = i__$1 - 1;
+      var G__3557 = j__$1 - 1;
+      var G__3558 = len__$1 - 1;
+      i__$1 = G__3556;
+      j__$1 = G__3557;
+      len__$1 = G__3558;
+      continue
+    }
+    break
+  }
+};
+cljs.core.lookup_sentinel = {};
+cljs.core.false_QMARK_ = function false_QMARK_(x) {
+  return x === false
+};
+cljs.core.true_QMARK_ = function true_QMARK_(x) {
+  return x === true
+};
+cljs.core.undefined_QMARK_ = function undefined_QMARK_(x) {
+  return void 0 === x
+};
+cljs.core.seq_QMARK_ = function seq_QMARK_(s) {
+  if(s == null) {
+    return false
+  }else {
+    var G__3560 = s;
+    if(G__3560) {
+      if(function() {
+        var or__3943__auto__ = G__3560.cljs$lang$protocol_mask$partition0$ & 64;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return G__3560.cljs$core$ISeq$
+        }
+      }()) {
+        return true
+      }else {
+        if(!G__3560.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.ISeq, G__3560)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.ISeq, G__3560)
+    }
+  }
+};
+cljs.core.seqable_QMARK_ = function seqable_QMARK_(s) {
+  var G__3562 = s;
+  if(G__3562) {
+    if(function() {
+      var or__3943__auto__ = G__3562.cljs$lang$protocol_mask$partition0$ & 8388608;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3562.cljs$core$ISeqable$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3562.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.ISeqable, G__3562)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.ISeqable, G__3562)
+  }
+};
+cljs.core.boolean$ = function boolean$(x) {
+  if(cljs.core.truth_(x)) {
+    return true
+  }else {
+    return false
+  }
+};
+cljs.core.keyword_QMARK_ = function keyword_QMARK_(x) {
+  var and__3941__auto__ = goog.isString(x);
+  if(and__3941__auto__) {
+    return x.charAt(0) === "\ufdd0"
+  }else {
+    return and__3941__auto__
+  }
+};
+cljs.core.ifn_QMARK_ = function ifn_QMARK_(f) {
+  var or__3943__auto__ = cljs.core.fn_QMARK_.call(null, f);
+  if(or__3943__auto__) {
+    return or__3943__auto__
+  }else {
+    var G__3564 = f;
+    if(G__3564) {
+      if(function() {
+        var or__3943__auto____$1 = G__3564.cljs$lang$protocol_mask$partition0$ & 1;
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          return G__3564.cljs$core$IFn$
+        }
+      }()) {
+        return true
+      }else {
+        if(!G__3564.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.IFn, G__3564)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.IFn, G__3564)
+    }
+  }
+};
+cljs.core.integer_QMARK_ = function integer_QMARK_(n) {
+  var and__3941__auto__ = typeof n === "number";
+  if(and__3941__auto__) {
+    var and__3941__auto____$1 = !isNaN(n);
+    if(and__3941__auto____$1) {
+      var and__3941__auto____$2 = !(n === Infinity);
+      if(and__3941__auto____$2) {
+        return parseFloat(n) === parseInt(n, 10)
+      }else {
+        return and__3941__auto____$2
+      }
+    }else {
+      return and__3941__auto____$1
+    }
+  }else {
+    return and__3941__auto__
+  }
+};
+cljs.core.contains_QMARK_ = function contains_QMARK_(coll, v) {
+  if(cljs.core.get.call(null, coll, v, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
+    return false
+  }else {
+    return true
+  }
+};
+cljs.core.find = function find(coll, k) {
+  if(function() {
+    var and__3941__auto__ = !(coll == null);
+    if(and__3941__auto__) {
+      var and__3941__auto____$1 = cljs.core.associative_QMARK_.call(null, coll);
+      if(and__3941__auto____$1) {
+        return cljs.core.contains_QMARK_.call(null, coll, k)
+      }else {
+        return and__3941__auto____$1
+      }
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return cljs.core.PersistentVector.fromArray([k, cljs.core.get.call(null, coll, k)], true)
+  }else {
+    return null
+  }
+};
+cljs.core.distinct_QMARK_ = function() {
+  var distinct_QMARK_ = null;
+  var distinct_QMARK___1 = function(x) {
+    return true
+  };
+  var distinct_QMARK___2 = function(x, y) {
+    return!cljs.core._EQ_.call(null, x, y)
+  };
+  var distinct_QMARK___3 = function() {
+    var G__3565__delegate = function(x, y, more) {
+      if(!cljs.core._EQ_.call(null, x, y)) {
+        var s = cljs.core.PersistentHashSet.fromArray([y, null, x, null], true);
+        var xs = more;
+        while(true) {
+          var x__$1 = cljs.core.first.call(null, xs);
+          var etc = cljs.core.next.call(null, xs);
+          if(cljs.core.truth_(xs)) {
+            if(cljs.core.contains_QMARK_.call(null, s, x__$1)) {
+              return false
+            }else {
+              var G__3566 = cljs.core.conj.call(null, s, x__$1);
+              var G__3567 = etc;
+              s = G__3566;
+              xs = G__3567;
+              continue
+            }
+          }else {
+            return true
+          }
+          break
+        }
+      }else {
+        return false
+      }
+    };
+    var G__3565 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3565__delegate.call(this, x, y, more)
+    };
+    G__3565.cljs$lang$maxFixedArity = 2;
+    G__3565.cljs$lang$applyTo = function(arglist__3568) {
+      var x = cljs.core.first(arglist__3568);
+      arglist__3568 = cljs.core.next(arglist__3568);
+      var y = cljs.core.first(arglist__3568);
+      var more = cljs.core.rest(arglist__3568);
+      return G__3565__delegate(x, y, more)
+    };
+    G__3565.cljs$core$IFn$_invoke$arity$variadic = G__3565__delegate;
+    return G__3565
+  }();
+  distinct_QMARK_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return distinct_QMARK___1.call(this, x);
+      case 2:
+        return distinct_QMARK___2.call(this, x, y);
+      default:
+        return distinct_QMARK___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  distinct_QMARK_.cljs$lang$maxFixedArity = 2;
+  distinct_QMARK_.cljs$lang$applyTo = distinct_QMARK___3.cljs$lang$applyTo;
+  distinct_QMARK_.cljs$core$IFn$_invoke$arity$1 = distinct_QMARK___1;
+  distinct_QMARK_.cljs$core$IFn$_invoke$arity$2 = distinct_QMARK___2;
+  distinct_QMARK_.cljs$core$IFn$_invoke$arity$variadic = distinct_QMARK___3.cljs$core$IFn$_invoke$arity$variadic;
+  return distinct_QMARK_
+}();
+cljs.core.compare = function compare(x, y) {
+  if(x === y) {
+    return 0
+  }else {
+    if(x == null) {
+      return-1
+    }else {
+      if(y == null) {
+        return 1
+      }else {
+        if(cljs.core.type.call(null, x) === cljs.core.type.call(null, y)) {
+          if(function() {
+            var G__3570 = x;
+            if(G__3570) {
+              if(function() {
+                var or__3943__auto__ = G__3570.cljs$lang$protocol_mask$partition1$ & 2048;
+                if(or__3943__auto__) {
+                  return or__3943__auto__
+                }else {
+                  return G__3570.cljs$core$IComparable$
+                }
+              }()) {
+                return true
+              }else {
+                return false
+              }
+            }else {
+              return false
+            }
+          }()) {
+            return cljs.core._compare.call(null, x, y)
+          }else {
+            return goog.array.defaultCompare(x, y)
+          }
+        }else {
+          if("\ufdd0:else") {
+            throw new Error("compare on non-nil objects of different types");
+          }else {
+            return null
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.compare_indexed = function() {
+  var compare_indexed = null;
+  var compare_indexed__2 = function(xs, ys) {
+    var xl = cljs.core.count.call(null, xs);
+    var yl = cljs.core.count.call(null, ys);
+    if(xl < yl) {
+      return-1
+    }else {
+      if(xl > yl) {
+        return 1
+      }else {
+        if("\ufdd0:else") {
+          return compare_indexed.call(null, xs, ys, xl, 0)
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var compare_indexed__4 = function(xs, ys, len, n) {
+    while(true) {
+      var d = cljs.core.compare.call(null, cljs.core.nth.call(null, xs, n), cljs.core.nth.call(null, ys, n));
+      if(function() {
+        var and__3941__auto__ = d === 0;
+        if(and__3941__auto__) {
+          return n + 1 < len
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        var G__3571 = xs;
+        var G__3572 = ys;
+        var G__3573 = len;
+        var G__3574 = n + 1;
+        xs = G__3571;
+        ys = G__3572;
+        len = G__3573;
+        n = G__3574;
+        continue
+      }else {
+        return d
+      }
+      break
+    }
+  };
+  compare_indexed = function(xs, ys, len, n) {
+    switch(arguments.length) {
+      case 2:
+        return compare_indexed__2.call(this, xs, ys);
+      case 4:
+        return compare_indexed__4.call(this, xs, ys, len, n)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  compare_indexed.cljs$core$IFn$_invoke$arity$2 = compare_indexed__2;
+  compare_indexed.cljs$core$IFn$_invoke$arity$4 = compare_indexed__4;
+  return compare_indexed
+}();
+cljs.core.fn__GT_comparator = function fn__GT_comparator(f) {
+  if(cljs.core._EQ_.call(null, f, cljs.core.compare)) {
+    return cljs.core.compare
+  }else {
+    return function(x, y) {
+      var r = f.call(null, x, y);
+      if(typeof r === "number") {
+        return r
+      }else {
+        if(cljs.core.truth_(r)) {
+          return-1
+        }else {
+          if(cljs.core.truth_(f.call(null, y, x))) {
+            return 1
+          }else {
+            return 0
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.sort = function() {
+  var sort = null;
+  var sort__1 = function(coll) {
+    return sort.call(null, cljs.core.compare, coll)
+  };
+  var sort__2 = function(comp, coll) {
+    if(cljs.core.seq.call(null, coll)) {
+      var a = cljs.core.to_array.call(null, coll);
+      goog.array.stableSort(a, cljs.core.fn__GT_comparator.call(null, comp));
+      return cljs.core.seq.call(null, a)
+    }else {
+      return cljs.core.List.EMPTY
+    }
+  };
+  sort = function(comp, coll) {
+    switch(arguments.length) {
+      case 1:
+        return sort__1.call(this, comp);
+      case 2:
+        return sort__2.call(this, comp, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  sort.cljs$core$IFn$_invoke$arity$1 = sort__1;
+  sort.cljs$core$IFn$_invoke$arity$2 = sort__2;
+  return sort
+}();
+cljs.core.sort_by = function() {
+  var sort_by = null;
+  var sort_by__2 = function(keyfn, coll) {
+    return sort_by.call(null, keyfn, cljs.core.compare, coll)
+  };
+  var sort_by__3 = function(keyfn, comp, coll) {
+    return cljs.core.sort.call(null, function(x, y) {
+      return cljs.core.fn__GT_comparator.call(null, comp).call(null, keyfn.call(null, x), keyfn.call(null, y))
+    }, coll)
+  };
+  sort_by = function(keyfn, comp, coll) {
+    switch(arguments.length) {
+      case 2:
+        return sort_by__2.call(this, keyfn, comp);
+      case 3:
+        return sort_by__3.call(this, keyfn, comp, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  sort_by.cljs$core$IFn$_invoke$arity$2 = sort_by__2;
+  sort_by.cljs$core$IFn$_invoke$arity$3 = sort_by__3;
+  return sort_by
+}();
+cljs.core.seq_reduce = function() {
+  var seq_reduce = null;
+  var seq_reduce__2 = function(f, coll) {
+    var temp__4090__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4090__auto__) {
+      var s = temp__4090__auto__;
+      return cljs.core.reduce.call(null, f, cljs.core.first.call(null, s), cljs.core.next.call(null, s))
+    }else {
+      return f.call(null)
+    }
+  };
+  var seq_reduce__3 = function(f, val, coll) {
+    var val__$1 = val;
+    var coll__$1 = cljs.core.seq.call(null, coll);
+    while(true) {
+      if(coll__$1) {
+        var nval = f.call(null, val__$1, cljs.core.first.call(null, coll__$1));
+        if(cljs.core.reduced_QMARK_.call(null, nval)) {
+          return cljs.core.deref.call(null, nval)
+        }else {
+          var G__3575 = nval;
+          var G__3576 = cljs.core.next.call(null, coll__$1);
+          val__$1 = G__3575;
+          coll__$1 = G__3576;
+          continue
+        }
+      }else {
+        return val__$1
+      }
+      break
+    }
+  };
+  seq_reduce = function(f, val, coll) {
+    switch(arguments.length) {
+      case 2:
+        return seq_reduce__2.call(this, f, val);
+      case 3:
+        return seq_reduce__3.call(this, f, val, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  seq_reduce.cljs$core$IFn$_invoke$arity$2 = seq_reduce__2;
+  seq_reduce.cljs$core$IFn$_invoke$arity$3 = seq_reduce__3;
+  return seq_reduce
+}();
+cljs.core.shuffle = function shuffle(coll) {
+  var a = cljs.core.to_array.call(null, coll);
+  goog.array.shuffle(a);
+  return cljs.core.vec.call(null, a)
+};
+cljs.core.reduce = function() {
+  var reduce = null;
+  var reduce__2 = function(f, coll) {
+    if(function() {
+      var G__3579 = coll;
+      if(G__3579) {
+        if(function() {
+          var or__3943__auto__ = G__3579.cljs$lang$protocol_mask$partition0$ & 524288;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3579.cljs$core$IReduce$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core._reduce.call(null, coll, f)
+    }else {
+      if(coll instanceof Array) {
+        return cljs.core.array_reduce.call(null, coll, f)
+      }else {
+        if(cljs.core.string_QMARK_.call(null, coll)) {
+          return cljs.core.array_reduce.call(null, coll, f)
+        }else {
+          if(cljs.core.type_satisfies_.call(null, cljs.core.IReduce, coll)) {
+            return cljs.core._reduce.call(null, coll, f)
+          }else {
+            if("\ufdd0:else") {
+              return cljs.core.seq_reduce.call(null, f, coll)
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }
+  };
+  var reduce__3 = function(f, val, coll) {
+    if(function() {
+      var G__3580 = coll;
+      if(G__3580) {
+        if(function() {
+          var or__3943__auto__ = G__3580.cljs$lang$protocol_mask$partition0$ & 524288;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3580.cljs$core$IReduce$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core._reduce.call(null, coll, f, val)
+    }else {
+      if(coll instanceof Array) {
+        return cljs.core.array_reduce.call(null, coll, f, val)
+      }else {
+        if(cljs.core.string_QMARK_.call(null, coll)) {
+          return cljs.core.array_reduce.call(null, coll, f, val)
+        }else {
+          if(cljs.core.type_satisfies_.call(null, cljs.core.IReduce, coll)) {
+            return cljs.core._reduce.call(null, coll, f, val)
+          }else {
+            if("\ufdd0:else") {
+              return cljs.core.seq_reduce.call(null, f, val, coll)
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }
+  };
+  reduce = function(f, val, coll) {
+    switch(arguments.length) {
+      case 2:
+        return reduce__2.call(this, f, val);
+      case 3:
+        return reduce__3.call(this, f, val, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  reduce.cljs$core$IFn$_invoke$arity$2 = reduce__2;
+  reduce.cljs$core$IFn$_invoke$arity$3 = reduce__3;
+  return reduce
+}();
+cljs.core.reduce_kv = function reduce_kv(f, init, coll) {
+  return cljs.core._kv_reduce.call(null, coll, f, init)
+};
+cljs.core._PLUS_ = function() {
+  var _PLUS_ = null;
+  var _PLUS___0 = function() {
+    return 0
+  };
+  var _PLUS___1 = function(x) {
+    return x
+  };
+  var _PLUS___2 = function(x, y) {
+    return x + y
+  };
+  var _PLUS___3 = function() {
+    var G__3581__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _PLUS_, x + y, more)
+    };
+    var G__3581 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3581__delegate.call(this, x, y, more)
+    };
+    G__3581.cljs$lang$maxFixedArity = 2;
+    G__3581.cljs$lang$applyTo = function(arglist__3582) {
+      var x = cljs.core.first(arglist__3582);
+      arglist__3582 = cljs.core.next(arglist__3582);
+      var y = cljs.core.first(arglist__3582);
+      var more = cljs.core.rest(arglist__3582);
+      return G__3581__delegate(x, y, more)
+    };
+    G__3581.cljs$core$IFn$_invoke$arity$variadic = G__3581__delegate;
+    return G__3581
+  }();
+  _PLUS_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 0:
+        return _PLUS___0.call(this);
+      case 1:
+        return _PLUS___1.call(this, x);
+      case 2:
+        return _PLUS___2.call(this, x, y);
+      default:
+        return _PLUS___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _PLUS_.cljs$lang$maxFixedArity = 2;
+  _PLUS_.cljs$lang$applyTo = _PLUS___3.cljs$lang$applyTo;
+  _PLUS_.cljs$core$IFn$_invoke$arity$0 = _PLUS___0;
+  _PLUS_.cljs$core$IFn$_invoke$arity$1 = _PLUS___1;
+  _PLUS_.cljs$core$IFn$_invoke$arity$2 = _PLUS___2;
+  _PLUS_.cljs$core$IFn$_invoke$arity$variadic = _PLUS___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _PLUS_
+}();
+cljs.core._ = function() {
+  var _ = null;
+  var ___1 = function(x) {
+    return-x
+  };
+  var ___2 = function(x, y) {
+    return x - y
+  };
+  var ___3 = function() {
+    var G__3583__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _, x - y, more)
+    };
+    var G__3583 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3583__delegate.call(this, x, y, more)
+    };
+    G__3583.cljs$lang$maxFixedArity = 2;
+    G__3583.cljs$lang$applyTo = function(arglist__3584) {
+      var x = cljs.core.first(arglist__3584);
+      arglist__3584 = cljs.core.next(arglist__3584);
+      var y = cljs.core.first(arglist__3584);
+      var more = cljs.core.rest(arglist__3584);
+      return G__3583__delegate(x, y, more)
+    };
+    G__3583.cljs$core$IFn$_invoke$arity$variadic = G__3583__delegate;
+    return G__3583
+  }();
+  _ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return ___1.call(this, x);
+      case 2:
+        return ___2.call(this, x, y);
+      default:
+        return ___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _.cljs$lang$maxFixedArity = 2;
+  _.cljs$lang$applyTo = ___3.cljs$lang$applyTo;
+  _.cljs$core$IFn$_invoke$arity$1 = ___1;
+  _.cljs$core$IFn$_invoke$arity$2 = ___2;
+  _.cljs$core$IFn$_invoke$arity$variadic = ___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _
+}();
+cljs.core._STAR_ = function() {
+  var _STAR_ = null;
+  var _STAR___0 = function() {
+    return 1
+  };
+  var _STAR___1 = function(x) {
+    return x
+  };
+  var _STAR___2 = function(x, y) {
+    return x * y
+  };
+  var _STAR___3 = function() {
+    var G__3585__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _STAR_, x * y, more)
+    };
+    var G__3585 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3585__delegate.call(this, x, y, more)
+    };
+    G__3585.cljs$lang$maxFixedArity = 2;
+    G__3585.cljs$lang$applyTo = function(arglist__3586) {
+      var x = cljs.core.first(arglist__3586);
+      arglist__3586 = cljs.core.next(arglist__3586);
+      var y = cljs.core.first(arglist__3586);
+      var more = cljs.core.rest(arglist__3586);
+      return G__3585__delegate(x, y, more)
+    };
+    G__3585.cljs$core$IFn$_invoke$arity$variadic = G__3585__delegate;
+    return G__3585
+  }();
+  _STAR_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 0:
+        return _STAR___0.call(this);
+      case 1:
+        return _STAR___1.call(this, x);
+      case 2:
+        return _STAR___2.call(this, x, y);
+      default:
+        return _STAR___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _STAR_.cljs$lang$maxFixedArity = 2;
+  _STAR_.cljs$lang$applyTo = _STAR___3.cljs$lang$applyTo;
+  _STAR_.cljs$core$IFn$_invoke$arity$0 = _STAR___0;
+  _STAR_.cljs$core$IFn$_invoke$arity$1 = _STAR___1;
+  _STAR_.cljs$core$IFn$_invoke$arity$2 = _STAR___2;
+  _STAR_.cljs$core$IFn$_invoke$arity$variadic = _STAR___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _STAR_
+}();
+cljs.core._SLASH_ = function() {
+  var _SLASH_ = null;
+  var _SLASH___1 = function(x) {
+    return _SLASH_.call(null, 1, x)
+  };
+  var _SLASH___2 = function(x, y) {
+    return x / y
+  };
+  var _SLASH___3 = function() {
+    var G__3587__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _SLASH_, _SLASH_.call(null, x, y), more)
+    };
+    var G__3587 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3587__delegate.call(this, x, y, more)
+    };
+    G__3587.cljs$lang$maxFixedArity = 2;
+    G__3587.cljs$lang$applyTo = function(arglist__3588) {
+      var x = cljs.core.first(arglist__3588);
+      arglist__3588 = cljs.core.next(arglist__3588);
+      var y = cljs.core.first(arglist__3588);
+      var more = cljs.core.rest(arglist__3588);
+      return G__3587__delegate(x, y, more)
+    };
+    G__3587.cljs$core$IFn$_invoke$arity$variadic = G__3587__delegate;
+    return G__3587
+  }();
+  _SLASH_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _SLASH___1.call(this, x);
+      case 2:
+        return _SLASH___2.call(this, x, y);
+      default:
+        return _SLASH___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _SLASH_.cljs$lang$maxFixedArity = 2;
+  _SLASH_.cljs$lang$applyTo = _SLASH___3.cljs$lang$applyTo;
+  _SLASH_.cljs$core$IFn$_invoke$arity$1 = _SLASH___1;
+  _SLASH_.cljs$core$IFn$_invoke$arity$2 = _SLASH___2;
+  _SLASH_.cljs$core$IFn$_invoke$arity$variadic = _SLASH___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _SLASH_
+}();
+cljs.core._LT_ = function() {
+  var _LT_ = null;
+  var _LT___1 = function(x) {
+    return true
+  };
+  var _LT___2 = function(x, y) {
+    return x < y
+  };
+  var _LT___3 = function() {
+    var G__3589__delegate = function(x, y, more) {
+      while(true) {
+        if(x < y) {
+          if(cljs.core.next.call(null, more)) {
+            var G__3590 = y;
+            var G__3591 = cljs.core.first.call(null, more);
+            var G__3592 = cljs.core.next.call(null, more);
+            x = G__3590;
+            y = G__3591;
+            more = G__3592;
+            continue
+          }else {
+            return y < cljs.core.first.call(null, more)
+          }
+        }else {
+          return false
+        }
+        break
+      }
+    };
+    var G__3589 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3589__delegate.call(this, x, y, more)
+    };
+    G__3589.cljs$lang$maxFixedArity = 2;
+    G__3589.cljs$lang$applyTo = function(arglist__3593) {
+      var x = cljs.core.first(arglist__3593);
+      arglist__3593 = cljs.core.next(arglist__3593);
+      var y = cljs.core.first(arglist__3593);
+      var more = cljs.core.rest(arglist__3593);
+      return G__3589__delegate(x, y, more)
+    };
+    G__3589.cljs$core$IFn$_invoke$arity$variadic = G__3589__delegate;
+    return G__3589
+  }();
+  _LT_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _LT___1.call(this, x);
+      case 2:
+        return _LT___2.call(this, x, y);
+      default:
+        return _LT___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _LT_.cljs$lang$maxFixedArity = 2;
+  _LT_.cljs$lang$applyTo = _LT___3.cljs$lang$applyTo;
+  _LT_.cljs$core$IFn$_invoke$arity$1 = _LT___1;
+  _LT_.cljs$core$IFn$_invoke$arity$2 = _LT___2;
+  _LT_.cljs$core$IFn$_invoke$arity$variadic = _LT___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _LT_
+}();
+cljs.core._LT__EQ_ = function() {
+  var _LT__EQ_ = null;
+  var _LT__EQ___1 = function(x) {
+    return true
+  };
+  var _LT__EQ___2 = function(x, y) {
+    return x <= y
+  };
+  var _LT__EQ___3 = function() {
+    var G__3594__delegate = function(x, y, more) {
+      while(true) {
+        if(x <= y) {
+          if(cljs.core.next.call(null, more)) {
+            var G__3595 = y;
+            var G__3596 = cljs.core.first.call(null, more);
+            var G__3597 = cljs.core.next.call(null, more);
+            x = G__3595;
+            y = G__3596;
+            more = G__3597;
+            continue
+          }else {
+            return y <= cljs.core.first.call(null, more)
+          }
+        }else {
+          return false
+        }
+        break
+      }
+    };
+    var G__3594 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3594__delegate.call(this, x, y, more)
+    };
+    G__3594.cljs$lang$maxFixedArity = 2;
+    G__3594.cljs$lang$applyTo = function(arglist__3598) {
+      var x = cljs.core.first(arglist__3598);
+      arglist__3598 = cljs.core.next(arglist__3598);
+      var y = cljs.core.first(arglist__3598);
+      var more = cljs.core.rest(arglist__3598);
+      return G__3594__delegate(x, y, more)
+    };
+    G__3594.cljs$core$IFn$_invoke$arity$variadic = G__3594__delegate;
+    return G__3594
+  }();
+  _LT__EQ_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _LT__EQ___1.call(this, x);
+      case 2:
+        return _LT__EQ___2.call(this, x, y);
+      default:
+        return _LT__EQ___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _LT__EQ_.cljs$lang$maxFixedArity = 2;
+  _LT__EQ_.cljs$lang$applyTo = _LT__EQ___3.cljs$lang$applyTo;
+  _LT__EQ_.cljs$core$IFn$_invoke$arity$1 = _LT__EQ___1;
+  _LT__EQ_.cljs$core$IFn$_invoke$arity$2 = _LT__EQ___2;
+  _LT__EQ_.cljs$core$IFn$_invoke$arity$variadic = _LT__EQ___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _LT__EQ_
+}();
+cljs.core._GT_ = function() {
+  var _GT_ = null;
+  var _GT___1 = function(x) {
+    return true
+  };
+  var _GT___2 = function(x, y) {
+    return x > y
+  };
+  var _GT___3 = function() {
+    var G__3599__delegate = function(x, y, more) {
+      while(true) {
+        if(x > y) {
+          if(cljs.core.next.call(null, more)) {
+            var G__3600 = y;
+            var G__3601 = cljs.core.first.call(null, more);
+            var G__3602 = cljs.core.next.call(null, more);
+            x = G__3600;
+            y = G__3601;
+            more = G__3602;
+            continue
+          }else {
+            return y > cljs.core.first.call(null, more)
+          }
+        }else {
+          return false
+        }
+        break
+      }
+    };
+    var G__3599 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3599__delegate.call(this, x, y, more)
+    };
+    G__3599.cljs$lang$maxFixedArity = 2;
+    G__3599.cljs$lang$applyTo = function(arglist__3603) {
+      var x = cljs.core.first(arglist__3603);
+      arglist__3603 = cljs.core.next(arglist__3603);
+      var y = cljs.core.first(arglist__3603);
+      var more = cljs.core.rest(arglist__3603);
+      return G__3599__delegate(x, y, more)
+    };
+    G__3599.cljs$core$IFn$_invoke$arity$variadic = G__3599__delegate;
+    return G__3599
+  }();
+  _GT_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _GT___1.call(this, x);
+      case 2:
+        return _GT___2.call(this, x, y);
+      default:
+        return _GT___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _GT_.cljs$lang$maxFixedArity = 2;
+  _GT_.cljs$lang$applyTo = _GT___3.cljs$lang$applyTo;
+  _GT_.cljs$core$IFn$_invoke$arity$1 = _GT___1;
+  _GT_.cljs$core$IFn$_invoke$arity$2 = _GT___2;
+  _GT_.cljs$core$IFn$_invoke$arity$variadic = _GT___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _GT_
+}();
+cljs.core._GT__EQ_ = function() {
+  var _GT__EQ_ = null;
+  var _GT__EQ___1 = function(x) {
+    return true
+  };
+  var _GT__EQ___2 = function(x, y) {
+    return x >= y
+  };
+  var _GT__EQ___3 = function() {
+    var G__3604__delegate = function(x, y, more) {
+      while(true) {
+        if(x >= y) {
+          if(cljs.core.next.call(null, more)) {
+            var G__3605 = y;
+            var G__3606 = cljs.core.first.call(null, more);
+            var G__3607 = cljs.core.next.call(null, more);
+            x = G__3605;
+            y = G__3606;
+            more = G__3607;
+            continue
+          }else {
+            return y >= cljs.core.first.call(null, more)
+          }
+        }else {
+          return false
+        }
+        break
+      }
+    };
+    var G__3604 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3604__delegate.call(this, x, y, more)
+    };
+    G__3604.cljs$lang$maxFixedArity = 2;
+    G__3604.cljs$lang$applyTo = function(arglist__3608) {
+      var x = cljs.core.first(arglist__3608);
+      arglist__3608 = cljs.core.next(arglist__3608);
+      var y = cljs.core.first(arglist__3608);
+      var more = cljs.core.rest(arglist__3608);
+      return G__3604__delegate(x, y, more)
+    };
+    G__3604.cljs$core$IFn$_invoke$arity$variadic = G__3604__delegate;
+    return G__3604
+  }();
+  _GT__EQ_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _GT__EQ___1.call(this, x);
+      case 2:
+        return _GT__EQ___2.call(this, x, y);
+      default:
+        return _GT__EQ___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _GT__EQ_.cljs$lang$maxFixedArity = 2;
+  _GT__EQ_.cljs$lang$applyTo = _GT__EQ___3.cljs$lang$applyTo;
+  _GT__EQ_.cljs$core$IFn$_invoke$arity$1 = _GT__EQ___1;
+  _GT__EQ_.cljs$core$IFn$_invoke$arity$2 = _GT__EQ___2;
+  _GT__EQ_.cljs$core$IFn$_invoke$arity$variadic = _GT__EQ___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _GT__EQ_
+}();
+cljs.core.dec = function dec(x) {
+  return x - 1
+};
+cljs.core.max = function() {
+  var max = null;
+  var max__1 = function(x) {
+    return x
+  };
+  var max__2 = function(x, y) {
+    return x > y ? x : y
+  };
+  var max__3 = function() {
+    var G__3609__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, max, x > y ? x : y, more)
+    };
+    var G__3609 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3609__delegate.call(this, x, y, more)
+    };
+    G__3609.cljs$lang$maxFixedArity = 2;
+    G__3609.cljs$lang$applyTo = function(arglist__3610) {
+      var x = cljs.core.first(arglist__3610);
+      arglist__3610 = cljs.core.next(arglist__3610);
+      var y = cljs.core.first(arglist__3610);
+      var more = cljs.core.rest(arglist__3610);
+      return G__3609__delegate(x, y, more)
+    };
+    G__3609.cljs$core$IFn$_invoke$arity$variadic = G__3609__delegate;
+    return G__3609
+  }();
+  max = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return max__1.call(this, x);
+      case 2:
+        return max__2.call(this, x, y);
+      default:
+        return max__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  max.cljs$lang$maxFixedArity = 2;
+  max.cljs$lang$applyTo = max__3.cljs$lang$applyTo;
+  max.cljs$core$IFn$_invoke$arity$1 = max__1;
+  max.cljs$core$IFn$_invoke$arity$2 = max__2;
+  max.cljs$core$IFn$_invoke$arity$variadic = max__3.cljs$core$IFn$_invoke$arity$variadic;
+  return max
+}();
+cljs.core.min = function() {
+  var min = null;
+  var min__1 = function(x) {
+    return x
+  };
+  var min__2 = function(x, y) {
+    return x < y ? x : y
+  };
+  var min__3 = function() {
+    var G__3611__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, min, x < y ? x : y, more)
+    };
+    var G__3611 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3611__delegate.call(this, x, y, more)
+    };
+    G__3611.cljs$lang$maxFixedArity = 2;
+    G__3611.cljs$lang$applyTo = function(arglist__3612) {
+      var x = cljs.core.first(arglist__3612);
+      arglist__3612 = cljs.core.next(arglist__3612);
+      var y = cljs.core.first(arglist__3612);
+      var more = cljs.core.rest(arglist__3612);
+      return G__3611__delegate(x, y, more)
+    };
+    G__3611.cljs$core$IFn$_invoke$arity$variadic = G__3611__delegate;
+    return G__3611
+  }();
+  min = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return min__1.call(this, x);
+      case 2:
+        return min__2.call(this, x, y);
+      default:
+        return min__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  min.cljs$lang$maxFixedArity = 2;
+  min.cljs$lang$applyTo = min__3.cljs$lang$applyTo;
+  min.cljs$core$IFn$_invoke$arity$1 = min__1;
+  min.cljs$core$IFn$_invoke$arity$2 = min__2;
+  min.cljs$core$IFn$_invoke$arity$variadic = min__3.cljs$core$IFn$_invoke$arity$variadic;
+  return min
+}();
+cljs.core.byte$ = function byte$(x) {
+  return x
+};
+cljs.core.char$ = function char$(x) {
+  if(typeof x === "number") {
+    return String.fromCharCode(x)
+  }else {
+    if(function() {
+      var and__3941__auto__ = cljs.core.string_QMARK_.call(null, x);
+      if(and__3941__auto__) {
+        return x.length === 1
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return x
+    }else {
+      if("\ufdd0:else") {
+        throw new Error("Argument to char must be a character or number");
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.short$ = function short$(x) {
+  return x
+};
+cljs.core.float$ = function float$(x) {
+  return x
+};
+cljs.core.double$ = function double$(x) {
+  return x
+};
+cljs.core.unchecked_byte = function unchecked_byte(x) {
+  return x
+};
+cljs.core.unchecked_char = function unchecked_char(x) {
+  return x
+};
+cljs.core.unchecked_short = function unchecked_short(x) {
+  return x
+};
+cljs.core.unchecked_float = function unchecked_float(x) {
+  return x
+};
+cljs.core.unchecked_double = function unchecked_double(x) {
+  return x
+};
+cljs.core.unchecked_add = function() {
+  var unchecked_add = null;
+  var unchecked_add__0 = function() {
+    return 0
+  };
+  var unchecked_add__1 = function(x) {
+    return x
+  };
+  var unchecked_add__2 = function(x, y) {
+    return x + y
+  };
+  var unchecked_add__3 = function() {
+    var G__3613__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_add, x + y, more)
+    };
+    var G__3613 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3613__delegate.call(this, x, y, more)
+    };
+    G__3613.cljs$lang$maxFixedArity = 2;
+    G__3613.cljs$lang$applyTo = function(arglist__3614) {
+      var x = cljs.core.first(arglist__3614);
+      arglist__3614 = cljs.core.next(arglist__3614);
+      var y = cljs.core.first(arglist__3614);
+      var more = cljs.core.rest(arglist__3614);
+      return G__3613__delegate(x, y, more)
+    };
+    G__3613.cljs$core$IFn$_invoke$arity$variadic = G__3613__delegate;
+    return G__3613
+  }();
+  unchecked_add = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 0:
+        return unchecked_add__0.call(this);
+      case 1:
+        return unchecked_add__1.call(this, x);
+      case 2:
+        return unchecked_add__2.call(this, x, y);
+      default:
+        return unchecked_add__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_add.cljs$lang$maxFixedArity = 2;
+  unchecked_add.cljs$lang$applyTo = unchecked_add__3.cljs$lang$applyTo;
+  unchecked_add.cljs$core$IFn$_invoke$arity$0 = unchecked_add__0;
+  unchecked_add.cljs$core$IFn$_invoke$arity$1 = unchecked_add__1;
+  unchecked_add.cljs$core$IFn$_invoke$arity$2 = unchecked_add__2;
+  unchecked_add.cljs$core$IFn$_invoke$arity$variadic = unchecked_add__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_add
+}();
+cljs.core.unchecked_add_int = function() {
+  var unchecked_add_int = null;
+  var unchecked_add_int__0 = function() {
+    return 0
+  };
+  var unchecked_add_int__1 = function(x) {
+    return x
+  };
+  var unchecked_add_int__2 = function(x, y) {
+    return x + y
+  };
+  var unchecked_add_int__3 = function() {
+    var G__3615__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_add_int, x + y, more)
+    };
+    var G__3615 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3615__delegate.call(this, x, y, more)
+    };
+    G__3615.cljs$lang$maxFixedArity = 2;
+    G__3615.cljs$lang$applyTo = function(arglist__3616) {
+      var x = cljs.core.first(arglist__3616);
+      arglist__3616 = cljs.core.next(arglist__3616);
+      var y = cljs.core.first(arglist__3616);
+      var more = cljs.core.rest(arglist__3616);
+      return G__3615__delegate(x, y, more)
+    };
+    G__3615.cljs$core$IFn$_invoke$arity$variadic = G__3615__delegate;
+    return G__3615
+  }();
+  unchecked_add_int = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 0:
+        return unchecked_add_int__0.call(this);
+      case 1:
+        return unchecked_add_int__1.call(this, x);
+      case 2:
+        return unchecked_add_int__2.call(this, x, y);
+      default:
+        return unchecked_add_int__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_add_int.cljs$lang$maxFixedArity = 2;
+  unchecked_add_int.cljs$lang$applyTo = unchecked_add_int__3.cljs$lang$applyTo;
+  unchecked_add_int.cljs$core$IFn$_invoke$arity$0 = unchecked_add_int__0;
+  unchecked_add_int.cljs$core$IFn$_invoke$arity$1 = unchecked_add_int__1;
+  unchecked_add_int.cljs$core$IFn$_invoke$arity$2 = unchecked_add_int__2;
+  unchecked_add_int.cljs$core$IFn$_invoke$arity$variadic = unchecked_add_int__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_add_int
+}();
+cljs.core.unchecked_dec = function unchecked_dec(x) {
+  return x - 1
+};
+cljs.core.unchecked_dec_int = function unchecked_dec_int(x) {
+  return x - 1
+};
+cljs.core.unchecked_divide_int = function() {
+  var unchecked_divide_int = null;
+  var unchecked_divide_int__1 = function(x) {
+    return unchecked_divide_int.call(null, 1, x)
+  };
+  var unchecked_divide_int__2 = function(x, y) {
+    return x / y
+  };
+  var unchecked_divide_int__3 = function() {
+    var G__3617__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_divide_int, unchecked_divide_int.call(null, x, y), more)
+    };
+    var G__3617 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3617__delegate.call(this, x, y, more)
+    };
+    G__3617.cljs$lang$maxFixedArity = 2;
+    G__3617.cljs$lang$applyTo = function(arglist__3618) {
+      var x = cljs.core.first(arglist__3618);
+      arglist__3618 = cljs.core.next(arglist__3618);
+      var y = cljs.core.first(arglist__3618);
+      var more = cljs.core.rest(arglist__3618);
+      return G__3617__delegate(x, y, more)
+    };
+    G__3617.cljs$core$IFn$_invoke$arity$variadic = G__3617__delegate;
+    return G__3617
+  }();
+  unchecked_divide_int = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return unchecked_divide_int__1.call(this, x);
+      case 2:
+        return unchecked_divide_int__2.call(this, x, y);
+      default:
+        return unchecked_divide_int__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_divide_int.cljs$lang$maxFixedArity = 2;
+  unchecked_divide_int.cljs$lang$applyTo = unchecked_divide_int__3.cljs$lang$applyTo;
+  unchecked_divide_int.cljs$core$IFn$_invoke$arity$1 = unchecked_divide_int__1;
+  unchecked_divide_int.cljs$core$IFn$_invoke$arity$2 = unchecked_divide_int__2;
+  unchecked_divide_int.cljs$core$IFn$_invoke$arity$variadic = unchecked_divide_int__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_divide_int
+}();
+cljs.core.unchecked_inc = function unchecked_inc(x) {
+  return x + 1
+};
+cljs.core.unchecked_inc_int = function unchecked_inc_int(x) {
+  return x + 1
+};
+cljs.core.unchecked_multiply = function() {
+  var unchecked_multiply = null;
+  var unchecked_multiply__0 = function() {
+    return 1
+  };
+  var unchecked_multiply__1 = function(x) {
+    return x
+  };
+  var unchecked_multiply__2 = function(x, y) {
+    return x * y
+  };
+  var unchecked_multiply__3 = function() {
+    var G__3619__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_multiply, x * y, more)
+    };
+    var G__3619 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3619__delegate.call(this, x, y, more)
+    };
+    G__3619.cljs$lang$maxFixedArity = 2;
+    G__3619.cljs$lang$applyTo = function(arglist__3620) {
+      var x = cljs.core.first(arglist__3620);
+      arglist__3620 = cljs.core.next(arglist__3620);
+      var y = cljs.core.first(arglist__3620);
+      var more = cljs.core.rest(arglist__3620);
+      return G__3619__delegate(x, y, more)
+    };
+    G__3619.cljs$core$IFn$_invoke$arity$variadic = G__3619__delegate;
+    return G__3619
+  }();
+  unchecked_multiply = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 0:
+        return unchecked_multiply__0.call(this);
+      case 1:
+        return unchecked_multiply__1.call(this, x);
+      case 2:
+        return unchecked_multiply__2.call(this, x, y);
+      default:
+        return unchecked_multiply__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_multiply.cljs$lang$maxFixedArity = 2;
+  unchecked_multiply.cljs$lang$applyTo = unchecked_multiply__3.cljs$lang$applyTo;
+  unchecked_multiply.cljs$core$IFn$_invoke$arity$0 = unchecked_multiply__0;
+  unchecked_multiply.cljs$core$IFn$_invoke$arity$1 = unchecked_multiply__1;
+  unchecked_multiply.cljs$core$IFn$_invoke$arity$2 = unchecked_multiply__2;
+  unchecked_multiply.cljs$core$IFn$_invoke$arity$variadic = unchecked_multiply__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_multiply
+}();
+cljs.core.unchecked_multiply_int = function() {
+  var unchecked_multiply_int = null;
+  var unchecked_multiply_int__0 = function() {
+    return 1
+  };
+  var unchecked_multiply_int__1 = function(x) {
+    return x
+  };
+  var unchecked_multiply_int__2 = function(x, y) {
+    return x * y
+  };
+  var unchecked_multiply_int__3 = function() {
+    var G__3621__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_multiply_int, x * y, more)
+    };
+    var G__3621 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3621__delegate.call(this, x, y, more)
+    };
+    G__3621.cljs$lang$maxFixedArity = 2;
+    G__3621.cljs$lang$applyTo = function(arglist__3622) {
+      var x = cljs.core.first(arglist__3622);
+      arglist__3622 = cljs.core.next(arglist__3622);
+      var y = cljs.core.first(arglist__3622);
+      var more = cljs.core.rest(arglist__3622);
+      return G__3621__delegate(x, y, more)
+    };
+    G__3621.cljs$core$IFn$_invoke$arity$variadic = G__3621__delegate;
+    return G__3621
+  }();
+  unchecked_multiply_int = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 0:
+        return unchecked_multiply_int__0.call(this);
+      case 1:
+        return unchecked_multiply_int__1.call(this, x);
+      case 2:
+        return unchecked_multiply_int__2.call(this, x, y);
+      default:
+        return unchecked_multiply_int__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_multiply_int.cljs$lang$maxFixedArity = 2;
+  unchecked_multiply_int.cljs$lang$applyTo = unchecked_multiply_int__3.cljs$lang$applyTo;
+  unchecked_multiply_int.cljs$core$IFn$_invoke$arity$0 = unchecked_multiply_int__0;
+  unchecked_multiply_int.cljs$core$IFn$_invoke$arity$1 = unchecked_multiply_int__1;
+  unchecked_multiply_int.cljs$core$IFn$_invoke$arity$2 = unchecked_multiply_int__2;
+  unchecked_multiply_int.cljs$core$IFn$_invoke$arity$variadic = unchecked_multiply_int__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_multiply_int
+}();
+cljs.core.unchecked_negate = function unchecked_negate(x) {
+  return-x
+};
+cljs.core.unchecked_negate_int = function unchecked_negate_int(x) {
+  return-x
+};
+cljs.core.unchecked_remainder_int = function unchecked_remainder_int(x, n) {
+  return cljs.core.mod.call(null, x, n)
+};
+cljs.core.unchecked_substract = function() {
+  var unchecked_substract = null;
+  var unchecked_substract__1 = function(x) {
+    return-x
+  };
+  var unchecked_substract__2 = function(x, y) {
+    return x - y
+  };
+  var unchecked_substract__3 = function() {
+    var G__3623__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_substract, x - y, more)
+    };
+    var G__3623 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3623__delegate.call(this, x, y, more)
+    };
+    G__3623.cljs$lang$maxFixedArity = 2;
+    G__3623.cljs$lang$applyTo = function(arglist__3624) {
+      var x = cljs.core.first(arglist__3624);
+      arglist__3624 = cljs.core.next(arglist__3624);
+      var y = cljs.core.first(arglist__3624);
+      var more = cljs.core.rest(arglist__3624);
+      return G__3623__delegate(x, y, more)
+    };
+    G__3623.cljs$core$IFn$_invoke$arity$variadic = G__3623__delegate;
+    return G__3623
+  }();
+  unchecked_substract = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return unchecked_substract__1.call(this, x);
+      case 2:
+        return unchecked_substract__2.call(this, x, y);
+      default:
+        return unchecked_substract__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_substract.cljs$lang$maxFixedArity = 2;
+  unchecked_substract.cljs$lang$applyTo = unchecked_substract__3.cljs$lang$applyTo;
+  unchecked_substract.cljs$core$IFn$_invoke$arity$1 = unchecked_substract__1;
+  unchecked_substract.cljs$core$IFn$_invoke$arity$2 = unchecked_substract__2;
+  unchecked_substract.cljs$core$IFn$_invoke$arity$variadic = unchecked_substract__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_substract
+}();
+cljs.core.unchecked_substract_int = function() {
+  var unchecked_substract_int = null;
+  var unchecked_substract_int__1 = function(x) {
+    return-x
+  };
+  var unchecked_substract_int__2 = function(x, y) {
+    return x - y
+  };
+  var unchecked_substract_int__3 = function() {
+    var G__3625__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_substract_int, x - y, more)
+    };
+    var G__3625 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3625__delegate.call(this, x, y, more)
+    };
+    G__3625.cljs$lang$maxFixedArity = 2;
+    G__3625.cljs$lang$applyTo = function(arglist__3626) {
+      var x = cljs.core.first(arglist__3626);
+      arglist__3626 = cljs.core.next(arglist__3626);
+      var y = cljs.core.first(arglist__3626);
+      var more = cljs.core.rest(arglist__3626);
+      return G__3625__delegate(x, y, more)
+    };
+    G__3625.cljs$core$IFn$_invoke$arity$variadic = G__3625__delegate;
+    return G__3625
+  }();
+  unchecked_substract_int = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return unchecked_substract_int__1.call(this, x);
+      case 2:
+        return unchecked_substract_int__2.call(this, x, y);
+      default:
+        return unchecked_substract_int__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  unchecked_substract_int.cljs$lang$maxFixedArity = 2;
+  unchecked_substract_int.cljs$lang$applyTo = unchecked_substract_int__3.cljs$lang$applyTo;
+  unchecked_substract_int.cljs$core$IFn$_invoke$arity$1 = unchecked_substract_int__1;
+  unchecked_substract_int.cljs$core$IFn$_invoke$arity$2 = unchecked_substract_int__2;
+  unchecked_substract_int.cljs$core$IFn$_invoke$arity$variadic = unchecked_substract_int__3.cljs$core$IFn$_invoke$arity$variadic;
+  return unchecked_substract_int
+}();
+cljs.core.fix = function fix(q) {
+  if(q >= 0) {
+    return Math.floor.call(null, q)
+  }else {
+    return Math.ceil.call(null, q)
+  }
+};
+cljs.core.int$ = function int$(x) {
+  return x | 0
+};
+cljs.core.unchecked_int = function unchecked_int(x) {
+  return cljs.core.fix.call(null, x)
+};
+cljs.core.long$ = function long$(x) {
+  return cljs.core.fix.call(null, x)
+};
+cljs.core.unchecked_long = function unchecked_long(x) {
+  return cljs.core.fix.call(null, x)
+};
+cljs.core.booleans = function booleans(x) {
+  return x
+};
+cljs.core.bytes = function bytes(x) {
+  return x
+};
+cljs.core.chars = function chars(x) {
+  return x
+};
+cljs.core.shorts = function shorts(x) {
+  return x
+};
+cljs.core.ints = function ints(x) {
+  return x
+};
+cljs.core.floats = function floats(x) {
+  return x
+};
+cljs.core.doubles = function doubles(x) {
+  return x
+};
+cljs.core.longs = function longs(x) {
+  return x
+};
+cljs.core.js_mod = function js_mod(n, d) {
+  return n % d
+};
+cljs.core.mod = function mod(n, d) {
+  return(n % d + d) % d
+};
+cljs.core.quot = function quot(n, d) {
+  var rem = n % d;
+  return cljs.core.fix.call(null, (n - rem) / d)
+};
+cljs.core.rem = function rem(n, d) {
+  var q = cljs.core.quot.call(null, n, d);
+  return n - d * q
+};
+cljs.core.rand = function() {
+  var rand = null;
+  var rand__0 = function() {
+    return Math.random.call(null)
+  };
+  var rand__1 = function(n) {
+    return n * rand.call(null)
+  };
+  rand = function(n) {
+    switch(arguments.length) {
+      case 0:
+        return rand__0.call(this);
+      case 1:
+        return rand__1.call(this, n)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  rand.cljs$core$IFn$_invoke$arity$0 = rand__0;
+  rand.cljs$core$IFn$_invoke$arity$1 = rand__1;
+  return rand
+}();
+cljs.core.rand_int = function rand_int(n) {
+  return cljs.core.fix.call(null, cljs.core.rand.call(null, n))
+};
+cljs.core.bit_xor = function bit_xor(x, y) {
+  return x ^ y
+};
+cljs.core.bit_and = function bit_and(x, y) {
+  return x & y
+};
+cljs.core.bit_or = function bit_or(x, y) {
+  return x | y
+};
+cljs.core.bit_and_not = function bit_and_not(x, y) {
+  return x & ~y
+};
+cljs.core.bit_clear = function bit_clear(x, n) {
+  return x & ~(1 << n)
+};
+cljs.core.bit_flip = function bit_flip(x, n) {
+  return x ^ 1 << n
+};
+cljs.core.bit_not = function bit_not(x) {
+  return~x
+};
+cljs.core.bit_set = function bit_set(x, n) {
+  return x | 1 << n
+};
+cljs.core.bit_test = function bit_test(x, n) {
+  return(x & 1 << n) != 0
+};
+cljs.core.bit_shift_left = function bit_shift_left(x, n) {
+  return x << n
+};
+cljs.core.bit_shift_right = function bit_shift_right(x, n) {
+  return x >> n
+};
+cljs.core.bit_shift_right_zero_fill = function bit_shift_right_zero_fill(x, n) {
+  return x >>> n
+};
+cljs.core.bit_count = function bit_count(v) {
+  var v__$1 = v - (v >> 1 & 1431655765);
+  var v__$2 = (v__$1 & 858993459) + (v__$1 >> 2 & 858993459);
+  return(v__$2 + (v__$2 >> 4) & 252645135) * 16843009 >> 24
+};
+cljs.core._EQ__EQ_ = function() {
+  var _EQ__EQ_ = null;
+  var _EQ__EQ___1 = function(x) {
+    return true
+  };
+  var _EQ__EQ___2 = function(x, y) {
+    return cljs.core._equiv.call(null, x, y)
+  };
+  var _EQ__EQ___3 = function() {
+    var G__3627__delegate = function(x, y, more) {
+      while(true) {
+        if(cljs.core.truth_(_EQ__EQ_.call(null, x, y))) {
+          if(cljs.core.next.call(null, more)) {
+            var G__3628 = y;
+            var G__3629 = cljs.core.first.call(null, more);
+            var G__3630 = cljs.core.next.call(null, more);
+            x = G__3628;
+            y = G__3629;
+            more = G__3630;
+            continue
+          }else {
+            return _EQ__EQ_.call(null, y, cljs.core.first.call(null, more))
+          }
+        }else {
+          return false
+        }
+        break
+      }
+    };
+    var G__3627 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3627__delegate.call(this, x, y, more)
+    };
+    G__3627.cljs$lang$maxFixedArity = 2;
+    G__3627.cljs$lang$applyTo = function(arglist__3631) {
+      var x = cljs.core.first(arglist__3631);
+      arglist__3631 = cljs.core.next(arglist__3631);
+      var y = cljs.core.first(arglist__3631);
+      var more = cljs.core.rest(arglist__3631);
+      return G__3627__delegate(x, y, more)
+    };
+    G__3627.cljs$core$IFn$_invoke$arity$variadic = G__3627__delegate;
+    return G__3627
+  }();
+  _EQ__EQ_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return _EQ__EQ___1.call(this, x);
+      case 2:
+        return _EQ__EQ___2.call(this, x, y);
+      default:
+        return _EQ__EQ___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  _EQ__EQ_.cljs$lang$maxFixedArity = 2;
+  _EQ__EQ_.cljs$lang$applyTo = _EQ__EQ___3.cljs$lang$applyTo;
+  _EQ__EQ_.cljs$core$IFn$_invoke$arity$1 = _EQ__EQ___1;
+  _EQ__EQ_.cljs$core$IFn$_invoke$arity$2 = _EQ__EQ___2;
+  _EQ__EQ_.cljs$core$IFn$_invoke$arity$variadic = _EQ__EQ___3.cljs$core$IFn$_invoke$arity$variadic;
+  return _EQ__EQ_
+}();
+cljs.core.pos_QMARK_ = function pos_QMARK_(n) {
+  return n > 0
+};
+cljs.core.zero_QMARK_ = function zero_QMARK_(n) {
+  return n === 0
+};
+cljs.core.neg_QMARK_ = function neg_QMARK_(x) {
+  return x < 0
+};
+cljs.core.nthnext = function nthnext(coll, n) {
+  var n__$1 = n;
+  var xs = cljs.core.seq.call(null, coll);
+  while(true) {
+    if(cljs.core.truth_(function() {
+      var and__3941__auto__ = xs;
+      if(and__3941__auto__) {
+        return n__$1 > 0
+      }else {
+        return and__3941__auto__
+      }
+    }())) {
+      var G__3632 = n__$1 - 1;
+      var G__3633 = cljs.core.next.call(null, xs);
+      n__$1 = G__3632;
+      xs = G__3633;
+      continue
+    }else {
+      return xs
+    }
+    break
+  }
+};
+cljs.core.str_STAR_ = function() {
+  var str_STAR_ = null;
+  var str_STAR___0 = function() {
+    return""
+  };
+  var str_STAR___1 = function(x) {
+    if(x == null) {
+      return""
+    }else {
+      if("\ufdd0:else") {
+        return x.toString()
+      }else {
+        return null
+      }
+    }
+  };
+  var str_STAR___2 = function() {
+    var G__3634__delegate = function(x, ys) {
+      return function(sb, more) {
+        while(true) {
+          if(cljs.core.truth_(more)) {
+            var G__3635 = sb.append(str_STAR_.call(null, cljs.core.first.call(null, more)));
+            var G__3636 = cljs.core.next.call(null, more);
+            sb = G__3635;
+            more = G__3636;
+            continue
+          }else {
+            return str_STAR_.call(null, sb)
+          }
+          break
+        }
+      }.call(null, new goog.string.StringBuffer(str_STAR_.call(null, x)), ys)
+    };
+    var G__3634 = function(x, var_args) {
+      var ys = null;
+      if(arguments.length > 1) {
+        ys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+      }
+      return G__3634__delegate.call(this, x, ys)
+    };
+    G__3634.cljs$lang$maxFixedArity = 1;
+    G__3634.cljs$lang$applyTo = function(arglist__3637) {
+      var x = cljs.core.first(arglist__3637);
+      var ys = cljs.core.rest(arglist__3637);
+      return G__3634__delegate(x, ys)
+    };
+    G__3634.cljs$core$IFn$_invoke$arity$variadic = G__3634__delegate;
+    return G__3634
+  }();
+  str_STAR_ = function(x, var_args) {
+    var ys = var_args;
+    switch(arguments.length) {
+      case 0:
+        return str_STAR___0.call(this);
+      case 1:
+        return str_STAR___1.call(this, x);
+      default:
+        return str_STAR___2.cljs$core$IFn$_invoke$arity$variadic(x, cljs.core.array_seq(arguments, 1))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  str_STAR_.cljs$lang$maxFixedArity = 1;
+  str_STAR_.cljs$lang$applyTo = str_STAR___2.cljs$lang$applyTo;
+  str_STAR_.cljs$core$IFn$_invoke$arity$0 = str_STAR___0;
+  str_STAR_.cljs$core$IFn$_invoke$arity$1 = str_STAR___1;
+  str_STAR_.cljs$core$IFn$_invoke$arity$variadic = str_STAR___2.cljs$core$IFn$_invoke$arity$variadic;
+  return str_STAR_
+}();
+cljs.core.str = function() {
+  var str = null;
+  var str__0 = function() {
+    return""
+  };
+  var str__1 = function(x) {
+    if(cljs.core.keyword_QMARK_.call(null, x)) {
+      return cljs.core.str_STAR_.call(null, ":", x.substring(2, x.length))
+    }else {
+      if(x == null) {
+        return""
+      }else {
+        if("\ufdd0:else") {
+          return x.toString()
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var str__2 = function() {
+    var G__3638__delegate = function(x, ys) {
+      return function(sb, more) {
+        while(true) {
+          if(cljs.core.truth_(more)) {
+            var G__3639 = sb.append(str.call(null, cljs.core.first.call(null, more)));
+            var G__3640 = cljs.core.next.call(null, more);
+            sb = G__3639;
+            more = G__3640;
+            continue
+          }else {
+            return cljs.core.str_STAR_.call(null, sb)
+          }
+          break
+        }
+      }.call(null, new goog.string.StringBuffer(str.call(null, x)), ys)
+    };
+    var G__3638 = function(x, var_args) {
+      var ys = null;
+      if(arguments.length > 1) {
+        ys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+      }
+      return G__3638__delegate.call(this, x, ys)
+    };
+    G__3638.cljs$lang$maxFixedArity = 1;
+    G__3638.cljs$lang$applyTo = function(arglist__3641) {
+      var x = cljs.core.first(arglist__3641);
+      var ys = cljs.core.rest(arglist__3641);
+      return G__3638__delegate(x, ys)
+    };
+    G__3638.cljs$core$IFn$_invoke$arity$variadic = G__3638__delegate;
+    return G__3638
+  }();
+  str = function(x, var_args) {
+    var ys = var_args;
+    switch(arguments.length) {
+      case 0:
+        return str__0.call(this);
+      case 1:
+        return str__1.call(this, x);
+      default:
+        return str__2.cljs$core$IFn$_invoke$arity$variadic(x, cljs.core.array_seq(arguments, 1))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  str.cljs$lang$maxFixedArity = 1;
+  str.cljs$lang$applyTo = str__2.cljs$lang$applyTo;
+  str.cljs$core$IFn$_invoke$arity$0 = str__0;
+  str.cljs$core$IFn$_invoke$arity$1 = str__1;
+  str.cljs$core$IFn$_invoke$arity$variadic = str__2.cljs$core$IFn$_invoke$arity$variadic;
+  return str
+}();
+cljs.core.subs = function() {
+  var subs = null;
+  var subs__2 = function(s, start) {
+    return s.substring(start)
+  };
+  var subs__3 = function(s, start, end) {
+    return s.substring(start, end)
+  };
+  subs = function(s, start, end) {
+    switch(arguments.length) {
+      case 2:
+        return subs__2.call(this, s, start);
+      case 3:
+        return subs__3.call(this, s, start, end)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  subs.cljs$core$IFn$_invoke$arity$2 = subs__2;
+  subs.cljs$core$IFn$_invoke$arity$3 = subs__3;
+  return subs
+}();
+cljs.core.format = function() {
+  var format__delegate = function(fmt, args) {
+    var args__$1 = cljs.core.map.call(null, function(x) {
+      if(function() {
+        var or__3943__auto__ = cljs.core.keyword_QMARK_.call(null, x);
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return x instanceof cljs.core.Symbol
+        }
+      }()) {
+        return[cljs.core.str(x)].join("")
+      }else {
+        return x
+      }
+    }, args);
+    return cljs.core.apply.call(null, goog.string.format, fmt, args__$1)
+  };
+  var format = function(fmt, var_args) {
+    var args = null;
+    if(arguments.length > 1) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return format__delegate.call(this, fmt, args)
+  };
+  format.cljs$lang$maxFixedArity = 1;
+  format.cljs$lang$applyTo = function(arglist__3642) {
+    var fmt = cljs.core.first(arglist__3642);
+    var args = cljs.core.rest(arglist__3642);
+    return format__delegate(fmt, args)
+  };
+  format.cljs$core$IFn$_invoke$arity$variadic = format__delegate;
+  return format
+}();
+cljs.core.keyword = function() {
+  var keyword = null;
+  var keyword__1 = function(name) {
+    if(cljs.core.keyword_QMARK_.call(null, name)) {
+      return name
+    }else {
+      if(name instanceof cljs.core.Symbol) {
+        return cljs.core.str_STAR_.call(null, "\ufdd0", ":", cljs.core.subs.call(null, name, 2))
+      }else {
+        if("\ufdd0:else") {
+          return cljs.core.str_STAR_.call(null, "\ufdd0", ":", name)
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var keyword__2 = function(ns, name) {
+    return keyword.call(null, cljs.core.str_STAR_.call(null, ns, "/", name))
+  };
+  keyword = function(ns, name) {
+    switch(arguments.length) {
+      case 1:
+        return keyword__1.call(this, ns);
+      case 2:
+        return keyword__2.call(this, ns, name)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  keyword.cljs$core$IFn$_invoke$arity$1 = keyword__1;
+  keyword.cljs$core$IFn$_invoke$arity$2 = keyword__2;
+  return keyword
+}();
+cljs.core.equiv_sequential = function equiv_sequential(x, y) {
+  return cljs.core.boolean$.call(null, cljs.core.sequential_QMARK_.call(null, y) ? function() {
+    var xs = cljs.core.seq.call(null, x);
+    var ys = cljs.core.seq.call(null, y);
+    while(true) {
+      if(xs == null) {
+        return ys == null
+      }else {
+        if(ys == null) {
+          return false
+        }else {
+          if(cljs.core._EQ_.call(null, cljs.core.first.call(null, xs), cljs.core.first.call(null, ys))) {
+            var G__3643 = cljs.core.next.call(null, xs);
+            var G__3644 = cljs.core.next.call(null, ys);
+            xs = G__3643;
+            ys = G__3644;
+            continue
+          }else {
+            if("\ufdd0:else") {
+              return false
+            }else {
+              return null
+            }
+          }
+        }
+      }
+      break
+    }
+  }() : null)
+};
+cljs.core.hash_combine = function hash_combine(seed, hash) {
+  return seed ^ hash + 2654435769 + (seed << 6) + (seed >> 2)
+};
+cljs.core.hash_coll = function hash_coll(coll) {
+  return cljs.core.reduce.call(null, function(p1__3645_SHARP_, p2__3646_SHARP_) {
+    return cljs.core.hash_combine.call(null, p1__3645_SHARP_, cljs.core.hash.call(null, p2__3646_SHARP_, false))
+  }, cljs.core.hash.call(null, cljs.core.first.call(null, coll), false), cljs.core.next.call(null, coll))
+};
+cljs.core.hash_imap = function hash_imap(m) {
+  var h = 0;
+  var s = cljs.core.seq.call(null, m);
+  while(true) {
+    if(s) {
+      var e = cljs.core.first.call(null, s);
+      var G__3647 = (h + (cljs.core.hash.call(null, cljs.core.key.call(null, e)) ^ cljs.core.hash.call(null, cljs.core.val.call(null, e)))) % 4503599627370496;
+      var G__3648 = cljs.core.next.call(null, s);
+      h = G__3647;
+      s = G__3648;
+      continue
+    }else {
+      return h
+    }
+    break
+  }
+};
+cljs.core.hash_iset = function hash_iset(s) {
+  var h = 0;
+  var s__$1 = cljs.core.seq.call(null, s);
+  while(true) {
+    if(s__$1) {
+      var e = cljs.core.first.call(null, s__$1);
+      var G__3649 = (h + cljs.core.hash.call(null, e)) % 4503599627370496;
+      var G__3650 = cljs.core.next.call(null, s__$1);
+      h = G__3649;
+      s__$1 = G__3650;
+      continue
+    }else {
+      return h
+    }
+    break
+  }
+};
+cljs.core.extend_object_BANG_ = function extend_object_BANG_(obj, fn_map) {
+  var seq__3657_3663 = cljs.core.seq.call(null, fn_map);
+  var chunk__3658_3664 = null;
+  var count__3659_3665 = 0;
+  var i__3660_3666 = 0;
+  while(true) {
+    if(i__3660_3666 < count__3659_3665) {
+      var vec__3661_3667 = cljs.core._nth.call(null, chunk__3658_3664, i__3660_3666);
+      var key_name_3668 = cljs.core.nth.call(null, vec__3661_3667, 0, null);
+      var f_3669 = cljs.core.nth.call(null, vec__3661_3667, 1, null);
+      var str_name_3670 = cljs.core.name.call(null, key_name_3668);
+      obj[str_name_3670] = f_3669;
+      var G__3671 = seq__3657_3663;
+      var G__3672 = chunk__3658_3664;
+      var G__3673 = count__3659_3665;
+      var G__3674 = i__3660_3666 + 1;
+      seq__3657_3663 = G__3671;
+      chunk__3658_3664 = G__3672;
+      count__3659_3665 = G__3673;
+      i__3660_3666 = G__3674;
+      continue
+    }else {
+      var temp__4092__auto___3675 = cljs.core.seq.call(null, seq__3657_3663);
+      if(temp__4092__auto___3675) {
+        var seq__3657_3676__$1 = temp__4092__auto___3675;
+        if(cljs.core.chunked_seq_QMARK_.call(null, seq__3657_3676__$1)) {
+          var c__3073__auto___3677 = cljs.core.chunk_first.call(null, seq__3657_3676__$1);
+          var G__3678 = cljs.core.chunk_rest.call(null, seq__3657_3676__$1);
+          var G__3679 = c__3073__auto___3677;
+          var G__3680 = cljs.core.count.call(null, c__3073__auto___3677);
+          var G__3681 = 0;
+          seq__3657_3663 = G__3678;
+          chunk__3658_3664 = G__3679;
+          count__3659_3665 = G__3680;
+          i__3660_3666 = G__3681;
+          continue
+        }else {
+          var vec__3662_3682 = cljs.core.first.call(null, seq__3657_3676__$1);
+          var key_name_3683 = cljs.core.nth.call(null, vec__3662_3682, 0, null);
+          var f_3684 = cljs.core.nth.call(null, vec__3662_3682, 1, null);
+          var str_name_3685 = cljs.core.name.call(null, key_name_3683);
+          obj[str_name_3685] = f_3684;
+          var G__3686 = cljs.core.next.call(null, seq__3657_3676__$1);
+          var G__3687 = null;
+          var G__3688 = 0;
+          var G__3689 = 0;
+          seq__3657_3663 = G__3686;
+          chunk__3658_3664 = G__3687;
+          count__3659_3665 = G__3688;
+          i__3660_3666 = G__3689;
+          continue
+        }
+      }else {
+      }
+    }
+    break
+  }
+  return obj
+};
+goog.provide("cljs.core.List");
+cljs.core.List = function(meta, first, rest, count, __hash) {
+  this.meta = meta;
+  this.first = first;
+  this.rest = rest;
+  this.count = count;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 65413358
+};
+cljs.core.List.cljs$lang$type = true;
+cljs.core.List.cljs$lang$ctorStr = "cljs.core/List";
+cljs.core.List.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/List")
+};
+cljs.core.List.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.List.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.count === 1) {
+    return null
+  }else {
+    return self__.rest
+  }
+};
+cljs.core.List.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return new cljs.core.List(self__.meta, o, coll, self__.count + 1, null)
+};
+cljs.core.List.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.List.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.List.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.count
+};
+cljs.core.List.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.first
+};
+cljs.core.List.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  return coll.cljs$core$ISeq$_rest$arity$1(coll)
+};
+cljs.core.List.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.first
+};
+cljs.core.List.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.count === 1) {
+    return cljs.core.List.EMPTY
+  }else {
+    return self__.rest
+  }
+};
+cljs.core.List.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.List.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.List(meta__$1, self__.first, self__.rest, self__.count, self__.__hash)
+};
+cljs.core.List.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.List.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.List.EMPTY
+};
+goog.provide("cljs.core.EmptyList");
+cljs.core.EmptyList = function(meta) {
+  this.meta = meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 65413326
+};
+cljs.core.EmptyList.cljs$lang$type = true;
+cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList";
+cljs.core.EmptyList.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/EmptyList")
+};
+cljs.core.EmptyList.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  return 0
+};
+cljs.core.EmptyList.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  return null
+};
+cljs.core.EmptyList.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return new cljs.core.List(self__.meta, o, null, 1, null)
+};
+cljs.core.EmptyList.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.EmptyList.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return null
+};
+cljs.core.EmptyList.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return 0
+};
+cljs.core.EmptyList.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  return null
+};
+cljs.core.EmptyList.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  throw new Error("Can't pop empty list");
+};
+cljs.core.EmptyList.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return null
+};
+cljs.core.EmptyList.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.List.EMPTY
+};
+cljs.core.EmptyList.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.EmptyList.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.EmptyList(meta__$1)
+};
+cljs.core.EmptyList.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.EmptyList.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.List.EMPTY = new cljs.core.EmptyList(null);
+cljs.core.reversible_QMARK_ = function reversible_QMARK_(coll) {
+  var G__3691 = coll;
+  if(G__3691) {
+    if(function() {
+      var or__3943__auto__ = G__3691.cljs$lang$protocol_mask$partition0$ & 134217728;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3691.cljs$core$IReversible$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3691.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IReversible, G__3691)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.IReversible, G__3691)
+  }
+};
+cljs.core.rseq = function rseq(coll) {
+  return cljs.core._rseq.call(null, coll)
+};
+cljs.core.reverse = function reverse(coll) {
+  if(cljs.core.reversible_QMARK_.call(null, coll)) {
+    return cljs.core.rseq.call(null, coll)
+  }else {
+    return cljs.core.reduce.call(null, cljs.core.conj, cljs.core.List.EMPTY, coll)
+  }
+};
+cljs.core.list = function() {
+  var list__delegate = function(xs) {
+    var arr = xs instanceof cljs.core.IndexedSeq ? xs.arr : function() {
+      var arr = [];
+      var xs__$1 = xs;
+      while(true) {
+        if(!(xs__$1 == null)) {
+          arr.push(cljs.core._first.call(null, xs__$1));
+          var G__3692 = cljs.core._next.call(null, xs__$1);
+          xs__$1 = G__3692;
+          continue
+        }else {
+          return arr
+        }
+        break
+      }
+    }();
+    var i = arr.length;
+    var r = cljs.core.List.EMPTY;
+    while(true) {
+      if(i > 0) {
+        var G__3693 = i - 1;
+        var G__3694 = cljs.core._conj.call(null, r, arr[i - 1]);
+        i = G__3693;
+        r = G__3694;
+        continue
+      }else {
+        return r
+      }
+      break
+    }
+  };
+  var list = function(var_args) {
+    var xs = null;
+    if(arguments.length > 0) {
+      xs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return list__delegate.call(this, xs)
+  };
+  list.cljs$lang$maxFixedArity = 0;
+  list.cljs$lang$applyTo = function(arglist__3695) {
+    var xs = cljs.core.seq(arglist__3695);
+    return list__delegate(xs)
+  };
+  list.cljs$core$IFn$_invoke$arity$variadic = list__delegate;
+  return list
+}();
+goog.provide("cljs.core.Cons");
+cljs.core.Cons = function(meta, first, rest, __hash) {
+  this.meta = meta;
+  this.first = first;
+  this.rest = rest;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 65405164
+};
+cljs.core.Cons.cljs$lang$type = true;
+cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons";
+cljs.core.Cons.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Cons")
+};
+cljs.core.Cons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.Cons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.rest == null) {
+    return null
+  }else {
+    return cljs.core._seq.call(null, self__.rest)
+  }
+};
+cljs.core.Cons.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return new cljs.core.Cons(null, o, coll, self__.__hash)
+};
+cljs.core.Cons.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.Cons.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.Cons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.first
+};
+cljs.core.Cons.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.rest == null) {
+    return cljs.core.List.EMPTY
+  }else {
+    return self__.rest
+  }
+};
+cljs.core.Cons.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.Cons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.Cons(meta__$1, self__.first, self__.rest, self__.__hash)
+};
+cljs.core.Cons.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.Cons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.cons = function cons(x, coll) {
+  if(function() {
+    var or__3943__auto__ = coll == null;
+    if(or__3943__auto__) {
+      return or__3943__auto__
+    }else {
+      var G__3697 = coll;
+      if(G__3697) {
+        if(function() {
+          var or__3943__auto____$1 = G__3697.cljs$lang$protocol_mask$partition0$ & 64;
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            return G__3697.cljs$core$ISeq$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }
+  }()) {
+    return new cljs.core.Cons(null, x, coll, null)
+  }else {
+    return new cljs.core.Cons(null, x, cljs.core.seq.call(null, coll), null)
+  }
+};
+cljs.core.list_QMARK_ = function list_QMARK_(x) {
+  var G__3699 = x;
+  if(G__3699) {
+    if(function() {
+      var or__3943__auto__ = G__3699.cljs$lang$protocol_mask$partition0$ & 33554432;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return G__3699.cljs$core$IList$
+      }
+    }()) {
+      return true
+    }else {
+      if(!G__3699.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IList, G__3699)
+      }else {
+        return false
+      }
+    }
+  }else {
+    return cljs.core.type_satisfies_.call(null, cljs.core.IList, G__3699)
+  }
+};
+cljs.core.ICounted["string"] = true;
+cljs.core._count["string"] = function(s) {
+  return s.length
+};
+cljs.core.IHash["string"] = true;
+cljs.core._hash["string"] = function(o) {
+  return goog.string.hashCode(o)
+};
+goog.provide("cljs.core.Keyword");
+cljs.core.Keyword = function(k) {
+  this.k = k;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 1
+};
+cljs.core.Keyword.cljs$lang$type = true;
+cljs.core.Keyword.cljs$lang$ctorStr = "cljs.core/Keyword";
+cljs.core.Keyword.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Keyword")
+};
+cljs.core.Keyword.prototype.call = function() {
+  var G__3701 = null;
+  var G__3701__2 = function(self__, coll) {
+    var self__ = this;
+    var self____$1 = this;
+    var _ = self____$1;
+    if(coll == null) {
+      return null
+    }else {
+      var strobj = coll.strobj;
+      if(strobj == null) {
+        return cljs.core._lookup.call(null, coll, self__.k, null)
+      }else {
+        return strobj[self__.k]
+      }
+    }
+  };
+  var G__3701__3 = function(self__, coll, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var _ = self____$1;
+    if(coll == null) {
+      return not_found
+    }else {
+      return cljs.core._lookup.call(null, coll, self__.k, not_found)
+    }
+  };
+  G__3701 = function(self__, coll, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3701__2.call(this, self__, coll);
+      case 3:
+        return G__3701__3.call(this, self__, coll, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3701
+}();
+cljs.core.Keyword.prototype.apply = function(self__, args3700) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3700.slice()))
+};
+String.prototype.cljs$core$IFn$ = true;
+String.prototype.call = function() {
+  var G__3703 = null;
+  var G__3703__2 = function(self__, coll) {
+    var self____$1 = this;
+    var this$ = self____$1;
+    return cljs.core.get.call(null, coll, this$.toString())
+  };
+  var G__3703__3 = function(self__, coll, not_found) {
+    var self____$1 = this;
+    var this$ = self____$1;
+    return cljs.core.get.call(null, coll, this$.toString(), not_found)
+  };
+  G__3703 = function(self__, coll, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3703__2.call(this, self__, coll);
+      case 3:
+        return G__3703__3.call(this, self__, coll, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3703
+}();
+String.prototype.apply = function(self__, args3702) {
+  return self__.call.apply(self__, [self__].concat(args3702.slice()))
+};
+String.prototype.apply = function(s, args) {
+  if(args.length < 2) {
+    return cljs.core.get.call(null, args[0], s)
+  }else {
+    return cljs.core.get.call(null, args[0], s, args[1])
+  }
+};
+cljs.core.lazy_seq_value = function lazy_seq_value(lazy_seq) {
+  var x = lazy_seq.x;
+  if(lazy_seq.realized) {
+    return x
+  }else {
+    lazy_seq.x = x.call(null);
+    lazy_seq.realized = true;
+    return lazy_seq.x
+  }
+};
+goog.provide("cljs.core.LazySeq");
+cljs.core.LazySeq = function(meta, realized, x, __hash) {
+  this.meta = meta;
+  this.realized = realized;
+  this.x = x;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31850700
+};
+cljs.core.LazySeq.cljs$lang$type = true;
+cljs.core.LazySeq.cljs$lang$ctorStr = "cljs.core/LazySeq";
+cljs.core.LazySeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/LazySeq")
+};
+cljs.core.LazySeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._seq.call(null, coll.cljs$core$ISeq$_rest$arity$1(coll))
+};
+cljs.core.LazySeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.LazySeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.LazySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.seq.call(null, cljs.core.lazy_seq_value.call(null, coll))
+};
+cljs.core.LazySeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.first.call(null, cljs.core.lazy_seq_value.call(null, coll))
+};
+cljs.core.LazySeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.rest.call(null, cljs.core.lazy_seq_value.call(null, coll))
+};
+cljs.core.LazySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.LazySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.LazySeq(meta__$1, self__.realized, self__.x, self__.__hash)
+};
+cljs.core.LazySeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.LazySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+goog.provide("cljs.core.ChunkBuffer");
+cljs.core.ChunkBuffer = function(buf, end) {
+  this.buf = buf;
+  this.end = end;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 2
+};
+cljs.core.ChunkBuffer.cljs$lang$type = true;
+cljs.core.ChunkBuffer.cljs$lang$ctorStr = "cljs.core/ChunkBuffer";
+cljs.core.ChunkBuffer.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ChunkBuffer")
+};
+cljs.core.ChunkBuffer.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
+  var self__ = this;
+  return self__.end
+};
+cljs.core.ChunkBuffer.prototype.add = function(o) {
+  var self__ = this;
+  var _ = this;
+  self__.buf[self__.end] = o;
+  return self__.end = self__.end + 1
+};
+cljs.core.ChunkBuffer.prototype.chunk = function(o) {
+  var self__ = this;
+  var _ = this;
+  var ret = new cljs.core.ArrayChunk(self__.buf, 0, self__.end);
+  self__.buf = null;
+  return ret
+};
+cljs.core.chunk_buffer = function chunk_buffer(capacity) {
+  return new cljs.core.ChunkBuffer(new Array(capacity), 0)
+};
+goog.provide("cljs.core.ArrayChunk");
+cljs.core.ArrayChunk = function(arr, off, end) {
+  this.arr = arr;
+  this.off = off;
+  this.end = end;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 524306
+};
+cljs.core.ArrayChunk.cljs$lang$type = true;
+cljs.core.ArrayChunk.cljs$lang$ctorStr = "cljs.core/ArrayChunk";
+cljs.core.ArrayChunk.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ArrayChunk")
+};
+cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  return cljs.core.array_reduce.call(null, self__.arr, f, self__.arr[self__.off], self__.off + 1)
+};
+cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  return cljs.core.array_reduce.call(null, self__.arr, f, start, self__.off)
+};
+cljs.core.ArrayChunk.prototype.cljs$core$IChunk$ = true;
+cljs.core.ArrayChunk.prototype.cljs$core$IChunk$_drop_first$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.off === self__.end) {
+    throw new Error("-drop-first of empty chunk");
+  }else {
+    return new cljs.core.ArrayChunk(self__.arr, self__.off + 1, self__.end)
+  }
+};
+cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, i) {
+  var self__ = this;
+  return self__.arr[self__.off + i]
+};
+cljs.core.ArrayChunk.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, i, not_found) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = i >= 0;
+    if(and__3941__auto__) {
+      return i < self__.end - self__.off
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return self__.arr[self__.off + i]
+  }else {
+    return not_found
+  }
+};
+cljs.core.ArrayChunk.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
+  var self__ = this;
+  return self__.end - self__.off
+};
+cljs.core.array_chunk = function() {
+  var array_chunk = null;
+  var array_chunk__1 = function(arr) {
+    return new cljs.core.ArrayChunk(arr, 0, arr.length)
+  };
+  var array_chunk__2 = function(arr, off) {
+    return new cljs.core.ArrayChunk(arr, off, arr.length)
+  };
+  var array_chunk__3 = function(arr, off, end) {
+    return new cljs.core.ArrayChunk(arr, off, end)
+  };
+  array_chunk = function(arr, off, end) {
+    switch(arguments.length) {
+      case 1:
+        return array_chunk__1.call(this, arr);
+      case 2:
+        return array_chunk__2.call(this, arr, off);
+      case 3:
+        return array_chunk__3.call(this, arr, off, end)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  array_chunk.cljs$core$IFn$_invoke$arity$1 = array_chunk__1;
+  array_chunk.cljs$core$IFn$_invoke$arity$2 = array_chunk__2;
+  array_chunk.cljs$core$IFn$_invoke$arity$3 = array_chunk__3;
+  return array_chunk
+}();
+goog.provide("cljs.core.ChunkedCons");
+cljs.core.ChunkedCons = function(chunk, more, meta, __hash) {
+  this.chunk = chunk;
+  this.more = more;
+  this.meta = meta;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition0$ = 31850604;
+  this.cljs$lang$protocol_mask$partition1$ = 1536
+};
+cljs.core.ChunkedCons.cljs$lang$type = true;
+cljs.core.ChunkedCons.cljs$lang$ctorStr = "cljs.core/ChunkedCons";
+cljs.core.ChunkedCons.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ChunkedCons")
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.ChunkedCons.prototype.cljs$core$ICollection$_conj$arity$2 = function(this$, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, this$)
+};
+cljs.core.ChunkedCons.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.ChunkedCons.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._nth.call(null, self__.chunk, 0)
+};
+cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(cljs.core._count.call(null, self__.chunk) > 1) {
+    return new cljs.core.ChunkedCons(cljs.core._drop_first.call(null, self__.chunk), self__.more, self__.meta, null)
+  }else {
+    if(self__.more == null) {
+      return cljs.core.List.EMPTY
+    }else {
+      return self__.more
+    }
+  }
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.more == null) {
+    return null
+  }else {
+    return self__.more
+  }
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, m) {
+  var self__ = this;
+  return new cljs.core.ChunkedCons(self__.chunk, self__.more, m, self__.__hash)
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.chunk
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.more == null) {
+    return cljs.core.List.EMPTY
+  }else {
+    return self__.more
+  }
+};
+cljs.core.chunk_cons = function chunk_cons(chunk, rest) {
+  if(cljs.core._count.call(null, chunk) === 0) {
+    return rest
+  }else {
+    return new cljs.core.ChunkedCons(chunk, rest, null, null)
+  }
+};
+cljs.core.chunk_append = function chunk_append(b, x) {
+  return b.add(x)
+};
+cljs.core.chunk = function chunk(b) {
+  return b.chunk()
+};
+cljs.core.chunk_first = function chunk_first(s) {
+  return cljs.core._chunked_first.call(null, s)
+};
+cljs.core.chunk_rest = function chunk_rest(s) {
+  return cljs.core._chunked_rest.call(null, s)
+};
+cljs.core.chunk_next = function chunk_next(s) {
+  if(function() {
+    var G__3705 = s;
+    if(G__3705) {
+      if(function() {
+        var or__3943__auto__ = G__3705.cljs$lang$protocol_mask$partition1$ & 1024;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return G__3705.cljs$core$IChunkedNext$
+        }
+      }()) {
+        return true
+      }else {
+        return false
+      }
+    }else {
+      return false
+    }
+  }()) {
+    return cljs.core._chunked_next.call(null, s)
+  }else {
+    return cljs.core.seq.call(null, cljs.core._chunked_rest.call(null, s))
+  }
+};
+cljs.core.to_array = function to_array(s) {
+  var ary = [];
+  var s__$1 = s;
+  while(true) {
+    if(cljs.core.seq.call(null, s__$1)) {
+      ary.push(cljs.core.first.call(null, s__$1));
+      var G__3706 = cljs.core.next.call(null, s__$1);
+      s__$1 = G__3706;
+      continue
+    }else {
+      return ary
+    }
+    break
+  }
+};
+cljs.core.to_array_2d = function to_array_2d(coll) {
+  var ret = new Array(cljs.core.count.call(null, coll));
+  var i_3707 = 0;
+  var xs_3708 = cljs.core.seq.call(null, coll);
+  while(true) {
+    if(xs_3708) {
+      ret[i_3707] = cljs.core.to_array.call(null, cljs.core.first.call(null, xs_3708));
+      var G__3709 = i_3707 + 1;
+      var G__3710 = cljs.core.next.call(null, xs_3708);
+      i_3707 = G__3709;
+      xs_3708 = G__3710;
+      continue
+    }else {
+    }
+    break
+  }
+  return ret
+};
+cljs.core.int_array = function() {
+  var int_array = null;
+  var int_array__1 = function(size_or_seq) {
+    if(typeof size_or_seq === "number") {
+      return int_array.call(null, size_or_seq, null)
+    }else {
+      if(cljs.core.seq_QMARK_.call(null, size_or_seq)) {
+        return cljs.core.into_array.call(null, size_or_seq)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error("int-array called with something other than size or ISeq");
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var int_array__2 = function(size, init_val_or_seq) {
+    var a = new Array(size);
+    if(cljs.core.seq_QMARK_.call(null, init_val_or_seq)) {
+      var s = cljs.core.seq.call(null, init_val_or_seq);
+      var i = 0;
+      var s__$1 = s;
+      while(true) {
+        if(cljs.core.truth_(function() {
+          var and__3941__auto__ = s__$1;
+          if(and__3941__auto__) {
+            return i < size
+          }else {
+            return and__3941__auto__
+          }
+        }())) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__3711 = i + 1;
+          var G__3712 = cljs.core.next.call(null, s__$1);
+          i = G__3711;
+          s__$1 = G__3712;
+          continue
+        }else {
+          return a
+        }
+        break
+      }
+    }else {
+      var n__3120__auto___3713 = size;
+      var i_3714 = 0;
+      while(true) {
+        if(i_3714 < n__3120__auto___3713) {
+          a[i_3714] = init_val_or_seq;
+          var G__3715 = i_3714 + 1;
+          i_3714 = G__3715;
+          continue
+        }else {
+        }
+        break
+      }
+      return a
+    }
+  };
+  int_array = function(size, init_val_or_seq) {
+    switch(arguments.length) {
+      case 1:
+        return int_array__1.call(this, size);
+      case 2:
+        return int_array__2.call(this, size, init_val_or_seq)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  int_array.cljs$core$IFn$_invoke$arity$1 = int_array__1;
+  int_array.cljs$core$IFn$_invoke$arity$2 = int_array__2;
+  return int_array
+}();
+cljs.core.long_array = function() {
+  var long_array = null;
+  var long_array__1 = function(size_or_seq) {
+    if(typeof size_or_seq === "number") {
+      return long_array.call(null, size_or_seq, null)
+    }else {
+      if(cljs.core.seq_QMARK_.call(null, size_or_seq)) {
+        return cljs.core.into_array.call(null, size_or_seq)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error("long-array called with something other than size or ISeq");
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var long_array__2 = function(size, init_val_or_seq) {
+    var a = new Array(size);
+    if(cljs.core.seq_QMARK_.call(null, init_val_or_seq)) {
+      var s = cljs.core.seq.call(null, init_val_or_seq);
+      var i = 0;
+      var s__$1 = s;
+      while(true) {
+        if(cljs.core.truth_(function() {
+          var and__3941__auto__ = s__$1;
+          if(and__3941__auto__) {
+            return i < size
+          }else {
+            return and__3941__auto__
+          }
+        }())) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__3716 = i + 1;
+          var G__3717 = cljs.core.next.call(null, s__$1);
+          i = G__3716;
+          s__$1 = G__3717;
+          continue
+        }else {
+          return a
+        }
+        break
+      }
+    }else {
+      var n__3120__auto___3718 = size;
+      var i_3719 = 0;
+      while(true) {
+        if(i_3719 < n__3120__auto___3718) {
+          a[i_3719] = init_val_or_seq;
+          var G__3720 = i_3719 + 1;
+          i_3719 = G__3720;
+          continue
+        }else {
+        }
+        break
+      }
+      return a
+    }
+  };
+  long_array = function(size, init_val_or_seq) {
+    switch(arguments.length) {
+      case 1:
+        return long_array__1.call(this, size);
+      case 2:
+        return long_array__2.call(this, size, init_val_or_seq)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  long_array.cljs$core$IFn$_invoke$arity$1 = long_array__1;
+  long_array.cljs$core$IFn$_invoke$arity$2 = long_array__2;
+  return long_array
+}();
+cljs.core.double_array = function() {
+  var double_array = null;
+  var double_array__1 = function(size_or_seq) {
+    if(typeof size_or_seq === "number") {
+      return double_array.call(null, size_or_seq, null)
+    }else {
+      if(cljs.core.seq_QMARK_.call(null, size_or_seq)) {
+        return cljs.core.into_array.call(null, size_or_seq)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error("double-array called with something other than size or ISeq");
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var double_array__2 = function(size, init_val_or_seq) {
+    var a = new Array(size);
+    if(cljs.core.seq_QMARK_.call(null, init_val_or_seq)) {
+      var s = cljs.core.seq.call(null, init_val_or_seq);
+      var i = 0;
+      var s__$1 = s;
+      while(true) {
+        if(cljs.core.truth_(function() {
+          var and__3941__auto__ = s__$1;
+          if(and__3941__auto__) {
+            return i < size
+          }else {
+            return and__3941__auto__
+          }
+        }())) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__3721 = i + 1;
+          var G__3722 = cljs.core.next.call(null, s__$1);
+          i = G__3721;
+          s__$1 = G__3722;
+          continue
+        }else {
+          return a
+        }
+        break
+      }
+    }else {
+      var n__3120__auto___3723 = size;
+      var i_3724 = 0;
+      while(true) {
+        if(i_3724 < n__3120__auto___3723) {
+          a[i_3724] = init_val_or_seq;
+          var G__3725 = i_3724 + 1;
+          i_3724 = G__3725;
+          continue
+        }else {
+        }
+        break
+      }
+      return a
+    }
+  };
+  double_array = function(size, init_val_or_seq) {
+    switch(arguments.length) {
+      case 1:
+        return double_array__1.call(this, size);
+      case 2:
+        return double_array__2.call(this, size, init_val_or_seq)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  double_array.cljs$core$IFn$_invoke$arity$1 = double_array__1;
+  double_array.cljs$core$IFn$_invoke$arity$2 = double_array__2;
+  return double_array
+}();
+cljs.core.object_array = function() {
+  var object_array = null;
+  var object_array__1 = function(size_or_seq) {
+    if(typeof size_or_seq === "number") {
+      return object_array.call(null, size_or_seq, null)
+    }else {
+      if(cljs.core.seq_QMARK_.call(null, size_or_seq)) {
+        return cljs.core.into_array.call(null, size_or_seq)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error("object-array called with something other than size or ISeq");
+        }else {
+          return null
+        }
+      }
+    }
+  };
+  var object_array__2 = function(size, init_val_or_seq) {
+    var a = new Array(size);
+    if(cljs.core.seq_QMARK_.call(null, init_val_or_seq)) {
+      var s = cljs.core.seq.call(null, init_val_or_seq);
+      var i = 0;
+      var s__$1 = s;
+      while(true) {
+        if(cljs.core.truth_(function() {
+          var and__3941__auto__ = s__$1;
+          if(and__3941__auto__) {
+            return i < size
+          }else {
+            return and__3941__auto__
+          }
+        }())) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__3726 = i + 1;
+          var G__3727 = cljs.core.next.call(null, s__$1);
+          i = G__3726;
+          s__$1 = G__3727;
+          continue
+        }else {
+          return a
+        }
+        break
+      }
+    }else {
+      var n__3120__auto___3728 = size;
+      var i_3729 = 0;
+      while(true) {
+        if(i_3729 < n__3120__auto___3728) {
+          a[i_3729] = init_val_or_seq;
+          var G__3730 = i_3729 + 1;
+          i_3729 = G__3730;
+          continue
+        }else {
+        }
+        break
+      }
+      return a
+    }
+  };
+  object_array = function(size, init_val_or_seq) {
+    switch(arguments.length) {
+      case 1:
+        return object_array__1.call(this, size);
+      case 2:
+        return object_array__2.call(this, size, init_val_or_seq)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  object_array.cljs$core$IFn$_invoke$arity$1 = object_array__1;
+  object_array.cljs$core$IFn$_invoke$arity$2 = object_array__2;
+  return object_array
+}();
+cljs.core.bounded_count = function bounded_count(s, n) {
+  if(cljs.core.counted_QMARK_.call(null, s)) {
+    return cljs.core.count.call(null, s)
+  }else {
+    var s__$1 = s;
+    var i = n;
+    var sum = 0;
+    while(true) {
+      if(cljs.core.truth_(function() {
+        var and__3941__auto__ = i > 0;
+        if(and__3941__auto__) {
+          return cljs.core.seq.call(null, s__$1)
+        }else {
+          return and__3941__auto__
+        }
+      }())) {
+        var G__3731 = cljs.core.next.call(null, s__$1);
+        var G__3732 = i - 1;
+        var G__3733 = sum + 1;
+        s__$1 = G__3731;
+        i = G__3732;
+        sum = G__3733;
+        continue
+      }else {
+        return sum
+      }
+      break
+    }
+  }
+};
+cljs.core.spread = function spread(arglist) {
+  if(arglist == null) {
+    return null
+  }else {
+    if(cljs.core.next.call(null, arglist) == null) {
+      return cljs.core.seq.call(null, cljs.core.first.call(null, arglist))
+    }else {
+      if("\ufdd0:else") {
+        return cljs.core.cons.call(null, cljs.core.first.call(null, arglist), spread.call(null, cljs.core.next.call(null, arglist)))
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.concat = function() {
+  var concat = null;
+  var concat__0 = function() {
+    return new cljs.core.LazySeq(null, false, function() {
+      return null
+    }, null)
+  };
+  var concat__1 = function(x) {
+    return new cljs.core.LazySeq(null, false, function() {
+      return x
+    }, null)
+  };
+  var concat__2 = function(x, y) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var s = cljs.core.seq.call(null, x);
+      if(s) {
+        if(cljs.core.chunked_seq_QMARK_.call(null, s)) {
+          return cljs.core.chunk_cons.call(null, cljs.core.chunk_first.call(null, s), concat.call(null, cljs.core.chunk_rest.call(null, s), y))
+        }else {
+          return cljs.core.cons.call(null, cljs.core.first.call(null, s), concat.call(null, cljs.core.rest.call(null, s), y))
+        }
+      }else {
+        return y
+      }
+    }, null)
+  };
+  var concat__3 = function() {
+    var G__3734__delegate = function(x, y, zs) {
+      var cat = function cat(xys, zs__$1) {
+        return new cljs.core.LazySeq(null, false, function() {
+          var xys__$1 = cljs.core.seq.call(null, xys);
+          if(xys__$1) {
+            if(cljs.core.chunked_seq_QMARK_.call(null, xys__$1)) {
+              return cljs.core.chunk_cons.call(null, cljs.core.chunk_first.call(null, xys__$1), cat.call(null, cljs.core.chunk_rest.call(null, xys__$1), zs__$1))
+            }else {
+              return cljs.core.cons.call(null, cljs.core.first.call(null, xys__$1), cat.call(null, cljs.core.rest.call(null, xys__$1), zs__$1))
+            }
+          }else {
+            if(cljs.core.truth_(zs__$1)) {
+              return cat.call(null, cljs.core.first.call(null, zs__$1), cljs.core.next.call(null, zs__$1))
+            }else {
+              return null
+            }
+          }
+        }, null)
+      };
+      return cat.call(null, concat.call(null, x, y), zs)
+    };
+    var G__3734 = function(x, y, var_args) {
+      var zs = null;
+      if(arguments.length > 2) {
+        zs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3734__delegate.call(this, x, y, zs)
+    };
+    G__3734.cljs$lang$maxFixedArity = 2;
+    G__3734.cljs$lang$applyTo = function(arglist__3735) {
+      var x = cljs.core.first(arglist__3735);
+      arglist__3735 = cljs.core.next(arglist__3735);
+      var y = cljs.core.first(arglist__3735);
+      var zs = cljs.core.rest(arglist__3735);
+      return G__3734__delegate(x, y, zs)
+    };
+    G__3734.cljs$core$IFn$_invoke$arity$variadic = G__3734__delegate;
+    return G__3734
+  }();
+  concat = function(x, y, var_args) {
+    var zs = var_args;
+    switch(arguments.length) {
+      case 0:
+        return concat__0.call(this);
+      case 1:
+        return concat__1.call(this, x);
+      case 2:
+        return concat__2.call(this, x, y);
+      default:
+        return concat__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  concat.cljs$lang$maxFixedArity = 2;
+  concat.cljs$lang$applyTo = concat__3.cljs$lang$applyTo;
+  concat.cljs$core$IFn$_invoke$arity$0 = concat__0;
+  concat.cljs$core$IFn$_invoke$arity$1 = concat__1;
+  concat.cljs$core$IFn$_invoke$arity$2 = concat__2;
+  concat.cljs$core$IFn$_invoke$arity$variadic = concat__3.cljs$core$IFn$_invoke$arity$variadic;
+  return concat
+}();
+cljs.core.list_STAR_ = function() {
+  var list_STAR_ = null;
+  var list_STAR___1 = function(args) {
+    return cljs.core.seq.call(null, args)
+  };
+  var list_STAR___2 = function(a, args) {
+    return cljs.core.cons.call(null, a, args)
+  };
+  var list_STAR___3 = function(a, b, args) {
+    return cljs.core.cons.call(null, a, cljs.core.cons.call(null, b, args))
+  };
+  var list_STAR___4 = function(a, b, c, args) {
+    return cljs.core.cons.call(null, a, cljs.core.cons.call(null, b, cljs.core.cons.call(null, c, args)))
+  };
+  var list_STAR___5 = function() {
+    var G__3736__delegate = function(a, b, c, d, more) {
+      return cljs.core.cons.call(null, a, cljs.core.cons.call(null, b, cljs.core.cons.call(null, c, cljs.core.cons.call(null, d, cljs.core.spread.call(null, more)))))
+    };
+    var G__3736 = function(a, b, c, d, var_args) {
+      var more = null;
+      if(arguments.length > 4) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4), 0)
+      }
+      return G__3736__delegate.call(this, a, b, c, d, more)
+    };
+    G__3736.cljs$lang$maxFixedArity = 4;
+    G__3736.cljs$lang$applyTo = function(arglist__3737) {
+      var a = cljs.core.first(arglist__3737);
+      arglist__3737 = cljs.core.next(arglist__3737);
+      var b = cljs.core.first(arglist__3737);
+      arglist__3737 = cljs.core.next(arglist__3737);
+      var c = cljs.core.first(arglist__3737);
+      arglist__3737 = cljs.core.next(arglist__3737);
+      var d = cljs.core.first(arglist__3737);
+      var more = cljs.core.rest(arglist__3737);
+      return G__3736__delegate(a, b, c, d, more)
+    };
+    G__3736.cljs$core$IFn$_invoke$arity$variadic = G__3736__delegate;
+    return G__3736
+  }();
+  list_STAR_ = function(a, b, c, d, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return list_STAR___1.call(this, a);
+      case 2:
+        return list_STAR___2.call(this, a, b);
+      case 3:
+        return list_STAR___3.call(this, a, b, c);
+      case 4:
+        return list_STAR___4.call(this, a, b, c, d);
+      default:
+        return list_STAR___5.cljs$core$IFn$_invoke$arity$variadic(a, b, c, d, cljs.core.array_seq(arguments, 4))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  list_STAR_.cljs$lang$maxFixedArity = 4;
+  list_STAR_.cljs$lang$applyTo = list_STAR___5.cljs$lang$applyTo;
+  list_STAR_.cljs$core$IFn$_invoke$arity$1 = list_STAR___1;
+  list_STAR_.cljs$core$IFn$_invoke$arity$2 = list_STAR___2;
+  list_STAR_.cljs$core$IFn$_invoke$arity$3 = list_STAR___3;
+  list_STAR_.cljs$core$IFn$_invoke$arity$4 = list_STAR___4;
+  list_STAR_.cljs$core$IFn$_invoke$arity$variadic = list_STAR___5.cljs$core$IFn$_invoke$arity$variadic;
+  return list_STAR_
+}();
+cljs.core.transient$ = function transient$(coll) {
+  return cljs.core._as_transient.call(null, coll)
+};
+cljs.core.persistent_BANG_ = function persistent_BANG_(tcoll) {
+  return cljs.core._persistent_BANG_.call(null, tcoll)
+};
+cljs.core.conj_BANG_ = function conj_BANG_(tcoll, val) {
+  return cljs.core._conj_BANG_.call(null, tcoll, val)
+};
+cljs.core.assoc_BANG_ = function assoc_BANG_(tcoll, key, val) {
+  return cljs.core._assoc_BANG_.call(null, tcoll, key, val)
+};
+cljs.core.dissoc_BANG_ = function dissoc_BANG_(tcoll, key) {
+  return cljs.core._dissoc_BANG_.call(null, tcoll, key)
+};
+cljs.core.pop_BANG_ = function pop_BANG_(tcoll) {
+  return cljs.core._pop_BANG_.call(null, tcoll)
+};
+cljs.core.disj_BANG_ = function disj_BANG_(tcoll, val) {
+  return cljs.core._disjoin_BANG_.call(null, tcoll, val)
+};
+cljs.core.apply_to = function apply_to(f, argc, args) {
+  var args__$1 = cljs.core.seq.call(null, args);
+  if(argc === 0) {
+    return f.call(null)
+  }else {
+    var a = cljs.core._first.call(null, args__$1);
+    var args__$2 = cljs.core._rest.call(null, args__$1);
+    if(argc === 1) {
+      if(f.cljs$core$IFn$_invoke$arity$1) {
+        return f.cljs$core$IFn$_invoke$arity$1(a)
+      }else {
+        return f.call(null, a)
+      }
+    }else {
+      var b = cljs.core._first.call(null, args__$2);
+      var args__$3 = cljs.core._rest.call(null, args__$2);
+      if(argc === 2) {
+        if(f.cljs$core$IFn$_invoke$arity$2) {
+          return f.cljs$core$IFn$_invoke$arity$2(a, b)
+        }else {
+          return f.call(null, a, b)
+        }
+      }else {
+        var c = cljs.core._first.call(null, args__$3);
+        var args__$4 = cljs.core._rest.call(null, args__$3);
+        if(argc === 3) {
+          if(f.cljs$core$IFn$_invoke$arity$3) {
+            return f.cljs$core$IFn$_invoke$arity$3(a, b, c)
+          }else {
+            return f.call(null, a, b, c)
+          }
+        }else {
+          var d = cljs.core._first.call(null, args__$4);
+          var args__$5 = cljs.core._rest.call(null, args__$4);
+          if(argc === 4) {
+            if(f.cljs$core$IFn$_invoke$arity$4) {
+              return f.cljs$core$IFn$_invoke$arity$4(a, b, c, d)
+            }else {
+              return f.call(null, a, b, c, d)
+            }
+          }else {
+            var e = cljs.core._first.call(null, args__$5);
+            var args__$6 = cljs.core._rest.call(null, args__$5);
+            if(argc === 5) {
+              if(f.cljs$core$IFn$_invoke$arity$5) {
+                return f.cljs$core$IFn$_invoke$arity$5(a, b, c, d, e)
+              }else {
+                return f.call(null, a, b, c, d, e)
+              }
+            }else {
+              var f__$1 = cljs.core._first.call(null, args__$6);
+              var args__$7 = cljs.core._rest.call(null, args__$6);
+              if(argc === 6) {
+                if(f__$1.cljs$core$IFn$_invoke$arity$6) {
+                  return f__$1.cljs$core$IFn$_invoke$arity$6(a, b, c, d, e, f__$1)
+                }else {
+                  return f__$1.call(null, a, b, c, d, e, f__$1)
+                }
+              }else {
+                var g = cljs.core._first.call(null, args__$7);
+                var args__$8 = cljs.core._rest.call(null, args__$7);
+                if(argc === 7) {
+                  if(f__$1.cljs$core$IFn$_invoke$arity$7) {
+                    return f__$1.cljs$core$IFn$_invoke$arity$7(a, b, c, d, e, f__$1, g)
+                  }else {
+                    return f__$1.call(null, a, b, c, d, e, f__$1, g)
+                  }
+                }else {
+                  var h = cljs.core._first.call(null, args__$8);
+                  var args__$9 = cljs.core._rest.call(null, args__$8);
+                  if(argc === 8) {
+                    if(f__$1.cljs$core$IFn$_invoke$arity$8) {
+                      return f__$1.cljs$core$IFn$_invoke$arity$8(a, b, c, d, e, f__$1, g, h)
+                    }else {
+                      return f__$1.call(null, a, b, c, d, e, f__$1, g, h)
+                    }
+                  }else {
+                    var i = cljs.core._first.call(null, args__$9);
+                    var args__$10 = cljs.core._rest.call(null, args__$9);
+                    if(argc === 9) {
+                      if(f__$1.cljs$core$IFn$_invoke$arity$9) {
+                        return f__$1.cljs$core$IFn$_invoke$arity$9(a, b, c, d, e, f__$1, g, h, i)
+                      }else {
+                        return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i)
+                      }
+                    }else {
+                      var j = cljs.core._first.call(null, args__$10);
+                      var args__$11 = cljs.core._rest.call(null, args__$10);
+                      if(argc === 10) {
+                        if(f__$1.cljs$core$IFn$_invoke$arity$10) {
+                          return f__$1.cljs$core$IFn$_invoke$arity$10(a, b, c, d, e, f__$1, g, h, i, j)
+                        }else {
+                          return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j)
+                        }
+                      }else {
+                        var k = cljs.core._first.call(null, args__$11);
+                        var args__$12 = cljs.core._rest.call(null, args__$11);
+                        if(argc === 11) {
+                          if(f__$1.cljs$core$IFn$_invoke$arity$11) {
+                            return f__$1.cljs$core$IFn$_invoke$arity$11(a, b, c, d, e, f__$1, g, h, i, j, k)
+                          }else {
+                            return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k)
+                          }
+                        }else {
+                          var l = cljs.core._first.call(null, args__$12);
+                          var args__$13 = cljs.core._rest.call(null, args__$12);
+                          if(argc === 12) {
+                            if(f__$1.cljs$core$IFn$_invoke$arity$12) {
+                              return f__$1.cljs$core$IFn$_invoke$arity$12(a, b, c, d, e, f__$1, g, h, i, j, k, l)
+                            }else {
+                              return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l)
+                            }
+                          }else {
+                            var m = cljs.core._first.call(null, args__$13);
+                            var args__$14 = cljs.core._rest.call(null, args__$13);
+                            if(argc === 13) {
+                              if(f__$1.cljs$core$IFn$_invoke$arity$13) {
+                                return f__$1.cljs$core$IFn$_invoke$arity$13(a, b, c, d, e, f__$1, g, h, i, j, k, l, m)
+                              }else {
+                                return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m)
+                              }
+                            }else {
+                              var n = cljs.core._first.call(null, args__$14);
+                              var args__$15 = cljs.core._rest.call(null, args__$14);
+                              if(argc === 14) {
+                                if(f__$1.cljs$core$IFn$_invoke$arity$14) {
+                                  return f__$1.cljs$core$IFn$_invoke$arity$14(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n)
+                                }else {
+                                  return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n)
+                                }
+                              }else {
+                                var o = cljs.core._first.call(null, args__$15);
+                                var args__$16 = cljs.core._rest.call(null, args__$15);
+                                if(argc === 15) {
+                                  if(f__$1.cljs$core$IFn$_invoke$arity$15) {
+                                    return f__$1.cljs$core$IFn$_invoke$arity$15(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o)
+                                  }else {
+                                    return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o)
+                                  }
+                                }else {
+                                  var p = cljs.core._first.call(null, args__$16);
+                                  var args__$17 = cljs.core._rest.call(null, args__$16);
+                                  if(argc === 16) {
+                                    if(f__$1.cljs$core$IFn$_invoke$arity$16) {
+                                      return f__$1.cljs$core$IFn$_invoke$arity$16(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p)
+                                    }else {
+                                      return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p)
+                                    }
+                                  }else {
+                                    var q = cljs.core._first.call(null, args__$17);
+                                    var args__$18 = cljs.core._rest.call(null, args__$17);
+                                    if(argc === 17) {
+                                      if(f__$1.cljs$core$IFn$_invoke$arity$17) {
+                                        return f__$1.cljs$core$IFn$_invoke$arity$17(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q)
+                                      }else {
+                                        return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q)
+                                      }
+                                    }else {
+                                      var r = cljs.core._first.call(null, args__$18);
+                                      var args__$19 = cljs.core._rest.call(null, args__$18);
+                                      if(argc === 18) {
+                                        if(f__$1.cljs$core$IFn$_invoke$arity$18) {
+                                          return f__$1.cljs$core$IFn$_invoke$arity$18(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q, r)
+                                        }else {
+                                          return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q, r)
+                                        }
+                                      }else {
+                                        var s = cljs.core._first.call(null, args__$19);
+                                        var args__$20 = cljs.core._rest.call(null, args__$19);
+                                        if(argc === 19) {
+                                          if(f__$1.cljs$core$IFn$_invoke$arity$19) {
+                                            return f__$1.cljs$core$IFn$_invoke$arity$19(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q, r, s)
+                                          }else {
+                                            return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q, r, s)
+                                          }
+                                        }else {
+                                          var t = cljs.core._first.call(null, args__$20);
+                                          var args__$21 = cljs.core._rest.call(null, args__$20);
+                                          if(argc === 20) {
+                                            if(f__$1.cljs$core$IFn$_invoke$arity$20) {
+                                              return f__$1.cljs$core$IFn$_invoke$arity$20(a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+                                            }else {
+                                              return f__$1.call(null, a, b, c, d, e, f__$1, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
+                                            }
+                                          }else {
+                                            throw new Error("Only up to 20 arguments supported on functions");
+                                          }
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.apply = function() {
+  var apply = null;
+  var apply__2 = function(f, args) {
+    var fixed_arity = f.cljs$lang$maxFixedArity;
+    if(f.cljs$lang$applyTo) {
+      var bc = cljs.core.bounded_count.call(null, args, fixed_arity + 1);
+      if(bc <= fixed_arity) {
+        return cljs.core.apply_to.call(null, f, bc, args)
+      }else {
+        return f.cljs$lang$applyTo(args)
+      }
+    }else {
+      return f.apply(f, cljs.core.to_array.call(null, args))
+    }
+  };
+  var apply__3 = function(f, x, args) {
+    var arglist = cljs.core.list_STAR_.call(null, x, args);
+    var fixed_arity = f.cljs$lang$maxFixedArity;
+    if(f.cljs$lang$applyTo) {
+      var bc = cljs.core.bounded_count.call(null, arglist, fixed_arity + 1);
+      if(bc <= fixed_arity) {
+        return cljs.core.apply_to.call(null, f, bc, arglist)
+      }else {
+        return f.cljs$lang$applyTo(arglist)
+      }
+    }else {
+      return f.apply(f, cljs.core.to_array.call(null, arglist))
+    }
+  };
+  var apply__4 = function(f, x, y, args) {
+    var arglist = cljs.core.list_STAR_.call(null, x, y, args);
+    var fixed_arity = f.cljs$lang$maxFixedArity;
+    if(f.cljs$lang$applyTo) {
+      var bc = cljs.core.bounded_count.call(null, arglist, fixed_arity + 1);
+      if(bc <= fixed_arity) {
+        return cljs.core.apply_to.call(null, f, bc, arglist)
+      }else {
+        return f.cljs$lang$applyTo(arglist)
+      }
+    }else {
+      return f.apply(f, cljs.core.to_array.call(null, arglist))
+    }
+  };
+  var apply__5 = function(f, x, y, z, args) {
+    var arglist = cljs.core.list_STAR_.call(null, x, y, z, args);
+    var fixed_arity = f.cljs$lang$maxFixedArity;
+    if(f.cljs$lang$applyTo) {
+      var bc = cljs.core.bounded_count.call(null, arglist, fixed_arity + 1);
+      if(bc <= fixed_arity) {
+        return cljs.core.apply_to.call(null, f, bc, arglist)
+      }else {
+        return f.cljs$lang$applyTo(arglist)
+      }
+    }else {
+      return f.apply(f, cljs.core.to_array.call(null, arglist))
+    }
+  };
+  var apply__6 = function() {
+    var G__3738__delegate = function(f, a, b, c, d, args) {
+      var arglist = cljs.core.cons.call(null, a, cljs.core.cons.call(null, b, cljs.core.cons.call(null, c, cljs.core.cons.call(null, d, cljs.core.spread.call(null, args)))));
+      var fixed_arity = f.cljs$lang$maxFixedArity;
+      if(f.cljs$lang$applyTo) {
+        var bc = cljs.core.bounded_count.call(null, arglist, fixed_arity + 1);
+        if(bc <= fixed_arity) {
+          return cljs.core.apply_to.call(null, f, bc, arglist)
+        }else {
+          return f.cljs$lang$applyTo(arglist)
+        }
+      }else {
+        return f.apply(f, cljs.core.to_array.call(null, arglist))
+      }
+    };
+    var G__3738 = function(f, a, b, c, d, var_args) {
+      var args = null;
+      if(arguments.length > 5) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 5), 0)
+      }
+      return G__3738__delegate.call(this, f, a, b, c, d, args)
+    };
+    G__3738.cljs$lang$maxFixedArity = 5;
+    G__3738.cljs$lang$applyTo = function(arglist__3739) {
+      var f = cljs.core.first(arglist__3739);
+      arglist__3739 = cljs.core.next(arglist__3739);
+      var a = cljs.core.first(arglist__3739);
+      arglist__3739 = cljs.core.next(arglist__3739);
+      var b = cljs.core.first(arglist__3739);
+      arglist__3739 = cljs.core.next(arglist__3739);
+      var c = cljs.core.first(arglist__3739);
+      arglist__3739 = cljs.core.next(arglist__3739);
+      var d = cljs.core.first(arglist__3739);
+      var args = cljs.core.rest(arglist__3739);
+      return G__3738__delegate(f, a, b, c, d, args)
+    };
+    G__3738.cljs$core$IFn$_invoke$arity$variadic = G__3738__delegate;
+    return G__3738
+  }();
+  apply = function(f, a, b, c, d, var_args) {
+    var args = var_args;
+    switch(arguments.length) {
+      case 2:
+        return apply__2.call(this, f, a);
+      case 3:
+        return apply__3.call(this, f, a, b);
+      case 4:
+        return apply__4.call(this, f, a, b, c);
+      case 5:
+        return apply__5.call(this, f, a, b, c, d);
+      default:
+        return apply__6.cljs$core$IFn$_invoke$arity$variadic(f, a, b, c, d, cljs.core.array_seq(arguments, 5))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  apply.cljs$lang$maxFixedArity = 5;
+  apply.cljs$lang$applyTo = apply__6.cljs$lang$applyTo;
+  apply.cljs$core$IFn$_invoke$arity$2 = apply__2;
+  apply.cljs$core$IFn$_invoke$arity$3 = apply__3;
+  apply.cljs$core$IFn$_invoke$arity$4 = apply__4;
+  apply.cljs$core$IFn$_invoke$arity$5 = apply__5;
+  apply.cljs$core$IFn$_invoke$arity$variadic = apply__6.cljs$core$IFn$_invoke$arity$variadic;
+  return apply
+}();
+cljs.core.vary_meta = function() {
+  var vary_meta__delegate = function(obj, f, args) {
+    return cljs.core.with_meta.call(null, obj, cljs.core.apply.call(null, f, cljs.core.meta.call(null, obj), args))
+  };
+  var vary_meta = function(obj, f, var_args) {
+    var args = null;
+    if(arguments.length > 2) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+    }
+    return vary_meta__delegate.call(this, obj, f, args)
+  };
+  vary_meta.cljs$lang$maxFixedArity = 2;
+  vary_meta.cljs$lang$applyTo = function(arglist__3740) {
+    var obj = cljs.core.first(arglist__3740);
+    arglist__3740 = cljs.core.next(arglist__3740);
+    var f = cljs.core.first(arglist__3740);
+    var args = cljs.core.rest(arglist__3740);
+    return vary_meta__delegate(obj, f, args)
+  };
+  vary_meta.cljs$core$IFn$_invoke$arity$variadic = vary_meta__delegate;
+  return vary_meta
+}();
+cljs.core.not_EQ_ = function() {
+  var not_EQ_ = null;
+  var not_EQ___1 = function(x) {
+    return false
+  };
+  var not_EQ___2 = function(x, y) {
+    return!cljs.core._EQ_.call(null, x, y)
+  };
+  var not_EQ___3 = function() {
+    var G__3741__delegate = function(x, y, more) {
+      return cljs.core.not.call(null, cljs.core.apply.call(null, cljs.core._EQ_, x, y, more))
+    };
+    var G__3741 = function(x, y, var_args) {
+      var more = null;
+      if(arguments.length > 2) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3741__delegate.call(this, x, y, more)
+    };
+    G__3741.cljs$lang$maxFixedArity = 2;
+    G__3741.cljs$lang$applyTo = function(arglist__3742) {
+      var x = cljs.core.first(arglist__3742);
+      arglist__3742 = cljs.core.next(arglist__3742);
+      var y = cljs.core.first(arglist__3742);
+      var more = cljs.core.rest(arglist__3742);
+      return G__3741__delegate(x, y, more)
+    };
+    G__3741.cljs$core$IFn$_invoke$arity$variadic = G__3741__delegate;
+    return G__3741
+  }();
+  not_EQ_ = function(x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return not_EQ___1.call(this, x);
+      case 2:
+        return not_EQ___2.call(this, x, y);
+      default:
+        return not_EQ___3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  not_EQ_.cljs$lang$maxFixedArity = 2;
+  not_EQ_.cljs$lang$applyTo = not_EQ___3.cljs$lang$applyTo;
+  not_EQ_.cljs$core$IFn$_invoke$arity$1 = not_EQ___1;
+  not_EQ_.cljs$core$IFn$_invoke$arity$2 = not_EQ___2;
+  not_EQ_.cljs$core$IFn$_invoke$arity$variadic = not_EQ___3.cljs$core$IFn$_invoke$arity$variadic;
+  return not_EQ_
+}();
+cljs.core.not_empty = function not_empty(coll) {
+  if(cljs.core.seq.call(null, coll)) {
+    return coll
+  }else {
+    return null
+  }
+};
+cljs.core.every_QMARK_ = function every_QMARK_(pred, coll) {
+  while(true) {
+    if(cljs.core.seq.call(null, coll) == null) {
+      return true
+    }else {
+      if(cljs.core.truth_(pred.call(null, cljs.core.first.call(null, coll)))) {
+        var G__3743 = pred;
+        var G__3744 = cljs.core.next.call(null, coll);
+        pred = G__3743;
+        coll = G__3744;
+        continue
+      }else {
+        if("\ufdd0:else") {
+          return false
+        }else {
+          return null
+        }
+      }
+    }
+    break
+  }
+};
+cljs.core.not_every_QMARK_ = function not_every_QMARK_(pred, coll) {
+  return!cljs.core.every_QMARK_.call(null, pred, coll)
+};
+cljs.core.some = function some(pred, coll) {
+  while(true) {
+    if(cljs.core.seq.call(null, coll)) {
+      var or__3943__auto__ = pred.call(null, cljs.core.first.call(null, coll));
+      if(cljs.core.truth_(or__3943__auto__)) {
+        return or__3943__auto__
+      }else {
+        var G__3745 = pred;
+        var G__3746 = cljs.core.next.call(null, coll);
+        pred = G__3745;
+        coll = G__3746;
+        continue
+      }
+    }else {
+      return null
+    }
+    break
+  }
+};
+cljs.core.not_any_QMARK_ = function not_any_QMARK_(pred, coll) {
+  return cljs.core.not.call(null, cljs.core.some.call(null, pred, coll))
+};
+cljs.core.even_QMARK_ = function even_QMARK_(n) {
+  if(cljs.core.integer_QMARK_.call(null, n)) {
+    return(n & 1) === 0
+  }else {
+    throw new Error([cljs.core.str("Argument must be an integer: "), cljs.core.str(n)].join(""));
+  }
+};
+cljs.core.odd_QMARK_ = function odd_QMARK_(n) {
+  return!cljs.core.even_QMARK_.call(null, n)
+};
+cljs.core.identity = function identity(x) {
+  return x
+};
+cljs.core.complement = function complement(f) {
+  return function() {
+    var G__3747 = null;
+    var G__3747__0 = function() {
+      return cljs.core.not.call(null, f.call(null))
+    };
+    var G__3747__1 = function(x) {
+      return cljs.core.not.call(null, f.call(null, x))
+    };
+    var G__3747__2 = function(x, y) {
+      return cljs.core.not.call(null, f.call(null, x, y))
+    };
+    var G__3747__3 = function() {
+      var G__3748__delegate = function(x, y, zs) {
+        return cljs.core.not.call(null, cljs.core.apply.call(null, f, x, y, zs))
+      };
+      var G__3748 = function(x, y, var_args) {
+        var zs = null;
+        if(arguments.length > 2) {
+          zs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+        }
+        return G__3748__delegate.call(this, x, y, zs)
+      };
+      G__3748.cljs$lang$maxFixedArity = 2;
+      G__3748.cljs$lang$applyTo = function(arglist__3749) {
+        var x = cljs.core.first(arglist__3749);
+        arglist__3749 = cljs.core.next(arglist__3749);
+        var y = cljs.core.first(arglist__3749);
+        var zs = cljs.core.rest(arglist__3749);
+        return G__3748__delegate(x, y, zs)
+      };
+      G__3748.cljs$core$IFn$_invoke$arity$variadic = G__3748__delegate;
+      return G__3748
+    }();
+    G__3747 = function(x, y, var_args) {
+      var zs = var_args;
+      switch(arguments.length) {
+        case 0:
+          return G__3747__0.call(this);
+        case 1:
+          return G__3747__1.call(this, x);
+        case 2:
+          return G__3747__2.call(this, x, y);
+        default:
+          return G__3747__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2))
+      }
+      throw new Error("Invalid arity: " + arguments.length);
+    };
+    G__3747.cljs$lang$maxFixedArity = 2;
+    G__3747.cljs$lang$applyTo = G__3747__3.cljs$lang$applyTo;
+    return G__3747
+  }()
+};
+cljs.core.constantly = function constantly(x) {
+  return function() {
+    var G__3750__delegate = function(args) {
+      return x
+    };
+    var G__3750 = function(var_args) {
+      var args = null;
+      if(arguments.length > 0) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+      }
+      return G__3750__delegate.call(this, args)
+    };
+    G__3750.cljs$lang$maxFixedArity = 0;
+    G__3750.cljs$lang$applyTo = function(arglist__3751) {
+      var args = cljs.core.seq(arglist__3751);
+      return G__3750__delegate(args)
+    };
+    G__3750.cljs$core$IFn$_invoke$arity$variadic = G__3750__delegate;
+    return G__3750
+  }()
+};
+cljs.core.comp = function() {
+  var comp = null;
+  var comp__0 = function() {
+    return cljs.core.identity
+  };
+  var comp__1 = function(f) {
+    return f
+  };
+  var comp__2 = function(f, g) {
+    return function() {
+      var G__3752 = null;
+      var G__3752__0 = function() {
+        return f.call(null, g.call(null))
+      };
+      var G__3752__1 = function(x) {
+        return f.call(null, g.call(null, x))
+      };
+      var G__3752__2 = function(x, y) {
+        return f.call(null, g.call(null, x, y))
+      };
+      var G__3752__3 = function(x, y, z) {
+        return f.call(null, g.call(null, x, y, z))
+      };
+      var G__3752__4 = function() {
+        var G__3753__delegate = function(x, y, z, args) {
+          return f.call(null, cljs.core.apply.call(null, g, x, y, z, args))
+        };
+        var G__3753 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3753__delegate.call(this, x, y, z, args)
+        };
+        G__3753.cljs$lang$maxFixedArity = 3;
+        G__3753.cljs$lang$applyTo = function(arglist__3754) {
+          var x = cljs.core.first(arglist__3754);
+          arglist__3754 = cljs.core.next(arglist__3754);
+          var y = cljs.core.first(arglist__3754);
+          arglist__3754 = cljs.core.next(arglist__3754);
+          var z = cljs.core.first(arglist__3754);
+          var args = cljs.core.rest(arglist__3754);
+          return G__3753__delegate(x, y, z, args)
+        };
+        G__3753.cljs$core$IFn$_invoke$arity$variadic = G__3753__delegate;
+        return G__3753
+      }();
+      G__3752 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__3752__0.call(this);
+          case 1:
+            return G__3752__1.call(this, x);
+          case 2:
+            return G__3752__2.call(this, x, y);
+          case 3:
+            return G__3752__3.call(this, x, y, z);
+          default:
+            return G__3752__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__3752.cljs$lang$maxFixedArity = 3;
+      G__3752.cljs$lang$applyTo = G__3752__4.cljs$lang$applyTo;
+      return G__3752
+    }()
+  };
+  var comp__3 = function(f, g, h) {
+    return function() {
+      var G__3755 = null;
+      var G__3755__0 = function() {
+        return f.call(null, g.call(null, h.call(null)))
+      };
+      var G__3755__1 = function(x) {
+        return f.call(null, g.call(null, h.call(null, x)))
+      };
+      var G__3755__2 = function(x, y) {
+        return f.call(null, g.call(null, h.call(null, x, y)))
+      };
+      var G__3755__3 = function(x, y, z) {
+        return f.call(null, g.call(null, h.call(null, x, y, z)))
+      };
+      var G__3755__4 = function() {
+        var G__3756__delegate = function(x, y, z, args) {
+          return f.call(null, g.call(null, cljs.core.apply.call(null, h, x, y, z, args)))
+        };
+        var G__3756 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3756__delegate.call(this, x, y, z, args)
+        };
+        G__3756.cljs$lang$maxFixedArity = 3;
+        G__3756.cljs$lang$applyTo = function(arglist__3757) {
+          var x = cljs.core.first(arglist__3757);
+          arglist__3757 = cljs.core.next(arglist__3757);
+          var y = cljs.core.first(arglist__3757);
+          arglist__3757 = cljs.core.next(arglist__3757);
+          var z = cljs.core.first(arglist__3757);
+          var args = cljs.core.rest(arglist__3757);
+          return G__3756__delegate(x, y, z, args)
+        };
+        G__3756.cljs$core$IFn$_invoke$arity$variadic = G__3756__delegate;
+        return G__3756
+      }();
+      G__3755 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__3755__0.call(this);
+          case 1:
+            return G__3755__1.call(this, x);
+          case 2:
+            return G__3755__2.call(this, x, y);
+          case 3:
+            return G__3755__3.call(this, x, y, z);
+          default:
+            return G__3755__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__3755.cljs$lang$maxFixedArity = 3;
+      G__3755.cljs$lang$applyTo = G__3755__4.cljs$lang$applyTo;
+      return G__3755
+    }()
+  };
+  var comp__4 = function() {
+    var G__3758__delegate = function(f1, f2, f3, fs) {
+      var fs__$1 = cljs.core.reverse.call(null, cljs.core.list_STAR_.call(null, f1, f2, f3, fs));
+      return function() {
+        var G__3759__delegate = function(args) {
+          var ret = cljs.core.apply.call(null, cljs.core.first.call(null, fs__$1), args);
+          var fs__$2 = cljs.core.next.call(null, fs__$1);
+          while(true) {
+            if(fs__$2) {
+              var G__3760 = cljs.core.first.call(null, fs__$2).call(null, ret);
+              var G__3761 = cljs.core.next.call(null, fs__$2);
+              ret = G__3760;
+              fs__$2 = G__3761;
+              continue
+            }else {
+              return ret
+            }
+            break
+          }
+        };
+        var G__3759 = function(var_args) {
+          var args = null;
+          if(arguments.length > 0) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+          }
+          return G__3759__delegate.call(this, args)
+        };
+        G__3759.cljs$lang$maxFixedArity = 0;
+        G__3759.cljs$lang$applyTo = function(arglist__3762) {
+          var args = cljs.core.seq(arglist__3762);
+          return G__3759__delegate(args)
+        };
+        G__3759.cljs$core$IFn$_invoke$arity$variadic = G__3759__delegate;
+        return G__3759
+      }()
+    };
+    var G__3758 = function(f1, f2, f3, var_args) {
+      var fs = null;
+      if(arguments.length > 3) {
+        fs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__3758__delegate.call(this, f1, f2, f3, fs)
+    };
+    G__3758.cljs$lang$maxFixedArity = 3;
+    G__3758.cljs$lang$applyTo = function(arglist__3763) {
+      var f1 = cljs.core.first(arglist__3763);
+      arglist__3763 = cljs.core.next(arglist__3763);
+      var f2 = cljs.core.first(arglist__3763);
+      arglist__3763 = cljs.core.next(arglist__3763);
+      var f3 = cljs.core.first(arglist__3763);
+      var fs = cljs.core.rest(arglist__3763);
+      return G__3758__delegate(f1, f2, f3, fs)
+    };
+    G__3758.cljs$core$IFn$_invoke$arity$variadic = G__3758__delegate;
+    return G__3758
+  }();
+  comp = function(f1, f2, f3, var_args) {
+    var fs = var_args;
+    switch(arguments.length) {
+      case 0:
+        return comp__0.call(this);
+      case 1:
+        return comp__1.call(this, f1);
+      case 2:
+        return comp__2.call(this, f1, f2);
+      case 3:
+        return comp__3.call(this, f1, f2, f3);
+      default:
+        return comp__4.cljs$core$IFn$_invoke$arity$variadic(f1, f2, f3, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  comp.cljs$lang$maxFixedArity = 3;
+  comp.cljs$lang$applyTo = comp__4.cljs$lang$applyTo;
+  comp.cljs$core$IFn$_invoke$arity$0 = comp__0;
+  comp.cljs$core$IFn$_invoke$arity$1 = comp__1;
+  comp.cljs$core$IFn$_invoke$arity$2 = comp__2;
+  comp.cljs$core$IFn$_invoke$arity$3 = comp__3;
+  comp.cljs$core$IFn$_invoke$arity$variadic = comp__4.cljs$core$IFn$_invoke$arity$variadic;
+  return comp
+}();
+cljs.core.partial = function() {
+  var partial = null;
+  var partial__2 = function(f, arg1) {
+    return function() {
+      var G__3764__delegate = function(args) {
+        return cljs.core.apply.call(null, f, arg1, args)
+      };
+      var G__3764 = function(var_args) {
+        var args = null;
+        if(arguments.length > 0) {
+          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+        }
+        return G__3764__delegate.call(this, args)
+      };
+      G__3764.cljs$lang$maxFixedArity = 0;
+      G__3764.cljs$lang$applyTo = function(arglist__3765) {
+        var args = cljs.core.seq(arglist__3765);
+        return G__3764__delegate(args)
+      };
+      G__3764.cljs$core$IFn$_invoke$arity$variadic = G__3764__delegate;
+      return G__3764
+    }()
+  };
+  var partial__3 = function(f, arg1, arg2) {
+    return function() {
+      var G__3766__delegate = function(args) {
+        return cljs.core.apply.call(null, f, arg1, arg2, args)
+      };
+      var G__3766 = function(var_args) {
+        var args = null;
+        if(arguments.length > 0) {
+          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+        }
+        return G__3766__delegate.call(this, args)
+      };
+      G__3766.cljs$lang$maxFixedArity = 0;
+      G__3766.cljs$lang$applyTo = function(arglist__3767) {
+        var args = cljs.core.seq(arglist__3767);
+        return G__3766__delegate(args)
+      };
+      G__3766.cljs$core$IFn$_invoke$arity$variadic = G__3766__delegate;
+      return G__3766
+    }()
+  };
+  var partial__4 = function(f, arg1, arg2, arg3) {
+    return function() {
+      var G__3768__delegate = function(args) {
+        return cljs.core.apply.call(null, f, arg1, arg2, arg3, args)
+      };
+      var G__3768 = function(var_args) {
+        var args = null;
+        if(arguments.length > 0) {
+          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+        }
+        return G__3768__delegate.call(this, args)
+      };
+      G__3768.cljs$lang$maxFixedArity = 0;
+      G__3768.cljs$lang$applyTo = function(arglist__3769) {
+        var args = cljs.core.seq(arglist__3769);
+        return G__3768__delegate(args)
+      };
+      G__3768.cljs$core$IFn$_invoke$arity$variadic = G__3768__delegate;
+      return G__3768
+    }()
+  };
+  var partial__5 = function() {
+    var G__3770__delegate = function(f, arg1, arg2, arg3, more) {
+      return function() {
+        var G__3771__delegate = function(args) {
+          return cljs.core.apply.call(null, f, arg1, arg2, arg3, cljs.core.concat.call(null, more, args))
+        };
+        var G__3771 = function(var_args) {
+          var args = null;
+          if(arguments.length > 0) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+          }
+          return G__3771__delegate.call(this, args)
+        };
+        G__3771.cljs$lang$maxFixedArity = 0;
+        G__3771.cljs$lang$applyTo = function(arglist__3772) {
+          var args = cljs.core.seq(arglist__3772);
+          return G__3771__delegate(args)
+        };
+        G__3771.cljs$core$IFn$_invoke$arity$variadic = G__3771__delegate;
+        return G__3771
+      }()
+    };
+    var G__3770 = function(f, arg1, arg2, arg3, var_args) {
+      var more = null;
+      if(arguments.length > 4) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4), 0)
+      }
+      return G__3770__delegate.call(this, f, arg1, arg2, arg3, more)
+    };
+    G__3770.cljs$lang$maxFixedArity = 4;
+    G__3770.cljs$lang$applyTo = function(arglist__3773) {
+      var f = cljs.core.first(arglist__3773);
+      arglist__3773 = cljs.core.next(arglist__3773);
+      var arg1 = cljs.core.first(arglist__3773);
+      arglist__3773 = cljs.core.next(arglist__3773);
+      var arg2 = cljs.core.first(arglist__3773);
+      arglist__3773 = cljs.core.next(arglist__3773);
+      var arg3 = cljs.core.first(arglist__3773);
+      var more = cljs.core.rest(arglist__3773);
+      return G__3770__delegate(f, arg1, arg2, arg3, more)
+    };
+    G__3770.cljs$core$IFn$_invoke$arity$variadic = G__3770__delegate;
+    return G__3770
+  }();
+  partial = function(f, arg1, arg2, arg3, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 2:
+        return partial__2.call(this, f, arg1);
+      case 3:
+        return partial__3.call(this, f, arg1, arg2);
+      case 4:
+        return partial__4.call(this, f, arg1, arg2, arg3);
+      default:
+        return partial__5.cljs$core$IFn$_invoke$arity$variadic(f, arg1, arg2, arg3, cljs.core.array_seq(arguments, 4))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  partial.cljs$lang$maxFixedArity = 4;
+  partial.cljs$lang$applyTo = partial__5.cljs$lang$applyTo;
+  partial.cljs$core$IFn$_invoke$arity$2 = partial__2;
+  partial.cljs$core$IFn$_invoke$arity$3 = partial__3;
+  partial.cljs$core$IFn$_invoke$arity$4 = partial__4;
+  partial.cljs$core$IFn$_invoke$arity$variadic = partial__5.cljs$core$IFn$_invoke$arity$variadic;
+  return partial
+}();
+cljs.core.fnil = function() {
+  var fnil = null;
+  var fnil__2 = function(f, x) {
+    return function() {
+      var G__3774 = null;
+      var G__3774__1 = function(a) {
+        return f.call(null, a == null ? x : a)
+      };
+      var G__3774__2 = function(a, b) {
+        return f.call(null, a == null ? x : a, b)
+      };
+      var G__3774__3 = function(a, b, c) {
+        return f.call(null, a == null ? x : a, b, c)
+      };
+      var G__3774__4 = function() {
+        var G__3775__delegate = function(a, b, c, ds) {
+          return cljs.core.apply.call(null, f, a == null ? x : a, b, c, ds)
+        };
+        var G__3775 = function(a, b, c, var_args) {
+          var ds = null;
+          if(arguments.length > 3) {
+            ds = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3775__delegate.call(this, a, b, c, ds)
+        };
+        G__3775.cljs$lang$maxFixedArity = 3;
+        G__3775.cljs$lang$applyTo = function(arglist__3776) {
+          var a = cljs.core.first(arglist__3776);
+          arglist__3776 = cljs.core.next(arglist__3776);
+          var b = cljs.core.first(arglist__3776);
+          arglist__3776 = cljs.core.next(arglist__3776);
+          var c = cljs.core.first(arglist__3776);
+          var ds = cljs.core.rest(arglist__3776);
+          return G__3775__delegate(a, b, c, ds)
+        };
+        G__3775.cljs$core$IFn$_invoke$arity$variadic = G__3775__delegate;
+        return G__3775
+      }();
+      G__3774 = function(a, b, c, var_args) {
+        var ds = var_args;
+        switch(arguments.length) {
+          case 1:
+            return G__3774__1.call(this, a);
+          case 2:
+            return G__3774__2.call(this, a, b);
+          case 3:
+            return G__3774__3.call(this, a, b, c);
+          default:
+            return G__3774__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__3774.cljs$lang$maxFixedArity = 3;
+      G__3774.cljs$lang$applyTo = G__3774__4.cljs$lang$applyTo;
+      return G__3774
+    }()
+  };
+  var fnil__3 = function(f, x, y) {
+    return function() {
+      var G__3777 = null;
+      var G__3777__2 = function(a, b) {
+        return f.call(null, a == null ? x : a, b == null ? y : b)
+      };
+      var G__3777__3 = function(a, b, c) {
+        return f.call(null, a == null ? x : a, b == null ? y : b, c)
+      };
+      var G__3777__4 = function() {
+        var G__3778__delegate = function(a, b, c, ds) {
+          return cljs.core.apply.call(null, f, a == null ? x : a, b == null ? y : b, c, ds)
+        };
+        var G__3778 = function(a, b, c, var_args) {
+          var ds = null;
+          if(arguments.length > 3) {
+            ds = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3778__delegate.call(this, a, b, c, ds)
+        };
+        G__3778.cljs$lang$maxFixedArity = 3;
+        G__3778.cljs$lang$applyTo = function(arglist__3779) {
+          var a = cljs.core.first(arglist__3779);
+          arglist__3779 = cljs.core.next(arglist__3779);
+          var b = cljs.core.first(arglist__3779);
+          arglist__3779 = cljs.core.next(arglist__3779);
+          var c = cljs.core.first(arglist__3779);
+          var ds = cljs.core.rest(arglist__3779);
+          return G__3778__delegate(a, b, c, ds)
+        };
+        G__3778.cljs$core$IFn$_invoke$arity$variadic = G__3778__delegate;
+        return G__3778
+      }();
+      G__3777 = function(a, b, c, var_args) {
+        var ds = var_args;
+        switch(arguments.length) {
+          case 2:
+            return G__3777__2.call(this, a, b);
+          case 3:
+            return G__3777__3.call(this, a, b, c);
+          default:
+            return G__3777__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__3777.cljs$lang$maxFixedArity = 3;
+      G__3777.cljs$lang$applyTo = G__3777__4.cljs$lang$applyTo;
+      return G__3777
+    }()
+  };
+  var fnil__4 = function(f, x, y, z) {
+    return function() {
+      var G__3780 = null;
+      var G__3780__2 = function(a, b) {
+        return f.call(null, a == null ? x : a, b == null ? y : b)
+      };
+      var G__3780__3 = function(a, b, c) {
+        return f.call(null, a == null ? x : a, b == null ? y : b, c == null ? z : c)
+      };
+      var G__3780__4 = function() {
+        var G__3781__delegate = function(a, b, c, ds) {
+          return cljs.core.apply.call(null, f, a == null ? x : a, b == null ? y : b, c == null ? z : c, ds)
+        };
+        var G__3781 = function(a, b, c, var_args) {
+          var ds = null;
+          if(arguments.length > 3) {
+            ds = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3781__delegate.call(this, a, b, c, ds)
+        };
+        G__3781.cljs$lang$maxFixedArity = 3;
+        G__3781.cljs$lang$applyTo = function(arglist__3782) {
+          var a = cljs.core.first(arglist__3782);
+          arglist__3782 = cljs.core.next(arglist__3782);
+          var b = cljs.core.first(arglist__3782);
+          arglist__3782 = cljs.core.next(arglist__3782);
+          var c = cljs.core.first(arglist__3782);
+          var ds = cljs.core.rest(arglist__3782);
+          return G__3781__delegate(a, b, c, ds)
+        };
+        G__3781.cljs$core$IFn$_invoke$arity$variadic = G__3781__delegate;
+        return G__3781
+      }();
+      G__3780 = function(a, b, c, var_args) {
+        var ds = var_args;
+        switch(arguments.length) {
+          case 2:
+            return G__3780__2.call(this, a, b);
+          case 3:
+            return G__3780__3.call(this, a, b, c);
+          default:
+            return G__3780__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__3780.cljs$lang$maxFixedArity = 3;
+      G__3780.cljs$lang$applyTo = G__3780__4.cljs$lang$applyTo;
+      return G__3780
+    }()
+  };
+  fnil = function(f, x, y, z) {
+    switch(arguments.length) {
+      case 2:
+        return fnil__2.call(this, f, x);
+      case 3:
+        return fnil__3.call(this, f, x, y);
+      case 4:
+        return fnil__4.call(this, f, x, y, z)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  fnil.cljs$core$IFn$_invoke$arity$2 = fnil__2;
+  fnil.cljs$core$IFn$_invoke$arity$3 = fnil__3;
+  fnil.cljs$core$IFn$_invoke$arity$4 = fnil__4;
+  return fnil
+}();
+cljs.core.map_indexed = function map_indexed(f, coll) {
+  var mapi = function mapi(idx, coll__$1) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll__$1);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        if(cljs.core.chunked_seq_QMARK_.call(null, s)) {
+          var c = cljs.core.chunk_first.call(null, s);
+          var size = cljs.core.count.call(null, c);
+          var b = cljs.core.chunk_buffer.call(null, size);
+          var n__3120__auto___3783 = size;
+          var i_3784 = 0;
+          while(true) {
+            if(i_3784 < n__3120__auto___3783) {
+              cljs.core.chunk_append.call(null, b, f.call(null, idx + i_3784, cljs.core._nth.call(null, c, i_3784)));
+              var G__3785 = i_3784 + 1;
+              i_3784 = G__3785;
+              continue
+            }else {
+            }
+            break
+          }
+          return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b), mapi.call(null, idx + size, cljs.core.chunk_rest.call(null, s)))
+        }else {
+          return cljs.core.cons.call(null, f.call(null, idx, cljs.core.first.call(null, s)), mapi.call(null, idx + 1, cljs.core.rest.call(null, s)))
+        }
+      }else {
+        return null
+      }
+    }, null)
+  };
+  return mapi.call(null, 0, coll)
+};
+cljs.core.keep = function keep(f, coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4092__auto__) {
+      var s = temp__4092__auto__;
+      if(cljs.core.chunked_seq_QMARK_.call(null, s)) {
+        var c = cljs.core.chunk_first.call(null, s);
+        var size = cljs.core.count.call(null, c);
+        var b = cljs.core.chunk_buffer.call(null, size);
+        var n__3120__auto___3786 = size;
+        var i_3787 = 0;
+        while(true) {
+          if(i_3787 < n__3120__auto___3786) {
+            var x_3788 = f.call(null, cljs.core._nth.call(null, c, i_3787));
+            if(x_3788 == null) {
+            }else {
+              cljs.core.chunk_append.call(null, b, x_3788)
+            }
+            var G__3789 = i_3787 + 1;
+            i_3787 = G__3789;
+            continue
+          }else {
+          }
+          break
+        }
+        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b), keep.call(null, f, cljs.core.chunk_rest.call(null, s)))
+      }else {
+        var x = f.call(null, cljs.core.first.call(null, s));
+        if(x == null) {
+          return keep.call(null, f, cljs.core.rest.call(null, s))
+        }else {
+          return cljs.core.cons.call(null, x, keep.call(null, f, cljs.core.rest.call(null, s)))
+        }
+      }
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.keep_indexed = function keep_indexed(f, coll) {
+  var keepi = function keepi(idx, coll__$1) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll__$1);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        if(cljs.core.chunked_seq_QMARK_.call(null, s)) {
+          var c = cljs.core.chunk_first.call(null, s);
+          var size = cljs.core.count.call(null, c);
+          var b = cljs.core.chunk_buffer.call(null, size);
+          var n__3120__auto___3796 = size;
+          var i_3797 = 0;
+          while(true) {
+            if(i_3797 < n__3120__auto___3796) {
+              var x_3798 = f.call(null, idx + i_3797, cljs.core._nth.call(null, c, i_3797));
+              if(x_3798 == null) {
+              }else {
+                cljs.core.chunk_append.call(null, b, x_3798)
+              }
+              var G__3799 = i_3797 + 1;
+              i_3797 = G__3799;
+              continue
+            }else {
+            }
+            break
+          }
+          return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b), keepi.call(null, idx + size, cljs.core.chunk_rest.call(null, s)))
+        }else {
+          var x = f.call(null, idx, cljs.core.first.call(null, s));
+          if(x == null) {
+            return keepi.call(null, idx + 1, cljs.core.rest.call(null, s))
+          }else {
+            return cljs.core.cons.call(null, x, keepi.call(null, idx + 1, cljs.core.rest.call(null, s)))
+          }
+        }
+      }else {
+        return null
+      }
+    }, null)
+  };
+  return keepi.call(null, 0, coll)
+};
+cljs.core.every_pred = function() {
+  var every_pred = null;
+  var every_pred__1 = function(p) {
+    return function() {
+      var ep1 = null;
+      var ep1__0 = function() {
+        return true
+      };
+      var ep1__1 = function(x) {
+        return cljs.core.boolean$.call(null, p.call(null, x))
+      };
+      var ep1__2 = function(x, y) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            return p.call(null, y)
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep1__3 = function(x, y, z) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = p.call(null, y);
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              return p.call(null, z)
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep1__4 = function() {
+        var G__3806__delegate = function(x, y, z, args) {
+          return cljs.core.boolean$.call(null, function() {
+            var and__3941__auto__ = ep1.call(null, x, y, z);
+            if(cljs.core.truth_(and__3941__auto__)) {
+              return cljs.core.every_QMARK_.call(null, p, args)
+            }else {
+              return and__3941__auto__
+            }
+          }())
+        };
+        var G__3806 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3806__delegate.call(this, x, y, z, args)
+        };
+        G__3806.cljs$lang$maxFixedArity = 3;
+        G__3806.cljs$lang$applyTo = function(arglist__3807) {
+          var x = cljs.core.first(arglist__3807);
+          arglist__3807 = cljs.core.next(arglist__3807);
+          var y = cljs.core.first(arglist__3807);
+          arglist__3807 = cljs.core.next(arglist__3807);
+          var z = cljs.core.first(arglist__3807);
+          var args = cljs.core.rest(arglist__3807);
+          return G__3806__delegate(x, y, z, args)
+        };
+        G__3806.cljs$core$IFn$_invoke$arity$variadic = G__3806__delegate;
+        return G__3806
+      }();
+      ep1 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return ep1__0.call(this);
+          case 1:
+            return ep1__1.call(this, x);
+          case 2:
+            return ep1__2.call(this, x, y);
+          case 3:
+            return ep1__3.call(this, x, y, z);
+          default:
+            return ep1__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      ep1.cljs$lang$maxFixedArity = 3;
+      ep1.cljs$lang$applyTo = ep1__4.cljs$lang$applyTo;
+      ep1.cljs$core$IFn$_invoke$arity$0 = ep1__0;
+      ep1.cljs$core$IFn$_invoke$arity$1 = ep1__1;
+      ep1.cljs$core$IFn$_invoke$arity$2 = ep1__2;
+      ep1.cljs$core$IFn$_invoke$arity$3 = ep1__3;
+      ep1.cljs$core$IFn$_invoke$arity$variadic = ep1__4.cljs$core$IFn$_invoke$arity$variadic;
+      return ep1
+    }()
+  };
+  var every_pred__2 = function(p1, p2) {
+    return function() {
+      var ep2 = null;
+      var ep2__0 = function() {
+        return true
+      };
+      var ep2__1 = function(x) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p1.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            return p2.call(null, x)
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep2__2 = function(x, y) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p1.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = p1.call(null, y);
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              var and__3941__auto____$2 = p2.call(null, x);
+              if(cljs.core.truth_(and__3941__auto____$2)) {
+                return p2.call(null, y)
+              }else {
+                return and__3941__auto____$2
+              }
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep2__3 = function(x, y, z) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p1.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = p1.call(null, y);
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              var and__3941__auto____$2 = p1.call(null, z);
+              if(cljs.core.truth_(and__3941__auto____$2)) {
+                var and__3941__auto____$3 = p2.call(null, x);
+                if(cljs.core.truth_(and__3941__auto____$3)) {
+                  var and__3941__auto____$4 = p2.call(null, y);
+                  if(cljs.core.truth_(and__3941__auto____$4)) {
+                    return p2.call(null, z)
+                  }else {
+                    return and__3941__auto____$4
+                  }
+                }else {
+                  return and__3941__auto____$3
+                }
+              }else {
+                return and__3941__auto____$2
+              }
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep2__4 = function() {
+        var G__3808__delegate = function(x, y, z, args) {
+          return cljs.core.boolean$.call(null, function() {
+            var and__3941__auto__ = ep2.call(null, x, y, z);
+            if(cljs.core.truth_(and__3941__auto__)) {
+              return cljs.core.every_QMARK_.call(null, function(p1__3790_SHARP_) {
+                var and__3941__auto____$1 = p1.call(null, p1__3790_SHARP_);
+                if(cljs.core.truth_(and__3941__auto____$1)) {
+                  return p2.call(null, p1__3790_SHARP_)
+                }else {
+                  return and__3941__auto____$1
+                }
+              }, args)
+            }else {
+              return and__3941__auto__
+            }
+          }())
+        };
+        var G__3808 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3808__delegate.call(this, x, y, z, args)
+        };
+        G__3808.cljs$lang$maxFixedArity = 3;
+        G__3808.cljs$lang$applyTo = function(arglist__3809) {
+          var x = cljs.core.first(arglist__3809);
+          arglist__3809 = cljs.core.next(arglist__3809);
+          var y = cljs.core.first(arglist__3809);
+          arglist__3809 = cljs.core.next(arglist__3809);
+          var z = cljs.core.first(arglist__3809);
+          var args = cljs.core.rest(arglist__3809);
+          return G__3808__delegate(x, y, z, args)
+        };
+        G__3808.cljs$core$IFn$_invoke$arity$variadic = G__3808__delegate;
+        return G__3808
+      }();
+      ep2 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return ep2__0.call(this);
+          case 1:
+            return ep2__1.call(this, x);
+          case 2:
+            return ep2__2.call(this, x, y);
+          case 3:
+            return ep2__3.call(this, x, y, z);
+          default:
+            return ep2__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      ep2.cljs$lang$maxFixedArity = 3;
+      ep2.cljs$lang$applyTo = ep2__4.cljs$lang$applyTo;
+      ep2.cljs$core$IFn$_invoke$arity$0 = ep2__0;
+      ep2.cljs$core$IFn$_invoke$arity$1 = ep2__1;
+      ep2.cljs$core$IFn$_invoke$arity$2 = ep2__2;
+      ep2.cljs$core$IFn$_invoke$arity$3 = ep2__3;
+      ep2.cljs$core$IFn$_invoke$arity$variadic = ep2__4.cljs$core$IFn$_invoke$arity$variadic;
+      return ep2
+    }()
+  };
+  var every_pred__3 = function(p1, p2, p3) {
+    return function() {
+      var ep3 = null;
+      var ep3__0 = function() {
+        return true
+      };
+      var ep3__1 = function(x) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p1.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = p2.call(null, x);
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              return p3.call(null, x)
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep3__2 = function(x, y) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p1.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = p2.call(null, x);
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              var and__3941__auto____$2 = p3.call(null, x);
+              if(cljs.core.truth_(and__3941__auto____$2)) {
+                var and__3941__auto____$3 = p1.call(null, y);
+                if(cljs.core.truth_(and__3941__auto____$3)) {
+                  var and__3941__auto____$4 = p2.call(null, y);
+                  if(cljs.core.truth_(and__3941__auto____$4)) {
+                    return p3.call(null, y)
+                  }else {
+                    return and__3941__auto____$4
+                  }
+                }else {
+                  return and__3941__auto____$3
+                }
+              }else {
+                return and__3941__auto____$2
+              }
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep3__3 = function(x, y, z) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3941__auto__ = p1.call(null, x);
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = p2.call(null, x);
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              var and__3941__auto____$2 = p3.call(null, x);
+              if(cljs.core.truth_(and__3941__auto____$2)) {
+                var and__3941__auto____$3 = p1.call(null, y);
+                if(cljs.core.truth_(and__3941__auto____$3)) {
+                  var and__3941__auto____$4 = p2.call(null, y);
+                  if(cljs.core.truth_(and__3941__auto____$4)) {
+                    var and__3941__auto____$5 = p3.call(null, y);
+                    if(cljs.core.truth_(and__3941__auto____$5)) {
+                      var and__3941__auto____$6 = p1.call(null, z);
+                      if(cljs.core.truth_(and__3941__auto____$6)) {
+                        var and__3941__auto____$7 = p2.call(null, z);
+                        if(cljs.core.truth_(and__3941__auto____$7)) {
+                          return p3.call(null, z)
+                        }else {
+                          return and__3941__auto____$7
+                        }
+                      }else {
+                        return and__3941__auto____$6
+                      }
+                    }else {
+                      return and__3941__auto____$5
+                    }
+                  }else {
+                    return and__3941__auto____$4
+                  }
+                }else {
+                  return and__3941__auto____$3
+                }
+              }else {
+                return and__3941__auto____$2
+              }
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())
+      };
+      var ep3__4 = function() {
+        var G__3810__delegate = function(x, y, z, args) {
+          return cljs.core.boolean$.call(null, function() {
+            var and__3941__auto__ = ep3.call(null, x, y, z);
+            if(cljs.core.truth_(and__3941__auto__)) {
+              return cljs.core.every_QMARK_.call(null, function(p1__3791_SHARP_) {
+                var and__3941__auto____$1 = p1.call(null, p1__3791_SHARP_);
+                if(cljs.core.truth_(and__3941__auto____$1)) {
+                  var and__3941__auto____$2 = p2.call(null, p1__3791_SHARP_);
+                  if(cljs.core.truth_(and__3941__auto____$2)) {
+                    return p3.call(null, p1__3791_SHARP_)
+                  }else {
+                    return and__3941__auto____$2
+                  }
+                }else {
+                  return and__3941__auto____$1
+                }
+              }, args)
+            }else {
+              return and__3941__auto__
+            }
+          }())
+        };
+        var G__3810 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3810__delegate.call(this, x, y, z, args)
+        };
+        G__3810.cljs$lang$maxFixedArity = 3;
+        G__3810.cljs$lang$applyTo = function(arglist__3811) {
+          var x = cljs.core.first(arglist__3811);
+          arglist__3811 = cljs.core.next(arglist__3811);
+          var y = cljs.core.first(arglist__3811);
+          arglist__3811 = cljs.core.next(arglist__3811);
+          var z = cljs.core.first(arglist__3811);
+          var args = cljs.core.rest(arglist__3811);
+          return G__3810__delegate(x, y, z, args)
+        };
+        G__3810.cljs$core$IFn$_invoke$arity$variadic = G__3810__delegate;
+        return G__3810
+      }();
+      ep3 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return ep3__0.call(this);
+          case 1:
+            return ep3__1.call(this, x);
+          case 2:
+            return ep3__2.call(this, x, y);
+          case 3:
+            return ep3__3.call(this, x, y, z);
+          default:
+            return ep3__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      ep3.cljs$lang$maxFixedArity = 3;
+      ep3.cljs$lang$applyTo = ep3__4.cljs$lang$applyTo;
+      ep3.cljs$core$IFn$_invoke$arity$0 = ep3__0;
+      ep3.cljs$core$IFn$_invoke$arity$1 = ep3__1;
+      ep3.cljs$core$IFn$_invoke$arity$2 = ep3__2;
+      ep3.cljs$core$IFn$_invoke$arity$3 = ep3__3;
+      ep3.cljs$core$IFn$_invoke$arity$variadic = ep3__4.cljs$core$IFn$_invoke$arity$variadic;
+      return ep3
+    }()
+  };
+  var every_pred__4 = function() {
+    var G__3812__delegate = function(p1, p2, p3, ps) {
+      var ps__$1 = cljs.core.list_STAR_.call(null, p1, p2, p3, ps);
+      return function() {
+        var epn = null;
+        var epn__0 = function() {
+          return true
+        };
+        var epn__1 = function(x) {
+          return cljs.core.every_QMARK_.call(null, function(p1__3792_SHARP_) {
+            return p1__3792_SHARP_.call(null, x)
+          }, ps__$1)
+        };
+        var epn__2 = function(x, y) {
+          return cljs.core.every_QMARK_.call(null, function(p1__3793_SHARP_) {
+            var and__3941__auto__ = p1__3793_SHARP_.call(null, x);
+            if(cljs.core.truth_(and__3941__auto__)) {
+              return p1__3793_SHARP_.call(null, y)
+            }else {
+              return and__3941__auto__
+            }
+          }, ps__$1)
+        };
+        var epn__3 = function(x, y, z) {
+          return cljs.core.every_QMARK_.call(null, function(p1__3794_SHARP_) {
+            var and__3941__auto__ = p1__3794_SHARP_.call(null, x);
+            if(cljs.core.truth_(and__3941__auto__)) {
+              var and__3941__auto____$1 = p1__3794_SHARP_.call(null, y);
+              if(cljs.core.truth_(and__3941__auto____$1)) {
+                return p1__3794_SHARP_.call(null, z)
+              }else {
+                return and__3941__auto____$1
+              }
+            }else {
+              return and__3941__auto__
+            }
+          }, ps__$1)
+        };
+        var epn__4 = function() {
+          var G__3813__delegate = function(x, y, z, args) {
+            return cljs.core.boolean$.call(null, function() {
+              var and__3941__auto__ = epn.call(null, x, y, z);
+              if(cljs.core.truth_(and__3941__auto__)) {
+                return cljs.core.every_QMARK_.call(null, function(p1__3795_SHARP_) {
+                  return cljs.core.every_QMARK_.call(null, p1__3795_SHARP_, args)
+                }, ps__$1)
+              }else {
+                return and__3941__auto__
+              }
+            }())
+          };
+          var G__3813 = function(x, y, z, var_args) {
+            var args = null;
+            if(arguments.length > 3) {
+              args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+            }
+            return G__3813__delegate.call(this, x, y, z, args)
+          };
+          G__3813.cljs$lang$maxFixedArity = 3;
+          G__3813.cljs$lang$applyTo = function(arglist__3814) {
+            var x = cljs.core.first(arglist__3814);
+            arglist__3814 = cljs.core.next(arglist__3814);
+            var y = cljs.core.first(arglist__3814);
+            arglist__3814 = cljs.core.next(arglist__3814);
+            var z = cljs.core.first(arglist__3814);
+            var args = cljs.core.rest(arglist__3814);
+            return G__3813__delegate(x, y, z, args)
+          };
+          G__3813.cljs$core$IFn$_invoke$arity$variadic = G__3813__delegate;
+          return G__3813
+        }();
+        epn = function(x, y, z, var_args) {
+          var args = var_args;
+          switch(arguments.length) {
+            case 0:
+              return epn__0.call(this);
+            case 1:
+              return epn__1.call(this, x);
+            case 2:
+              return epn__2.call(this, x, y);
+            case 3:
+              return epn__3.call(this, x, y, z);
+            default:
+              return epn__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+          }
+          throw new Error("Invalid arity: " + arguments.length);
+        };
+        epn.cljs$lang$maxFixedArity = 3;
+        epn.cljs$lang$applyTo = epn__4.cljs$lang$applyTo;
+        epn.cljs$core$IFn$_invoke$arity$0 = epn__0;
+        epn.cljs$core$IFn$_invoke$arity$1 = epn__1;
+        epn.cljs$core$IFn$_invoke$arity$2 = epn__2;
+        epn.cljs$core$IFn$_invoke$arity$3 = epn__3;
+        epn.cljs$core$IFn$_invoke$arity$variadic = epn__4.cljs$core$IFn$_invoke$arity$variadic;
+        return epn
+      }()
+    };
+    var G__3812 = function(p1, p2, p3, var_args) {
+      var ps = null;
+      if(arguments.length > 3) {
+        ps = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__3812__delegate.call(this, p1, p2, p3, ps)
+    };
+    G__3812.cljs$lang$maxFixedArity = 3;
+    G__3812.cljs$lang$applyTo = function(arglist__3815) {
+      var p1 = cljs.core.first(arglist__3815);
+      arglist__3815 = cljs.core.next(arglist__3815);
+      var p2 = cljs.core.first(arglist__3815);
+      arglist__3815 = cljs.core.next(arglist__3815);
+      var p3 = cljs.core.first(arglist__3815);
+      var ps = cljs.core.rest(arglist__3815);
+      return G__3812__delegate(p1, p2, p3, ps)
+    };
+    G__3812.cljs$core$IFn$_invoke$arity$variadic = G__3812__delegate;
+    return G__3812
+  }();
+  every_pred = function(p1, p2, p3, var_args) {
+    var ps = var_args;
+    switch(arguments.length) {
+      case 1:
+        return every_pred__1.call(this, p1);
+      case 2:
+        return every_pred__2.call(this, p1, p2);
+      case 3:
+        return every_pred__3.call(this, p1, p2, p3);
+      default:
+        return every_pred__4.cljs$core$IFn$_invoke$arity$variadic(p1, p2, p3, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  every_pred.cljs$lang$maxFixedArity = 3;
+  every_pred.cljs$lang$applyTo = every_pred__4.cljs$lang$applyTo;
+  every_pred.cljs$core$IFn$_invoke$arity$1 = every_pred__1;
+  every_pred.cljs$core$IFn$_invoke$arity$2 = every_pred__2;
+  every_pred.cljs$core$IFn$_invoke$arity$3 = every_pred__3;
+  every_pred.cljs$core$IFn$_invoke$arity$variadic = every_pred__4.cljs$core$IFn$_invoke$arity$variadic;
+  return every_pred
+}();
+cljs.core.some_fn = function() {
+  var some_fn = null;
+  var some_fn__1 = function(p) {
+    return function() {
+      var sp1 = null;
+      var sp1__0 = function() {
+        return null
+      };
+      var sp1__1 = function(x) {
+        return p.call(null, x)
+      };
+      var sp1__2 = function(x, y) {
+        var or__3943__auto__ = p.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          return p.call(null, y)
+        }
+      };
+      var sp1__3 = function(x, y, z) {
+        var or__3943__auto__ = p.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = p.call(null, y);
+          if(cljs.core.truth_(or__3943__auto____$1)) {
+            return or__3943__auto____$1
+          }else {
+            return p.call(null, z)
+          }
+        }
+      };
+      var sp1__4 = function() {
+        var G__3817__delegate = function(x, y, z, args) {
+          var or__3943__auto__ = sp1.call(null, x, y, z);
+          if(cljs.core.truth_(or__3943__auto__)) {
+            return or__3943__auto__
+          }else {
+            return cljs.core.some.call(null, p, args)
+          }
+        };
+        var G__3817 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3817__delegate.call(this, x, y, z, args)
+        };
+        G__3817.cljs$lang$maxFixedArity = 3;
+        G__3817.cljs$lang$applyTo = function(arglist__3818) {
+          var x = cljs.core.first(arglist__3818);
+          arglist__3818 = cljs.core.next(arglist__3818);
+          var y = cljs.core.first(arglist__3818);
+          arglist__3818 = cljs.core.next(arglist__3818);
+          var z = cljs.core.first(arglist__3818);
+          var args = cljs.core.rest(arglist__3818);
+          return G__3817__delegate(x, y, z, args)
+        };
+        G__3817.cljs$core$IFn$_invoke$arity$variadic = G__3817__delegate;
+        return G__3817
+      }();
+      sp1 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return sp1__0.call(this);
+          case 1:
+            return sp1__1.call(this, x);
+          case 2:
+            return sp1__2.call(this, x, y);
+          case 3:
+            return sp1__3.call(this, x, y, z);
+          default:
+            return sp1__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      sp1.cljs$lang$maxFixedArity = 3;
+      sp1.cljs$lang$applyTo = sp1__4.cljs$lang$applyTo;
+      sp1.cljs$core$IFn$_invoke$arity$0 = sp1__0;
+      sp1.cljs$core$IFn$_invoke$arity$1 = sp1__1;
+      sp1.cljs$core$IFn$_invoke$arity$2 = sp1__2;
+      sp1.cljs$core$IFn$_invoke$arity$3 = sp1__3;
+      sp1.cljs$core$IFn$_invoke$arity$variadic = sp1__4.cljs$core$IFn$_invoke$arity$variadic;
+      return sp1
+    }()
+  };
+  var some_fn__2 = function(p1, p2) {
+    return function() {
+      var sp2 = null;
+      var sp2__0 = function() {
+        return null
+      };
+      var sp2__1 = function(x) {
+        var or__3943__auto__ = p1.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          return p2.call(null, x)
+        }
+      };
+      var sp2__2 = function(x, y) {
+        var or__3943__auto__ = p1.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = p1.call(null, y);
+          if(cljs.core.truth_(or__3943__auto____$1)) {
+            return or__3943__auto____$1
+          }else {
+            var or__3943__auto____$2 = p2.call(null, x);
+            if(cljs.core.truth_(or__3943__auto____$2)) {
+              return or__3943__auto____$2
+            }else {
+              return p2.call(null, y)
+            }
+          }
+        }
+      };
+      var sp2__3 = function(x, y, z) {
+        var or__3943__auto__ = p1.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = p1.call(null, y);
+          if(cljs.core.truth_(or__3943__auto____$1)) {
+            return or__3943__auto____$1
+          }else {
+            var or__3943__auto____$2 = p1.call(null, z);
+            if(cljs.core.truth_(or__3943__auto____$2)) {
+              return or__3943__auto____$2
+            }else {
+              var or__3943__auto____$3 = p2.call(null, x);
+              if(cljs.core.truth_(or__3943__auto____$3)) {
+                return or__3943__auto____$3
+              }else {
+                var or__3943__auto____$4 = p2.call(null, y);
+                if(cljs.core.truth_(or__3943__auto____$4)) {
+                  return or__3943__auto____$4
+                }else {
+                  return p2.call(null, z)
+                }
+              }
+            }
+          }
+        }
+      };
+      var sp2__4 = function() {
+        var G__3819__delegate = function(x, y, z, args) {
+          var or__3943__auto__ = sp2.call(null, x, y, z);
+          if(cljs.core.truth_(or__3943__auto__)) {
+            return or__3943__auto__
+          }else {
+            return cljs.core.some.call(null, function(p1__3800_SHARP_) {
+              var or__3943__auto____$1 = p1.call(null, p1__3800_SHARP_);
+              if(cljs.core.truth_(or__3943__auto____$1)) {
+                return or__3943__auto____$1
+              }else {
+                return p2.call(null, p1__3800_SHARP_)
+              }
+            }, args)
+          }
+        };
+        var G__3819 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3819__delegate.call(this, x, y, z, args)
+        };
+        G__3819.cljs$lang$maxFixedArity = 3;
+        G__3819.cljs$lang$applyTo = function(arglist__3820) {
+          var x = cljs.core.first(arglist__3820);
+          arglist__3820 = cljs.core.next(arglist__3820);
+          var y = cljs.core.first(arglist__3820);
+          arglist__3820 = cljs.core.next(arglist__3820);
+          var z = cljs.core.first(arglist__3820);
+          var args = cljs.core.rest(arglist__3820);
+          return G__3819__delegate(x, y, z, args)
+        };
+        G__3819.cljs$core$IFn$_invoke$arity$variadic = G__3819__delegate;
+        return G__3819
+      }();
+      sp2 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return sp2__0.call(this);
+          case 1:
+            return sp2__1.call(this, x);
+          case 2:
+            return sp2__2.call(this, x, y);
+          case 3:
+            return sp2__3.call(this, x, y, z);
+          default:
+            return sp2__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      sp2.cljs$lang$maxFixedArity = 3;
+      sp2.cljs$lang$applyTo = sp2__4.cljs$lang$applyTo;
+      sp2.cljs$core$IFn$_invoke$arity$0 = sp2__0;
+      sp2.cljs$core$IFn$_invoke$arity$1 = sp2__1;
+      sp2.cljs$core$IFn$_invoke$arity$2 = sp2__2;
+      sp2.cljs$core$IFn$_invoke$arity$3 = sp2__3;
+      sp2.cljs$core$IFn$_invoke$arity$variadic = sp2__4.cljs$core$IFn$_invoke$arity$variadic;
+      return sp2
+    }()
+  };
+  var some_fn__3 = function(p1, p2, p3) {
+    return function() {
+      var sp3 = null;
+      var sp3__0 = function() {
+        return null
+      };
+      var sp3__1 = function(x) {
+        var or__3943__auto__ = p1.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = p2.call(null, x);
+          if(cljs.core.truth_(or__3943__auto____$1)) {
+            return or__3943__auto____$1
+          }else {
+            return p3.call(null, x)
+          }
+        }
+      };
+      var sp3__2 = function(x, y) {
+        var or__3943__auto__ = p1.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = p2.call(null, x);
+          if(cljs.core.truth_(or__3943__auto____$1)) {
+            return or__3943__auto____$1
+          }else {
+            var or__3943__auto____$2 = p3.call(null, x);
+            if(cljs.core.truth_(or__3943__auto____$2)) {
+              return or__3943__auto____$2
+            }else {
+              var or__3943__auto____$3 = p1.call(null, y);
+              if(cljs.core.truth_(or__3943__auto____$3)) {
+                return or__3943__auto____$3
+              }else {
+                var or__3943__auto____$4 = p2.call(null, y);
+                if(cljs.core.truth_(or__3943__auto____$4)) {
+                  return or__3943__auto____$4
+                }else {
+                  return p3.call(null, y)
+                }
+              }
+            }
+          }
+        }
+      };
+      var sp3__3 = function(x, y, z) {
+        var or__3943__auto__ = p1.call(null, x);
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = p2.call(null, x);
+          if(cljs.core.truth_(or__3943__auto____$1)) {
+            return or__3943__auto____$1
+          }else {
+            var or__3943__auto____$2 = p3.call(null, x);
+            if(cljs.core.truth_(or__3943__auto____$2)) {
+              return or__3943__auto____$2
+            }else {
+              var or__3943__auto____$3 = p1.call(null, y);
+              if(cljs.core.truth_(or__3943__auto____$3)) {
+                return or__3943__auto____$3
+              }else {
+                var or__3943__auto____$4 = p2.call(null, y);
+                if(cljs.core.truth_(or__3943__auto____$4)) {
+                  return or__3943__auto____$4
+                }else {
+                  var or__3943__auto____$5 = p3.call(null, y);
+                  if(cljs.core.truth_(or__3943__auto____$5)) {
+                    return or__3943__auto____$5
+                  }else {
+                    var or__3943__auto____$6 = p1.call(null, z);
+                    if(cljs.core.truth_(or__3943__auto____$6)) {
+                      return or__3943__auto____$6
+                    }else {
+                      var or__3943__auto____$7 = p2.call(null, z);
+                      if(cljs.core.truth_(or__3943__auto____$7)) {
+                        return or__3943__auto____$7
+                      }else {
+                        return p3.call(null, z)
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      var sp3__4 = function() {
+        var G__3821__delegate = function(x, y, z, args) {
+          var or__3943__auto__ = sp3.call(null, x, y, z);
+          if(cljs.core.truth_(or__3943__auto__)) {
+            return or__3943__auto__
+          }else {
+            return cljs.core.some.call(null, function(p1__3801_SHARP_) {
+              var or__3943__auto____$1 = p1.call(null, p1__3801_SHARP_);
+              if(cljs.core.truth_(or__3943__auto____$1)) {
+                return or__3943__auto____$1
+              }else {
+                var or__3943__auto____$2 = p2.call(null, p1__3801_SHARP_);
+                if(cljs.core.truth_(or__3943__auto____$2)) {
+                  return or__3943__auto____$2
+                }else {
+                  return p3.call(null, p1__3801_SHARP_)
+                }
+              }
+            }, args)
+          }
+        };
+        var G__3821 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__3821__delegate.call(this, x, y, z, args)
+        };
+        G__3821.cljs$lang$maxFixedArity = 3;
+        G__3821.cljs$lang$applyTo = function(arglist__3822) {
+          var x = cljs.core.first(arglist__3822);
+          arglist__3822 = cljs.core.next(arglist__3822);
+          var y = cljs.core.first(arglist__3822);
+          arglist__3822 = cljs.core.next(arglist__3822);
+          var z = cljs.core.first(arglist__3822);
+          var args = cljs.core.rest(arglist__3822);
+          return G__3821__delegate(x, y, z, args)
+        };
+        G__3821.cljs$core$IFn$_invoke$arity$variadic = G__3821__delegate;
+        return G__3821
+      }();
+      sp3 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return sp3__0.call(this);
+          case 1:
+            return sp3__1.call(this, x);
+          case 2:
+            return sp3__2.call(this, x, y);
+          case 3:
+            return sp3__3.call(this, x, y, z);
+          default:
+            return sp3__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      sp3.cljs$lang$maxFixedArity = 3;
+      sp3.cljs$lang$applyTo = sp3__4.cljs$lang$applyTo;
+      sp3.cljs$core$IFn$_invoke$arity$0 = sp3__0;
+      sp3.cljs$core$IFn$_invoke$arity$1 = sp3__1;
+      sp3.cljs$core$IFn$_invoke$arity$2 = sp3__2;
+      sp3.cljs$core$IFn$_invoke$arity$3 = sp3__3;
+      sp3.cljs$core$IFn$_invoke$arity$variadic = sp3__4.cljs$core$IFn$_invoke$arity$variadic;
+      return sp3
+    }()
+  };
+  var some_fn__4 = function() {
+    var G__3823__delegate = function(p1, p2, p3, ps) {
+      var ps__$1 = cljs.core.list_STAR_.call(null, p1, p2, p3, ps);
+      return function() {
+        var spn = null;
+        var spn__0 = function() {
+          return null
+        };
+        var spn__1 = function(x) {
+          return cljs.core.some.call(null, function(p1__3802_SHARP_) {
+            return p1__3802_SHARP_.call(null, x)
+          }, ps__$1)
+        };
+        var spn__2 = function(x, y) {
+          return cljs.core.some.call(null, function(p1__3803_SHARP_) {
+            var or__3943__auto__ = p1__3803_SHARP_.call(null, x);
+            if(cljs.core.truth_(or__3943__auto__)) {
+              return or__3943__auto__
+            }else {
+              return p1__3803_SHARP_.call(null, y)
+            }
+          }, ps__$1)
+        };
+        var spn__3 = function(x, y, z) {
+          return cljs.core.some.call(null, function(p1__3804_SHARP_) {
+            var or__3943__auto__ = p1__3804_SHARP_.call(null, x);
+            if(cljs.core.truth_(or__3943__auto__)) {
+              return or__3943__auto__
+            }else {
+              var or__3943__auto____$1 = p1__3804_SHARP_.call(null, y);
+              if(cljs.core.truth_(or__3943__auto____$1)) {
+                return or__3943__auto____$1
+              }else {
+                return p1__3804_SHARP_.call(null, z)
+              }
+            }
+          }, ps__$1)
+        };
+        var spn__4 = function() {
+          var G__3824__delegate = function(x, y, z, args) {
+            var or__3943__auto__ = spn.call(null, x, y, z);
+            if(cljs.core.truth_(or__3943__auto__)) {
+              return or__3943__auto__
+            }else {
+              return cljs.core.some.call(null, function(p1__3805_SHARP_) {
+                return cljs.core.some.call(null, p1__3805_SHARP_, args)
+              }, ps__$1)
+            }
+          };
+          var G__3824 = function(x, y, z, var_args) {
+            var args = null;
+            if(arguments.length > 3) {
+              args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+            }
+            return G__3824__delegate.call(this, x, y, z, args)
+          };
+          G__3824.cljs$lang$maxFixedArity = 3;
+          G__3824.cljs$lang$applyTo = function(arglist__3825) {
+            var x = cljs.core.first(arglist__3825);
+            arglist__3825 = cljs.core.next(arglist__3825);
+            var y = cljs.core.first(arglist__3825);
+            arglist__3825 = cljs.core.next(arglist__3825);
+            var z = cljs.core.first(arglist__3825);
+            var args = cljs.core.rest(arglist__3825);
+            return G__3824__delegate(x, y, z, args)
+          };
+          G__3824.cljs$core$IFn$_invoke$arity$variadic = G__3824__delegate;
+          return G__3824
+        }();
+        spn = function(x, y, z, var_args) {
+          var args = var_args;
+          switch(arguments.length) {
+            case 0:
+              return spn__0.call(this);
+            case 1:
+              return spn__1.call(this, x);
+            case 2:
+              return spn__2.call(this, x, y);
+            case 3:
+              return spn__3.call(this, x, y, z);
+            default:
+              return spn__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+          }
+          throw new Error("Invalid arity: " + arguments.length);
+        };
+        spn.cljs$lang$maxFixedArity = 3;
+        spn.cljs$lang$applyTo = spn__4.cljs$lang$applyTo;
+        spn.cljs$core$IFn$_invoke$arity$0 = spn__0;
+        spn.cljs$core$IFn$_invoke$arity$1 = spn__1;
+        spn.cljs$core$IFn$_invoke$arity$2 = spn__2;
+        spn.cljs$core$IFn$_invoke$arity$3 = spn__3;
+        spn.cljs$core$IFn$_invoke$arity$variadic = spn__4.cljs$core$IFn$_invoke$arity$variadic;
+        return spn
+      }()
+    };
+    var G__3823 = function(p1, p2, p3, var_args) {
+      var ps = null;
+      if(arguments.length > 3) {
+        ps = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__3823__delegate.call(this, p1, p2, p3, ps)
+    };
+    G__3823.cljs$lang$maxFixedArity = 3;
+    G__3823.cljs$lang$applyTo = function(arglist__3826) {
+      var p1 = cljs.core.first(arglist__3826);
+      arglist__3826 = cljs.core.next(arglist__3826);
+      var p2 = cljs.core.first(arglist__3826);
+      arglist__3826 = cljs.core.next(arglist__3826);
+      var p3 = cljs.core.first(arglist__3826);
+      var ps = cljs.core.rest(arglist__3826);
+      return G__3823__delegate(p1, p2, p3, ps)
+    };
+    G__3823.cljs$core$IFn$_invoke$arity$variadic = G__3823__delegate;
+    return G__3823
+  }();
+  some_fn = function(p1, p2, p3, var_args) {
+    var ps = var_args;
+    switch(arguments.length) {
+      case 1:
+        return some_fn__1.call(this, p1);
+      case 2:
+        return some_fn__2.call(this, p1, p2);
+      case 3:
+        return some_fn__3.call(this, p1, p2, p3);
+      default:
+        return some_fn__4.cljs$core$IFn$_invoke$arity$variadic(p1, p2, p3, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  some_fn.cljs$lang$maxFixedArity = 3;
+  some_fn.cljs$lang$applyTo = some_fn__4.cljs$lang$applyTo;
+  some_fn.cljs$core$IFn$_invoke$arity$1 = some_fn__1;
+  some_fn.cljs$core$IFn$_invoke$arity$2 = some_fn__2;
+  some_fn.cljs$core$IFn$_invoke$arity$3 = some_fn__3;
+  some_fn.cljs$core$IFn$_invoke$arity$variadic = some_fn__4.cljs$core$IFn$_invoke$arity$variadic;
+  return some_fn
+}();
+cljs.core.map = function() {
+  var map = null;
+  var map__2 = function(f, coll) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        if(cljs.core.chunked_seq_QMARK_.call(null, s)) {
+          var c = cljs.core.chunk_first.call(null, s);
+          var size = cljs.core.count.call(null, c);
+          var b = cljs.core.chunk_buffer.call(null, size);
+          var n__3120__auto___3827 = size;
+          var i_3828 = 0;
+          while(true) {
+            if(i_3828 < n__3120__auto___3827) {
+              cljs.core.chunk_append.call(null, b, f.call(null, cljs.core._nth.call(null, c, i_3828)));
+              var G__3829 = i_3828 + 1;
+              i_3828 = G__3829;
+              continue
+            }else {
+            }
+            break
+          }
+          return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b), map.call(null, f, cljs.core.chunk_rest.call(null, s)))
+        }else {
+          return cljs.core.cons.call(null, f.call(null, cljs.core.first.call(null, s)), map.call(null, f, cljs.core.rest.call(null, s)))
+        }
+      }else {
+        return null
+      }
+    }, null)
+  };
+  var map__3 = function(f, c1, c2) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var s1 = cljs.core.seq.call(null, c1);
+      var s2 = cljs.core.seq.call(null, c2);
+      if(function() {
+        var and__3941__auto__ = s1;
+        if(and__3941__auto__) {
+          return s2
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        return cljs.core.cons.call(null, f.call(null, cljs.core.first.call(null, s1), cljs.core.first.call(null, s2)), map.call(null, f, cljs.core.rest.call(null, s1), cljs.core.rest.call(null, s2)))
+      }else {
+        return null
+      }
+    }, null)
+  };
+  var map__4 = function(f, c1, c2, c3) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var s1 = cljs.core.seq.call(null, c1);
+      var s2 = cljs.core.seq.call(null, c2);
+      var s3 = cljs.core.seq.call(null, c3);
+      if(function() {
+        var and__3941__auto__ = s1;
+        if(and__3941__auto__) {
+          var and__3941__auto____$1 = s2;
+          if(and__3941__auto____$1) {
+            return s3
+          }else {
+            return and__3941__auto____$1
+          }
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        return cljs.core.cons.call(null, f.call(null, cljs.core.first.call(null, s1), cljs.core.first.call(null, s2), cljs.core.first.call(null, s3)), map.call(null, f, cljs.core.rest.call(null, s1), cljs.core.rest.call(null, s2), cljs.core.rest.call(null, s3)))
+      }else {
+        return null
+      }
+    }, null)
+  };
+  var map__5 = function() {
+    var G__3830__delegate = function(f, c1, c2, c3, colls) {
+      var step = function step(cs) {
+        return new cljs.core.LazySeq(null, false, function() {
+          var ss = map.call(null, cljs.core.seq, cs);
+          if(cljs.core.every_QMARK_.call(null, cljs.core.identity, ss)) {
+            return cljs.core.cons.call(null, map.call(null, cljs.core.first, ss), step.call(null, map.call(null, cljs.core.rest, ss)))
+          }else {
+            return null
+          }
+        }, null)
+      };
+      return map.call(null, function(p1__3816_SHARP_) {
+        return cljs.core.apply.call(null, f, p1__3816_SHARP_)
+      }, step.call(null, cljs.core.conj.call(null, colls, c3, c2, c1)))
+    };
+    var G__3830 = function(f, c1, c2, c3, var_args) {
+      var colls = null;
+      if(arguments.length > 4) {
+        colls = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4), 0)
+      }
+      return G__3830__delegate.call(this, f, c1, c2, c3, colls)
+    };
+    G__3830.cljs$lang$maxFixedArity = 4;
+    G__3830.cljs$lang$applyTo = function(arglist__3831) {
+      var f = cljs.core.first(arglist__3831);
+      arglist__3831 = cljs.core.next(arglist__3831);
+      var c1 = cljs.core.first(arglist__3831);
+      arglist__3831 = cljs.core.next(arglist__3831);
+      var c2 = cljs.core.first(arglist__3831);
+      arglist__3831 = cljs.core.next(arglist__3831);
+      var c3 = cljs.core.first(arglist__3831);
+      var colls = cljs.core.rest(arglist__3831);
+      return G__3830__delegate(f, c1, c2, c3, colls)
+    };
+    G__3830.cljs$core$IFn$_invoke$arity$variadic = G__3830__delegate;
+    return G__3830
+  }();
+  map = function(f, c1, c2, c3, var_args) {
+    var colls = var_args;
+    switch(arguments.length) {
+      case 2:
+        return map__2.call(this, f, c1);
+      case 3:
+        return map__3.call(this, f, c1, c2);
+      case 4:
+        return map__4.call(this, f, c1, c2, c3);
+      default:
+        return map__5.cljs$core$IFn$_invoke$arity$variadic(f, c1, c2, c3, cljs.core.array_seq(arguments, 4))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  map.cljs$lang$maxFixedArity = 4;
+  map.cljs$lang$applyTo = map__5.cljs$lang$applyTo;
+  map.cljs$core$IFn$_invoke$arity$2 = map__2;
+  map.cljs$core$IFn$_invoke$arity$3 = map__3;
+  map.cljs$core$IFn$_invoke$arity$4 = map__4;
+  map.cljs$core$IFn$_invoke$arity$variadic = map__5.cljs$core$IFn$_invoke$arity$variadic;
+  return map
+}();
+cljs.core.take = function take(n, coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    if(n > 0) {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        return cljs.core.cons.call(null, cljs.core.first.call(null, s), take.call(null, n - 1, cljs.core.rest.call(null, s)))
+      }else {
+        return null
+      }
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.drop = function drop(n, coll) {
+  var step = function(n__$1, coll__$1) {
+    while(true) {
+      var s = cljs.core.seq.call(null, coll__$1);
+      if(cljs.core.truth_(function() {
+        var and__3941__auto__ = n__$1 > 0;
+        if(and__3941__auto__) {
+          return s
+        }else {
+          return and__3941__auto__
+        }
+      }())) {
+        var G__3832 = n__$1 - 1;
+        var G__3833 = cljs.core.rest.call(null, s);
+        n__$1 = G__3832;
+        coll__$1 = G__3833;
+        continue
+      }else {
+        return s
+      }
+      break
+    }
+  };
+  return new cljs.core.LazySeq(null, false, function() {
+    return step.call(null, n, coll)
+  }, null)
+};
+cljs.core.drop_last = function() {
+  var drop_last = null;
+  var drop_last__1 = function(s) {
+    return drop_last.call(null, 1, s)
+  };
+  var drop_last__2 = function(n, s) {
+    return cljs.core.map.call(null, function(x, _) {
+      return x
+    }, s, cljs.core.drop.call(null, n, s))
+  };
+  drop_last = function(n, s) {
+    switch(arguments.length) {
+      case 1:
+        return drop_last__1.call(this, n);
+      case 2:
+        return drop_last__2.call(this, n, s)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  drop_last.cljs$core$IFn$_invoke$arity$1 = drop_last__1;
+  drop_last.cljs$core$IFn$_invoke$arity$2 = drop_last__2;
+  return drop_last
+}();
+cljs.core.take_last = function take_last(n, coll) {
+  var s = cljs.core.seq.call(null, coll);
+  var lead = cljs.core.seq.call(null, cljs.core.drop.call(null, n, coll));
+  while(true) {
+    if(lead) {
+      var G__3834 = cljs.core.next.call(null, s);
+      var G__3835 = cljs.core.next.call(null, lead);
+      s = G__3834;
+      lead = G__3835;
+      continue
+    }else {
+      return s
+    }
+    break
+  }
+};
+cljs.core.drop_while = function drop_while(pred, coll) {
+  var step = function(pred__$1, coll__$1) {
+    while(true) {
+      var s = cljs.core.seq.call(null, coll__$1);
+      if(cljs.core.truth_(function() {
+        var and__3941__auto__ = s;
+        if(and__3941__auto__) {
+          return pred__$1.call(null, cljs.core.first.call(null, s))
+        }else {
+          return and__3941__auto__
+        }
+      }())) {
+        var G__3836 = pred__$1;
+        var G__3837 = cljs.core.rest.call(null, s);
+        pred__$1 = G__3836;
+        coll__$1 = G__3837;
+        continue
+      }else {
+        return s
+      }
+      break
+    }
+  };
+  return new cljs.core.LazySeq(null, false, function() {
+    return step.call(null, pred, coll)
+  }, null)
+};
+cljs.core.cycle = function cycle(coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4092__auto__) {
+      var s = temp__4092__auto__;
+      return cljs.core.concat.call(null, s, cycle.call(null, s))
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.split_at = function split_at(n, coll) {
+  return cljs.core.PersistentVector.fromArray([cljs.core.take.call(null, n, coll), cljs.core.drop.call(null, n, coll)], true)
+};
+cljs.core.repeat = function() {
+  var repeat = null;
+  var repeat__1 = function(x) {
+    return new cljs.core.LazySeq(null, false, function() {
+      return cljs.core.cons.call(null, x, repeat.call(null, x))
+    }, null)
+  };
+  var repeat__2 = function(n, x) {
+    return cljs.core.take.call(null, n, repeat.call(null, x))
+  };
+  repeat = function(n, x) {
+    switch(arguments.length) {
+      case 1:
+        return repeat__1.call(this, n);
+      case 2:
+        return repeat__2.call(this, n, x)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  repeat.cljs$core$IFn$_invoke$arity$1 = repeat__1;
+  repeat.cljs$core$IFn$_invoke$arity$2 = repeat__2;
+  return repeat
+}();
+cljs.core.replicate = function replicate(n, x) {
+  return cljs.core.take.call(null, n, cljs.core.repeat.call(null, x))
+};
+cljs.core.repeatedly = function() {
+  var repeatedly = null;
+  var repeatedly__1 = function(f) {
+    return new cljs.core.LazySeq(null, false, function() {
+      return cljs.core.cons.call(null, f.call(null), repeatedly.call(null, f))
+    }, null)
+  };
+  var repeatedly__2 = function(n, f) {
+    return cljs.core.take.call(null, n, repeatedly.call(null, f))
+  };
+  repeatedly = function(n, f) {
+    switch(arguments.length) {
+      case 1:
+        return repeatedly__1.call(this, n);
+      case 2:
+        return repeatedly__2.call(this, n, f)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  repeatedly.cljs$core$IFn$_invoke$arity$1 = repeatedly__1;
+  repeatedly.cljs$core$IFn$_invoke$arity$2 = repeatedly__2;
+  return repeatedly
+}();
+cljs.core.iterate = function iterate(f, x) {
+  return cljs.core.cons.call(null, x, new cljs.core.LazySeq(null, false, function() {
+    return iterate.call(null, f, f.call(null, x))
+  }, null))
+};
+cljs.core.interleave = function() {
+  var interleave = null;
+  var interleave__2 = function(c1, c2) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var s1 = cljs.core.seq.call(null, c1);
+      var s2 = cljs.core.seq.call(null, c2);
+      if(function() {
+        var and__3941__auto__ = s1;
+        if(and__3941__auto__) {
+          return s2
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        return cljs.core.cons.call(null, cljs.core.first.call(null, s1), cljs.core.cons.call(null, cljs.core.first.call(null, s2), interleave.call(null, cljs.core.rest.call(null, s1), cljs.core.rest.call(null, s2))))
+      }else {
+        return null
+      }
+    }, null)
+  };
+  var interleave__3 = function() {
+    var G__3838__delegate = function(c1, c2, colls) {
+      return new cljs.core.LazySeq(null, false, function() {
+        var ss = cljs.core.map.call(null, cljs.core.seq, cljs.core.conj.call(null, colls, c2, c1));
+        if(cljs.core.every_QMARK_.call(null, cljs.core.identity, ss)) {
+          return cljs.core.concat.call(null, cljs.core.map.call(null, cljs.core.first, ss), cljs.core.apply.call(null, interleave, cljs.core.map.call(null, cljs.core.rest, ss)))
+        }else {
+          return null
+        }
+      }, null)
+    };
+    var G__3838 = function(c1, c2, var_args) {
+      var colls = null;
+      if(arguments.length > 2) {
+        colls = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3838__delegate.call(this, c1, c2, colls)
+    };
+    G__3838.cljs$lang$maxFixedArity = 2;
+    G__3838.cljs$lang$applyTo = function(arglist__3839) {
+      var c1 = cljs.core.first(arglist__3839);
+      arglist__3839 = cljs.core.next(arglist__3839);
+      var c2 = cljs.core.first(arglist__3839);
+      var colls = cljs.core.rest(arglist__3839);
+      return G__3838__delegate(c1, c2, colls)
+    };
+    G__3838.cljs$core$IFn$_invoke$arity$variadic = G__3838__delegate;
+    return G__3838
+  }();
+  interleave = function(c1, c2, var_args) {
+    var colls = var_args;
+    switch(arguments.length) {
+      case 2:
+        return interleave__2.call(this, c1, c2);
+      default:
+        return interleave__3.cljs$core$IFn$_invoke$arity$variadic(c1, c2, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  interleave.cljs$lang$maxFixedArity = 2;
+  interleave.cljs$lang$applyTo = interleave__3.cljs$lang$applyTo;
+  interleave.cljs$core$IFn$_invoke$arity$2 = interleave__2;
+  interleave.cljs$core$IFn$_invoke$arity$variadic = interleave__3.cljs$core$IFn$_invoke$arity$variadic;
+  return interleave
+}();
+cljs.core.interpose = function interpose(sep, coll) {
+  return cljs.core.drop.call(null, 1, cljs.core.interleave.call(null, cljs.core.repeat.call(null, sep), coll))
+};
+cljs.core.flatten1 = function flatten1(colls) {
+  var cat = function cat(coll, colls__$1) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4090__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4090__auto__) {
+        var coll__$1 = temp__4090__auto__;
+        return cljs.core.cons.call(null, cljs.core.first.call(null, coll__$1), cat.call(null, cljs.core.rest.call(null, coll__$1), colls__$1))
+      }else {
+        if(cljs.core.seq.call(null, colls__$1)) {
+          return cat.call(null, cljs.core.first.call(null, colls__$1), cljs.core.rest.call(null, colls__$1))
+        }else {
+          return null
+        }
+      }
+    }, null)
+  };
+  return cat.call(null, null, colls)
+};
+cljs.core.mapcat = function() {
+  var mapcat = null;
+  var mapcat__2 = function(f, coll) {
+    return cljs.core.flatten1.call(null, cljs.core.map.call(null, f, coll))
+  };
+  var mapcat__3 = function() {
+    var G__3840__delegate = function(f, coll, colls) {
+      return cljs.core.flatten1.call(null, cljs.core.apply.call(null, cljs.core.map, f, coll, colls))
+    };
+    var G__3840 = function(f, coll, var_args) {
+      var colls = null;
+      if(arguments.length > 2) {
+        colls = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+      }
+      return G__3840__delegate.call(this, f, coll, colls)
+    };
+    G__3840.cljs$lang$maxFixedArity = 2;
+    G__3840.cljs$lang$applyTo = function(arglist__3841) {
+      var f = cljs.core.first(arglist__3841);
+      arglist__3841 = cljs.core.next(arglist__3841);
+      var coll = cljs.core.first(arglist__3841);
+      var colls = cljs.core.rest(arglist__3841);
+      return G__3840__delegate(f, coll, colls)
+    };
+    G__3840.cljs$core$IFn$_invoke$arity$variadic = G__3840__delegate;
+    return G__3840
+  }();
+  mapcat = function(f, coll, var_args) {
+    var colls = var_args;
+    switch(arguments.length) {
+      case 2:
+        return mapcat__2.call(this, f, coll);
+      default:
+        return mapcat__3.cljs$core$IFn$_invoke$arity$variadic(f, coll, cljs.core.array_seq(arguments, 2))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  mapcat.cljs$lang$maxFixedArity = 2;
+  mapcat.cljs$lang$applyTo = mapcat__3.cljs$lang$applyTo;
+  mapcat.cljs$core$IFn$_invoke$arity$2 = mapcat__2;
+  mapcat.cljs$core$IFn$_invoke$arity$variadic = mapcat__3.cljs$core$IFn$_invoke$arity$variadic;
+  return mapcat
+}();
+cljs.core.filter = function filter(pred, coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4092__auto__) {
+      var s = temp__4092__auto__;
+      if(cljs.core.chunked_seq_QMARK_.call(null, s)) {
+        var c = cljs.core.chunk_first.call(null, s);
+        var size = cljs.core.count.call(null, c);
+        var b = cljs.core.chunk_buffer.call(null, size);
+        var n__3120__auto___3842 = size;
+        var i_3843 = 0;
+        while(true) {
+          if(i_3843 < n__3120__auto___3842) {
+            if(cljs.core.truth_(pred.call(null, cljs.core._nth.call(null, c, i_3843)))) {
+              cljs.core.chunk_append.call(null, b, cljs.core._nth.call(null, c, i_3843))
+            }else {
+            }
+            var G__3844 = i_3843 + 1;
+            i_3843 = G__3844;
+            continue
+          }else {
+          }
+          break
+        }
+        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b), filter.call(null, pred, cljs.core.chunk_rest.call(null, s)))
+      }else {
+        var f = cljs.core.first.call(null, s);
+        var r = cljs.core.rest.call(null, s);
+        if(cljs.core.truth_(pred.call(null, f))) {
+          return cljs.core.cons.call(null, f, filter.call(null, pred, r))
+        }else {
+          return filter.call(null, pred, r)
+        }
+      }
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.remove = function remove(pred, coll) {
+  return cljs.core.filter.call(null, cljs.core.complement.call(null, pred), coll)
+};
+cljs.core.tree_seq = function tree_seq(branch_QMARK_, children, root) {
+  var walk = function walk(node) {
+    return new cljs.core.LazySeq(null, false, function() {
+      return cljs.core.cons.call(null, node, cljs.core.truth_(branch_QMARK_.call(null, node)) ? cljs.core.mapcat.call(null, walk, children.call(null, node)) : null)
+    }, null)
+  };
+  return walk.call(null, root)
+};
+cljs.core.flatten = function flatten(x) {
+  return cljs.core.filter.call(null, function(p1__3845_SHARP_) {
+    return!cljs.core.sequential_QMARK_.call(null, p1__3845_SHARP_)
+  }, cljs.core.rest.call(null, cljs.core.tree_seq.call(null, cljs.core.sequential_QMARK_, cljs.core.seq, x)))
+};
+cljs.core.into = function into(to, from) {
+  if(!(to == null)) {
+    if(function() {
+      var G__3847 = to;
+      if(G__3847) {
+        if(function() {
+          var or__3943__auto__ = G__3847.cljs$lang$protocol_mask$partition1$ & 4;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3847.cljs$core$IEditableCollection$
+          }
+        }()) {
+          return true
+        }else {
+          return false
+        }
+      }else {
+        return false
+      }
+    }()) {
+      return cljs.core.persistent_BANG_.call(null, cljs.core.reduce.call(null, cljs.core._conj_BANG_, cljs.core.transient$.call(null, to), from))
+    }else {
+      return cljs.core.reduce.call(null, cljs.core._conj, to, from)
+    }
+  }else {
+    return cljs.core.reduce.call(null, cljs.core.conj, cljs.core.List.EMPTY, from)
+  }
+};
+cljs.core.mapv = function() {
+  var mapv = null;
+  var mapv__2 = function(f, coll) {
+    return cljs.core.persistent_BANG_.call(null, cljs.core.reduce.call(null, function(v, o) {
+      return cljs.core.conj_BANG_.call(null, v, f.call(null, o))
+    }, cljs.core.transient$.call(null, cljs.core.PersistentVector.EMPTY), coll))
+  };
+  var mapv__3 = function(f, c1, c2) {
+    return cljs.core.into.call(null, cljs.core.PersistentVector.EMPTY, cljs.core.map.call(null, f, c1, c2))
+  };
+  var mapv__4 = function(f, c1, c2, c3) {
+    return cljs.core.into.call(null, cljs.core.PersistentVector.EMPTY, cljs.core.map.call(null, f, c1, c2, c3))
+  };
+  var mapv__5 = function() {
+    var G__3848__delegate = function(f, c1, c2, c3, colls) {
+      return cljs.core.into.call(null, cljs.core.PersistentVector.EMPTY, cljs.core.apply.call(null, cljs.core.map, f, c1, c2, c3, colls))
+    };
+    var G__3848 = function(f, c1, c2, c3, var_args) {
+      var colls = null;
+      if(arguments.length > 4) {
+        colls = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4), 0)
+      }
+      return G__3848__delegate.call(this, f, c1, c2, c3, colls)
+    };
+    G__3848.cljs$lang$maxFixedArity = 4;
+    G__3848.cljs$lang$applyTo = function(arglist__3849) {
+      var f = cljs.core.first(arglist__3849);
+      arglist__3849 = cljs.core.next(arglist__3849);
+      var c1 = cljs.core.first(arglist__3849);
+      arglist__3849 = cljs.core.next(arglist__3849);
+      var c2 = cljs.core.first(arglist__3849);
+      arglist__3849 = cljs.core.next(arglist__3849);
+      var c3 = cljs.core.first(arglist__3849);
+      var colls = cljs.core.rest(arglist__3849);
+      return G__3848__delegate(f, c1, c2, c3, colls)
+    };
+    G__3848.cljs$core$IFn$_invoke$arity$variadic = G__3848__delegate;
+    return G__3848
+  }();
+  mapv = function(f, c1, c2, c3, var_args) {
+    var colls = var_args;
+    switch(arguments.length) {
+      case 2:
+        return mapv__2.call(this, f, c1);
+      case 3:
+        return mapv__3.call(this, f, c1, c2);
+      case 4:
+        return mapv__4.call(this, f, c1, c2, c3);
+      default:
+        return mapv__5.cljs$core$IFn$_invoke$arity$variadic(f, c1, c2, c3, cljs.core.array_seq(arguments, 4))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  mapv.cljs$lang$maxFixedArity = 4;
+  mapv.cljs$lang$applyTo = mapv__5.cljs$lang$applyTo;
+  mapv.cljs$core$IFn$_invoke$arity$2 = mapv__2;
+  mapv.cljs$core$IFn$_invoke$arity$3 = mapv__3;
+  mapv.cljs$core$IFn$_invoke$arity$4 = mapv__4;
+  mapv.cljs$core$IFn$_invoke$arity$variadic = mapv__5.cljs$core$IFn$_invoke$arity$variadic;
+  return mapv
+}();
+cljs.core.filterv = function filterv(pred, coll) {
+  return cljs.core.persistent_BANG_.call(null, cljs.core.reduce.call(null, function(v, o) {
+    if(cljs.core.truth_(pred.call(null, o))) {
+      return cljs.core.conj_BANG_.call(null, v, o)
+    }else {
+      return v
+    }
+  }, cljs.core.transient$.call(null, cljs.core.PersistentVector.EMPTY), coll))
+};
+cljs.core.partition = function() {
+  var partition = null;
+  var partition__2 = function(n, coll) {
+    return partition.call(null, n, n, coll)
+  };
+  var partition__3 = function(n, step, coll) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        var p = cljs.core.take.call(null, n, s);
+        if(n === cljs.core.count.call(null, p)) {
+          return cljs.core.cons.call(null, p, partition.call(null, n, step, cljs.core.drop.call(null, step, s)))
+        }else {
+          return null
+        }
+      }else {
+        return null
+      }
+    }, null)
+  };
+  var partition__4 = function(n, step, pad, coll) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        var p = cljs.core.take.call(null, n, s);
+        if(n === cljs.core.count.call(null, p)) {
+          return cljs.core.cons.call(null, p, partition.call(null, n, step, pad, cljs.core.drop.call(null, step, s)))
+        }else {
+          return cljs.core.list.call(null, cljs.core.take.call(null, n, cljs.core.concat.call(null, p, pad)))
+        }
+      }else {
+        return null
+      }
+    }, null)
+  };
+  partition = function(n, step, pad, coll) {
+    switch(arguments.length) {
+      case 2:
+        return partition__2.call(this, n, step);
+      case 3:
+        return partition__3.call(this, n, step, pad);
+      case 4:
+        return partition__4.call(this, n, step, pad, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  partition.cljs$core$IFn$_invoke$arity$2 = partition__2;
+  partition.cljs$core$IFn$_invoke$arity$3 = partition__3;
+  partition.cljs$core$IFn$_invoke$arity$4 = partition__4;
+  return partition
+}();
+cljs.core.get_in = function() {
+  var get_in = null;
+  var get_in__2 = function(m, ks) {
+    return get_in.call(null, m, ks, null)
+  };
+  var get_in__3 = function(m, ks, not_found) {
+    var sentinel = cljs.core.lookup_sentinel;
+    var m__$1 = m;
+    var ks__$1 = cljs.core.seq.call(null, ks);
+    while(true) {
+      if(ks__$1) {
+        if(!function() {
+          var G__3851 = m__$1;
+          if(G__3851) {
+            if(function() {
+              var or__3943__auto__ = G__3851.cljs$lang$protocol_mask$partition0$ & 256;
+              if(or__3943__auto__) {
+                return or__3943__auto__
+              }else {
+                return G__3851.cljs$core$ILookup$
+              }
+            }()) {
+              return true
+            }else {
+              if(!G__3851.cljs$lang$protocol_mask$partition0$) {
+                return cljs.core.type_satisfies_.call(null, cljs.core.ILookup, G__3851)
+              }else {
+                return false
+              }
+            }
+          }else {
+            return cljs.core.type_satisfies_.call(null, cljs.core.ILookup, G__3851)
+          }
+        }()) {
+          return not_found
+        }else {
+          var m__$2 = cljs.core.get.call(null, m__$1, cljs.core.first.call(null, ks__$1), sentinel);
+          if(sentinel === m__$2) {
+            return not_found
+          }else {
+            var G__3852 = sentinel;
+            var G__3853 = m__$2;
+            var G__3854 = cljs.core.next.call(null, ks__$1);
+            sentinel = G__3852;
+            m__$1 = G__3853;
+            ks__$1 = G__3854;
+            continue
+          }
+        }
+      }else {
+        return m__$1
+      }
+      break
+    }
+  };
+  get_in = function(m, ks, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return get_in__2.call(this, m, ks);
+      case 3:
+        return get_in__3.call(this, m, ks, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  get_in.cljs$core$IFn$_invoke$arity$2 = get_in__2;
+  get_in.cljs$core$IFn$_invoke$arity$3 = get_in__3;
+  return get_in
+}();
+cljs.core.assoc_in = function assoc_in(m, p__3855, v) {
+  var vec__3857 = p__3855;
+  var k = cljs.core.nth.call(null, vec__3857, 0, null);
+  var ks = cljs.core.nthnext.call(null, vec__3857, 1);
+  if(cljs.core.truth_(ks)) {
+    return cljs.core.assoc.call(null, m, k, assoc_in.call(null, cljs.core.get.call(null, m, k), ks, v))
+  }else {
+    return cljs.core.assoc.call(null, m, k, v)
+  }
+};
+cljs.core.update_in = function() {
+  var update_in = null;
+  var update_in__3 = function(m, p__3858, f) {
+    var vec__3868 = p__3858;
+    var k = cljs.core.nth.call(null, vec__3868, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__3868, 1);
+    if(cljs.core.truth_(ks)) {
+      return cljs.core.assoc.call(null, m, k, update_in.call(null, cljs.core.get.call(null, m, k), ks, f))
+    }else {
+      return cljs.core.assoc.call(null, m, k, f.call(null, cljs.core.get.call(null, m, k)))
+    }
+  };
+  var update_in__4 = function(m, p__3859, f, a) {
+    var vec__3869 = p__3859;
+    var k = cljs.core.nth.call(null, vec__3869, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__3869, 1);
+    if(cljs.core.truth_(ks)) {
+      return cljs.core.assoc.call(null, m, k, update_in.call(null, cljs.core.get.call(null, m, k), ks, f, a))
+    }else {
+      return cljs.core.assoc.call(null, m, k, f.call(null, cljs.core.get.call(null, m, k), a))
+    }
+  };
+  var update_in__5 = function(m, p__3860, f, a, b) {
+    var vec__3870 = p__3860;
+    var k = cljs.core.nth.call(null, vec__3870, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__3870, 1);
+    if(cljs.core.truth_(ks)) {
+      return cljs.core.assoc.call(null, m, k, update_in.call(null, cljs.core.get.call(null, m, k), ks, f, a, b))
+    }else {
+      return cljs.core.assoc.call(null, m, k, f.call(null, cljs.core.get.call(null, m, k), a, b))
+    }
+  };
+  var update_in__6 = function(m, p__3861, f, a, b, c) {
+    var vec__3871 = p__3861;
+    var k = cljs.core.nth.call(null, vec__3871, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__3871, 1);
+    if(cljs.core.truth_(ks)) {
+      return cljs.core.assoc.call(null, m, k, update_in.call(null, cljs.core.get.call(null, m, k), ks, f, a, b, c))
+    }else {
+      return cljs.core.assoc.call(null, m, k, f.call(null, cljs.core.get.call(null, m, k), a, b, c))
+    }
+  };
+  var update_in__7 = function() {
+    var G__3873__delegate = function(m, p__3862, f, a, b, c, args) {
+      var vec__3872 = p__3862;
+      var k = cljs.core.nth.call(null, vec__3872, 0, null);
+      var ks = cljs.core.nthnext.call(null, vec__3872, 1);
+      if(cljs.core.truth_(ks)) {
+        return cljs.core.assoc.call(null, m, k, cljs.core.apply.call(null, update_in, cljs.core.get.call(null, m, k), ks, f, a, b, c, args))
+      }else {
+        return cljs.core.assoc.call(null, m, k, cljs.core.apply.call(null, f, cljs.core.get.call(null, m, k), a, b, c, args))
+      }
+    };
+    var G__3873 = function(m, p__3862, f, a, b, c, var_args) {
+      var args = null;
+      if(arguments.length > 6) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 6), 0)
+      }
+      return G__3873__delegate.call(this, m, p__3862, f, a, b, c, args)
+    };
+    G__3873.cljs$lang$maxFixedArity = 6;
+    G__3873.cljs$lang$applyTo = function(arglist__3874) {
+      var m = cljs.core.first(arglist__3874);
+      arglist__3874 = cljs.core.next(arglist__3874);
+      var p__3862 = cljs.core.first(arglist__3874);
+      arglist__3874 = cljs.core.next(arglist__3874);
+      var f = cljs.core.first(arglist__3874);
+      arglist__3874 = cljs.core.next(arglist__3874);
+      var a = cljs.core.first(arglist__3874);
+      arglist__3874 = cljs.core.next(arglist__3874);
+      var b = cljs.core.first(arglist__3874);
+      arglist__3874 = cljs.core.next(arglist__3874);
+      var c = cljs.core.first(arglist__3874);
+      var args = cljs.core.rest(arglist__3874);
+      return G__3873__delegate(m, p__3862, f, a, b, c, args)
+    };
+    G__3873.cljs$core$IFn$_invoke$arity$variadic = G__3873__delegate;
+    return G__3873
+  }();
+  update_in = function(m, p__3862, f, a, b, c, var_args) {
+    var args = var_args;
+    switch(arguments.length) {
+      case 3:
+        return update_in__3.call(this, m, p__3862, f);
+      case 4:
+        return update_in__4.call(this, m, p__3862, f, a);
+      case 5:
+        return update_in__5.call(this, m, p__3862, f, a, b);
+      case 6:
+        return update_in__6.call(this, m, p__3862, f, a, b, c);
+      default:
+        return update_in__7.cljs$core$IFn$_invoke$arity$variadic(m, p__3862, f, a, b, c, cljs.core.array_seq(arguments, 6))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  update_in.cljs$lang$maxFixedArity = 6;
+  update_in.cljs$lang$applyTo = update_in__7.cljs$lang$applyTo;
+  update_in.cljs$core$IFn$_invoke$arity$3 = update_in__3;
+  update_in.cljs$core$IFn$_invoke$arity$4 = update_in__4;
+  update_in.cljs$core$IFn$_invoke$arity$5 = update_in__5;
+  update_in.cljs$core$IFn$_invoke$arity$6 = update_in__6;
+  update_in.cljs$core$IFn$_invoke$arity$variadic = update_in__7.cljs$core$IFn$_invoke$arity$variadic;
+  return update_in
+}();
+goog.provide("cljs.core.VectorNode");
+cljs.core.VectorNode = function(edit, arr) {
+  this.edit = edit;
+  this.arr = arr
+};
+cljs.core.VectorNode.cljs$lang$type = true;
+cljs.core.VectorNode.cljs$lang$ctorStr = "cljs.core/VectorNode";
+cljs.core.VectorNode.cljs$lang$ctorPrWriter = function(this__2885__auto__, writer__2886__auto__, opts__2887__auto__) {
+  return cljs.core._write.call(null, writer__2886__auto__, "cljs.core/VectorNode")
+};
+cljs.core.pv_fresh_node = function pv_fresh_node(edit) {
+  return new cljs.core.VectorNode(edit, new Array(32))
+};
+cljs.core.pv_aget = function pv_aget(node, idx) {
+  return node.arr[idx]
+};
+cljs.core.pv_aset = function pv_aset(node, idx, val) {
+  return node.arr[idx] = val
+};
+cljs.core.pv_clone_node = function pv_clone_node(node) {
+  return new cljs.core.VectorNode(node.edit, node.arr.slice())
+};
+cljs.core.tail_off = function tail_off(pv) {
+  var cnt = pv.cnt;
+  if(cnt < 32) {
+    return 0
+  }else {
+    return cnt - 1 >>> 5 << 5
+  }
+};
+cljs.core.new_path = function new_path(edit, level, node) {
+  var ll = level;
+  var ret = node;
+  while(true) {
+    if(ll === 0) {
+      return ret
+    }else {
+      var embed = ret;
+      var r = cljs.core.pv_fresh_node.call(null, edit);
+      var _ = cljs.core.pv_aset.call(null, r, 0, embed);
+      var G__3875 = ll - 5;
+      var G__3876 = r;
+      ll = G__3875;
+      ret = G__3876;
+      continue
+    }
+    break
+  }
+};
+cljs.core.push_tail = function push_tail(pv, level, parent, tailnode) {
+  var ret = cljs.core.pv_clone_node.call(null, parent);
+  var subidx = pv.cnt - 1 >>> level & 31;
+  if(5 === level) {
+    cljs.core.pv_aset.call(null, ret, subidx, tailnode);
+    return ret
+  }else {
+    var child = cljs.core.pv_aget.call(null, parent, subidx);
+    if(!(child == null)) {
+      var node_to_insert = push_tail.call(null, pv, level - 5, child, tailnode);
+      cljs.core.pv_aset.call(null, ret, subidx, node_to_insert);
+      return ret
+    }else {
+      var node_to_insert = cljs.core.new_path.call(null, null, level - 5, tailnode);
+      cljs.core.pv_aset.call(null, ret, subidx, node_to_insert);
+      return ret
+    }
+  }
+};
+cljs.core.array_for = function array_for(pv, i) {
+  if(function() {
+    var and__3941__auto__ = 0 <= i;
+    if(and__3941__auto__) {
+      return i < pv.cnt
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    if(i >= cljs.core.tail_off.call(null, pv)) {
+      return pv.tail
+    }else {
+      var node = pv.root;
+      var level = pv.shift;
+      while(true) {
+        if(level > 0) {
+          var G__3877 = cljs.core.pv_aget.call(null, node, i >>> level & 31);
+          var G__3878 = level - 5;
+          node = G__3877;
+          level = G__3878;
+          continue
+        }else {
+          return node.arr
+        }
+        break
+      }
+    }
+  }else {
+    throw new Error([cljs.core.str("No item "), cljs.core.str(i), cljs.core.str(" in vector of length "), cljs.core.str(pv.cnt)].join(""));
+  }
+};
+cljs.core.do_assoc = function do_assoc(pv, level, node, i, val) {
+  var ret = cljs.core.pv_clone_node.call(null, node);
+  if(level === 0) {
+    cljs.core.pv_aset.call(null, ret, i & 31, val);
+    return ret
+  }else {
+    var subidx = i >>> level & 31;
+    cljs.core.pv_aset.call(null, ret, subidx, do_assoc.call(null, pv, level - 5, cljs.core.pv_aget.call(null, node, subidx), i, val));
+    return ret
+  }
+};
+cljs.core.pop_tail = function pop_tail(pv, level, node) {
+  var subidx = pv.cnt - 2 >>> level & 31;
+  if(level > 5) {
+    var new_child = pop_tail.call(null, pv, level - 5, cljs.core.pv_aget.call(null, node, subidx));
+    if(function() {
+      var and__3941__auto__ = new_child == null;
+      if(and__3941__auto__) {
+        return subidx === 0
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return null
+    }else {
+      var ret = cljs.core.pv_clone_node.call(null, node);
+      cljs.core.pv_aset.call(null, ret, subidx, new_child);
+      return ret
+    }
+  }else {
+    if(subidx === 0) {
+      return null
+    }else {
+      if("\ufdd0:else") {
+        var ret = cljs.core.pv_clone_node.call(null, node);
+        cljs.core.pv_aset.call(null, ret, subidx, null);
+        return ret
+      }else {
+        return null
+      }
+    }
+  }
+};
+goog.provide("cljs.core.PersistentVector");
+cljs.core.PersistentVector = function(meta, cnt, shift, root, tail, __hash) {
+  this.meta = meta;
+  this.cnt = cnt;
+  this.shift = shift;
+  this.root = root;
+  this.tail = tail;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 4;
+  this.cljs$lang$protocol_mask$partition0$ = 167668511
+};
+cljs.core.PersistentVector.cljs$lang$type = true;
+cljs.core.PersistentVector.cljs$lang$ctorStr = "cljs.core/PersistentVector";
+cljs.core.PersistentVector.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentVector")
+};
+cljs.core.PersistentVector.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  return new cljs.core.TransientVector(self__.cnt, self__.shift, cljs.core.tv_editable_root.call(null, self__.root), cljs.core.tv_editable_tail.call(null, self__.tail))
+};
+cljs.core.PersistentVector.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(coll, k, null)
+};
+cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(coll, k, not_found)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = 0 <= k;
+    if(and__3941__auto__) {
+      return k < self__.cnt
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    if(cljs.core.tail_off.call(null, coll) <= k) {
+      var new_tail = self__.tail.slice();
+      new_tail[k & 31] = v;
+      return new cljs.core.PersistentVector(self__.meta, self__.cnt, self__.shift, self__.root, new_tail, null)
+    }else {
+      return new cljs.core.PersistentVector(self__.meta, self__.cnt, self__.shift, cljs.core.do_assoc.call(null, coll, self__.shift, self__.root, k, v), self__.tail, null)
+    }
+  }else {
+    if(k === self__.cnt) {
+      return coll.cljs$core$ICollection$_conj$arity$2(coll, v)
+    }else {
+      if("\ufdd0:else") {
+        throw new Error([cljs.core.str("Index "), cljs.core.str(k), cljs.core.str(" out of bounds  [0,"), cljs.core.str(self__.cnt), cljs.core.str("]")].join(""));
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentVector.prototype.call = function() {
+  var G__3880 = null;
+  var G__3880__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3880__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3880 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3880__2.call(this, self__, k);
+      case 3:
+        return G__3880__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3880
+}();
+cljs.core.PersistentVector.prototype.apply = function(self__, args3879) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3879.slice()))
+};
+cljs.core.PersistentVector.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(v, f, init) {
+  var self__ = this;
+  var step_init = [0, init];
+  var i = 0;
+  while(true) {
+    if(i < self__.cnt) {
+      var arr = cljs.core.array_for.call(null, v, i);
+      var len = arr.length;
+      var init__$1 = function() {
+        var j = 0;
+        var init__$1 = step_init[1];
+        while(true) {
+          if(j < len) {
+            var init__$2 = f.call(null, init__$1, j + i, arr[j]);
+            if(cljs.core.reduced_QMARK_.call(null, init__$2)) {
+              return init__$2
+            }else {
+              var G__3881 = j + 1;
+              var G__3882 = init__$2;
+              j = G__3881;
+              init__$1 = G__3882;
+              continue
+            }
+          }else {
+            step_init[0] = len;
+            step_init[1] = init__$1;
+            return init__$1
+          }
+          break
+        }
+      }();
+      if(cljs.core.reduced_QMARK_.call(null, init__$1)) {
+        return cljs.core.deref.call(null, init__$1)
+      }else {
+        var G__3883 = i + step_init[0];
+        i = G__3883;
+        continue
+      }
+    }else {
+      return step_init[1]
+    }
+    break
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  if(self__.cnt - cljs.core.tail_off.call(null, coll) < 32) {
+    var new_tail = self__.tail.slice();
+    new_tail.push(o);
+    return new cljs.core.PersistentVector(self__.meta, self__.cnt + 1, self__.shift, self__.root, new_tail, null)
+  }else {
+    var root_overflow_QMARK_ = self__.cnt >>> 5 > 1 << self__.shift;
+    var new_shift = root_overflow_QMARK_ ? self__.shift + 5 : self__.shift;
+    var new_root = root_overflow_QMARK_ ? function() {
+      var n_r = cljs.core.pv_fresh_node.call(null, null);
+      cljs.core.pv_aset.call(null, n_r, 0, self__.root);
+      cljs.core.pv_aset.call(null, n_r, 1, cljs.core.new_path.call(null, null, self__.shift, new cljs.core.VectorNode(null, self__.tail)));
+      return n_r
+    }() : cljs.core.push_tail.call(null, coll, self__.shift, self__.root, new cljs.core.VectorNode(null, self__.tail));
+    return new cljs.core.PersistentVector(self__.meta, self__.cnt + 1, new_shift, new_root, [o], null)
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    return new cljs.core.RSeq(coll, self__.cnt - 1, null)
+  }else {
+    return cljs.core.List.EMPTY
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_key$arity$1 = function(coll) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$2(coll, 0)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_val$arity$1 = function(coll) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$2(coll, 1)
+};
+cljs.core.PersistentVector.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$2 = function(v, f) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, v, f)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$3 = function(v, f, start) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, v, f, start)
+};
+cljs.core.PersistentVector.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt === 0) {
+    return null
+  }else {
+    if(self__.cnt < 32) {
+      return cljs.core.array_seq.call(null, self__.tail)
+    }else {
+      if("\ufdd0:else") {
+        return cljs.core.chunked_seq.call(null, coll, 0, 0)
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.cnt
+};
+cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    return coll.cljs$core$IIndexed$_nth$arity$2(coll, self__.cnt - 1)
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt === 0) {
+    throw new Error("Can't pop empty vector");
+  }else {
+    if(1 === self__.cnt) {
+      return cljs.core._with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta)
+    }else {
+      if(1 < self__.cnt - cljs.core.tail_off.call(null, coll)) {
+        return new cljs.core.PersistentVector(self__.meta, self__.cnt - 1, self__.shift, self__.root, self__.tail.slice(0, -1), null)
+      }else {
+        if("\ufdd0:else") {
+          var new_tail = cljs.core.array_for.call(null, coll, self__.cnt - 2);
+          var nr = cljs.core.pop_tail.call(null, coll, self__.shift, self__.root);
+          var new_root = nr == null ? cljs.core.PersistentVector.EMPTY_NODE : nr;
+          var cnt_1 = self__.cnt - 1;
+          if(function() {
+            var and__3941__auto__ = 5 < self__.shift;
+            if(and__3941__auto__) {
+              return cljs.core.pv_aget.call(null, new_root, 1) == null
+            }else {
+              return and__3941__auto__
+            }
+          }()) {
+            return new cljs.core.PersistentVector(self__.meta, cnt_1, self__.shift - 5, cljs.core.pv_aget.call(null, new_root, 0), new_tail, null)
+          }else {
+            return new cljs.core.PersistentVector(self__.meta, cnt_1, self__.shift, new_root, new_tail, null)
+          }
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(coll, n, val) {
+  var self__ = this;
+  return coll.cljs$core$IAssociative$_assoc$arity$3(coll, n, val)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentVector(meta__$1, self__.cnt, self__.shift, self__.root, self__.tail, self__.__hash)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  return cljs.core.array_for.call(null, coll, n)[n & 31]
+};
+cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = 0 <= n;
+    if(and__3941__auto__) {
+      return n < self__.cnt
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IIndexed$_nth$arity$2(coll, n)
+  }else {
+    return not_found
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta)
+};
+cljs.core.PersistentVector.EMPTY_NODE = new cljs.core.VectorNode(null, new Array(32));
+cljs.core.PersistentVector.EMPTY = new cljs.core.PersistentVector(null, 0, 5, cljs.core.PersistentVector.EMPTY_NODE, [], 0);
+cljs.core.PersistentVector.fromArray = function(xs, no_clone) {
+  var l = xs.length;
+  var xs__$1 = no_clone ? xs : xs.slice();
+  if(l < 32) {
+    return new cljs.core.PersistentVector(null, l, 5, cljs.core.PersistentVector.EMPTY_NODE, xs__$1, null)
+  }else {
+    var node = xs__$1.slice(0, 32);
+    var v = new cljs.core.PersistentVector(null, 32, 5, cljs.core.PersistentVector.EMPTY_NODE, node, null);
+    var i = 32;
+    var out = cljs.core._as_transient.call(null, v);
+    while(true) {
+      if(i < l) {
+        var G__3884 = i + 1;
+        var G__3885 = cljs.core.conj_BANG_.call(null, out, xs__$1[i]);
+        i = G__3884;
+        out = G__3885;
+        continue
+      }else {
+        return cljs.core.persistent_BANG_.call(null, out)
+      }
+      break
+    }
+  }
+};
+cljs.core.vec = function vec(coll) {
+  return cljs.core._persistent_BANG_.call(null, cljs.core.reduce.call(null, cljs.core._conj_BANG_, cljs.core._as_transient.call(null, cljs.core.PersistentVector.EMPTY), coll))
+};
+cljs.core.vector = function() {
+  var vector__delegate = function(args) {
+    return cljs.core.vec.call(null, args)
+  };
+  var vector = function(var_args) {
+    var args = null;
+    if(arguments.length > 0) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return vector__delegate.call(this, args)
+  };
+  vector.cljs$lang$maxFixedArity = 0;
+  vector.cljs$lang$applyTo = function(arglist__3886) {
+    var args = cljs.core.seq(arglist__3886);
+    return vector__delegate(args)
+  };
+  vector.cljs$core$IFn$_invoke$arity$variadic = vector__delegate;
+  return vector
+}();
+goog.provide("cljs.core.ChunkedSeq");
+cljs.core.ChunkedSeq = function(vec, node, i, off, meta, __hash) {
+  this.vec = vec;
+  this.node = node;
+  this.i = i;
+  this.off = off;
+  this.meta = meta;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition0$ = 31719660;
+  this.cljs$lang$protocol_mask$partition1$ = 1536
+};
+cljs.core.ChunkedSeq.cljs$lang$type = true;
+cljs.core.ChunkedSeq.cljs$lang$ctorStr = "cljs.core/ChunkedSeq";
+cljs.core.ChunkedSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ChunkedSeq")
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.off + 1 < self__.node.length) {
+    var s = cljs.core.chunked_seq.call(null, self__.vec, self__.node, self__.i, self__.off + 1);
+    if(s == null) {
+      return null
+    }else {
+      return s
+    }
+  }else {
+    return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll)
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.ChunkedSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.node[self__.off]
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.off + 1 < self__.node.length) {
+    var s = cljs.core.chunked_seq.call(null, self__.vec, self__.node, self__.i, self__.off + 1);
+    if(s == null) {
+      return cljs.core.List.EMPTY
+    }else {
+      return s
+    }
+  }else {
+    return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll)
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = function(coll) {
+  var self__ = this;
+  var l = self__.node.length;
+  var s = self__.i + l < cljs.core._count.call(null, self__.vec) ? cljs.core.chunked_seq.call(null, self__.vec, self__.i + l, 0) : null;
+  if(s == null) {
+    return null
+  }else {
+    return s
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, m) {
+  var self__ = this;
+  return cljs.core.chunked_seq.call(null, self__.vec, self__.node, self__.i, self__.off, m)
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta)
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.array_chunk.call(null, self__.node, self__.off)
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var l = self__.node.length;
+  var s = self__.i + l < cljs.core._count.call(null, self__.vec) ? cljs.core.chunked_seq.call(null, self__.vec, self__.i + l, 0) : null;
+  if(s == null) {
+    return cljs.core.List.EMPTY
+  }else {
+    return s
+  }
+};
+cljs.core.chunked_seq = function() {
+  var chunked_seq = null;
+  var chunked_seq__3 = function(vec, i, off) {
+    return new cljs.core.ChunkedSeq(vec, cljs.core.array_for.call(null, vec, i), i, off, null, null)
+  };
+  var chunked_seq__4 = function(vec, node, i, off) {
+    return new cljs.core.ChunkedSeq(vec, node, i, off, null, null)
+  };
+  var chunked_seq__5 = function(vec, node, i, off, meta) {
+    return new cljs.core.ChunkedSeq(vec, node, i, off, meta, null)
+  };
+  chunked_seq = function(vec, node, i, off, meta) {
+    switch(arguments.length) {
+      case 3:
+        return chunked_seq__3.call(this, vec, node, i);
+      case 4:
+        return chunked_seq__4.call(this, vec, node, i, off);
+      case 5:
+        return chunked_seq__5.call(this, vec, node, i, off, meta)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  chunked_seq.cljs$core$IFn$_invoke$arity$3 = chunked_seq__3;
+  chunked_seq.cljs$core$IFn$_invoke$arity$4 = chunked_seq__4;
+  chunked_seq.cljs$core$IFn$_invoke$arity$5 = chunked_seq__5;
+  return chunked_seq
+}();
+goog.provide("cljs.core.Subvec");
+cljs.core.Subvec = function(meta, v, start, end, __hash) {
+  this.meta = meta;
+  this.v = v;
+  this.start = start;
+  this.end = end;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32400159
+};
+cljs.core.Subvec.cljs$lang$type = true;
+cljs.core.Subvec.cljs$lang$ctorStr = "cljs.core/Subvec";
+cljs.core.Subvec.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Subvec")
+};
+cljs.core.Subvec.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(coll, k, null)
+};
+cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(coll, k, not_found)
+};
+cljs.core.Subvec.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, key, val) {
+  var self__ = this;
+  var v_pos = self__.start + key;
+  return cljs.core.build_subvec.call(null, self__.meta, cljs.core.assoc.call(null, self__.v, v_pos, val), self__.start, self__.end > v_pos + 1 ? self__.end : v_pos + 1, null)
+};
+cljs.core.Subvec.prototype.call = function() {
+  var G__3888 = null;
+  var G__3888__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3888__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3888 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3888__2.call(this, self__, k);
+      case 3:
+        return G__3888__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3888
+}();
+cljs.core.Subvec.prototype.apply = function(self__, args3887) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3887.slice()))
+};
+cljs.core.Subvec.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.build_subvec.call(null, self__.meta, cljs.core._assoc_n.call(null, self__.v, self__.end, o), self__.start, self__.end + 1, null)
+};
+cljs.core.Subvec.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, coll, f)
+};
+cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start__$1) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, coll, f, start__$1)
+};
+cljs.core.Subvec.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var subvec_seq = function subvec_seq(i) {
+    if(i === self__.end) {
+      return null
+    }else {
+      return cljs.core.cons.call(null, cljs.core._nth.call(null, self__.v, i), new cljs.core.LazySeq(null, false, function() {
+        return subvec_seq.call(null, i + 1)
+      }, null))
+    }
+  };
+  return subvec_seq.call(null, self__.start)
+};
+cljs.core.Subvec.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.end - self__.start
+};
+cljs.core.Subvec.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._nth.call(null, self__.v, self__.end - 1)
+};
+cljs.core.Subvec.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.start === self__.end) {
+    throw new Error("Can't pop empty vector");
+  }else {
+    return cljs.core.build_subvec.call(null, self__.meta, self__.v, self__.start, self__.end - 1, null)
+  }
+};
+cljs.core.Subvec.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(coll, n, val) {
+  var self__ = this;
+  return coll.cljs$core$IAssociative$_assoc$arity$3(coll, n, val)
+};
+cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return cljs.core.build_subvec.call(null, meta__$1, self__.v, self__.start, self__.end, self__.__hash)
+};
+cljs.core.Subvec.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  return cljs.core._nth.call(null, self__.v, self__.start + n)
+};
+cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) {
+  var self__ = this;
+  return cljs.core._nth.call(null, self__.v, self__.start + n, not_found)
+};
+cljs.core.Subvec.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta)
+};
+cljs.core.build_subvec = function build_subvec(meta, v, start, end, __hash) {
+  while(true) {
+    if(v instanceof cljs.core.Subvec) {
+      var G__3889 = meta;
+      var G__3890 = v.v;
+      var G__3891 = v.start + start;
+      var G__3892 = v.start + end;
+      var G__3893 = __hash;
+      meta = G__3889;
+      v = G__3890;
+      start = G__3891;
+      end = G__3892;
+      __hash = G__3893;
+      continue
+    }else {
+      var c = cljs.core.count.call(null, v);
+      if(function() {
+        var or__3943__auto__ = start < 0;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          var or__3943__auto____$1 = end < 0;
+          if(or__3943__auto____$1) {
+            return or__3943__auto____$1
+          }else {
+            var or__3943__auto____$2 = start > c;
+            if(or__3943__auto____$2) {
+              return or__3943__auto____$2
+            }else {
+              return end > c
+            }
+          }
+        }
+      }()) {
+        throw new Error("Index out of bounds");
+      }else {
+      }
+      return new cljs.core.Subvec(meta, v, start, end, __hash)
+    }
+    break
+  }
+};
+cljs.core.subvec = function() {
+  var subvec = null;
+  var subvec__2 = function(v, start) {
+    return subvec.call(null, v, start, cljs.core.count.call(null, v))
+  };
+  var subvec__3 = function(v, start, end) {
+    return cljs.core.build_subvec.call(null, null, v, start, end, null)
+  };
+  subvec = function(v, start, end) {
+    switch(arguments.length) {
+      case 2:
+        return subvec__2.call(this, v, start);
+      case 3:
+        return subvec__3.call(this, v, start, end)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  subvec.cljs$core$IFn$_invoke$arity$2 = subvec__2;
+  subvec.cljs$core$IFn$_invoke$arity$3 = subvec__3;
+  return subvec
+}();
+cljs.core.tv_ensure_editable = function tv_ensure_editable(edit, node) {
+  if(edit === node.edit) {
+    return node
+  }else {
+    return new cljs.core.VectorNode(edit, node.arr.slice())
+  }
+};
+cljs.core.tv_editable_root = function tv_editable_root(node) {
+  return new cljs.core.VectorNode({}, node.arr.slice())
+};
+cljs.core.tv_editable_tail = function tv_editable_tail(tl) {
+  var ret = new Array(32);
+  cljs.core.array_copy.call(null, tl, 0, ret, 0, tl.length);
+  return ret
+};
+cljs.core.tv_push_tail = function tv_push_tail(tv, level, parent, tail_node) {
+  var ret = cljs.core.tv_ensure_editable.call(null, tv.root.edit, parent);
+  var subidx = tv.cnt - 1 >>> level & 31;
+  cljs.core.pv_aset.call(null, ret, subidx, level === 5 ? tail_node : function() {
+    var child = cljs.core.pv_aget.call(null, ret, subidx);
+    if(!(child == null)) {
+      return tv_push_tail.call(null, tv, level - 5, child, tail_node)
+    }else {
+      return cljs.core.new_path.call(null, tv.root.edit, level - 5, tail_node)
+    }
+  }());
+  return ret
+};
+cljs.core.tv_pop_tail = function tv_pop_tail(tv, level, node) {
+  var node__$1 = cljs.core.tv_ensure_editable.call(null, tv.root.edit, node);
+  var subidx = tv.cnt - 2 >>> level & 31;
+  if(level > 5) {
+    var new_child = tv_pop_tail.call(null, tv, level - 5, cljs.core.pv_aget.call(null, node__$1, subidx));
+    if(function() {
+      var and__3941__auto__ = new_child == null;
+      if(and__3941__auto__) {
+        return subidx === 0
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return null
+    }else {
+      cljs.core.pv_aset.call(null, node__$1, subidx, new_child);
+      return node__$1
+    }
+  }else {
+    if(subidx === 0) {
+      return null
+    }else {
+      if("\ufdd0:else") {
+        cljs.core.pv_aset.call(null, node__$1, subidx, null);
+        return node__$1
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.editable_array_for = function editable_array_for(tv, i) {
+  if(function() {
+    var and__3941__auto__ = 0 <= i;
+    if(and__3941__auto__) {
+      return i < tv.cnt
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    if(i >= cljs.core.tail_off.call(null, tv)) {
+      return tv.tail
+    }else {
+      var root = tv.root;
+      var node = root;
+      var level = tv.shift;
+      while(true) {
+        if(level > 0) {
+          var G__3894 = cljs.core.tv_ensure_editable.call(null, root.edit, cljs.core.pv_aget.call(null, node, i >>> level & 31));
+          var G__3895 = level - 5;
+          node = G__3894;
+          level = G__3895;
+          continue
+        }else {
+          return node.arr
+        }
+        break
+      }
+    }
+  }else {
+    throw new Error([cljs.core.str("No item "), cljs.core.str(i), cljs.core.str(" in transient vector of length "), cljs.core.str(tv.cnt)].join(""));
+  }
+};
+goog.provide("cljs.core.TransientVector");
+cljs.core.TransientVector = function(cnt, shift, root, tail) {
+  this.cnt = cnt;
+  this.shift = shift;
+  this.root = root;
+  this.tail = tail;
+  this.cljs$lang$protocol_mask$partition0$ = 275;
+  this.cljs$lang$protocol_mask$partition1$ = 88
+};
+cljs.core.TransientVector.cljs$lang$type = true;
+cljs.core.TransientVector.cljs$lang$ctorStr = "cljs.core/TransientVector";
+cljs.core.TransientVector.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/TransientVector")
+};
+cljs.core.TransientVector.prototype.call = function() {
+  var G__3897 = null;
+  var G__3897__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3897__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3897 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3897__2.call(this, self__, k);
+      case 3:
+        return G__3897__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3897
+}();
+cljs.core.TransientVector.prototype.apply = function(self__, args3896) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3896.slice()))
+};
+cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(coll, k, null)
+};
+cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(coll, k, not_found)
+};
+cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  if(self__.root.edit) {
+    return cljs.core.array_for.call(null, coll, n)[n & 31]
+  }else {
+    throw new Error("nth after persistent!");
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = 0 <= n;
+    if(and__3941__auto__) {
+      return n < self__.cnt
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return coll.cljs$core$IIndexed$_nth$arity$2(coll, n)
+  }else {
+    return not_found
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.root.edit) {
+    return self__.cnt
+  }else {
+    throw new Error("count after persistent!");
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3 = function(tcoll, n, val) {
+  var self__ = this;
+  if(self__.root.edit) {
+    if(function() {
+      var and__3941__auto__ = 0 <= n;
+      if(and__3941__auto__) {
+        return n < self__.cnt
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      if(cljs.core.tail_off.call(null, tcoll) <= n) {
+        self__.tail[n & 31] = val;
+        return tcoll
+      }else {
+        var new_root = function go(level, node) {
+          var node__$1 = cljs.core.tv_ensure_editable.call(null, self__.root.edit, node);
+          if(level === 0) {
+            cljs.core.pv_aset.call(null, node__$1, n & 31, val);
+            return node__$1
+          }else {
+            var subidx = n >>> level & 31;
+            cljs.core.pv_aset.call(null, node__$1, subidx, go.call(null, level - 5, cljs.core.pv_aget.call(null, node__$1, subidx)));
+            return node__$1
+          }
+        }.call(null, self__.shift, self__.root);
+        self__.root = new_root;
+        return tcoll
+      }
+    }else {
+      if(n === self__.cnt) {
+        return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll, val)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error([cljs.core.str("Index "), cljs.core.str(n), cljs.core.str(" out of bounds for TransientVector of length"), cljs.core.str(self__.cnt)].join(""));
+        }else {
+          return null
+        }
+      }
+    }
+  }else {
+    throw new Error("assoc! after persistent!");
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_pop_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  if(self__.root.edit) {
+    if(self__.cnt === 0) {
+      throw new Error("Can't pop empty vector");
+    }else {
+      if(1 === self__.cnt) {
+        self__.cnt = 0;
+        return tcoll
+      }else {
+        if((self__.cnt - 1 & 31) > 0) {
+          self__.cnt = self__.cnt - 1;
+          return tcoll
+        }else {
+          if("\ufdd0:else") {
+            var new_tail = cljs.core.editable_array_for.call(null, tcoll, self__.cnt - 2);
+            var new_root = function() {
+              var nr = cljs.core.tv_pop_tail.call(null, tcoll, self__.shift, self__.root);
+              if(!(nr == null)) {
+                return nr
+              }else {
+                return new cljs.core.VectorNode(self__.root.edit, new Array(32))
+              }
+            }();
+            if(function() {
+              var and__3941__auto__ = 5 < self__.shift;
+              if(and__3941__auto__) {
+                return cljs.core.pv_aget.call(null, new_root, 1) == null
+              }else {
+                return and__3941__auto__
+              }
+            }()) {
+              var new_root__$1 = cljs.core.tv_ensure_editable.call(null, self__.root.edit, cljs.core.pv_aget.call(null, new_root, 0));
+              self__.root = new_root__$1;
+              self__.shift = self__.shift - 5;
+              self__.cnt = self__.cnt - 1;
+              self__.tail = new_tail;
+              return tcoll
+            }else {
+              self__.root = new_root;
+              self__.cnt = self__.cnt - 1;
+              self__.tail = new_tail;
+              return tcoll
+            }
+          }else {
+            return null
+          }
+        }
+      }
+    }
+  }else {
+    throw new Error("pop! after persistent!");
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = function(tcoll, key, val) {
+  var self__ = this;
+  return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll, key, val)
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
+  var self__ = this;
+  if(self__.root.edit) {
+    if(self__.cnt - cljs.core.tail_off.call(null, tcoll) < 32) {
+      self__.tail[self__.cnt & 31] = o;
+      self__.cnt = self__.cnt + 1;
+      return tcoll
+    }else {
+      var tail_node = new cljs.core.VectorNode(self__.root.edit, self__.tail);
+      var new_tail = new Array(32);
+      new_tail[0] = o;
+      self__.tail = new_tail;
+      if(self__.cnt >>> 5 > 1 << self__.shift) {
+        var new_root_array = new Array(32);
+        var new_shift = self__.shift + 5;
+        new_root_array[0] = self__.root;
+        new_root_array[1] = cljs.core.new_path.call(null, self__.root.edit, self__.shift, tail_node);
+        self__.root = new cljs.core.VectorNode(self__.root.edit, new_root_array);
+        self__.shift = new_shift;
+        self__.cnt = self__.cnt + 1;
+        return tcoll
+      }else {
+        var new_root = cljs.core.tv_push_tail.call(null, tcoll, self__.shift, self__.root, tail_node);
+        self__.root = new_root;
+        self__.cnt = self__.cnt + 1;
+        return tcoll
+      }
+    }
+  }else {
+    throw new Error("conj! after persistent!");
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  if(self__.root.edit) {
+    self__.root.edit = null;
+    var len = self__.cnt - cljs.core.tail_off.call(null, tcoll);
+    var trimmed_tail = new Array(len);
+    cljs.core.array_copy.call(null, self__.tail, 0, trimmed_tail, 0, len);
+    return new cljs.core.PersistentVector(null, self__.cnt, self__.shift, self__.root, trimmed_tail, null)
+  }else {
+    throw new Error("persistent! called twice");
+  }
+};
+goog.provide("cljs.core.PersistentQueueSeq");
+cljs.core.PersistentQueueSeq = function(meta, front, rear, __hash) {
+  this.meta = meta;
+  this.front = front;
+  this.rear = rear;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31850572
+};
+cljs.core.PersistentQueueSeq.cljs$lang$type = true;
+cljs.core.PersistentQueueSeq.cljs$lang$ctorStr = "cljs.core/PersistentQueueSeq";
+cljs.core.PersistentQueueSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentQueueSeq")
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.PersistentQueueSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return coll
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.first.call(null, self__.front)
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var temp__4090__auto__ = cljs.core.next.call(null, self__.front);
+  if(temp__4090__auto__) {
+    var f1 = temp__4090__auto__;
+    return new cljs.core.PersistentQueueSeq(self__.meta, f1, self__.rear, null)
+  }else {
+    if(self__.rear == null) {
+      return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll)
+    }else {
+      return new cljs.core.PersistentQueueSeq(self__.meta, self__.rear, null, null)
+    }
+  }
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentQueueSeq(meta__$1, self__.front, self__.rear, self__.__hash)
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+goog.provide("cljs.core.PersistentQueue");
+cljs.core.PersistentQueue = function(meta, count, front, rear, __hash) {
+  this.meta = meta;
+  this.count = count;
+  this.front = front;
+  this.rear = rear;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31858766
+};
+cljs.core.PersistentQueue.cljs$lang$type = true;
+cljs.core.PersistentQueue.cljs$lang$ctorStr = "cljs.core/PersistentQueue";
+cljs.core.PersistentQueue.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentQueue")
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.front)) {
+    return new cljs.core.PersistentQueue(self__.meta, self__.count + 1, self__.front, cljs.core.conj.call(null, function() {
+      var or__3943__auto__ = self__.rear;
+      if(cljs.core.truth_(or__3943__auto__)) {
+        return or__3943__auto__
+      }else {
+        return cljs.core.PersistentVector.EMPTY
+      }
+    }(), o), null)
+  }else {
+    return new cljs.core.PersistentQueue(self__.meta, self__.count + 1, cljs.core.conj.call(null, self__.front, o), cljs.core.PersistentVector.EMPTY, null)
+  }
+};
+cljs.core.PersistentQueue.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var rear__$1 = cljs.core.seq.call(null, self__.rear);
+  if(cljs.core.truth_(function() {
+    var or__3943__auto__ = self__.front;
+    if(cljs.core.truth_(or__3943__auto__)) {
+      return or__3943__auto__
+    }else {
+      return rear__$1
+    }
+  }())) {
+    return new cljs.core.PersistentQueueSeq(null, self__.front, cljs.core.seq.call(null, rear__$1), null)
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.count
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.first.call(null, self__.front)
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.front)) {
+    var temp__4090__auto__ = cljs.core.next.call(null, self__.front);
+    if(temp__4090__auto__) {
+      var f1 = temp__4090__auto__;
+      return new cljs.core.PersistentQueue(self__.meta, self__.count - 1, f1, self__.rear, null)
+    }else {
+      return new cljs.core.PersistentQueue(self__.meta, self__.count - 1, cljs.core.seq.call(null, self__.rear), cljs.core.PersistentVector.EMPTY, null)
+    }
+  }else {
+    return coll
+  }
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.first.call(null, self__.front)
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.rest.call(null, cljs.core.seq.call(null, coll))
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentQueue(meta__$1, self__.count, self__.front, self__.rear, self__.__hash)
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.PersistentQueue.EMPTY
+};
+cljs.core.PersistentQueue.EMPTY = new cljs.core.PersistentQueue(null, 0, null, cljs.core.PersistentVector.EMPTY, 0);
+goog.provide("cljs.core.NeverEquiv");
+cljs.core.NeverEquiv = function() {
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 2097152
+};
+cljs.core.NeverEquiv.cljs$lang$type = true;
+cljs.core.NeverEquiv.cljs$lang$ctorStr = "cljs.core/NeverEquiv";
+cljs.core.NeverEquiv.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/NeverEquiv")
+};
+cljs.core.NeverEquiv.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
+  var self__ = this;
+  return false
+};
+cljs.core.never_equiv = new cljs.core.NeverEquiv;
+cljs.core.equiv_map = function equiv_map(x, y) {
+  return cljs.core.boolean$.call(null, cljs.core.map_QMARK_.call(null, y) ? cljs.core.count.call(null, x) === cljs.core.count.call(null, y) ? cljs.core.every_QMARK_.call(null, cljs.core.identity, cljs.core.map.call(null, function(xkv) {
+    return cljs.core._EQ_.call(null, cljs.core.get.call(null, y, cljs.core.first.call(null, xkv), cljs.core.never_equiv), cljs.core.second.call(null, xkv))
+  }, x)) : null : null)
+};
+cljs.core.scan_array = function scan_array(incr, k, array) {
+  var len = array.length;
+  var i = 0;
+  while(true) {
+    if(i < len) {
+      if(k === array[i]) {
+        return i
+      }else {
+        var G__3898 = i + incr;
+        i = G__3898;
+        continue
+      }
+    }else {
+      return null
+    }
+    break
+  }
+};
+cljs.core.obj_map_compare_keys = function obj_map_compare_keys(a, b) {
+  var a__$1 = cljs.core.hash.call(null, a);
+  var b__$1 = cljs.core.hash.call(null, b);
+  if(a__$1 < b__$1) {
+    return-1
+  }else {
+    if(a__$1 > b__$1) {
+      return 1
+    }else {
+      if("\ufdd0:else") {
+        return 0
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.obj_map__GT_hash_map = function obj_map__GT_hash_map(m, k, v) {
+  var ks = m.keys;
+  var len = ks.length;
+  var so = m.strobj;
+  var mm = cljs.core.meta.call(null, m);
+  var i = 0;
+  var out = cljs.core.transient$.call(null, cljs.core.PersistentHashMap.EMPTY);
+  while(true) {
+    if(i < len) {
+      var k__$1 = ks[i];
+      var G__3899 = i + 1;
+      var G__3900 = cljs.core.assoc_BANG_.call(null, out, k__$1, so[k__$1]);
+      i = G__3899;
+      out = G__3900;
+      continue
+    }else {
+      return cljs.core.with_meta.call(null, cljs.core.persistent_BANG_.call(null, cljs.core.assoc_BANG_.call(null, out, k, v)), mm)
+    }
+    break
+  }
+};
+cljs.core.obj_clone = function obj_clone(obj, ks) {
+  var new_obj = {};
+  var l = ks.length;
+  var i_3902 = 0;
+  while(true) {
+    if(i_3902 < l) {
+      var k_3903 = ks[i_3902];
+      new_obj[k_3903] = obj[k_3903];
+      var G__3904 = i_3902 + 1;
+      i_3902 = G__3904;
+      continue
+    }else {
+    }
+    break
+  }
+  return new_obj
+};
+goog.provide("cljs.core.ObjMap");
+cljs.core.ObjMap = function(meta, keys, strobj, update_count, __hash) {
+  this.meta = meta;
+  this.keys = keys;
+  this.strobj = strobj;
+  this.update_count = update_count;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 4;
+  this.cljs$lang$protocol_mask$partition0$ = 16123663
+};
+cljs.core.ObjMap.cljs$lang$type = true;
+cljs.core.ObjMap.cljs$lang$ctorStr = "cljs.core/ObjMap";
+cljs.core.ObjMap.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ObjMap")
+};
+cljs.core.ObjMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.transient$.call(null, cljs.core.into.call(null, cljs.core.hash_map.call(null), coll))
+};
+cljs.core.ObjMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_imap.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, null)
+};
+cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = goog.isString(k);
+    if(and__3941__auto__) {
+      return!(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return self__.strobj[k]
+  }else {
+    return not_found
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
+  var self__ = this;
+  if(goog.isString(k)) {
+    if(function() {
+      var or__3943__auto__ = self__.update_count > cljs.core.ObjMap.HASHMAP_THRESHOLD;
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        return self__.keys.length >= cljs.core.ObjMap.HASHMAP_THRESHOLD
+      }
+    }()) {
+      return cljs.core.obj_map__GT_hash_map.call(null, coll, k, v)
+    }else {
+      if(!(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
+        var new_strobj = cljs.core.obj_clone.call(null, self__.strobj, self__.keys);
+        new_strobj[k] = v;
+        return new cljs.core.ObjMap(self__.meta, self__.keys, new_strobj, self__.update_count + 1, null)
+      }else {
+        var new_strobj = cljs.core.obj_clone.call(null, self__.strobj, self__.keys);
+        var new_keys = self__.keys.slice();
+        new_strobj[k] = v;
+        new_keys.push(k);
+        return new cljs.core.ObjMap(self__.meta, new_keys, new_strobj, self__.update_count + 1, null)
+      }
+    }
+  }else {
+    return cljs.core.obj_map__GT_hash_map.call(null, coll, k, v)
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = function(coll, k) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = goog.isString(k);
+    if(and__3941__auto__) {
+      return!(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return true
+  }else {
+    return false
+  }
+};
+cljs.core.ObjMap.prototype.call = function() {
+  var G__3906 = null;
+  var G__3906__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3906__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3906 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3906__2.call(this, self__, k);
+      case 3:
+        return G__3906__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3906
+}();
+cljs.core.ObjMap.prototype.apply = function(self__, args3905) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3905.slice()))
+};
+cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var len = self__.keys.length;
+  var keys__$1 = self__.keys.sort(cljs.core.obj_map_compare_keys);
+  var init__$1 = init;
+  while(true) {
+    if(cljs.core.seq.call(null, keys__$1)) {
+      var k = cljs.core.first.call(null, keys__$1);
+      var init__$2 = f.call(null, init__$1, k, self__.strobj[k]);
+      if(cljs.core.reduced_QMARK_.call(null, init__$2)) {
+        return cljs.core.deref.call(null, init__$2)
+      }else {
+        var G__3907 = cljs.core.rest.call(null, keys__$1);
+        var G__3908 = init__$2;
+        keys__$1 = G__3907;
+        init__$1 = G__3908;
+        continue
+      }
+    }else {
+      return init__$1
+    }
+    break
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  if(cljs.core.vector_QMARK_.call(null, entry)) {
+    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, cljs.core._nth.call(null, entry, 0), cljs.core._nth.call(null, entry, 1))
+  }else {
+    return cljs.core.reduce.call(null, cljs.core._conj, coll, entry)
+  }
+};
+cljs.core.ObjMap.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.ObjMap.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.keys.length > 0) {
+    return cljs.core.map.call(null, function(p1__3901_SHARP_) {
+      return cljs.core.vector.call(null, p1__3901_SHARP_, self__.strobj[p1__3901_SHARP_])
+    }, self__.keys.sort(cljs.core.obj_map_compare_keys))
+  }else {
+    return null
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.keys.length
+};
+cljs.core.ObjMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_map.call(null, coll, other)
+};
+cljs.core.ObjMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.ObjMap(meta__$1, self__.keys, self__.strobj, self__.update_count, self__.__hash)
+};
+cljs.core.ObjMap.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.ObjMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.ObjMap.EMPTY, self__.meta)
+};
+cljs.core.ObjMap.prototype.cljs$core$IMap$_dissoc$arity$2 = function(coll, k) {
+  var self__ = this;
+  if(function() {
+    var and__3941__auto__ = goog.isString(k);
+    if(and__3941__auto__) {
+      return!(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    var new_keys = self__.keys.slice();
+    var new_strobj = cljs.core.obj_clone.call(null, self__.strobj, self__.keys);
+    new_keys.splice(cljs.core.scan_array.call(null, 1, k, new_keys), 1);
+    delete new_strobj[k];
+    return new cljs.core.ObjMap(self__.meta, new_keys, new_strobj, self__.update_count + 1, null)
+  }else {
+    return coll
+  }
+};
+cljs.core.ObjMap.EMPTY = new cljs.core.ObjMap(null, [], {}, 0, 0);
+cljs.core.ObjMap.HASHMAP_THRESHOLD = 8;
+cljs.core.ObjMap.fromObject = function(ks, obj) {
+  return new cljs.core.ObjMap(null, ks, obj, 0, null)
+};
+cljs.core.array_map_index_of_nil_QMARK_ = function array_map_index_of_nil_QMARK_(arr, m, k) {
+  var len = arr.length;
+  var i = 0;
+  while(true) {
+    if(len <= i) {
+      return-1
+    }else {
+      if(arr[i] == null) {
+        return i
+      }else {
+        if("\ufdd0:else") {
+          var G__3909 = i + 2;
+          i = G__3909;
+          continue
+        }else {
+          return null
+        }
+      }
+    }
+    break
+  }
+};
+cljs.core.array_map_index_of_symbol_QMARK_ = function array_map_index_of_symbol_QMARK_(arr, m, k) {
+  var len = arr.length;
+  var kstr = k.str;
+  var i = 0;
+  while(true) {
+    if(len <= i) {
+      return-1
+    }else {
+      if(function() {
+        var k_SINGLEQUOTE_ = arr[i];
+        var and__3941__auto__ = k_SINGLEQUOTE_ instanceof cljs.core.Symbol;
+        if(and__3941__auto__) {
+          return kstr === k_SINGLEQUOTE_.str
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        return i
+      }else {
+        if("\ufdd0:else") {
+          var G__3910 = i + 2;
+          i = G__3910;
+          continue
+        }else {
+          return null
+        }
+      }
+    }
+    break
+  }
+};
+cljs.core.array_map_index_of_identical_QMARK_ = function array_map_index_of_identical_QMARK_(arr, m, k) {
+  var len = arr.length;
+  var i = 0;
+  while(true) {
+    if(len <= i) {
+      return-1
+    }else {
+      if(k === arr[i]) {
+        return i
+      }else {
+        if("\ufdd0:else") {
+          var G__3911 = i + 2;
+          i = G__3911;
+          continue
+        }else {
+          return null
+        }
+      }
+    }
+    break
+  }
+};
+cljs.core.array_map_index_of_equiv_QMARK_ = function array_map_index_of_equiv_QMARK_(arr, m, k) {
+  var len = arr.length;
+  var i = 0;
+  while(true) {
+    if(len <= i) {
+      return-1
+    }else {
+      if(cljs.core._EQ_.call(null, k, arr[i])) {
+        return i
+      }else {
+        if("\ufdd0:else") {
+          var G__3912 = i + 2;
+          i = G__3912;
+          continue
+        }else {
+          return null
+        }
+      }
+    }
+    break
+  }
+};
+cljs.core.array_map_index_of = function array_map_index_of(m, k) {
+  var arr = m.arr;
+  if(function() {
+    var or__3943__auto__ = goog.isString(k);
+    if(or__3943__auto__) {
+      return or__3943__auto__
+    }else {
+      return typeof k === "number"
+    }
+  }()) {
+    return cljs.core.array_map_index_of_identical_QMARK_.call(null, arr, m, k)
+  }else {
+    if(k instanceof cljs.core.Symbol) {
+      return cljs.core.array_map_index_of_symbol_QMARK_.call(null, arr, m, k)
+    }else {
+      if(k == null) {
+        return cljs.core.array_map_index_of_nil_QMARK_.call(null, arr, m, k)
+      }else {
+        if("\ufdd0:else") {
+          return cljs.core.array_map_index_of_equiv_QMARK_.call(null, arr, m, k)
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.array_map_extend_kv = function array_map_extend_kv(m, k, v) {
+  var arr = m.arr;
+  var l = arr.length;
+  var narr = new Array(l + 2);
+  var i_3913 = 0;
+  while(true) {
+    if(i_3913 < l) {
+      narr[i_3913] = arr[i_3913];
+      var G__3914 = i_3913 + 1;
+      i_3913 = G__3914;
+      continue
+    }else {
+    }
+    break
+  }
+  narr[l] = k;
+  narr[l + 1] = v;
+  return narr
+};
+goog.provide("cljs.core.PersistentArrayMap");
+cljs.core.PersistentArrayMap = function(meta, cnt, arr, __hash) {
+  this.meta = meta;
+  this.cnt = cnt;
+  this.arr = arr;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 4;
+  this.cljs$lang$protocol_mask$partition0$ = 16123663
+};
+cljs.core.PersistentArrayMap.cljs$lang$type = true;
+cljs.core.PersistentArrayMap.cljs$lang$ctorStr = "cljs.core/PersistentArrayMap";
+cljs.core.PersistentArrayMap.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentArrayMap")
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  return new cljs.core.TransientArrayMap({}, self__.arr.length, self__.arr.slice())
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_imap.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, null)
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var idx = cljs.core.array_map_index_of.call(null, coll, k);
+  if(idx === -1) {
+    return not_found
+  }else {
+    return self__.arr[idx + 1]
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
+  var self__ = this;
+  var idx = cljs.core.array_map_index_of.call(null, coll, k);
+  if(idx === -1) {
+    if(self__.cnt < cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
+      var arr__$1 = cljs.core.array_map_extend_kv.call(null, coll, k, v);
+      return new cljs.core.PersistentArrayMap(self__.meta, self__.cnt + 1, arr__$1, null)
+    }else {
+      return cljs.core._with_meta.call(null, cljs.core._assoc.call(null, cljs.core.into.call(null, cljs.core.PersistentHashMap.EMPTY, coll), k, v), self__.meta)
+    }
+  }else {
+    if(v === self__.arr[idx + 1]) {
+      return coll
+    }else {
+      if("\ufdd0:else") {
+        var arr__$1 = function() {
+          var G__3916 = self__.arr.slice();
+          G__3916[idx + 1] = v;
+          return G__3916
+        }();
+        return new cljs.core.PersistentArrayMap(self__.meta, self__.cnt, arr__$1, null)
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = function(coll, k) {
+  var self__ = this;
+  return!(cljs.core.array_map_index_of.call(null, coll, k) === -1)
+};
+cljs.core.PersistentArrayMap.prototype.call = function() {
+  var G__3917 = null;
+  var G__3917__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3917__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3917 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3917__2.call(this, self__, k);
+      case 3:
+        return G__3917__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3917
+}();
+cljs.core.PersistentArrayMap.prototype.apply = function(self__, args3915) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3915.slice()))
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var len = self__.arr.length;
+  var i = 0;
+  var init__$1 = init;
+  while(true) {
+    if(i < len) {
+      var init__$2 = f.call(null, init__$1, self__.arr[i], self__.arr[i + 1]);
+      if(cljs.core.reduced_QMARK_.call(null, init__$2)) {
+        return cljs.core.deref.call(null, init__$2)
+      }else {
+        var G__3918 = i + 2;
+        var G__3919 = init__$2;
+        i = G__3918;
+        init__$1 = G__3919;
+        continue
+      }
+    }else {
+      return init__$1
+    }
+    break
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  if(cljs.core.vector_QMARK_.call(null, entry)) {
+    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, cljs.core._nth.call(null, entry, 0), cljs.core._nth.call(null, entry, 1))
+  }else {
+    return cljs.core.reduce.call(null, cljs.core._conj, coll, entry)
+  }
+};
+cljs.core.PersistentArrayMap.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    var len = self__.arr.length;
+    var array_map_seq = function(len) {
+      return function array_map_seq(i) {
+        return new cljs.core.LazySeq(null, false, function(len) {
+          return function() {
+            if(i < len) {
+              return cljs.core.cons.call(null, cljs.core.PersistentVector.fromArray([self__.arr[i], self__.arr[i + 1]], true), array_map_seq.call(null, i + 2))
+            }else {
+              return null
+            }
+          }
+        }(len), null)
+      }
+    }(len);
+    return array_map_seq.call(null, 0)
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.cnt
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_map.call(null, coll, other)
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentArrayMap(meta__$1, self__.cnt, self__.arr, self__.__hash)
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._with_meta.call(null, cljs.core.PersistentArrayMap.EMPTY, self__.meta)
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IMap$_dissoc$arity$2 = function(coll, k) {
+  var self__ = this;
+  var idx = cljs.core.array_map_index_of.call(null, coll, k);
+  if(idx >= 0) {
+    var len = self__.arr.length;
+    var new_len = len - 2;
+    if(new_len === 0) {
+      return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll)
+    }else {
+      var new_arr = new Array(new_len);
+      var s = 0;
+      var d = 0;
+      while(true) {
+        if(s >= len) {
+          return new cljs.core.PersistentArrayMap(self__.meta, self__.cnt - 1, new_arr, null)
+        }else {
+          if(cljs.core._EQ_.call(null, k, self__.arr[s])) {
+            var G__3920 = s + 2;
+            var G__3921 = d;
+            s = G__3920;
+            d = G__3921;
+            continue
+          }else {
+            if("\ufdd0:else") {
+              new_arr[d] = self__.arr[s];
+              new_arr[d + 1] = self__.arr[s + 1];
+              var G__3922 = s + 2;
+              var G__3923 = d + 2;
+              s = G__3922;
+              d = G__3923;
+              continue
+            }else {
+              return null
+            }
+          }
+        }
+        break
+      }
+    }
+  }else {
+    return coll
+  }
+};
+cljs.core.PersistentArrayMap.EMPTY = new cljs.core.PersistentArrayMap(null, 0, [], null);
+cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD = 8;
+cljs.core.PersistentArrayMap.fromArray = function(arr, no_clone) {
+  var arr__$1 = no_clone ? arr : arr.slice();
+  var cnt = arr__$1.length / 2;
+  return new cljs.core.PersistentArrayMap(null, cnt, arr__$1, null)
+};
+goog.provide("cljs.core.TransientArrayMap");
+cljs.core.TransientArrayMap = function(editable_QMARK_, len, arr) {
+  this.editable_QMARK_ = editable_QMARK_;
+  this.len = len;
+  this.arr = arr;
+  this.cljs$lang$protocol_mask$partition1$ = 56;
+  this.cljs$lang$protocol_mask$partition0$ = 258
+};
+cljs.core.TransientArrayMap.cljs$lang$type = true;
+cljs.core.TransientArrayMap.cljs$lang$ctorStr = "cljs.core/TransientArrayMap";
+cljs.core.TransientArrayMap.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/TransientArrayMap")
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = function(tcoll, key) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.editable_QMARK_)) {
+    var idx = cljs.core.array_map_index_of.call(null, tcoll, key);
+    if(idx >= 0) {
+      self__.arr[idx] = self__.arr[self__.len - 2];
+      self__.arr[idx + 1] = self__.arr[self__.len - 1];
+      var G__3924_3926 = self__.arr;
+      G__3924_3926.pop();
+      G__3924_3926.pop();
+      self__.len = self__.len - 2
+    }else {
+    }
+    return tcoll
+  }else {
+    throw new Error("dissoc! after persistent!");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = function(tcoll, key, val) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.editable_QMARK_)) {
+    var idx = cljs.core.array_map_index_of.call(null, tcoll, key);
+    if(idx === -1) {
+      if(self__.len + 2 <= 2 * cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
+        self__.len = self__.len + 2;
+        self__.arr.push(key);
+        self__.arr.push(val);
+        return tcoll
+      }else {
+        return cljs.core.assoc_BANG_.call(null, cljs.core.array__GT_transient_hash_map.call(null, self__.len, self__.arr), key, val)
+      }
+    }else {
+      if(val === self__.arr[idx + 1]) {
+        return tcoll
+      }else {
+        self__.arr[idx + 1] = val;
+        return tcoll
+      }
+    }
+  }else {
+    throw new Error("assoc! after persistent!");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.editable_QMARK_)) {
+    if(function() {
+      var G__3925 = o;
+      if(G__3925) {
+        if(function() {
+          var or__3943__auto__ = G__3925.cljs$lang$protocol_mask$partition0$ & 2048;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3925.cljs$core$IMapEntry$
+          }
+        }()) {
+          return true
+        }else {
+          if(!G__3925.cljs$lang$protocol_mask$partition0$) {
+            return cljs.core.type_satisfies_.call(null, cljs.core.IMapEntry, G__3925)
+          }else {
+            return false
+          }
+        }
+      }else {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IMapEntry, G__3925)
+      }
+    }()) {
+      return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll, cljs.core.key.call(null, o), cljs.core.val.call(null, o))
+    }else {
+      var es = cljs.core.seq.call(null, o);
+      var tcoll__$1 = tcoll;
+      while(true) {
+        var temp__4090__auto__ = cljs.core.first.call(null, es);
+        if(cljs.core.truth_(temp__4090__auto__)) {
+          var e = temp__4090__auto__;
+          var G__3927 = cljs.core.next.call(null, es);
+          var G__3928 = tcoll__$1.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll__$1, cljs.core.key.call(null, e), cljs.core.val.call(null, e));
+          es = G__3927;
+          tcoll__$1 = G__3928;
+          continue
+        }else {
+          return tcoll__$1
+        }
+        break
+      }
+    }
+  }else {
+    throw new Error("conj! after persistent!");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.editable_QMARK_)) {
+    self__.editable_QMARK_ = false;
+    return new cljs.core.PersistentArrayMap(null, cljs.core.quot.call(null, self__.len, 2), self__.arr, null)
+  }else {
+    throw new Error("persistent! called twice");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, k) {
+  var self__ = this;
+  return tcoll.cljs$core$ILookup$_lookup$arity$3(tcoll, k, null)
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, k, not_found) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.editable_QMARK_)) {
+    var idx = cljs.core.array_map_index_of.call(null, tcoll, k);
+    if(idx === -1) {
+      return not_found
+    }else {
+      return self__.arr[idx + 1]
+    }
+  }else {
+    throw new Error("lookup after persistent!");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ICounted$_count$arity$1 = function(tcoll) {
+  var self__ = this;
+  if(cljs.core.truth_(self__.editable_QMARK_)) {
+    return cljs.core.quot.call(null, self__.len, 2)
+  }else {
+    throw new Error("count after persistent!");
+  }
+};
+cljs.core.array__GT_transient_hash_map = function array__GT_transient_hash_map(len, arr) {
+  var out = cljs.core.transient$.call(null, cljs.core.ObjMap.EMPTY);
+  var i = 0;
+  while(true) {
+    if(i < len) {
+      var G__3929 = cljs.core.assoc_BANG_.call(null, out, arr[i], arr[i + 1]);
+      var G__3930 = i + 2;
+      out = G__3929;
+      i = G__3930;
+      continue
+    }else {
+      return out
+    }
+    break
+  }
+};
+goog.provide("cljs.core.Box");
+cljs.core.Box = function(val) {
+  this.val = val
+};
+cljs.core.Box.cljs$lang$type = true;
+cljs.core.Box.cljs$lang$ctorStr = "cljs.core/Box";
+cljs.core.Box.cljs$lang$ctorPrWriter = function(this__2885__auto__, writer__2886__auto__, opts__2887__auto__) {
+  return cljs.core._write.call(null, writer__2886__auto__, "cljs.core/Box")
+};
+cljs.core.key_test = function key_test(key, other) {
+  if(goog.isString(key)) {
+    return key === other
+  }else {
+    return cljs.core._EQ_.call(null, key, other)
+  }
+};
+cljs.core.mask = function mask(hash, shift) {
+  return hash >>> shift & 31
+};
+cljs.core.clone_and_set = function() {
+  var clone_and_set = null;
+  var clone_and_set__3 = function(arr, i, a) {
+    var G__3933 = arr.slice();
+    G__3933[i] = a;
+    return G__3933
+  };
+  var clone_and_set__5 = function(arr, i, a, j, b) {
+    var G__3934 = arr.slice();
+    G__3934[i] = a;
+    G__3934[j] = b;
+    return G__3934
+  };
+  clone_and_set = function(arr, i, a, j, b) {
+    switch(arguments.length) {
+      case 3:
+        return clone_and_set__3.call(this, arr, i, a);
+      case 5:
+        return clone_and_set__5.call(this, arr, i, a, j, b)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  clone_and_set.cljs$core$IFn$_invoke$arity$3 = clone_and_set__3;
+  clone_and_set.cljs$core$IFn$_invoke$arity$5 = clone_and_set__5;
+  return clone_and_set
+}();
+cljs.core.remove_pair = function remove_pair(arr, i) {
+  var new_arr = new Array(arr.length - 2);
+  cljs.core.array_copy.call(null, arr, 0, new_arr, 0, 2 * i);
+  cljs.core.array_copy.call(null, arr, 2 * (i + 1), new_arr, 2 * i, new_arr.length - 2 * i);
+  return new_arr
+};
+cljs.core.bitmap_indexed_node_index = function bitmap_indexed_node_index(bitmap, bit) {
+  return cljs.core.bit_count.call(null, bitmap & bit - 1)
+};
+cljs.core.bitpos = function bitpos(hash, shift) {
+  return 1 << (hash >>> shift & 31)
+};
+cljs.core.edit_and_set = function() {
+  var edit_and_set = null;
+  var edit_and_set__4 = function(inode, edit, i, a) {
+    var editable = inode.ensure_editable(edit);
+    editable.arr[i] = a;
+    return editable
+  };
+  var edit_and_set__6 = function(inode, edit, i, a, j, b) {
+    var editable = inode.ensure_editable(edit);
+    editable.arr[i] = a;
+    editable.arr[j] = b;
+    return editable
+  };
+  edit_and_set = function(inode, edit, i, a, j, b) {
+    switch(arguments.length) {
+      case 4:
+        return edit_and_set__4.call(this, inode, edit, i, a);
+      case 6:
+        return edit_and_set__6.call(this, inode, edit, i, a, j, b)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  edit_and_set.cljs$core$IFn$_invoke$arity$4 = edit_and_set__4;
+  edit_and_set.cljs$core$IFn$_invoke$arity$6 = edit_and_set__6;
+  return edit_and_set
+}();
+cljs.core.inode_kv_reduce = function inode_kv_reduce(arr, f, init) {
+  var len = arr.length;
+  var i = 0;
+  var init__$1 = init;
+  while(true) {
+    if(i < len) {
+      var init__$2 = function() {
+        var k = arr[i];
+        if(!(k == null)) {
+          return f.call(null, init__$1, k, arr[i + 1])
+        }else {
+          var node = arr[i + 1];
+          if(!(node == null)) {
+            return node.kv_reduce(f, init__$1)
+          }else {
+            return init__$1
+          }
+        }
+      }();
+      if(cljs.core.reduced_QMARK_.call(null, init__$2)) {
+        return cljs.core.deref.call(null, init__$2)
+      }else {
+        var G__3935 = i + 2;
+        var G__3936 = init__$2;
+        i = G__3935;
+        init__$1 = G__3936;
+        continue
+      }
+    }else {
+      return init__$1
+    }
+    break
+  }
+};
+goog.provide("cljs.core.BitmapIndexedNode");
+cljs.core.BitmapIndexedNode = function(edit, bitmap, arr) {
+  this.edit = edit;
+  this.bitmap = bitmap;
+  this.arr = arr
+};
+cljs.core.BitmapIndexedNode.cljs$lang$type = true;
+cljs.core.BitmapIndexedNode.cljs$lang$ctorStr = "cljs.core/BitmapIndexedNode";
+cljs.core.BitmapIndexedNode.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/BitmapIndexedNode")
+};
+cljs.core.BitmapIndexedNode.prototype.edit_and_remove_pair = function(e, bit, i) {
+  var self__ = this;
+  var inode = this;
+  if(self__.bitmap === bit) {
+    return null
+  }else {
+    var editable = inode.ensure_editable(e);
+    var earr = editable.arr;
+    var len = earr.length;
+    editable.bitmap = bit ^ editable.bitmap;
+    cljs.core.array_copy.call(null, earr, 2 * (i + 1), earr, 2 * i, len - 2 * (i + 1));
+    earr[len - 2] = null;
+    earr[len - 1] = null;
+    return editable
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.inode_assoc_BANG_ = function(edit__$1, shift, hash, key, val, added_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var bit = 1 << (hash >>> shift & 31);
+  var idx = cljs.core.bitmap_indexed_node_index.call(null, self__.bitmap, bit);
+  if((self__.bitmap & bit) === 0) {
+    var n = cljs.core.bit_count.call(null, self__.bitmap);
+    if(2 * n < self__.arr.length) {
+      var editable = inode.ensure_editable(edit__$1);
+      var earr = editable.arr;
+      added_leaf_QMARK_.val = true;
+      cljs.core.array_copy_downward.call(null, earr, 2 * idx, earr, 2 * (idx + 1), 2 * (n - idx));
+      earr[2 * idx] = key;
+      earr[2 * idx + 1] = val;
+      editable.bitmap = editable.bitmap | bit;
+      return editable
+    }else {
+      if(n >= 16) {
+        var nodes = new Array(32);
+        var jdx = hash >>> shift & 31;
+        nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1, shift + 5, hash, key, val, added_leaf_QMARK_);
+        var i_3937 = 0;
+        var j_3938 = 0;
+        while(true) {
+          if(i_3937 < 32) {
+            if((self__.bitmap >>> i_3937 & 1) === 0) {
+              var G__3939 = i_3937 + 1;
+              var G__3940 = j_3938;
+              i_3937 = G__3939;
+              j_3938 = G__3940;
+              continue
+            }else {
+              nodes[i_3937] = !(self__.arr[j_3938] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1, shift + 5, cljs.core.hash.call(null, self__.arr[j_3938]), self__.arr[j_3938], self__.arr[j_3938 + 1], added_leaf_QMARK_) : self__.arr[j_3938 + 1];
+              var G__3941 = i_3937 + 1;
+              var G__3942 = j_3938 + 2;
+              i_3937 = G__3941;
+              j_3938 = G__3942;
+              continue
+            }
+          }else {
+          }
+          break
+        }
+        return new cljs.core.ArrayNode(edit__$1, n + 1, nodes)
+      }else {
+        if("\ufdd0:else") {
+          var new_arr = new Array(2 * (n + 4));
+          cljs.core.array_copy.call(null, self__.arr, 0, new_arr, 0, 2 * idx);
+          new_arr[2 * idx] = key;
+          new_arr[2 * idx + 1] = val;
+          cljs.core.array_copy.call(null, self__.arr, 2 * idx, new_arr, 2 * (idx + 1), 2 * (n - idx));
+          added_leaf_QMARK_.val = true;
+          var editable = inode.ensure_editable(edit__$1);
+          editable.arr = new_arr;
+          editable.bitmap = editable.bitmap | bit;
+          return editable
+        }else {
+          return null
+        }
+      }
+    }
+  }else {
+    var key_or_nil = self__.arr[2 * idx];
+    var val_or_node = self__.arr[2 * idx + 1];
+    if(key_or_nil == null) {
+      var n = val_or_node.inode_assoc_BANG_(edit__$1, shift + 5, hash, key, val, added_leaf_QMARK_);
+      if(n === val_or_node) {
+        return inode
+      }else {
+        return cljs.core.edit_and_set.call(null, inode, edit__$1, 2 * idx + 1, n)
+      }
+    }else {
+      if(cljs.core.key_test.call(null, key, key_or_nil)) {
+        if(val === val_or_node) {
+          return inode
+        }else {
+          return cljs.core.edit_and_set.call(null, inode, edit__$1, 2 * idx + 1, val)
+        }
+      }else {
+        if("\ufdd0:else") {
+          added_leaf_QMARK_.val = true;
+          return cljs.core.edit_and_set.call(null, inode, edit__$1, 2 * idx, null, 2 * idx + 1, cljs.core.create_node.call(null, edit__$1, shift + 5, key_or_nil, val_or_node, hash, key, val))
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.inode_seq = function() {
+  var self__ = this;
+  var inode = this;
+  return cljs.core.create_inode_seq.call(null, self__.arr)
+};
+cljs.core.BitmapIndexedNode.prototype.inode_without_BANG_ = function(edit__$1, shift, hash, key, removed_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var bit = 1 << (hash >>> shift & 31);
+  if((self__.bitmap & bit) === 0) {
+    return inode
+  }else {
+    var idx = cljs.core.bitmap_indexed_node_index.call(null, self__.bitmap, bit);
+    var key_or_nil = self__.arr[2 * idx];
+    var val_or_node = self__.arr[2 * idx + 1];
+    if(key_or_nil == null) {
+      var n = val_or_node.inode_without_BANG_(edit__$1, shift + 5, hash, key, removed_leaf_QMARK_);
+      if(n === val_or_node) {
+        return inode
+      }else {
+        if(!(n == null)) {
+          return cljs.core.edit_and_set.call(null, inode, edit__$1, 2 * idx + 1, n)
+        }else {
+          if(self__.bitmap === bit) {
+            return null
+          }else {
+            if("\ufdd0:else") {
+              return inode.edit_and_remove_pair(edit__$1, bit, idx)
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }else {
+      if(cljs.core.key_test.call(null, key, key_or_nil)) {
+        removed_leaf_QMARK_[0] = true;
+        return inode.edit_and_remove_pair(edit__$1, bit, idx)
+      }else {
+        if("\ufdd0:else") {
+          return inode
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.ensure_editable = function(e) {
+  var self__ = this;
+  var inode = this;
+  if(e === self__.edit) {
+    return inode
+  }else {
+    var n = cljs.core.bit_count.call(null, self__.bitmap);
+    var new_arr = new Array(n < 0 ? 4 : 2 * (n + 1));
+    cljs.core.array_copy.call(null, self__.arr, 0, new_arr, 0, 2 * n);
+    return new cljs.core.BitmapIndexedNode(e, self__.bitmap, new_arr)
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.kv_reduce = function(f, init) {
+  var self__ = this;
+  var inode = this;
+  return cljs.core.inode_kv_reduce.call(null, self__.arr, f, init)
+};
+cljs.core.BitmapIndexedNode.prototype.inode_find = function(shift, hash, key, not_found) {
+  var self__ = this;
+  var inode = this;
+  var bit = 1 << (hash >>> shift & 31);
+  if((self__.bitmap & bit) === 0) {
+    return not_found
+  }else {
+    var idx = cljs.core.bitmap_indexed_node_index.call(null, self__.bitmap, bit);
+    var key_or_nil = self__.arr[2 * idx];
+    var val_or_node = self__.arr[2 * idx + 1];
+    if(key_or_nil == null) {
+      return val_or_node.inode_find(shift + 5, hash, key, not_found)
+    }else {
+      if(cljs.core.key_test.call(null, key, key_or_nil)) {
+        return cljs.core.PersistentVector.fromArray([key_or_nil, val_or_node], true)
+      }else {
+        if("\ufdd0:else") {
+          return not_found
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.inode_without = function(shift, hash, key) {
+  var self__ = this;
+  var inode = this;
+  var bit = 1 << (hash >>> shift & 31);
+  if((self__.bitmap & bit) === 0) {
+    return inode
+  }else {
+    var idx = cljs.core.bitmap_indexed_node_index.call(null, self__.bitmap, bit);
+    var key_or_nil = self__.arr[2 * idx];
+    var val_or_node = self__.arr[2 * idx + 1];
+    if(key_or_nil == null) {
+      var n = val_or_node.inode_without(shift + 5, hash, key);
+      if(n === val_or_node) {
+        return inode
+      }else {
+        if(!(n == null)) {
+          return new cljs.core.BitmapIndexedNode(null, self__.bitmap, cljs.core.clone_and_set.call(null, self__.arr, 2 * idx + 1, n))
+        }else {
+          if(self__.bitmap === bit) {
+            return null
+          }else {
+            if("\ufdd0:else") {
+              return new cljs.core.BitmapIndexedNode(null, self__.bitmap ^ bit, cljs.core.remove_pair.call(null, self__.arr, idx))
+            }else {
+              return null
+            }
+          }
+        }
+      }
+    }else {
+      if(cljs.core.key_test.call(null, key, key_or_nil)) {
+        return new cljs.core.BitmapIndexedNode(null, self__.bitmap ^ bit, cljs.core.remove_pair.call(null, self__.arr, idx))
+      }else {
+        if("\ufdd0:else") {
+          return inode
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.inode_assoc = function(shift, hash, key, val, added_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var bit = 1 << (hash >>> shift & 31);
+  var idx = cljs.core.bitmap_indexed_node_index.call(null, self__.bitmap, bit);
+  if((self__.bitmap & bit) === 0) {
+    var n = cljs.core.bit_count.call(null, self__.bitmap);
+    if(n >= 16) {
+      var nodes = new Array(32);
+      var jdx = hash >>> shift & 31;
+      nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, hash, key, val, added_leaf_QMARK_);
+      var i_3943 = 0;
+      var j_3944 = 0;
+      while(true) {
+        if(i_3943 < 32) {
+          if((self__.bitmap >>> i_3943 & 1) === 0) {
+            var G__3945 = i_3943 + 1;
+            var G__3946 = j_3944;
+            i_3943 = G__3945;
+            j_3944 = G__3946;
+            continue
+          }else {
+            nodes[i_3943] = !(self__.arr[j_3944] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, cljs.core.hash.call(null, self__.arr[j_3944]), self__.arr[j_3944], self__.arr[j_3944 + 1], added_leaf_QMARK_) : self__.arr[j_3944 + 1];
+            var G__3947 = i_3943 + 1;
+            var G__3948 = j_3944 + 2;
+            i_3943 = G__3947;
+            j_3944 = G__3948;
+            continue
+          }
+        }else {
+        }
+        break
+      }
+      return new cljs.core.ArrayNode(null, n + 1, nodes)
+    }else {
+      var new_arr = new Array(2 * (n + 1));
+      cljs.core.array_copy.call(null, self__.arr, 0, new_arr, 0, 2 * idx);
+      new_arr[2 * idx] = key;
+      new_arr[2 * idx + 1] = val;
+      cljs.core.array_copy.call(null, self__.arr, 2 * idx, new_arr, 2 * (idx + 1), 2 * (n - idx));
+      added_leaf_QMARK_.val = true;
+      return new cljs.core.BitmapIndexedNode(null, self__.bitmap | bit, new_arr)
+    }
+  }else {
+    var key_or_nil = self__.arr[2 * idx];
+    var val_or_node = self__.arr[2 * idx + 1];
+    if(key_or_nil == null) {
+      var n = val_or_node.inode_assoc(shift + 5, hash, key, val, added_leaf_QMARK_);
+      if(n === val_or_node) {
+        return inode
+      }else {
+        return new cljs.core.BitmapIndexedNode(null, self__.bitmap, cljs.core.clone_and_set.call(null, self__.arr, 2 * idx + 1, n))
+      }
+    }else {
+      if(cljs.core.key_test.call(null, key, key_or_nil)) {
+        if(val === val_or_node) {
+          return inode
+        }else {
+          return new cljs.core.BitmapIndexedNode(null, self__.bitmap, cljs.core.clone_and_set.call(null, self__.arr, 2 * idx + 1, val))
+        }
+      }else {
+        if("\ufdd0:else") {
+          added_leaf_QMARK_.val = true;
+          return new cljs.core.BitmapIndexedNode(null, self__.bitmap, cljs.core.clone_and_set.call(null, self__.arr, 2 * idx, null, 2 * idx + 1, cljs.core.create_node.call(null, shift + 5, key_or_nil, val_or_node, hash, key, val)))
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.BitmapIndexedNode.prototype.inode_lookup = function(shift, hash, key, not_found) {
+  var self__ = this;
+  var inode = this;
+  var bit = 1 << (hash >>> shift & 31);
+  if((self__.bitmap & bit) === 0) {
+    return not_found
+  }else {
+    var idx = cljs.core.bitmap_indexed_node_index.call(null, self__.bitmap, bit);
+    var key_or_nil = self__.arr[2 * idx];
+    var val_or_node = self__.arr[2 * idx + 1];
+    if(key_or_nil == null) {
+      return val_or_node.inode_lookup(shift + 5, hash, key, not_found)
+    }else {
+      if(cljs.core.key_test.call(null, key, key_or_nil)) {
+        return val_or_node
+      }else {
+        if("\ufdd0:else") {
+          return not_found
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.BitmapIndexedNode.EMPTY = new cljs.core.BitmapIndexedNode(null, 0, new Array(0));
+cljs.core.pack_array_node = function pack_array_node(array_node, edit, idx) {
+  var arr = array_node.arr;
+  var len = 2 * (array_node.cnt - 1);
+  var new_arr = new Array(len);
+  var i = 0;
+  var j = 1;
+  var bitmap = 0;
+  while(true) {
+    if(i < len) {
+      if(function() {
+        var and__3941__auto__ = !(i === idx);
+        if(and__3941__auto__) {
+          return!(arr[i] == null)
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        new_arr[j] = arr[i];
+        var G__3949 = i + 1;
+        var G__3950 = j + 2;
+        var G__3951 = bitmap | 1 << i;
+        i = G__3949;
+        j = G__3950;
+        bitmap = G__3951;
+        continue
+      }else {
+        var G__3952 = i + 1;
+        var G__3953 = j;
+        var G__3954 = bitmap;
+        i = G__3952;
+        j = G__3953;
+        bitmap = G__3954;
+        continue
+      }
+    }else {
+      return new cljs.core.BitmapIndexedNode(edit, bitmap, new_arr)
+    }
+    break
+  }
+};
+goog.provide("cljs.core.ArrayNode");
+cljs.core.ArrayNode = function(edit, cnt, arr) {
+  this.edit = edit;
+  this.cnt = cnt;
+  this.arr = arr
+};
+cljs.core.ArrayNode.cljs$lang$type = true;
+cljs.core.ArrayNode.cljs$lang$ctorStr = "cljs.core/ArrayNode";
+cljs.core.ArrayNode.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ArrayNode")
+};
+cljs.core.ArrayNode.prototype.inode_assoc_BANG_ = function(edit__$1, shift, hash, key, val, added_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var idx = hash >>> shift & 31;
+  var node = self__.arr[idx];
+  if(node == null) {
+    var editable = cljs.core.edit_and_set.call(null, inode, edit__$1, idx, cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1, shift + 5, hash, key, val, added_leaf_QMARK_));
+    editable.cnt = editable.cnt + 1;
+    return editable
+  }else {
+    var n = node.inode_assoc_BANG_(edit__$1, shift + 5, hash, key, val, added_leaf_QMARK_);
+    if(n === node) {
+      return inode
+    }else {
+      return cljs.core.edit_and_set.call(null, inode, edit__$1, idx, n)
+    }
+  }
+};
+cljs.core.ArrayNode.prototype.inode_seq = function() {
+  var self__ = this;
+  var inode = this;
+  return cljs.core.create_array_node_seq.call(null, self__.arr)
+};
+cljs.core.ArrayNode.prototype.inode_without_BANG_ = function(edit__$1, shift, hash, key, removed_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var idx = hash >>> shift & 31;
+  var node = self__.arr[idx];
+  if(node == null) {
+    return inode
+  }else {
+    var n = node.inode_without_BANG_(edit__$1, shift + 5, hash, key, removed_leaf_QMARK_);
+    if(n === node) {
+      return inode
+    }else {
+      if(n == null) {
+        if(self__.cnt <= 8) {
+          return cljs.core.pack_array_node.call(null, inode, edit__$1, idx)
+        }else {
+          var editable = cljs.core.edit_and_set.call(null, inode, edit__$1, idx, n);
+          editable.cnt = editable.cnt - 1;
+          return editable
+        }
+      }else {
+        if("\ufdd0:else") {
+          return cljs.core.edit_and_set.call(null, inode, edit__$1, idx, n)
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.ArrayNode.prototype.ensure_editable = function(e) {
+  var self__ = this;
+  var inode = this;
+  if(e === self__.edit) {
+    return inode
+  }else {
+    return new cljs.core.ArrayNode(e, self__.cnt, self__.arr.slice())
+  }
+};
+cljs.core.ArrayNode.prototype.kv_reduce = function(f, init) {
+  var self__ = this;
+  var inode = this;
+  var len = self__.arr.length;
+  var i = 0;
+  var init__$1 = init;
+  while(true) {
+    if(i < len) {
+      var node = self__.arr[i];
+      if(!(node == null)) {
+        var init__$2 = node.kv_reduce(f, init__$1);
+        if(cljs.core.reduced_QMARK_.call(null, init__$2)) {
+          return cljs.core.deref.call(null, init__$2)
+        }else {
+          var G__3955 = i + 1;
+          var G__3956 = init__$2;
+          i = G__3955;
+          init__$1 = G__3956;
+          continue
+        }
+      }else {
+        var G__3957 = i + 1;
+        var G__3958 = init__$1;
+        i = G__3957;
+        init__$1 = G__3958;
+        continue
+      }
+    }else {
+      return init__$1
+    }
+    break
+  }
+};
+cljs.core.ArrayNode.prototype.inode_find = function(shift, hash, key, not_found) {
+  var self__ = this;
+  var inode = this;
+  var idx = hash >>> shift & 31;
+  var node = self__.arr[idx];
+  if(!(node == null)) {
+    return node.inode_find(shift + 5, hash, key, not_found)
+  }else {
+    return not_found
+  }
+};
+cljs.core.ArrayNode.prototype.inode_without = function(shift, hash, key) {
+  var self__ = this;
+  var inode = this;
+  var idx = hash >>> shift & 31;
+  var node = self__.arr[idx];
+  if(!(node == null)) {
+    var n = node.inode_without(shift + 5, hash, key);
+    if(n === node) {
+      return inode
+    }else {
+      if(n == null) {
+        if(self__.cnt <= 8) {
+          return cljs.core.pack_array_node.call(null, inode, null, idx)
+        }else {
+          return new cljs.core.ArrayNode(null, self__.cnt - 1, cljs.core.clone_and_set.call(null, self__.arr, idx, n))
+        }
+      }else {
+        if("\ufdd0:else") {
+          return new cljs.core.ArrayNode(null, self__.cnt, cljs.core.clone_and_set.call(null, self__.arr, idx, n))
+        }else {
+          return null
+        }
+      }
+    }
+  }else {
+    return inode
+  }
+};
+cljs.core.ArrayNode.prototype.inode_assoc = function(shift, hash, key, val, added_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var idx = hash >>> shift & 31;
+  var node = self__.arr[idx];
+  if(node == null) {
+    return new cljs.core.ArrayNode(null, self__.cnt + 1, cljs.core.clone_and_set.call(null, self__.arr, idx, cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, hash, key, val, added_leaf_QMARK_)))
+  }else {
+    var n = node.inode_assoc(shift + 5, hash, key, val, added_leaf_QMARK_);
+    if(n === node) {
+      return inode
+    }else {
+      return new cljs.core.ArrayNode(null, self__.cnt, cljs.core.clone_and_set.call(null, self__.arr, idx, n))
+    }
+  }
+};
+cljs.core.ArrayNode.prototype.inode_lookup = function(shift, hash, key, not_found) {
+  var self__ = this;
+  var inode = this;
+  var idx = hash >>> shift & 31;
+  var node = self__.arr[idx];
+  if(!(node == null)) {
+    return node.inode_lookup(shift + 5, hash, key, not_found)
+  }else {
+    return not_found
+  }
+};
+cljs.core.hash_collision_node_find_index = function hash_collision_node_find_index(arr, cnt, key) {
+  var lim = 2 * cnt;
+  var i = 0;
+  while(true) {
+    if(i < lim) {
+      if(cljs.core.key_test.call(null, key, arr[i])) {
+        return i
+      }else {
+        var G__3959 = i + 2;
+        i = G__3959;
+        continue
+      }
+    }else {
+      return-1
+    }
+    break
+  }
+};
+goog.provide("cljs.core.HashCollisionNode");
+cljs.core.HashCollisionNode = function(edit, collision_hash, cnt, arr) {
+  this.edit = edit;
+  this.collision_hash = collision_hash;
+  this.cnt = cnt;
+  this.arr = arr
+};
+cljs.core.HashCollisionNode.cljs$lang$type = true;
+cljs.core.HashCollisionNode.cljs$lang$ctorStr = "cljs.core/HashCollisionNode";
+cljs.core.HashCollisionNode.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/HashCollisionNode")
+};
+cljs.core.HashCollisionNode.prototype.inode_assoc_BANG_ = function(edit__$1, shift, hash, key, val, added_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  if(hash === self__.collision_hash) {
+    var idx = cljs.core.hash_collision_node_find_index.call(null, self__.arr, self__.cnt, key);
+    if(idx === -1) {
+      if(self__.arr.length > 2 * self__.cnt) {
+        var editable = cljs.core.edit_and_set.call(null, inode, edit__$1, 2 * self__.cnt, key, 2 * self__.cnt + 1, val);
+        added_leaf_QMARK_.val = true;
+        editable.cnt = editable.cnt + 1;
+        return editable
+      }else {
+        var len = self__.arr.length;
+        var new_arr = new Array(len + 2);
+        cljs.core.array_copy.call(null, self__.arr, 0, new_arr, 0, len);
+        new_arr[len] = key;
+        new_arr[len + 1] = val;
+        added_leaf_QMARK_.val = true;
+        return inode.ensure_editable_array(edit__$1, self__.cnt + 1, new_arr)
+      }
+    }else {
+      if(self__.arr[idx + 1] === val) {
+        return inode
+      }else {
+        return cljs.core.edit_and_set.call(null, inode, edit__$1, idx + 1, val)
+      }
+    }
+  }else {
+    return(new cljs.core.BitmapIndexedNode(edit__$1, 1 << (self__.collision_hash >>> shift & 31), [null, inode, null, null])).inode_assoc_BANG_(edit__$1, shift, hash, key, val, added_leaf_QMARK_)
+  }
+};
+cljs.core.HashCollisionNode.prototype.inode_seq = function() {
+  var self__ = this;
+  var inode = this;
+  return cljs.core.create_inode_seq.call(null, self__.arr)
+};
+cljs.core.HashCollisionNode.prototype.inode_without_BANG_ = function(edit__$1, shift, hash, key, removed_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  var idx = cljs.core.hash_collision_node_find_index.call(null, self__.arr, self__.cnt, key);
+  if(idx === -1) {
+    return inode
+  }else {
+    removed_leaf_QMARK_[0] = true;
+    if(self__.cnt === 1) {
+      return null
+    }else {
+      var editable = inode.ensure_editable(edit__$1);
+      var earr = editable.arr;
+      earr[idx] = earr[2 * self__.cnt - 2];
+      earr[idx + 1] = earr[2 * self__.cnt - 1];
+      earr[2 * self__.cnt - 1] = null;
+      earr[2 * self__.cnt - 2] = null;
+      editable.cnt = editable.cnt - 1;
+      return editable
+    }
+  }
+};
+cljs.core.HashCollisionNode.prototype.ensure_editable = function(e) {
+  var self__ = this;
+  var inode = this;
+  if(e === self__.edit) {
+    return inode
+  }else {
+    var new_arr = new Array(2 * (self__.cnt + 1));
+    cljs.core.array_copy.call(null, self__.arr, 0, new_arr, 0, 2 * self__.cnt);
+    return new cljs.core.HashCollisionNode(e, self__.collision_hash, self__.cnt, new_arr)
+  }
+};
+cljs.core.HashCollisionNode.prototype.kv_reduce = function(f, init) {
+  var self__ = this;
+  var inode = this;
+  return cljs.core.inode_kv_reduce.call(null, self__.arr, f, init)
+};
+cljs.core.HashCollisionNode.prototype.inode_find = function(shift, hash, key, not_found) {
+  var self__ = this;
+  var inode = this;
+  var idx = cljs.core.hash_collision_node_find_index.call(null, self__.arr, self__.cnt, key);
+  if(idx < 0) {
+    return not_found
+  }else {
+    if(cljs.core.key_test.call(null, key, self__.arr[idx])) {
+      return cljs.core.PersistentVector.fromArray([self__.arr[idx], self__.arr[idx + 1]], true)
+    }else {
+      if("\ufdd0:else") {
+        return not_found
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.HashCollisionNode.prototype.inode_without = function(shift, hash, key) {
+  var self__ = this;
+  var inode = this;
+  var idx = cljs.core.hash_collision_node_find_index.call(null, self__.arr, self__.cnt, key);
+  if(idx === -1) {
+    return inode
+  }else {
+    if(self__.cnt === 1) {
+      return null
+    }else {
+      if("\ufdd0:else") {
+        return new cljs.core.HashCollisionNode(null, self__.collision_hash, self__.cnt - 1, cljs.core.remove_pair.call(null, self__.arr, cljs.core.quot.call(null, idx, 2)))
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.HashCollisionNode.prototype.inode_assoc = function(shift, hash, key, val, added_leaf_QMARK_) {
+  var self__ = this;
+  var inode = this;
+  if(hash === self__.collision_hash) {
+    var idx = cljs.core.hash_collision_node_find_index.call(null, self__.arr, self__.cnt, key);
+    if(idx === -1) {
+      var len = self__.arr.length;
+      var new_arr = new Array(len + 2);
+      cljs.core.array_copy.call(null, self__.arr, 0, new_arr, 0, len);
+      new_arr[len] = key;
+      new_arr[len + 1] = val;
+      added_leaf_QMARK_.val = true;
+      return new cljs.core.HashCollisionNode(null, self__.collision_hash, self__.cnt + 1, new_arr)
+    }else {
+      if(cljs.core._EQ_.call(null, self__.arr[idx], val)) {
+        return inode
+      }else {
+        return new cljs.core.HashCollisionNode(null, self__.collision_hash, self__.cnt, cljs.core.clone_and_set.call(null, self__.arr, idx + 1, val))
+      }
+    }
+  }else {
+    return(new cljs.core.BitmapIndexedNode(null, 1 << (self__.collision_hash >>> shift & 31), [null, inode])).inode_assoc(shift, hash, key, val, added_leaf_QMARK_)
+  }
+};
+cljs.core.HashCollisionNode.prototype.inode_lookup = function(shift, hash, key, not_found) {
+  var self__ = this;
+  var inode = this;
+  var idx = cljs.core.hash_collision_node_find_index.call(null, self__.arr, self__.cnt, key);
+  if(idx < 0) {
+    return not_found
+  }else {
+    if(cljs.core.key_test.call(null, key, self__.arr[idx])) {
+      return self__.arr[idx + 1]
+    }else {
+      if("\ufdd0:else") {
+        return not_found
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.HashCollisionNode.prototype.ensure_editable_array = function(e, count, array) {
+  var self__ = this;
+  var inode = this;
+  if(e === self__.edit) {
+    self__.arr = array;
+    self__.cnt = count;
+    return inode
+  }else {
+    return new cljs.core.HashCollisionNode(self__.edit, self__.collision_hash, count, array)
+  }
+};
+cljs.core.create_node = function() {
+  var create_node = null;
+  var create_node__6 = function(shift, key1, val1, key2hash, key2, val2) {
+    var key1hash = cljs.core.hash.call(null, key1);
+    if(key1hash === key2hash) {
+      return new cljs.core.HashCollisionNode(null, key1hash, 2, [key1, val1, key2, val2])
+    }else {
+      var added_leaf_QMARK_ = new cljs.core.Box(false);
+      return cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift, key1hash, key1, val1, added_leaf_QMARK_).inode_assoc(shift, key2hash, key2, val2, added_leaf_QMARK_)
+    }
+  };
+  var create_node__7 = function(edit, shift, key1, val1, key2hash, key2, val2) {
+    var key1hash = cljs.core.hash.call(null, key1);
+    if(key1hash === key2hash) {
+      return new cljs.core.HashCollisionNode(null, key1hash, 2, [key1, val1, key2, val2])
+    }else {
+      var added_leaf_QMARK_ = new cljs.core.Box(false);
+      return cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit, shift, key1hash, key1, val1, added_leaf_QMARK_).inode_assoc_BANG_(edit, shift, key2hash, key2, val2, added_leaf_QMARK_)
+    }
+  };
+  create_node = function(edit, shift, key1, val1, key2hash, key2, val2) {
+    switch(arguments.length) {
+      case 6:
+        return create_node__6.call(this, edit, shift, key1, val1, key2hash, key2);
+      case 7:
+        return create_node__7.call(this, edit, shift, key1, val1, key2hash, key2, val2)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  create_node.cljs$core$IFn$_invoke$arity$6 = create_node__6;
+  create_node.cljs$core$IFn$_invoke$arity$7 = create_node__7;
+  return create_node
+}();
+goog.provide("cljs.core.NodeSeq");
+cljs.core.NodeSeq = function(meta, nodes, i, s, __hash) {
+  this.meta = meta;
+  this.nodes = nodes;
+  this.i = i;
+  this.s = s;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31850572
+};
+cljs.core.NodeSeq.cljs$lang$type = true;
+cljs.core.NodeSeq.cljs$lang$ctorStr = "cljs.core/NodeSeq";
+cljs.core.NodeSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/NodeSeq")
+};
+cljs.core.NodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.NodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.NodeSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.NodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  return this$
+};
+cljs.core.NodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.s == null) {
+    return cljs.core.PersistentVector.fromArray([self__.nodes[self__.i], self__.nodes[self__.i + 1]], true)
+  }else {
+    return cljs.core.first.call(null, self__.s)
+  }
+};
+cljs.core.NodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.s == null) {
+    return cljs.core.create_inode_seq.call(null, self__.nodes, self__.i + 2, null)
+  }else {
+    return cljs.core.create_inode_seq.call(null, self__.nodes, self__.i, cljs.core.next.call(null, self__.s))
+  }
+};
+cljs.core.NodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.NodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.NodeSeq(meta__$1, self__.nodes, self__.i, self__.s, self__.__hash)
+};
+cljs.core.NodeSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.NodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.create_inode_seq = function() {
+  var create_inode_seq = null;
+  var create_inode_seq__1 = function(nodes) {
+    return create_inode_seq.call(null, nodes, 0, null)
+  };
+  var create_inode_seq__3 = function(nodes, i, s) {
+    if(s == null) {
+      var len = nodes.length;
+      var j = i;
+      while(true) {
+        if(j < len) {
+          if(!(nodes[j] == null)) {
+            return new cljs.core.NodeSeq(null, nodes, j, null, null)
+          }else {
+            var temp__4090__auto__ = nodes[j + 1];
+            if(cljs.core.truth_(temp__4090__auto__)) {
+              var node = temp__4090__auto__;
+              var temp__4090__auto____$1 = node.inode_seq();
+              if(cljs.core.truth_(temp__4090__auto____$1)) {
+                var node_seq = temp__4090__auto____$1;
+                return new cljs.core.NodeSeq(null, nodes, j + 2, node_seq, null)
+              }else {
+                var G__3960 = j + 2;
+                j = G__3960;
+                continue
+              }
+            }else {
+              var G__3961 = j + 2;
+              j = G__3961;
+              continue
+            }
+          }
+        }else {
+          return null
+        }
+        break
+      }
+    }else {
+      return new cljs.core.NodeSeq(null, nodes, i, s, null)
+    }
+  };
+  create_inode_seq = function(nodes, i, s) {
+    switch(arguments.length) {
+      case 1:
+        return create_inode_seq__1.call(this, nodes);
+      case 3:
+        return create_inode_seq__3.call(this, nodes, i, s)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  create_inode_seq.cljs$core$IFn$_invoke$arity$1 = create_inode_seq__1;
+  create_inode_seq.cljs$core$IFn$_invoke$arity$3 = create_inode_seq__3;
+  return create_inode_seq
+}();
+goog.provide("cljs.core.ArrayNodeSeq");
+cljs.core.ArrayNodeSeq = function(meta, nodes, i, s, __hash) {
+  this.meta = meta;
+  this.nodes = nodes;
+  this.i = i;
+  this.s = s;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31850572
+};
+cljs.core.ArrayNodeSeq.cljs$lang$type = true;
+cljs.core.ArrayNodeSeq.cljs$lang$ctorStr = "cljs.core/ArrayNodeSeq";
+cljs.core.ArrayNodeSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/ArrayNodeSeq")
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.ArrayNodeSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  return this$
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.first.call(null, self__.s)
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.create_array_node_seq.call(null, null, self__.nodes, self__.i, cljs.core.next.call(null, self__.s))
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.ArrayNodeSeq(meta__$1, self__.nodes, self__.i, self__.s, self__.__hash)
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.create_array_node_seq = function() {
+  var create_array_node_seq = null;
+  var create_array_node_seq__1 = function(nodes) {
+    return create_array_node_seq.call(null, null, nodes, 0, null)
+  };
+  var create_array_node_seq__4 = function(meta, nodes, i, s) {
+    if(s == null) {
+      var len = nodes.length;
+      var j = i;
+      while(true) {
+        if(j < len) {
+          var temp__4090__auto__ = nodes[j];
+          if(cljs.core.truth_(temp__4090__auto__)) {
+            var nj = temp__4090__auto__;
+            var temp__4090__auto____$1 = nj.inode_seq();
+            if(cljs.core.truth_(temp__4090__auto____$1)) {
+              var ns = temp__4090__auto____$1;
+              return new cljs.core.ArrayNodeSeq(meta, nodes, j + 1, ns, null)
+            }else {
+              var G__3962 = j + 1;
+              j = G__3962;
+              continue
+            }
+          }else {
+            var G__3963 = j + 1;
+            j = G__3963;
+            continue
+          }
+        }else {
+          return null
+        }
+        break
+      }
+    }else {
+      return new cljs.core.ArrayNodeSeq(meta, nodes, i, s, null)
+    }
+  };
+  create_array_node_seq = function(meta, nodes, i, s) {
+    switch(arguments.length) {
+      case 1:
+        return create_array_node_seq__1.call(this, meta);
+      case 4:
+        return create_array_node_seq__4.call(this, meta, nodes, i, s)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  create_array_node_seq.cljs$core$IFn$_invoke$arity$1 = create_array_node_seq__1;
+  create_array_node_seq.cljs$core$IFn$_invoke$arity$4 = create_array_node_seq__4;
+  return create_array_node_seq
+}();
+goog.provide("cljs.core.PersistentHashMap");
+cljs.core.PersistentHashMap = function(meta, cnt, root, has_nil_QMARK_, nil_val, __hash) {
+  this.meta = meta;
+  this.cnt = cnt;
+  this.root = root;
+  this.has_nil_QMARK_ = has_nil_QMARK_;
+  this.nil_val = nil_val;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 4;
+  this.cljs$lang$protocol_mask$partition0$ = 16123663
+};
+cljs.core.PersistentHashMap.cljs$lang$type = true;
+cljs.core.PersistentHashMap.cljs$lang$ctorStr = "cljs.core/PersistentHashMap";
+cljs.core.PersistentHashMap.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentHashMap")
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  return new cljs.core.TransientHashMap({}, self__.root, self__.cnt, self__.has_nil_QMARK_, self__.nil_val)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_imap.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, null)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  if(k == null) {
+    if(self__.has_nil_QMARK_) {
+      return self__.nil_val
+    }else {
+      return not_found
+    }
+  }else {
+    if(self__.root == null) {
+      return not_found
+    }else {
+      if("\ufdd0:else") {
+        return self__.root.inode_lookup(0, cljs.core.hash.call(null, k), k, not_found)
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
+  var self__ = this;
+  if(k == null) {
+    if(function() {
+      var and__3941__auto__ = self__.has_nil_QMARK_;
+      if(and__3941__auto__) {
+        return v === self__.nil_val
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return coll
+    }else {
+      return new cljs.core.PersistentHashMap(self__.meta, self__.has_nil_QMARK_ ? self__.cnt : self__.cnt + 1, self__.root, true, v, null)
+    }
+  }else {
+    var added_leaf_QMARK_ = new cljs.core.Box(false);
+    var new_root = (self__.root == null ? cljs.core.BitmapIndexedNode.EMPTY : self__.root).inode_assoc(0, cljs.core.hash.call(null, k), k, v, added_leaf_QMARK_);
+    if(new_root === self__.root) {
+      return coll
+    }else {
+      return new cljs.core.PersistentHashMap(self__.meta, added_leaf_QMARK_.val ? self__.cnt + 1 : self__.cnt, new_root, self__.has_nil_QMARK_, self__.nil_val, null)
+    }
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = function(coll, k) {
+  var self__ = this;
+  if(k == null) {
+    return self__.has_nil_QMARK_
+  }else {
+    if(self__.root == null) {
+      return false
+    }else {
+      if("\ufdd0:else") {
+        return!(self__.root.inode_lookup(0, cljs.core.hash.call(null, k), k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel)
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentHashMap.prototype.call = function() {
+  var G__3965 = null;
+  var G__3965__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3965__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3965 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3965__2.call(this, self__, k);
+      case 3:
+        return G__3965__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3965
+}();
+cljs.core.PersistentHashMap.prototype.apply = function(self__, args3964) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3964.slice()))
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var init__$1 = self__.has_nil_QMARK_ ? f.call(null, init, null, self__.nil_val) : init;
+  if(cljs.core.reduced_QMARK_.call(null, init__$1)) {
+    return cljs.core.deref.call(null, init__$1)
+  }else {
+    if(!(self__.root == null)) {
+      return self__.root.kv_reduce(f, init__$1)
+    }else {
+      if("\ufdd0:else") {
+        return init__$1
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  if(cljs.core.vector_QMARK_.call(null, entry)) {
+    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, cljs.core._nth.call(null, entry, 0), cljs.core._nth.call(null, entry, 1))
+  }else {
+    return cljs.core.reduce.call(null, cljs.core._conj, coll, entry)
+  }
+};
+cljs.core.PersistentHashMap.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    var s = !(self__.root == null) ? self__.root.inode_seq() : null;
+    if(self__.has_nil_QMARK_) {
+      return cljs.core.cons.call(null, cljs.core.PersistentVector.fromArray([null, self__.nil_val], true), s)
+    }else {
+      return s
+    }
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.cnt
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_map.call(null, coll, other)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentHashMap(meta__$1, self__.cnt, self__.root, self__.has_nil_QMARK_, self__.nil_val, self__.__hash)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._with_meta.call(null, cljs.core.PersistentHashMap.EMPTY, self__.meta)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IMap$_dissoc$arity$2 = function(coll, k) {
+  var self__ = this;
+  if(k == null) {
+    if(self__.has_nil_QMARK_) {
+      return new cljs.core.PersistentHashMap(self__.meta, self__.cnt - 1, self__.root, false, null, null)
+    }else {
+      return coll
+    }
+  }else {
+    if(self__.root == null) {
+      return coll
+    }else {
+      if("\ufdd0:else") {
+        var new_root = self__.root.inode_without(0, cljs.core.hash.call(null, k), k);
+        if(new_root === self__.root) {
+          return coll
+        }else {
+          return new cljs.core.PersistentHashMap(self__.meta, self__.cnt - 1, new_root, self__.has_nil_QMARK_, self__.nil_val, null)
+        }
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.PersistentHashMap.EMPTY = new cljs.core.PersistentHashMap(null, 0, null, false, null, 0);
+cljs.core.PersistentHashMap.fromArrays = function(ks, vs) {
+  var len = ks.length;
+  var i = 0;
+  var out = cljs.core.transient$.call(null, cljs.core.PersistentHashMap.EMPTY);
+  while(true) {
+    if(i < len) {
+      var G__3966 = i + 1;
+      var G__3967 = cljs.core.assoc_BANG_.call(null, out, ks[i], vs[i]);
+      i = G__3966;
+      out = G__3967;
+      continue
+    }else {
+      return cljs.core.persistent_BANG_.call(null, out)
+    }
+    break
+  }
+};
+goog.provide("cljs.core.TransientHashMap");
+cljs.core.TransientHashMap = function(edit, root, count, has_nil_QMARK_, nil_val) {
+  this.edit = edit;
+  this.root = root;
+  this.count = count;
+  this.has_nil_QMARK_ = has_nil_QMARK_;
+  this.nil_val = nil_val;
+  this.cljs$lang$protocol_mask$partition1$ = 56;
+  this.cljs$lang$protocol_mask$partition0$ = 258
+};
+cljs.core.TransientHashMap.cljs$lang$type = true;
+cljs.core.TransientHashMap.cljs$lang$ctorStr = "cljs.core/TransientHashMap";
+cljs.core.TransientHashMap.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/TransientHashMap")
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = function(tcoll, key) {
+  var self__ = this;
+  return tcoll.without_BANG_(key)
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = function(tcoll, key, val) {
+  var self__ = this;
+  return tcoll.assoc_BANG_(key, val)
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, val) {
+  var self__ = this;
+  return tcoll.conj_BANG_(val)
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  return tcoll.persistent_BANG_()
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, k) {
+  var self__ = this;
+  if(k == null) {
+    if(self__.has_nil_QMARK_) {
+      return self__.nil_val
+    }else {
+      return null
+    }
+  }else {
+    if(self__.root == null) {
+      return null
+    }else {
+      return self__.root.inode_lookup(0, cljs.core.hash.call(null, k), k)
+    }
+  }
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, k, not_found) {
+  var self__ = this;
+  if(k == null) {
+    if(self__.has_nil_QMARK_) {
+      return self__.nil_val
+    }else {
+      return not_found
+    }
+  }else {
+    if(self__.root == null) {
+      return not_found
+    }else {
+      return self__.root.inode_lookup(0, cljs.core.hash.call(null, k), k, not_found)
+    }
+  }
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.edit) {
+    return self__.count
+  }else {
+    throw new Error("count after persistent!");
+  }
+};
+cljs.core.TransientHashMap.prototype.conj_BANG_ = function(o) {
+  var self__ = this;
+  var tcoll = this;
+  if(self__.edit) {
+    if(function() {
+      var G__3968 = o;
+      if(G__3968) {
+        if(function() {
+          var or__3943__auto__ = G__3968.cljs$lang$protocol_mask$partition0$ & 2048;
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return G__3968.cljs$core$IMapEntry$
+          }
+        }()) {
+          return true
+        }else {
+          if(!G__3968.cljs$lang$protocol_mask$partition0$) {
+            return cljs.core.type_satisfies_.call(null, cljs.core.IMapEntry, G__3968)
+          }else {
+            return false
+          }
+        }
+      }else {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IMapEntry, G__3968)
+      }
+    }()) {
+      return tcoll.assoc_BANG_(cljs.core.key.call(null, o), cljs.core.val.call(null, o))
+    }else {
+      var es = cljs.core.seq.call(null, o);
+      var tcoll__$1 = tcoll;
+      while(true) {
+        var temp__4090__auto__ = cljs.core.first.call(null, es);
+        if(cljs.core.truth_(temp__4090__auto__)) {
+          var e = temp__4090__auto__;
+          var G__3969 = cljs.core.next.call(null, es);
+          var G__3970 = tcoll__$1.assoc_BANG_(cljs.core.key.call(null, e), cljs.core.val.call(null, e));
+          es = G__3969;
+          tcoll__$1 = G__3970;
+          continue
+        }else {
+          return tcoll__$1
+        }
+        break
+      }
+    }
+  }else {
+    throw new Error("conj! after persistent");
+  }
+};
+cljs.core.TransientHashMap.prototype.assoc_BANG_ = function(k, v) {
+  var self__ = this;
+  var tcoll = this;
+  if(self__.edit) {
+    if(k == null) {
+      if(self__.nil_val === v) {
+      }else {
+        self__.nil_val = v
+      }
+      if(self__.has_nil_QMARK_) {
+      }else {
+        self__.count = self__.count + 1;
+        self__.has_nil_QMARK_ = true
+      }
+      return tcoll
+    }else {
+      var added_leaf_QMARK_ = new cljs.core.Box(false);
+      var node = (self__.root == null ? cljs.core.BitmapIndexedNode.EMPTY : self__.root).inode_assoc_BANG_(self__.edit, 0, cljs.core.hash.call(null, k), k, v, added_leaf_QMARK_);
+      if(node === self__.root) {
+      }else {
+        self__.root = node
+      }
+      if(added_leaf_QMARK_.val) {
+        self__.count = self__.count + 1
+      }else {
+      }
+      return tcoll
+    }
+  }else {
+    throw new Error("assoc! after persistent!");
+  }
+};
+cljs.core.TransientHashMap.prototype.without_BANG_ = function(k) {
+  var self__ = this;
+  var tcoll = this;
+  if(self__.edit) {
+    if(k == null) {
+      if(self__.has_nil_QMARK_) {
+        self__.has_nil_QMARK_ = false;
+        self__.nil_val = null;
+        self__.count = self__.count - 1;
+        return tcoll
+      }else {
+        return tcoll
+      }
+    }else {
+      if(self__.root == null) {
+        return tcoll
+      }else {
+        var removed_leaf_QMARK_ = new cljs.core.Box(false);
+        var node = self__.root.inode_without_BANG_(self__.edit, 0, cljs.core.hash.call(null, k), k, removed_leaf_QMARK_);
+        if(node === self__.root) {
+        }else {
+          self__.root = node
+        }
+        if(cljs.core.truth_(removed_leaf_QMARK_[0])) {
+          self__.count = self__.count - 1
+        }else {
+        }
+        return tcoll
+      }
+    }
+  }else {
+    throw new Error("dissoc! after persistent!");
+  }
+};
+cljs.core.TransientHashMap.prototype.persistent_BANG_ = function() {
+  var self__ = this;
+  var tcoll = this;
+  if(self__.edit) {
+    self__.edit = null;
+    return new cljs.core.PersistentHashMap(null, self__.count, self__.root, self__.has_nil_QMARK_, self__.nil_val, null)
+  }else {
+    throw new Error("persistent! called twice");
+  }
+};
+cljs.core.tree_map_seq_push = function tree_map_seq_push(node, stack, ascending_QMARK_) {
+  var t = node;
+  var stack__$1 = stack;
+  while(true) {
+    if(!(t == null)) {
+      var G__3971 = ascending_QMARK_ ? t.left : t.right;
+      var G__3972 = cljs.core.conj.call(null, stack__$1, t);
+      t = G__3971;
+      stack__$1 = G__3972;
+      continue
+    }else {
+      return stack__$1
+    }
+    break
+  }
+};
+goog.provide("cljs.core.PersistentTreeMapSeq");
+cljs.core.PersistentTreeMapSeq = function(meta, stack, ascending_QMARK_, cnt, __hash) {
+  this.meta = meta;
+  this.stack = stack;
+  this.ascending_QMARK_ = ascending_QMARK_;
+  this.cnt = cnt;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 31850574
+};
+cljs.core.PersistentTreeMapSeq.cljs$lang$type = true;
+cljs.core.PersistentTreeMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentTreeMapSeq";
+cljs.core.PersistentTreeMapSeq.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentTreeMapSeq")
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, coll)
+};
+cljs.core.PersistentTreeMapSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  return this$
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt < 0) {
+    return cljs.core.count.call(null, cljs.core.next.call(null, coll)) + 1
+  }else {
+    return self__.cnt
+  }
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(this$) {
+  var self__ = this;
+  return cljs.core.peek.call(null, self__.stack)
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(this$) {
+  var self__ = this;
+  var t = cljs.core.first.call(null, self__.stack);
+  var next_stack = cljs.core.tree_map_seq_push.call(null, self__.ascending_QMARK_ ? t.right : t.left, cljs.core.next.call(null, self__.stack), self__.ascending_QMARK_);
+  if(!(next_stack == null)) {
+    return new cljs.core.PersistentTreeMapSeq(null, next_stack, self__.ascending_QMARK_, self__.cnt - 1, null)
+  }else {
+    return cljs.core.List.EMPTY
+  }
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentTreeMapSeq(meta__$1, self__.stack, self__.ascending_QMARK_, self__.cnt, self__.__hash)
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.create_tree_map_seq = function create_tree_map_seq(tree, ascending_QMARK_, cnt) {
+  return new cljs.core.PersistentTreeMapSeq(null, cljs.core.tree_map_seq_push.call(null, tree, null, ascending_QMARK_), ascending_QMARK_, cnt, null)
+};
+cljs.core.balance_left = function balance_left(key, val, ins, right) {
+  if(ins instanceof cljs.core.RedNode) {
+    if(ins.left instanceof cljs.core.RedNode) {
+      return new cljs.core.RedNode(ins.key, ins.val, ins.left.blacken(), new cljs.core.BlackNode(key, val, ins.right, right, null), null)
+    }else {
+      if(ins.right instanceof cljs.core.RedNode) {
+        return new cljs.core.RedNode(ins.right.key, ins.right.val, new cljs.core.BlackNode(ins.key, ins.val, ins.left, ins.right.left, null), new cljs.core.BlackNode(key, val, ins.right.right, right, null), null)
+      }else {
+        if("\ufdd0:else") {
+          return new cljs.core.BlackNode(key, val, ins, right, null)
+        }else {
+          return null
+        }
+      }
+    }
+  }else {
+    return new cljs.core.BlackNode(key, val, ins, right, null)
+  }
+};
+cljs.core.balance_right = function balance_right(key, val, left, ins) {
+  if(ins instanceof cljs.core.RedNode) {
+    if(ins.right instanceof cljs.core.RedNode) {
+      return new cljs.core.RedNode(ins.key, ins.val, new cljs.core.BlackNode(key, val, left, ins.left, null), ins.right.blacken(), null)
+    }else {
+      if(ins.left instanceof cljs.core.RedNode) {
+        return new cljs.core.RedNode(ins.left.key, ins.left.val, new cljs.core.BlackNode(key, val, left, ins.left.left, null), new cljs.core.BlackNode(ins.key, ins.val, ins.left.right, ins.right, null), null)
+      }else {
+        if("\ufdd0:else") {
+          return new cljs.core.BlackNode(key, val, left, ins, null)
+        }else {
+          return null
+        }
+      }
+    }
+  }else {
+    return new cljs.core.BlackNode(key, val, left, ins, null)
+  }
+};
+cljs.core.balance_left_del = function balance_left_del(key, val, del, right) {
+  if(del instanceof cljs.core.RedNode) {
+    return new cljs.core.RedNode(key, val, del.blacken(), right, null)
+  }else {
+    if(right instanceof cljs.core.BlackNode) {
+      return cljs.core.balance_right.call(null, key, val, del, right.redden())
+    }else {
+      if(function() {
+        var and__3941__auto__ = right instanceof cljs.core.RedNode;
+        if(and__3941__auto__) {
+          return right.left instanceof cljs.core.BlackNode
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        return new cljs.core.RedNode(right.left.key, right.left.val, new cljs.core.BlackNode(key, val, del, right.left.left, null), cljs.core.balance_right.call(null, right.key, right.val, right.left.right, right.right.redden()), null)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error("red-black tree invariant violation");
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.balance_right_del = function balance_right_del(key, val, left, del) {
+  if(del instanceof cljs.core.RedNode) {
+    return new cljs.core.RedNode(key, val, left, del.blacken(), null)
+  }else {
+    if(left instanceof cljs.core.BlackNode) {
+      return cljs.core.balance_left.call(null, key, val, left.redden(), del)
+    }else {
+      if(function() {
+        var and__3941__auto__ = left instanceof cljs.core.RedNode;
+        if(and__3941__auto__) {
+          return left.right instanceof cljs.core.BlackNode
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        return new cljs.core.RedNode(left.right.key, left.right.val, cljs.core.balance_left.call(null, left.key, left.val, left.left.redden(), left.right.left), new cljs.core.BlackNode(key, val, left.right.right, del, null), null)
+      }else {
+        if("\ufdd0:else") {
+          throw new Error("red-black tree invariant violation");
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.tree_map_kv_reduce = function tree_map_kv_reduce(node, f, init) {
+  var init__$1 = !(node.left == null) ? tree_map_kv_reduce.call(null, node.left, f, init) : init;
+  if(cljs.core.reduced_QMARK_.call(null, init__$1)) {
+    return cljs.core.deref.call(null, init__$1)
+  }else {
+    var init__$2 = f.call(null, init__$1, node.key, node.val);
+    if(cljs.core.reduced_QMARK_.call(null, init__$2)) {
+      return cljs.core.deref.call(null, init__$2)
+    }else {
+      var init__$3 = !(node.right == null) ? tree_map_kv_reduce.call(null, node.right, f, init__$2) : init__$2;
+      if(cljs.core.reduced_QMARK_.call(null, init__$3)) {
+        return cljs.core.deref.call(null, init__$3)
+      }else {
+        return init__$3
+      }
+    }
+  }
+};
+goog.provide("cljs.core.BlackNode");
+cljs.core.BlackNode = function(key, val, left, right, __hash) {
+  this.key = key;
+  this.val = val;
+  this.left = left;
+  this.right = right;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32402207
+};
+cljs.core.BlackNode.cljs$lang$type = true;
+cljs.core.BlackNode.cljs$lang$ctorStr = "cljs.core/BlackNode";
+cljs.core.BlackNode.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/BlackNode")
+};
+cljs.core.BlackNode.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$2 = function(node, k) {
+  var self__ = this;
+  return node.cljs$core$IIndexed$_nth$arity$3(node, k, null)
+};
+cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$3 = function(node, k, not_found) {
+  var self__ = this;
+  return node.cljs$core$IIndexed$_nth$arity$3(node, k, not_found)
+};
+cljs.core.BlackNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(node, k, v) {
+  var self__ = this;
+  return cljs.core.assoc.call(null, cljs.core.PersistentVector.fromArray([self__.key, self__.val], true), k, v)
+};
+cljs.core.BlackNode.prototype.call = function() {
+  var G__3974 = null;
+  var G__3974__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var node = self____$1;
+    return node.cljs$core$ILookup$_lookup$arity$2(node, k)
+  };
+  var G__3974__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var node = self____$1;
+    return node.cljs$core$ILookup$_lookup$arity$3(node, k, not_found)
+  };
+  G__3974 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3974__2.call(this, self__, k);
+      case 3:
+        return G__3974__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3974
+}();
+cljs.core.BlackNode.prototype.apply = function(self__, args3973) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3973.slice()))
+};
+cljs.core.BlackNode.prototype.cljs$core$ICollection$_conj$arity$2 = function(node, o) {
+  var self__ = this;
+  return cljs.core.PersistentVector.fromArray([self__.key, self__.val, o], true)
+};
+cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_key$arity$1 = function(node) {
+  var self__ = this;
+  return self__.key
+};
+cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_val$arity$1 = function(node) {
+  var self__ = this;
+  return self__.val
+};
+cljs.core.BlackNode.prototype.add_right = function(ins) {
+  var self__ = this;
+  var node = this;
+  return ins.balance_right(node)
+};
+cljs.core.BlackNode.prototype.redden = function() {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.RedNode(self__.key, self__.val, self__.left, self__.right, null)
+};
+cljs.core.BlackNode.prototype.remove_right = function(del) {
+  var self__ = this;
+  var node = this;
+  return cljs.core.balance_right_del.call(null, self__.key, self__.val, self__.left, del)
+};
+cljs.core.BlackNode.prototype.replace = function(key__$1, val__$1, left__$1, right__$1) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.BlackNode(key__$1, val__$1, left__$1, right__$1, null)
+};
+cljs.core.BlackNode.prototype.kv_reduce = function(f, init) {
+  var self__ = this;
+  var node = this;
+  return cljs.core.tree_map_kv_reduce.call(null, node, f, init)
+};
+cljs.core.BlackNode.prototype.remove_left = function(del) {
+  var self__ = this;
+  var node = this;
+  return cljs.core.balance_left_del.call(null, self__.key, self__.val, del, self__.right)
+};
+cljs.core.BlackNode.prototype.add_left = function(ins) {
+  var self__ = this;
+  var node = this;
+  return ins.balance_left(node)
+};
+cljs.core.BlackNode.prototype.balance_left = function(parent) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.BlackNode(parent.key, parent.val, node, parent.right, null)
+};
+cljs.core.BlackNode.prototype.balance_right = function(parent) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.BlackNode(parent.key, parent.val, parent.left, node, null)
+};
+cljs.core.BlackNode.prototype.blacken = function() {
+  var self__ = this;
+  var node = this;
+  return node
+};
+cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$2 = function(node, f) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, node, f)
+};
+cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$3 = function(node, f, start) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, node, f, start)
+};
+cljs.core.BlackNode.prototype.cljs$core$ISeqable$_seq$arity$1 = function(node) {
+  var self__ = this;
+  return cljs.core.list.call(null, self__.key, self__.val)
+};
+cljs.core.BlackNode.prototype.cljs$core$ICounted$_count$arity$1 = function(node) {
+  var self__ = this;
+  return 2
+};
+cljs.core.BlackNode.prototype.cljs$core$IStack$_peek$arity$1 = function(node) {
+  var self__ = this;
+  return self__.val
+};
+cljs.core.BlackNode.prototype.cljs$core$IStack$_pop$arity$1 = function(node) {
+  var self__ = this;
+  return cljs.core.PersistentVector.fromArray([self__.key], true)
+};
+cljs.core.BlackNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(node, n, v) {
+  var self__ = this;
+  return cljs.core._assoc_n.call(null, cljs.core.PersistentVector.fromArray([self__.key, self__.val], true), n, v)
+};
+cljs.core.BlackNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.BlackNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(node, meta) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.fromArray([self__.key, self__.val], true), meta)
+};
+cljs.core.BlackNode.prototype.cljs$core$IMeta$_meta$arity$1 = function(node) {
+  var self__ = this;
+  return null
+};
+cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$2 = function(node, n) {
+  var self__ = this;
+  if(n === 0) {
+    return self__.key
+  }else {
+    if(n === 1) {
+      return self__.val
+    }else {
+      if("\ufdd0:else") {
+        return null
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$3 = function(node, n, not_found) {
+  var self__ = this;
+  if(n === 0) {
+    return self__.key
+  }else {
+    if(n === 1) {
+      return self__.val
+    }else {
+      if("\ufdd0:else") {
+        return not_found
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.BlackNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(node) {
+  var self__ = this;
+  return cljs.core.PersistentVector.EMPTY
+};
+goog.provide("cljs.core.RedNode");
+cljs.core.RedNode = function(key, val, left, right, __hash) {
+  this.key = key;
+  this.val = val;
+  this.left = left;
+  this.right = right;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32402207
+};
+cljs.core.RedNode.cljs$lang$type = true;
+cljs.core.RedNode.cljs$lang$ctorStr = "cljs.core/RedNode";
+cljs.core.RedNode.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/RedNode")
+};
+cljs.core.RedNode.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$2 = function(node, k) {
+  var self__ = this;
+  return node.cljs$core$IIndexed$_nth$arity$3(node, k, null)
+};
+cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$3 = function(node, k, not_found) {
+  var self__ = this;
+  return node.cljs$core$IIndexed$_nth$arity$3(node, k, not_found)
+};
+cljs.core.RedNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(node, k, v) {
+  var self__ = this;
+  return cljs.core.assoc.call(null, cljs.core.PersistentVector.fromArray([self__.key, self__.val], true), k, v)
+};
+cljs.core.RedNode.prototype.call = function() {
+  var G__3976 = null;
+  var G__3976__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var node = self____$1;
+    return node.cljs$core$ILookup$_lookup$arity$2(node, k)
+  };
+  var G__3976__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var node = self____$1;
+    return node.cljs$core$ILookup$_lookup$arity$3(node, k, not_found)
+  };
+  G__3976 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3976__2.call(this, self__, k);
+      case 3:
+        return G__3976__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3976
+}();
+cljs.core.RedNode.prototype.apply = function(self__, args3975) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3975.slice()))
+};
+cljs.core.RedNode.prototype.cljs$core$ICollection$_conj$arity$2 = function(node, o) {
+  var self__ = this;
+  return cljs.core.PersistentVector.fromArray([self__.key, self__.val, o], true)
+};
+cljs.core.RedNode.prototype.cljs$core$IMapEntry$_key$arity$1 = function(node) {
+  var self__ = this;
+  return self__.key
+};
+cljs.core.RedNode.prototype.cljs$core$IMapEntry$_val$arity$1 = function(node) {
+  var self__ = this;
+  return self__.val
+};
+cljs.core.RedNode.prototype.add_right = function(ins) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.RedNode(self__.key, self__.val, self__.left, ins, null)
+};
+cljs.core.RedNode.prototype.redden = function() {
+  var self__ = this;
+  var node = this;
+  throw new Error("red-black tree invariant violation");
+};
+cljs.core.RedNode.prototype.remove_right = function(del) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.RedNode(self__.key, self__.val, self__.left, del, null)
+};
+cljs.core.RedNode.prototype.replace = function(key__$1, val__$1, left__$1, right__$1) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.RedNode(key__$1, val__$1, left__$1, right__$1, null)
+};
+cljs.core.RedNode.prototype.kv_reduce = function(f, init) {
+  var self__ = this;
+  var node = this;
+  return cljs.core.tree_map_kv_reduce.call(null, node, f, init)
+};
+cljs.core.RedNode.prototype.remove_left = function(del) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.RedNode(self__.key, self__.val, del, self__.right, null)
+};
+cljs.core.RedNode.prototype.add_left = function(ins) {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.RedNode(self__.key, self__.val, ins, self__.right, null)
+};
+cljs.core.RedNode.prototype.balance_left = function(parent) {
+  var self__ = this;
+  var node = this;
+  if(self__.left instanceof cljs.core.RedNode) {
+    return new cljs.core.RedNode(self__.key, self__.val, self__.left.blacken(), new cljs.core.BlackNode(parent.key, parent.val, self__.right, parent.right, null), null)
+  }else {
+    if(self__.right instanceof cljs.core.RedNode) {
+      return new cljs.core.RedNode(self__.right.key, self__.right.val, new cljs.core.BlackNode(self__.key, self__.val, self__.left, self__.right.left, null), new cljs.core.BlackNode(parent.key, parent.val, self__.right.right, parent.right, null), null)
+    }else {
+      if("\ufdd0:else") {
+        return new cljs.core.BlackNode(parent.key, parent.val, node, parent.right, null)
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.RedNode.prototype.balance_right = function(parent) {
+  var self__ = this;
+  var node = this;
+  if(self__.right instanceof cljs.core.RedNode) {
+    return new cljs.core.RedNode(self__.key, self__.val, new cljs.core.BlackNode(parent.key, parent.val, parent.left, self__.left, null), self__.right.blacken(), null)
+  }else {
+    if(self__.left instanceof cljs.core.RedNode) {
+      return new cljs.core.RedNode(self__.left.key, self__.left.val, new cljs.core.BlackNode(parent.key, parent.val, parent.left, self__.left.left, null), new cljs.core.BlackNode(self__.key, self__.val, self__.left.right, self__.right, null), null)
+    }else {
+      if("\ufdd0:else") {
+        return new cljs.core.BlackNode(parent.key, parent.val, parent.left, node, null)
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.RedNode.prototype.blacken = function() {
+  var self__ = this;
+  var node = this;
+  return new cljs.core.BlackNode(self__.key, self__.val, self__.left, self__.right, null)
+};
+cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$2 = function(node, f) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, node, f)
+};
+cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$3 = function(node, f, start) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, node, f, start)
+};
+cljs.core.RedNode.prototype.cljs$core$ISeqable$_seq$arity$1 = function(node) {
+  var self__ = this;
+  return cljs.core.list.call(null, self__.key, self__.val)
+};
+cljs.core.RedNode.prototype.cljs$core$ICounted$_count$arity$1 = function(node) {
+  var self__ = this;
+  return 2
+};
+cljs.core.RedNode.prototype.cljs$core$IStack$_peek$arity$1 = function(node) {
+  var self__ = this;
+  return self__.val
+};
+cljs.core.RedNode.prototype.cljs$core$IStack$_pop$arity$1 = function(node) {
+  var self__ = this;
+  return cljs.core.PersistentVector.fromArray([self__.key], true)
+};
+cljs.core.RedNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(node, n, v) {
+  var self__ = this;
+  return cljs.core._assoc_n.call(null, cljs.core.PersistentVector.fromArray([self__.key, self__.val], true), n, v)
+};
+cljs.core.RedNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, coll, other)
+};
+cljs.core.RedNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(node, meta) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.fromArray([self__.key, self__.val], true), meta)
+};
+cljs.core.RedNode.prototype.cljs$core$IMeta$_meta$arity$1 = function(node) {
+  var self__ = this;
+  return null
+};
+cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$2 = function(node, n) {
+  var self__ = this;
+  if(n === 0) {
+    return self__.key
+  }else {
+    if(n === 1) {
+      return self__.val
+    }else {
+      if("\ufdd0:else") {
+        return null
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$3 = function(node, n, not_found) {
+  var self__ = this;
+  if(n === 0) {
+    return self__.key
+  }else {
+    if(n === 1) {
+      return self__.val
+    }else {
+      if("\ufdd0:else") {
+        return not_found
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.RedNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(node) {
+  var self__ = this;
+  return cljs.core.PersistentVector.EMPTY
+};
+cljs.core.tree_map_add = function tree_map_add(comp, tree, k, v, found) {
+  if(tree == null) {
+    return new cljs.core.RedNode(k, v, null, null, null)
+  }else {
+    var c = comp.call(null, k, tree.key);
+    if(c === 0) {
+      found[0] = tree;
+      return null
+    }else {
+      if(c < 0) {
+        var ins = tree_map_add.call(null, comp, tree.left, k, v, found);
+        if(!(ins == null)) {
+          return tree.add_left(ins)
+        }else {
+          return null
+        }
+      }else {
+        if("\ufdd0:else") {
+          var ins = tree_map_add.call(null, comp, tree.right, k, v, found);
+          if(!(ins == null)) {
+            return tree.add_right(ins)
+          }else {
+            return null
+          }
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.tree_map_append = function tree_map_append(left, right) {
+  if(left == null) {
+    return right
+  }else {
+    if(right == null) {
+      return left
+    }else {
+      if(left instanceof cljs.core.RedNode) {
+        if(right instanceof cljs.core.RedNode) {
+          var app = tree_map_append.call(null, left.right, right.left);
+          if(app instanceof cljs.core.RedNode) {
+            return new cljs.core.RedNode(app.key, app.val, new cljs.core.RedNode(left.key, left.val, left.left, app.left, null), new cljs.core.RedNode(right.key, right.val, app.right, right.right, null), null)
+          }else {
+            return new cljs.core.RedNode(left.key, left.val, left.left, new cljs.core.RedNode(right.key, right.val, app, right.right, null), null)
+          }
+        }else {
+          return new cljs.core.RedNode(left.key, left.val, left.left, tree_map_append.call(null, left.right, right), null)
+        }
+      }else {
+        if(right instanceof cljs.core.RedNode) {
+          return new cljs.core.RedNode(right.key, right.val, tree_map_append.call(null, left, right.left), right.right, null)
+        }else {
+          if("\ufdd0:else") {
+            var app = tree_map_append.call(null, left.right, right.left);
+            if(app instanceof cljs.core.RedNode) {
+              return new cljs.core.RedNode(app.key, app.val, new cljs.core.BlackNode(left.key, left.val, left.left, app.left, null), new cljs.core.BlackNode(right.key, right.val, app.right, right.right, null), null)
+            }else {
+              return cljs.core.balance_left_del.call(null, left.key, left.val, left.left, new cljs.core.BlackNode(right.key, right.val, app, right.right, null))
+            }
+          }else {
+            return null
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.tree_map_remove = function tree_map_remove(comp, tree, k, found) {
+  if(!(tree == null)) {
+    var c = comp.call(null, k, tree.key);
+    if(c === 0) {
+      found[0] = tree;
+      return cljs.core.tree_map_append.call(null, tree.left, tree.right)
+    }else {
+      if(c < 0) {
+        var del = tree_map_remove.call(null, comp, tree.left, k, found);
+        if(function() {
+          var or__3943__auto__ = !(del == null);
+          if(or__3943__auto__) {
+            return or__3943__auto__
+          }else {
+            return!(found[0] == null)
+          }
+        }()) {
+          if(tree.left instanceof cljs.core.BlackNode) {
+            return cljs.core.balance_left_del.call(null, tree.key, tree.val, del, tree.right)
+          }else {
+            return new cljs.core.RedNode(tree.key, tree.val, del, tree.right, null)
+          }
+        }else {
+          return null
+        }
+      }else {
+        if("\ufdd0:else") {
+          var del = tree_map_remove.call(null, comp, tree.right, k, found);
+          if(function() {
+            var or__3943__auto__ = !(del == null);
+            if(or__3943__auto__) {
+              return or__3943__auto__
+            }else {
+              return!(found[0] == null)
+            }
+          }()) {
+            if(tree.right instanceof cljs.core.BlackNode) {
+              return cljs.core.balance_right_del.call(null, tree.key, tree.val, tree.left, del)
+            }else {
+              return new cljs.core.RedNode(tree.key, tree.val, tree.left, del, null)
+            }
+          }else {
+            return null
+          }
+        }else {
+          return null
+        }
+      }
+    }
+  }else {
+    return null
+  }
+};
+cljs.core.tree_map_replace = function tree_map_replace(comp, tree, k, v) {
+  var tk = tree.key;
+  var c = comp.call(null, k, tk);
+  if(c === 0) {
+    return tree.replace(tk, v, tree.left, tree.right)
+  }else {
+    if(c < 0) {
+      return tree.replace(tk, tree.val, tree_map_replace.call(null, comp, tree.left, k, v), tree.right)
+    }else {
+      if("\ufdd0:else") {
+        return tree.replace(tk, tree.val, tree.left, tree_map_replace.call(null, comp, tree.right, k, v))
+      }else {
+        return null
+      }
+    }
+  }
+};
+goog.provide("cljs.core.PersistentTreeMap");
+cljs.core.PersistentTreeMap = function(comp, tree, cnt, meta, __hash) {
+  this.comp = comp;
+  this.tree = tree;
+  this.cnt = cnt;
+  this.meta = meta;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 418776847
+};
+cljs.core.PersistentTreeMap.cljs$lang$type = true;
+cljs.core.PersistentTreeMap.cljs$lang$ctorStr = "cljs.core/PersistentTreeMap";
+cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentTreeMap")
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_imap.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, null)
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var n = coll.entry_at(k);
+  if(!(n == null)) {
+    return n.val
+  }else {
+    return not_found
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
+  var self__ = this;
+  var found = [null];
+  var t = cljs.core.tree_map_add.call(null, self__.comp, self__.tree, k, v, found);
+  if(t == null) {
+    var found_node = cljs.core.nth.call(null, found, 0);
+    if(cljs.core._EQ_.call(null, v, found_node.val)) {
+      return coll
+    }else {
+      return new cljs.core.PersistentTreeMap(self__.comp, cljs.core.tree_map_replace.call(null, self__.comp, self__.tree, k, v), self__.cnt, self__.meta, null)
+    }
+  }else {
+    return new cljs.core.PersistentTreeMap(self__.comp, t.blacken(), self__.cnt + 1, self__.meta, null)
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = function(coll, k) {
+  var self__ = this;
+  return!(coll.entry_at(k) == null)
+};
+cljs.core.PersistentTreeMap.prototype.call = function() {
+  var G__3978 = null;
+  var G__3978__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__3978__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__3978 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__3978__2.call(this, self__, k);
+      case 3:
+        return G__3978__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__3978
+}();
+cljs.core.PersistentTreeMap.prototype.apply = function(self__, args3977) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args3977.slice()))
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  if(!(self__.tree == null)) {
+    return cljs.core.tree_map_kv_reduce.call(null, self__.tree, f, init)
+  }else {
+    return init
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  if(cljs.core.vector_QMARK_.call(null, entry)) {
+    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, cljs.core._nth.call(null, entry, 0), cljs.core._nth.call(null, entry, 1))
+  }else {
+    return cljs.core.reduce.call(null, cljs.core._conj, coll, entry)
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    return cljs.core.create_tree_map_seq.call(null, self__.tree, false, self__.cnt)
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentTreeMap.prototype.entry_at = function(k) {
+  var self__ = this;
+  var coll = this;
+  var t = self__.tree;
+  while(true) {
+    if(!(t == null)) {
+      var c = self__.comp.call(null, k, t.key);
+      if(c === 0) {
+        return t
+      }else {
+        if(c < 0) {
+          var G__3979 = t.left;
+          t = G__3979;
+          continue
+        }else {
+          if("\ufdd0:else") {
+            var G__3980 = t.right;
+            t = G__3980;
+            continue
+          }else {
+            return null
+          }
+        }
+      }
+    }else {
+      return null
+    }
+    break
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq$arity$2 = function(coll, ascending_QMARK_) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    return cljs.core.create_tree_map_seq.call(null, self__.tree, ascending_QMARK_, self__.cnt)
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq_from$arity$3 = function(coll, k, ascending_QMARK_) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    var stack = null;
+    var t = self__.tree;
+    while(true) {
+      if(!(t == null)) {
+        var c = self__.comp.call(null, k, t.key);
+        if(c === 0) {
+          return new cljs.core.PersistentTreeMapSeq(null, cljs.core.conj.call(null, stack, t), ascending_QMARK_, -1, null)
+        }else {
+          if(cljs.core.truth_(ascending_QMARK_)) {
+            if(c < 0) {
+              var G__3981 = cljs.core.conj.call(null, stack, t);
+              var G__3982 = t.left;
+              stack = G__3981;
+              t = G__3982;
+              continue
+            }else {
+              var G__3983 = stack;
+              var G__3984 = t.right;
+              stack = G__3983;
+              t = G__3984;
+              continue
+            }
+          }else {
+            if("\ufdd0:else") {
+              if(c > 0) {
+                var G__3985 = cljs.core.conj.call(null, stack, t);
+                var G__3986 = t.right;
+                stack = G__3985;
+                t = G__3986;
+                continue
+              }else {
+                var G__3987 = stack;
+                var G__3988 = t.left;
+                stack = G__3987;
+                t = G__3988;
+                continue
+              }
+            }else {
+              return null
+            }
+          }
+        }
+      }else {
+        if(stack == null) {
+          return null
+        }else {
+          return new cljs.core.PersistentTreeMapSeq(null, stack, ascending_QMARK_, -1, null)
+        }
+      }
+      break
+    }
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_entry_key$arity$2 = function(coll, entry) {
+  var self__ = this;
+  return cljs.core.key.call(null, entry)
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_comparator$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.comp
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  if(self__.cnt > 0) {
+    return cljs.core.create_tree_map_seq.call(null, self__.tree, true, self__.cnt)
+  }else {
+    return null
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.cnt
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  return cljs.core.equiv_map.call(null, coll, other)
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentTreeMap(self__.comp, self__.tree, self__.cnt, meta__$1, self__.__hash)
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentTreeMap.EMPTY, self__.meta)
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IMap$_dissoc$arity$2 = function(coll, k) {
+  var self__ = this;
+  var found = [null];
+  var t = cljs.core.tree_map_remove.call(null, self__.comp, self__.tree, k, found);
+  if(t == null) {
+    if(cljs.core.nth.call(null, found, 0) == null) {
+      return coll
+    }else {
+      return new cljs.core.PersistentTreeMap(self__.comp, null, 0, self__.meta, null)
+    }
+  }else {
+    return new cljs.core.PersistentTreeMap(self__.comp, t.blacken(), self__.cnt - 1, self__.meta, null)
+  }
+};
+cljs.core.PersistentTreeMap.EMPTY = new cljs.core.PersistentTreeMap(cljs.core.compare, null, 0, null, 0);
+cljs.core.hash_map = function() {
+  var hash_map__delegate = function(keyvals) {
+    var in$ = cljs.core.seq.call(null, keyvals);
+    var out = cljs.core.transient$.call(null, cljs.core.PersistentHashMap.EMPTY);
+    while(true) {
+      if(in$) {
+        var G__3989 = cljs.core.nnext.call(null, in$);
+        var G__3990 = cljs.core.assoc_BANG_.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
+        in$ = G__3989;
+        out = G__3990;
+        continue
+      }else {
+        return cljs.core.persistent_BANG_.call(null, out)
+      }
+      break
+    }
+  };
+  var hash_map = function(var_args) {
+    var keyvals = null;
+    if(arguments.length > 0) {
+      keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return hash_map__delegate.call(this, keyvals)
+  };
+  hash_map.cljs$lang$maxFixedArity = 0;
+  hash_map.cljs$lang$applyTo = function(arglist__3991) {
+    var keyvals = cljs.core.seq(arglist__3991);
+    return hash_map__delegate(keyvals)
+  };
+  hash_map.cljs$core$IFn$_invoke$arity$variadic = hash_map__delegate;
+  return hash_map
+}();
+cljs.core.array_map = function() {
+  var array_map__delegate = function(keyvals) {
+    return new cljs.core.PersistentArrayMap(null, cljs.core.quot.call(null, cljs.core.count.call(null, keyvals), 2), cljs.core.apply.call(null, cljs.core.array, keyvals), null)
+  };
+  var array_map = function(var_args) {
+    var keyvals = null;
+    if(arguments.length > 0) {
+      keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return array_map__delegate.call(this, keyvals)
+  };
+  array_map.cljs$lang$maxFixedArity = 0;
+  array_map.cljs$lang$applyTo = function(arglist__3992) {
+    var keyvals = cljs.core.seq(arglist__3992);
+    return array_map__delegate(keyvals)
+  };
+  array_map.cljs$core$IFn$_invoke$arity$variadic = array_map__delegate;
+  return array_map
+}();
+cljs.core.obj_map = function() {
+  var obj_map__delegate = function(keyvals) {
+    var ks = [];
+    var obj = {};
+    var kvs = cljs.core.seq.call(null, keyvals);
+    while(true) {
+      if(kvs) {
+        ks.push(cljs.core.first.call(null, kvs));
+        obj[cljs.core.first.call(null, kvs)] = cljs.core.second.call(null, kvs);
+        var G__3993 = cljs.core.nnext.call(null, kvs);
+        kvs = G__3993;
+        continue
+      }else {
+        return cljs.core.ObjMap.fromObject.call(null, ks, obj)
+      }
+      break
+    }
+  };
+  var obj_map = function(var_args) {
+    var keyvals = null;
+    if(arguments.length > 0) {
+      keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return obj_map__delegate.call(this, keyvals)
+  };
+  obj_map.cljs$lang$maxFixedArity = 0;
+  obj_map.cljs$lang$applyTo = function(arglist__3994) {
+    var keyvals = cljs.core.seq(arglist__3994);
+    return obj_map__delegate(keyvals)
+  };
+  obj_map.cljs$core$IFn$_invoke$arity$variadic = obj_map__delegate;
+  return obj_map
+}();
+cljs.core.sorted_map = function() {
+  var sorted_map__delegate = function(keyvals) {
+    var in$ = cljs.core.seq.call(null, keyvals);
+    var out = cljs.core.PersistentTreeMap.EMPTY;
+    while(true) {
+      if(in$) {
+        var G__3995 = cljs.core.nnext.call(null, in$);
+        var G__3996 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
+        in$ = G__3995;
+        out = G__3996;
+        continue
+      }else {
+        return out
+      }
+      break
+    }
+  };
+  var sorted_map = function(var_args) {
+    var keyvals = null;
+    if(arguments.length > 0) {
+      keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return sorted_map__delegate.call(this, keyvals)
+  };
+  sorted_map.cljs$lang$maxFixedArity = 0;
+  sorted_map.cljs$lang$applyTo = function(arglist__3997) {
+    var keyvals = cljs.core.seq(arglist__3997);
+    return sorted_map__delegate(keyvals)
+  };
+  sorted_map.cljs$core$IFn$_invoke$arity$variadic = sorted_map__delegate;
+  return sorted_map
+}();
+cljs.core.sorted_map_by = function() {
+  var sorted_map_by__delegate = function(comparator, keyvals) {
+    var in$ = cljs.core.seq.call(null, keyvals);
+    var out = new cljs.core.PersistentTreeMap(cljs.core.fn__GT_comparator.call(null, comparator), null, 0, null, 0);
+    while(true) {
+      if(in$) {
+        var G__3998 = cljs.core.nnext.call(null, in$);
+        var G__3999 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
+        in$ = G__3998;
+        out = G__3999;
+        continue
+      }else {
+        return out
+      }
+      break
+    }
+  };
+  var sorted_map_by = function(comparator, var_args) {
+    var keyvals = null;
+    if(arguments.length > 1) {
+      keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return sorted_map_by__delegate.call(this, comparator, keyvals)
+  };
+  sorted_map_by.cljs$lang$maxFixedArity = 1;
+  sorted_map_by.cljs$lang$applyTo = function(arglist__4000) {
+    var comparator = cljs.core.first(arglist__4000);
+    var keyvals = cljs.core.rest(arglist__4000);
+    return sorted_map_by__delegate(comparator, keyvals)
+  };
+  sorted_map_by.cljs$core$IFn$_invoke$arity$variadic = sorted_map_by__delegate;
+  return sorted_map_by
+}();
+cljs.core.keys = function keys(hash_map) {
+  return cljs.core.seq.call(null, cljs.core.map.call(null, cljs.core.first, hash_map))
+};
+cljs.core.key = function key(map_entry) {
+  return cljs.core._key.call(null, map_entry)
+};
+cljs.core.vals = function vals(hash_map) {
+  return cljs.core.seq.call(null, cljs.core.map.call(null, cljs.core.second, hash_map))
+};
+cljs.core.val = function val(map_entry) {
+  return cljs.core._val.call(null, map_entry)
+};
+cljs.core.merge = function() {
+  var merge__delegate = function(maps) {
+    if(cljs.core.truth_(cljs.core.some.call(null, cljs.core.identity, maps))) {
+      return cljs.core.reduce.call(null, function(p1__4001_SHARP_, p2__4002_SHARP_) {
+        return cljs.core.conj.call(null, function() {
+          var or__3943__auto__ = p1__4001_SHARP_;
+          if(cljs.core.truth_(or__3943__auto__)) {
+            return or__3943__auto__
+          }else {
+            return cljs.core.ObjMap.EMPTY
+          }
+        }(), p2__4002_SHARP_)
+      }, maps)
+    }else {
+      return null
+    }
+  };
+  var merge = function(var_args) {
+    var maps = null;
+    if(arguments.length > 0) {
+      maps = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return merge__delegate.call(this, maps)
+  };
+  merge.cljs$lang$maxFixedArity = 0;
+  merge.cljs$lang$applyTo = function(arglist__4003) {
+    var maps = cljs.core.seq(arglist__4003);
+    return merge__delegate(maps)
+  };
+  merge.cljs$core$IFn$_invoke$arity$variadic = merge__delegate;
+  return merge
+}();
+cljs.core.merge_with = function() {
+  var merge_with__delegate = function(f, maps) {
+    if(cljs.core.truth_(cljs.core.some.call(null, cljs.core.identity, maps))) {
+      var merge_entry = function(m, e) {
+        var k = cljs.core.first.call(null, e);
+        var v = cljs.core.second.call(null, e);
+        if(cljs.core.contains_QMARK_.call(null, m, k)) {
+          return cljs.core.assoc.call(null, m, k, f.call(null, cljs.core.get.call(null, m, k), v))
+        }else {
+          return cljs.core.assoc.call(null, m, k, v)
+        }
+      };
+      var merge2 = function(merge_entry) {
+        return function(m1, m2) {
+          return cljs.core.reduce.call(null, merge_entry, function() {
+            var or__3943__auto__ = m1;
+            if(cljs.core.truth_(or__3943__auto__)) {
+              return or__3943__auto__
+            }else {
+              return cljs.core.ObjMap.EMPTY
+            }
+          }(), cljs.core.seq.call(null, m2))
+        }
+      }(merge_entry);
+      return cljs.core.reduce.call(null, merge2, maps)
+    }else {
+      return null
+    }
+  };
+  var merge_with = function(f, var_args) {
+    var maps = null;
+    if(arguments.length > 1) {
+      maps = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return merge_with__delegate.call(this, f, maps)
+  };
+  merge_with.cljs$lang$maxFixedArity = 1;
+  merge_with.cljs$lang$applyTo = function(arglist__4004) {
+    var f = cljs.core.first(arglist__4004);
+    var maps = cljs.core.rest(arglist__4004);
+    return merge_with__delegate(f, maps)
+  };
+  merge_with.cljs$core$IFn$_invoke$arity$variadic = merge_with__delegate;
+  return merge_with
+}();
+cljs.core.select_keys = function select_keys(map, keyseq) {
+  var ret = cljs.core.ObjMap.EMPTY;
+  var keys = cljs.core.seq.call(null, keyseq);
+  while(true) {
+    if(keys) {
+      var key = cljs.core.first.call(null, keys);
+      var entry = cljs.core.get.call(null, map, key, "\ufdd0:cljs.core/not-found");
+      var G__4005 = cljs.core.not_EQ_.call(null, entry, "\ufdd0:cljs.core/not-found") ? cljs.core.assoc.call(null, ret, key, entry) : ret;
+      var G__4006 = cljs.core.next.call(null, keys);
+      ret = G__4005;
+      keys = G__4006;
+      continue
+    }else {
+      return ret
+    }
+    break
+  }
+};
+goog.provide("cljs.core.PersistentHashSet");
+cljs.core.PersistentHashSet = function(meta, hash_map, __hash) {
+  this.meta = meta;
+  this.hash_map = hash_map;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 4;
+  this.cljs$lang$protocol_mask$partition0$ = 15077647
+};
+cljs.core.PersistentHashSet.cljs$lang$type = true;
+cljs.core.PersistentHashSet.cljs$lang$ctorStr = "cljs.core/PersistentHashSet";
+cljs.core.PersistentHashSet.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentHashSet")
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  return new cljs.core.TransientHashSet(cljs.core._as_transient.call(null, self__.hash_map))
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_iset.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, v) {
+  var self__ = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(coll, v, null)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, v, not_found) {
+  var self__ = this;
+  if(cljs.core.truth_(cljs.core._contains_key_QMARK_.call(null, self__.hash_map, v))) {
+    return v
+  }else {
+    return not_found
+  }
+};
+cljs.core.PersistentHashSet.prototype.call = function() {
+  var G__4009 = null;
+  var G__4009__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__4009__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__4009 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__4009__2.call(this, self__, k);
+      case 3:
+        return G__4009__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__4009
+}();
+cljs.core.PersistentHashSet.prototype.apply = function(self__, args4008) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args4008.slice()))
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return new cljs.core.PersistentHashSet(self__.meta, cljs.core.assoc.call(null, self__.hash_map, o, null), null)
+};
+cljs.core.PersistentHashSet.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.keys.call(null, self__.hash_map)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ISet$_disjoin$arity$2 = function(coll, v) {
+  var self__ = this;
+  return new cljs.core.PersistentHashSet(self__.meta, cljs.core._dissoc.call(null, self__.hash_map, v), null)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._count.call(null, self__.hash_map)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var and__3941__auto__ = cljs.core.set_QMARK_.call(null, other);
+  if(and__3941__auto__) {
+    var and__3941__auto____$1 = cljs.core.count.call(null, coll) === cljs.core.count.call(null, other);
+    if(and__3941__auto____$1) {
+      return cljs.core.every_QMARK_.call(null, function(p1__4007_SHARP_) {
+        return cljs.core.contains_QMARK_.call(null, coll, p1__4007_SHARP_)
+      }, other)
+    }else {
+      return and__3941__auto____$1
+    }
+  }else {
+    return and__3941__auto__
+  }
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentHashSet(meta__$1, self__.hash_map, self__.__hash)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentHashSet.EMPTY, self__.meta)
+};
+cljs.core.PersistentHashSet.EMPTY = new cljs.core.PersistentHashSet(null, cljs.core.PersistentArrayMap.EMPTY, 0);
+cljs.core.PersistentHashSet.fromArray = function(items, no_clone) {
+  var len = items.length;
+  if(len / 2 <= cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
+    var arr = no_clone ? items : items.slice();
+    return new cljs.core.PersistentHashSet(null, cljs.core.PersistentArrayMap.fromArray.call(null, arr, true), null)
+  }else {
+    var i = 0;
+    var out = cljs.core.transient$.call(null, cljs.core.PersistentHashSet.EMPTY);
+    while(true) {
+      if(i < len) {
+        var G__4010 = i + 2;
+        var G__4011 = cljs.core.conj_BANG_.call(null, out, items[i]);
+        i = G__4010;
+        out = G__4011;
+        continue
+      }else {
+        return cljs.core.persistent_BANG_.call(null, out)
+      }
+      break
+    }
+  }
+};
+goog.provide("cljs.core.TransientHashSet");
+cljs.core.TransientHashSet = function(transient_map) {
+  this.transient_map = transient_map;
+  this.cljs$lang$protocol_mask$partition0$ = 259;
+  this.cljs$lang$protocol_mask$partition1$ = 136
+};
+cljs.core.TransientHashSet.cljs$lang$type = true;
+cljs.core.TransientHashSet.cljs$lang$ctorStr = "cljs.core/TransientHashSet";
+cljs.core.TransientHashSet.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/TransientHashSet")
+};
+cljs.core.TransientHashSet.prototype.call = function() {
+  var G__4014 = null;
+  var G__4014__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var tcoll = self____$1;
+    if(cljs.core._lookup.call(null, self__.transient_map, k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
+      return null
+    }else {
+      return k
+    }
+  };
+  var G__4014__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var tcoll = self____$1;
+    if(cljs.core._lookup.call(null, self__.transient_map, k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
+      return not_found
+    }else {
+      return k
+    }
+  };
+  G__4014 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__4014__2.call(this, self__, k);
+      case 3:
+        return G__4014__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__4014
+}();
+cljs.core.TransientHashSet.prototype.apply = function(self__, args4013) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args4013.slice()))
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, v) {
+  var self__ = this;
+  return tcoll.cljs$core$ILookup$_lookup$arity$3(tcoll, v, null)
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, v, not_found) {
+  var self__ = this;
+  if(cljs.core._lookup.call(null, self__.transient_map, v, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
+    return not_found
+  }else {
+    return v
+  }
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ICounted$_count$arity$1 = function(tcoll) {
+  var self__ = this;
+  return cljs.core.count.call(null, self__.transient_map)
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ITransientSet$_disjoin_BANG_$arity$2 = function(tcoll, v) {
+  var self__ = this;
+  self__.transient_map = cljs.core.dissoc_BANG_.call(null, self__.transient_map, v);
+  return tcoll
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
+  var self__ = this;
+  self__.transient_map = cljs.core.assoc_BANG_.call(null, self__.transient_map, o, null);
+  return tcoll
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  return new cljs.core.PersistentHashSet(null, cljs.core.persistent_BANG_.call(null, self__.transient_map), null)
+};
+goog.provide("cljs.core.PersistentTreeSet");
+cljs.core.PersistentTreeSet = function(meta, tree_map, __hash) {
+  this.meta = meta;
+  this.tree_map = tree_map;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 417730831
+};
+cljs.core.PersistentTreeSet.cljs$lang$type = true;
+cljs.core.PersistentTreeSet.cljs$lang$ctorStr = "cljs.core/PersistentTreeSet";
+cljs.core.PersistentTreeSet.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/PersistentTreeSet")
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_iset.call(null, coll);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, v) {
+  var self__ = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(coll, v, null)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, v, not_found) {
+  var self__ = this;
+  var n = self__.tree_map.entry_at(v);
+  if(!(n == null)) {
+    return n.key
+  }else {
+    return not_found
+  }
+};
+cljs.core.PersistentTreeSet.prototype.call = function() {
+  var G__4016 = null;
+  var G__4016__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(coll, k)
+  };
+  var G__4016__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$3(coll, k, not_found)
+  };
+  G__4016 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__4016__2.call(this, self__, k);
+      case 3:
+        return G__4016__3.call(this, self__, k, not_found)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__4016
+}();
+cljs.core.PersistentTreeSet.prototype.apply = function(self__, args4015) {
+  var self__ = this;
+  return self__.call.apply(self__, [self__].concat(args4015.slice()))
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  return new cljs.core.PersistentTreeSet(self__.meta, cljs.core.assoc.call(null, self__.tree_map, o, null), null)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.map.call(null, cljs.core.key, cljs.core.rseq.call(null, self__.tree_map))
+};
+cljs.core.PersistentTreeSet.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_sorted_seq$arity$2 = function(coll, ascending_QMARK_) {
+  var self__ = this;
+  return cljs.core.map.call(null, cljs.core.key, cljs.core._sorted_seq.call(null, self__.tree_map, ascending_QMARK_))
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_sorted_seq_from$arity$3 = function(coll, k, ascending_QMARK_) {
+  var self__ = this;
+  return cljs.core.map.call(null, cljs.core.key, cljs.core._sorted_seq_from.call(null, self__.tree_map, k, ascending_QMARK_))
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_entry_key$arity$2 = function(coll, entry) {
+  var self__ = this;
+  return entry
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_comparator$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core._comparator.call(null, self__.tree_map)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.keys.call(null, self__.tree_map)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISet$_disjoin$arity$2 = function(coll, v) {
+  var self__ = this;
+  return new cljs.core.PersistentTreeSet(self__.meta, cljs.core.dissoc.call(null, self__.tree_map, v), null)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.count.call(null, self__.tree_map)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var and__3941__auto__ = cljs.core.set_QMARK_.call(null, other);
+  if(and__3941__auto__) {
+    var and__3941__auto____$1 = cljs.core.count.call(null, coll) === cljs.core.count.call(null, other);
+    if(and__3941__auto____$1) {
+      return cljs.core.every_QMARK_.call(null, function(p1__4012_SHARP_) {
+        return cljs.core.contains_QMARK_.call(null, coll, p1__4012_SHARP_)
+      }, other)
+    }else {
+      return and__3941__auto____$1
+    }
+  }else {
+    return and__3941__auto__
+  }
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  return new cljs.core.PersistentTreeSet(meta__$1, self__.tree_map, self__.__hash)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentTreeSet.EMPTY, self__.meta)
+};
+cljs.core.PersistentTreeSet.EMPTY = new cljs.core.PersistentTreeSet(null, cljs.core.PersistentTreeMap.EMPTY, 0);
+cljs.core.hash_set = function() {
+  var hash_set = null;
+  var hash_set__0 = function() {
+    return cljs.core.PersistentHashSet.EMPTY
+  };
+  var hash_set__1 = function() {
+    var G__4017__delegate = function(keys) {
+      if(function() {
+        var and__3941__auto__ = keys instanceof cljs.core.IndexedSeq;
+        if(and__3941__auto__) {
+          return keys.arr.length < cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD
+        }else {
+          return and__3941__auto__
+        }
+      }()) {
+        var karr = keys.arr;
+        var klen = karr.length;
+        var alen = 2 * klen;
+        var arr = new Array(alen);
+        var ki = 0;
+        while(true) {
+          if(ki < klen) {
+            var ai = 2 * ki;
+            arr[ai] = karr[ki];
+            arr[ai + 1] = null;
+            var G__4018 = ki + 1;
+            ki = G__4018;
+            continue
+          }else {
+            return cljs.core.PersistentHashSet.fromArray.call(null, arr, true)
+          }
+          break
+        }
+      }else {
+        var in$ = keys;
+        var out = cljs.core._as_transient.call(null, cljs.core.PersistentHashSet.EMPTY);
+        while(true) {
+          if(!(in$ == null)) {
+            var G__4019 = cljs.core._next.call(null, in$);
+            var G__4020 = cljs.core._conj_BANG_.call(null, out, cljs.core._first.call(null, in$));
+            in$ = G__4019;
+            out = G__4020;
+            continue
+          }else {
+            return cljs.core._persistent_BANG_.call(null, out)
+          }
+          break
+        }
+      }
+    };
+    var G__4017 = function(var_args) {
+      var keys = null;
+      if(arguments.length > 0) {
+        keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+      }
+      return G__4017__delegate.call(this, keys)
+    };
+    G__4017.cljs$lang$maxFixedArity = 0;
+    G__4017.cljs$lang$applyTo = function(arglist__4021) {
+      var keys = cljs.core.seq(arglist__4021);
+      return G__4017__delegate(keys)
+    };
+    G__4017.cljs$core$IFn$_invoke$arity$variadic = G__4017__delegate;
+    return G__4017
+  }();
+  hash_set = function(var_args) {
+    var keys = var_args;
+    switch(arguments.length) {
+      case 0:
+        return hash_set__0.call(this);
+      default:
+        return hash_set__1.cljs$core$IFn$_invoke$arity$variadic(cljs.core.array_seq(arguments, 0))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  hash_set.cljs$lang$maxFixedArity = 0;
+  hash_set.cljs$lang$applyTo = hash_set__1.cljs$lang$applyTo;
+  hash_set.cljs$core$IFn$_invoke$arity$0 = hash_set__0;
+  hash_set.cljs$core$IFn$_invoke$arity$variadic = hash_set__1.cljs$core$IFn$_invoke$arity$variadic;
+  return hash_set
+}();
+cljs.core.set = function set(coll) {
+  return cljs.core.apply.call(null, cljs.core.hash_set, coll)
+};
+cljs.core.sorted_set = function() {
+  var sorted_set__delegate = function(keys) {
+    return cljs.core.reduce.call(null, cljs.core._conj, cljs.core.PersistentTreeSet.EMPTY, keys)
+  };
+  var sorted_set = function(var_args) {
+    var keys = null;
+    if(arguments.length > 0) {
+      keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return sorted_set__delegate.call(this, keys)
+  };
+  sorted_set.cljs$lang$maxFixedArity = 0;
+  sorted_set.cljs$lang$applyTo = function(arglist__4022) {
+    var keys = cljs.core.seq(arglist__4022);
+    return sorted_set__delegate(keys)
+  };
+  sorted_set.cljs$core$IFn$_invoke$arity$variadic = sorted_set__delegate;
+  return sorted_set
+}();
+cljs.core.sorted_set_by = function() {
+  var sorted_set_by__delegate = function(comparator, keys) {
+    return cljs.core.reduce.call(null, cljs.core._conj, new cljs.core.PersistentTreeSet(null, cljs.core.sorted_map_by.call(null, comparator), 0), keys)
+  };
+  var sorted_set_by = function(comparator, var_args) {
+    var keys = null;
+    if(arguments.length > 1) {
+      keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return sorted_set_by__delegate.call(this, comparator, keys)
+  };
+  sorted_set_by.cljs$lang$maxFixedArity = 1;
+  sorted_set_by.cljs$lang$applyTo = function(arglist__4024) {
+    var comparator = cljs.core.first(arglist__4024);
+    var keys = cljs.core.rest(arglist__4024);
+    return sorted_set_by__delegate(comparator, keys)
+  };
+  sorted_set_by.cljs$core$IFn$_invoke$arity$variadic = sorted_set_by__delegate;
+  return sorted_set_by
+}();
+cljs.core.replace = function replace(smap, coll) {
+  if(cljs.core.vector_QMARK_.call(null, coll)) {
+    var n = cljs.core.count.call(null, coll);
+    return cljs.core.reduce.call(null, function(v, i) {
+      var temp__4090__auto__ = cljs.core.find.call(null, smap, cljs.core.nth.call(null, v, i));
+      if(cljs.core.truth_(temp__4090__auto__)) {
+        var e = temp__4090__auto__;
+        return cljs.core.assoc.call(null, v, i, cljs.core.second.call(null, e))
+      }else {
+        return v
+      }
+    }, coll, cljs.core.take.call(null, n, cljs.core.iterate.call(null, cljs.core.inc, 0)))
+  }else {
+    return cljs.core.map.call(null, function(p1__4023_SHARP_) {
+      var temp__4090__auto__ = cljs.core.find.call(null, smap, p1__4023_SHARP_);
+      if(cljs.core.truth_(temp__4090__auto__)) {
+        var e = temp__4090__auto__;
+        return cljs.core.second.call(null, e)
+      }else {
+        return p1__4023_SHARP_
+      }
+    }, coll)
+  }
+};
+cljs.core.distinct = function distinct(coll) {
+  var step = function step(xs, seen) {
+    return new cljs.core.LazySeq(null, false, function() {
+      return function(p__4031, seen__$1) {
+        while(true) {
+          var vec__4032 = p__4031;
+          var f = cljs.core.nth.call(null, vec__4032, 0, null);
+          var xs__$1 = vec__4032;
+          var temp__4092__auto__ = cljs.core.seq.call(null, xs__$1);
+          if(temp__4092__auto__) {
+            var s = temp__4092__auto__;
+            if(cljs.core.contains_QMARK_.call(null, seen__$1, f)) {
+              var G__4033 = cljs.core.rest.call(null, s);
+              var G__4034 = seen__$1;
+              p__4031 = G__4033;
+              seen__$1 = G__4034;
+              continue
+            }else {
+              return cljs.core.cons.call(null, f, step.call(null, cljs.core.rest.call(null, s), cljs.core.conj.call(null, seen__$1, f)))
+            }
+          }else {
+            return null
+          }
+          break
+        }
+      }.call(null, xs, seen)
+    }, null)
+  };
+  return step.call(null, coll, cljs.core.PersistentHashSet.EMPTY)
+};
+cljs.core.butlast = function butlast(s) {
+  var ret = cljs.core.PersistentVector.EMPTY;
+  var s__$1 = s;
+  while(true) {
+    if(cljs.core.next.call(null, s__$1)) {
+      var G__4035 = cljs.core.conj.call(null, ret, cljs.core.first.call(null, s__$1));
+      var G__4036 = cljs.core.next.call(null, s__$1);
+      ret = G__4035;
+      s__$1 = G__4036;
+      continue
+    }else {
+      return cljs.core.seq.call(null, ret)
+    }
+    break
+  }
+};
+cljs.core.name = function name(x) {
+  if(function() {
+    var G__4038 = x;
+    if(G__4038) {
+      if(cljs.core.truth_(function() {
+        var or__3943__auto__ = null;
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          return G__4038.cljs$core$INamed$
+        }
+      }())) {
+        return true
+      }else {
+        return false
+      }
+    }else {
+      return false
+    }
+  }()) {
+    return cljs.core._name.call(null, x)
+  }else {
+    if(cljs.core.string_QMARK_.call(null, x)) {
+      return x
+    }else {
+      if(cljs.core.keyword_QMARK_.call(null, x)) {
+        var i = x.lastIndexOf("/", x.length - 2);
+        if(i < 0) {
+          return cljs.core.subs.call(null, x, 2)
+        }else {
+          return cljs.core.subs.call(null, x, i + 1)
+        }
+      }else {
+        if("\ufdd0:else") {
+          throw new Error([cljs.core.str("Doesn't support name: "), cljs.core.str(x)].join(""));
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.namespace = function namespace(x) {
+  if(function() {
+    var G__4040 = x;
+    if(G__4040) {
+      if(cljs.core.truth_(function() {
+        var or__3943__auto__ = null;
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          return G__4040.cljs$core$INamed$
+        }
+      }())) {
+        return true
+      }else {
+        return false
+      }
+    }else {
+      return false
+    }
+  }()) {
+    return cljs.core._namespace.call(null, x)
+  }else {
+    if(cljs.core.keyword_QMARK_.call(null, x)) {
+      var i = x.lastIndexOf("/", x.length - 2);
+      if(i > -1) {
+        return cljs.core.subs.call(null, x, 2, i)
+      }else {
+        return null
+      }
+    }else {
+      throw new Error([cljs.core.str("Doesn't support namespace: "), cljs.core.str(x)].join(""));
+    }
+  }
+};
+cljs.core.zipmap = function zipmap(keys, vals) {
+  var map = cljs.core.ObjMap.EMPTY;
+  var ks = cljs.core.seq.call(null, keys);
+  var vs = cljs.core.seq.call(null, vals);
+  while(true) {
+    if(function() {
+      var and__3941__auto__ = ks;
+      if(and__3941__auto__) {
+        return vs
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      var G__4043 = cljs.core.assoc.call(null, map, cljs.core.first.call(null, ks), cljs.core.first.call(null, vs));
+      var G__4044 = cljs.core.next.call(null, ks);
+      var G__4045 = cljs.core.next.call(null, vs);
+      map = G__4043;
+      ks = G__4044;
+      vs = G__4045;
+      continue
+    }else {
+      return map
+    }
+    break
+  }
+};
+cljs.core.max_key = function() {
+  var max_key = null;
+  var max_key__2 = function(k, x) {
+    return x
+  };
+  var max_key__3 = function(k, x, y) {
+    if(k.call(null, x) > k.call(null, y)) {
+      return x
+    }else {
+      return y
+    }
+  };
+  var max_key__4 = function() {
+    var G__4048__delegate = function(k, x, y, more) {
+      return cljs.core.reduce.call(null, function(p1__4041_SHARP_, p2__4042_SHARP_) {
+        return max_key.call(null, k, p1__4041_SHARP_, p2__4042_SHARP_)
+      }, max_key.call(null, k, x, y), more)
+    };
+    var G__4048 = function(k, x, y, var_args) {
+      var more = null;
+      if(arguments.length > 3) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__4048__delegate.call(this, k, x, y, more)
+    };
+    G__4048.cljs$lang$maxFixedArity = 3;
+    G__4048.cljs$lang$applyTo = function(arglist__4049) {
+      var k = cljs.core.first(arglist__4049);
+      arglist__4049 = cljs.core.next(arglist__4049);
+      var x = cljs.core.first(arglist__4049);
+      arglist__4049 = cljs.core.next(arglist__4049);
+      var y = cljs.core.first(arglist__4049);
+      var more = cljs.core.rest(arglist__4049);
+      return G__4048__delegate(k, x, y, more)
+    };
+    G__4048.cljs$core$IFn$_invoke$arity$variadic = G__4048__delegate;
+    return G__4048
+  }();
+  max_key = function(k, x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 2:
+        return max_key__2.call(this, k, x);
+      case 3:
+        return max_key__3.call(this, k, x, y);
+      default:
+        return max_key__4.cljs$core$IFn$_invoke$arity$variadic(k, x, y, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  max_key.cljs$lang$maxFixedArity = 3;
+  max_key.cljs$lang$applyTo = max_key__4.cljs$lang$applyTo;
+  max_key.cljs$core$IFn$_invoke$arity$2 = max_key__2;
+  max_key.cljs$core$IFn$_invoke$arity$3 = max_key__3;
+  max_key.cljs$core$IFn$_invoke$arity$variadic = max_key__4.cljs$core$IFn$_invoke$arity$variadic;
+  return max_key
+}();
+cljs.core.min_key = function() {
+  var min_key = null;
+  var min_key__2 = function(k, x) {
+    return x
+  };
+  var min_key__3 = function(k, x, y) {
+    if(k.call(null, x) < k.call(null, y)) {
+      return x
+    }else {
+      return y
+    }
+  };
+  var min_key__4 = function() {
+    var G__4050__delegate = function(k, x, y, more) {
+      return cljs.core.reduce.call(null, function(p1__4046_SHARP_, p2__4047_SHARP_) {
+        return min_key.call(null, k, p1__4046_SHARP_, p2__4047_SHARP_)
+      }, min_key.call(null, k, x, y), more)
+    };
+    var G__4050 = function(k, x, y, var_args) {
+      var more = null;
+      if(arguments.length > 3) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__4050__delegate.call(this, k, x, y, more)
+    };
+    G__4050.cljs$lang$maxFixedArity = 3;
+    G__4050.cljs$lang$applyTo = function(arglist__4051) {
+      var k = cljs.core.first(arglist__4051);
+      arglist__4051 = cljs.core.next(arglist__4051);
+      var x = cljs.core.first(arglist__4051);
+      arglist__4051 = cljs.core.next(arglist__4051);
+      var y = cljs.core.first(arglist__4051);
+      var more = cljs.core.rest(arglist__4051);
+      return G__4050__delegate(k, x, y, more)
+    };
+    G__4050.cljs$core$IFn$_invoke$arity$variadic = G__4050__delegate;
+    return G__4050
+  }();
+  min_key = function(k, x, y, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 2:
+        return min_key__2.call(this, k, x);
+      case 3:
+        return min_key__3.call(this, k, x, y);
+      default:
+        return min_key__4.cljs$core$IFn$_invoke$arity$variadic(k, x, y, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  min_key.cljs$lang$maxFixedArity = 3;
+  min_key.cljs$lang$applyTo = min_key__4.cljs$lang$applyTo;
+  min_key.cljs$core$IFn$_invoke$arity$2 = min_key__2;
+  min_key.cljs$core$IFn$_invoke$arity$3 = min_key__3;
+  min_key.cljs$core$IFn$_invoke$arity$variadic = min_key__4.cljs$core$IFn$_invoke$arity$variadic;
+  return min_key
+}();
+cljs.core.partition_all = function() {
+  var partition_all = null;
+  var partition_all__2 = function(n, coll) {
+    return partition_all.call(null, n, n, coll)
+  };
+  var partition_all__3 = function(n, step, coll) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        return cljs.core.cons.call(null, cljs.core.take.call(null, n, s), partition_all.call(null, n, step, cljs.core.drop.call(null, step, s)))
+      }else {
+        return null
+      }
+    }, null)
+  };
+  partition_all = function(n, step, coll) {
+    switch(arguments.length) {
+      case 2:
+        return partition_all__2.call(this, n, step);
+      case 3:
+        return partition_all__3.call(this, n, step, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  partition_all.cljs$core$IFn$_invoke$arity$2 = partition_all__2;
+  partition_all.cljs$core$IFn$_invoke$arity$3 = partition_all__3;
+  return partition_all
+}();
+cljs.core.take_while = function take_while(pred, coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4092__auto__) {
+      var s = temp__4092__auto__;
+      if(cljs.core.truth_(pred.call(null, cljs.core.first.call(null, s)))) {
+        return cljs.core.cons.call(null, cljs.core.first.call(null, s), take_while.call(null, pred, cljs.core.rest.call(null, s)))
+      }else {
+        return null
+      }
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.mk_bound_fn = function mk_bound_fn(sc, test, key) {
+  return function(e) {
+    var comp = cljs.core._comparator.call(null, sc);
+    return test.call(null, comp.call(null, cljs.core._entry_key.call(null, sc, e), key), 0)
+  }
+};
+cljs.core.subseq = function() {
+  var subseq = null;
+  var subseq__3 = function(sc, test, key) {
+    var include = cljs.core.mk_bound_fn.call(null, sc, test, key);
+    if(cljs.core.truth_(cljs.core.PersistentHashSet.fromArray([cljs.core._GT_, null, cljs.core._GT__EQ_, null], true).call(null, test))) {
+      var temp__4092__auto__ = cljs.core._sorted_seq_from.call(null, sc, key, true);
+      if(cljs.core.truth_(temp__4092__auto__)) {
+        var vec__4054 = temp__4092__auto__;
+        var e = cljs.core.nth.call(null, vec__4054, 0, null);
+        var s = vec__4054;
+        if(cljs.core.truth_(include.call(null, e))) {
+          return s
+        }else {
+          return cljs.core.next.call(null, s)
+        }
+      }else {
+        return null
+      }
+    }else {
+      return cljs.core.take_while.call(null, include, cljs.core._sorted_seq.call(null, sc, true))
+    }
+  };
+  var subseq__5 = function(sc, start_test, start_key, end_test, end_key) {
+    var temp__4092__auto__ = cljs.core._sorted_seq_from.call(null, sc, start_key, true);
+    if(cljs.core.truth_(temp__4092__auto__)) {
+      var vec__4055 = temp__4092__auto__;
+      var e = cljs.core.nth.call(null, vec__4055, 0, null);
+      var s = vec__4055;
+      return cljs.core.take_while.call(null, cljs.core.mk_bound_fn.call(null, sc, end_test, end_key), cljs.core.truth_(cljs.core.mk_bound_fn.call(null, sc, start_test, start_key).call(null, e)) ? s : cljs.core.next.call(null, s))
+    }else {
+      return null
+    }
+  };
+  subseq = function(sc, start_test, start_key, end_test, end_key) {
+    switch(arguments.length) {
+      case 3:
+        return subseq__3.call(this, sc, start_test, start_key);
+      case 5:
+        return subseq__5.call(this, sc, start_test, start_key, end_test, end_key)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  subseq.cljs$core$IFn$_invoke$arity$3 = subseq__3;
+  subseq.cljs$core$IFn$_invoke$arity$5 = subseq__5;
+  return subseq
+}();
+cljs.core.rsubseq = function() {
+  var rsubseq = null;
+  var rsubseq__3 = function(sc, test, key) {
+    var include = cljs.core.mk_bound_fn.call(null, sc, test, key);
+    if(cljs.core.truth_(cljs.core.PersistentHashSet.fromArray([cljs.core._LT_, null, cljs.core._LT__EQ_, null], true).call(null, test))) {
+      var temp__4092__auto__ = cljs.core._sorted_seq_from.call(null, sc, key, false);
+      if(cljs.core.truth_(temp__4092__auto__)) {
+        var vec__4058 = temp__4092__auto__;
+        var e = cljs.core.nth.call(null, vec__4058, 0, null);
+        var s = vec__4058;
+        if(cljs.core.truth_(include.call(null, e))) {
+          return s
+        }else {
+          return cljs.core.next.call(null, s)
+        }
+      }else {
+        return null
+      }
+    }else {
+      return cljs.core.take_while.call(null, include, cljs.core._sorted_seq.call(null, sc, false))
+    }
+  };
+  var rsubseq__5 = function(sc, start_test, start_key, end_test, end_key) {
+    var temp__4092__auto__ = cljs.core._sorted_seq_from.call(null, sc, end_key, false);
+    if(cljs.core.truth_(temp__4092__auto__)) {
+      var vec__4059 = temp__4092__auto__;
+      var e = cljs.core.nth.call(null, vec__4059, 0, null);
+      var s = vec__4059;
+      return cljs.core.take_while.call(null, cljs.core.mk_bound_fn.call(null, sc, start_test, start_key), cljs.core.truth_(cljs.core.mk_bound_fn.call(null, sc, end_test, end_key).call(null, e)) ? s : cljs.core.next.call(null, s))
+    }else {
+      return null
+    }
+  };
+  rsubseq = function(sc, start_test, start_key, end_test, end_key) {
+    switch(arguments.length) {
+      case 3:
+        return rsubseq__3.call(this, sc, start_test, start_key);
+      case 5:
+        return rsubseq__5.call(this, sc, start_test, start_key, end_test, end_key)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  rsubseq.cljs$core$IFn$_invoke$arity$3 = rsubseq__3;
+  rsubseq.cljs$core$IFn$_invoke$arity$5 = rsubseq__5;
+  return rsubseq
+}();
+goog.provide("cljs.core.Range");
+cljs.core.Range = function(meta, start, end, step, __hash) {
+  this.meta = meta;
+  this.start = start;
+  this.end = end;
+  this.step = step;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32375006
+};
+cljs.core.Range.cljs$lang$type = true;
+cljs.core.Range.cljs$lang$ctorStr = "cljs.core/Range";
+cljs.core.Range.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Range")
+};
+cljs.core.Range.prototype.cljs$core$IHash$_hash$arity$1 = function(rng) {
+  var self__ = this;
+  var h__2768__auto__ = self__.__hash;
+  if(!(h__2768__auto__ == null)) {
+    return h__2768__auto__
+  }else {
+    var h__2768__auto____$1 = cljs.core.hash_coll.call(null, rng);
+    self__.__hash = h__2768__auto____$1;
+    return h__2768__auto____$1
+  }
+};
+cljs.core.Range.prototype.cljs$core$INext$_next$arity$1 = function(rng) {
+  var self__ = this;
+  if(self__.step > 0) {
+    if(self__.start + self__.step < self__.end) {
+      return new cljs.core.Range(self__.meta, self__.start + self__.step, self__.end, self__.step, null)
+    }else {
+      return null
+    }
+  }else {
+    if(self__.start + self__.step > self__.end) {
+      return new cljs.core.Range(self__.meta, self__.start + self__.step, self__.end, self__.step, null)
+    }else {
+      return null
+    }
+  }
+};
+cljs.core.Range.prototype.cljs$core$ICollection$_conj$arity$2 = function(rng, o) {
+  var self__ = this;
+  return cljs.core.cons.call(null, o, rng)
+};
+cljs.core.Range.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll)
+};
+cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$2 = function(rng, f) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, rng, f)
+};
+cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$3 = function(rng, f, s) {
+  var self__ = this;
+  return cljs.core.ci_reduce.call(null, rng, f, s)
+};
+cljs.core.Range.prototype.cljs$core$ISeqable$_seq$arity$1 = function(rng) {
+  var self__ = this;
+  if(self__.step > 0) {
+    if(self__.start < self__.end) {
+      return rng
+    }else {
+      return null
+    }
+  }else {
+    if(self__.start > self__.end) {
+      return rng
+    }else {
+      return null
+    }
+  }
+};
+cljs.core.Range.prototype.cljs$core$ICounted$_count$arity$1 = function(rng) {
+  var self__ = this;
+  if(cljs.core.not.call(null, rng.cljs$core$ISeqable$_seq$arity$1(rng))) {
+    return 0
+  }else {
+    return Math.ceil((self__.end - self__.start) / self__.step)
+  }
+};
+cljs.core.Range.prototype.cljs$core$ISeq$_first$arity$1 = function(rng) {
+  var self__ = this;
+  return self__.start
+};
+cljs.core.Range.prototype.cljs$core$ISeq$_rest$arity$1 = function(rng) {
+  var self__ = this;
+  if(!(rng.cljs$core$ISeqable$_seq$arity$1(rng) == null)) {
+    return new cljs.core.Range(self__.meta, self__.start + self__.step, self__.end, self__.step, null)
+  }else {
+    return cljs.core.List.EMPTY
+  }
+};
+cljs.core.Range.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(rng, other) {
+  var self__ = this;
+  return cljs.core.equiv_sequential.call(null, rng, other)
+};
+cljs.core.Range.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(rng, meta__$1) {
+  var self__ = this;
+  return new cljs.core.Range(meta__$1, self__.start, self__.end, self__.step, self__.__hash)
+};
+cljs.core.Range.prototype.cljs$core$IMeta$_meta$arity$1 = function(rng) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$2 = function(rng, n) {
+  var self__ = this;
+  if(n < rng.cljs$core$ICounted$_count$arity$1(rng)) {
+    return self__.start + n * self__.step
+  }else {
+    if(function() {
+      var and__3941__auto__ = self__.start > self__.end;
+      if(and__3941__auto__) {
+        return self__.step === 0
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return self__.start
+    }else {
+      throw new Error("Index out of bounds");
+    }
+  }
+};
+cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$3 = function(rng, n, not_found) {
+  var self__ = this;
+  if(n < rng.cljs$core$ICounted$_count$arity$1(rng)) {
+    return self__.start + n * self__.step
+  }else {
+    if(function() {
+      var and__3941__auto__ = self__.start > self__.end;
+      if(and__3941__auto__) {
+        return self__.step === 0
+      }else {
+        return and__3941__auto__
+      }
+    }()) {
+      return self__.start
+    }else {
+      return not_found
+    }
+  }
+};
+cljs.core.Range.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(rng) {
+  var self__ = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta)
+};
+cljs.core.range = function() {
+  var range = null;
+  var range__0 = function() {
+    return range.call(null, 0, Number.MAX_VALUE, 1)
+  };
+  var range__1 = function(end) {
+    return range.call(null, 0, end, 1)
+  };
+  var range__2 = function(start, end) {
+    return range.call(null, start, end, 1)
+  };
+  var range__3 = function(start, end, step) {
+    return new cljs.core.Range(null, start, end, step, null)
+  };
+  range = function(start, end, step) {
+    switch(arguments.length) {
+      case 0:
+        return range__0.call(this);
+      case 1:
+        return range__1.call(this, start);
+      case 2:
+        return range__2.call(this, start, end);
+      case 3:
+        return range__3.call(this, start, end, step)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  range.cljs$core$IFn$_invoke$arity$0 = range__0;
+  range.cljs$core$IFn$_invoke$arity$1 = range__1;
+  range.cljs$core$IFn$_invoke$arity$2 = range__2;
+  range.cljs$core$IFn$_invoke$arity$3 = range__3;
+  return range
+}();
+cljs.core.take_nth = function take_nth(n, coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4092__auto__) {
+      var s = temp__4092__auto__;
+      return cljs.core.cons.call(null, cljs.core.first.call(null, s), take_nth.call(null, n, cljs.core.drop.call(null, n, s)))
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.split_with = function split_with(pred, coll) {
+  return cljs.core.PersistentVector.fromArray([cljs.core.take_while.call(null, pred, coll), cljs.core.drop_while.call(null, pred, coll)], true)
+};
+cljs.core.partition_by = function partition_by(f, coll) {
+  return new cljs.core.LazySeq(null, false, function() {
+    var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+    if(temp__4092__auto__) {
+      var s = temp__4092__auto__;
+      var fst = cljs.core.first.call(null, s);
+      var fv = f.call(null, fst);
+      var run = cljs.core.cons.call(null, fst, cljs.core.take_while.call(null, function(fst, fv) {
+        return function(p1__4060_SHARP_) {
+          return cljs.core._EQ_.call(null, fv, f.call(null, p1__4060_SHARP_))
+        }
+      }(fst, fv), cljs.core.next.call(null, s)));
+      return cljs.core.cons.call(null, run, partition_by.call(null, f, cljs.core.seq.call(null, cljs.core.drop.call(null, cljs.core.count.call(null, run), s))))
+    }else {
+      return null
+    }
+  }, null)
+};
+cljs.core.frequencies = function frequencies(coll) {
+  return cljs.core.persistent_BANG_.call(null, cljs.core.reduce.call(null, function(counts, x) {
+    return cljs.core.assoc_BANG_.call(null, counts, x, cljs.core.get.call(null, counts, x, 0) + 1)
+  }, cljs.core.transient$.call(null, cljs.core.ObjMap.EMPTY), coll))
+};
+cljs.core.reductions = function() {
+  var reductions = null;
+  var reductions__2 = function(f, coll) {
+    return new cljs.core.LazySeq(null, false, function() {
+      var temp__4090__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4090__auto__) {
+        var s = temp__4090__auto__;
+        return reductions.call(null, f, cljs.core.first.call(null, s), cljs.core.rest.call(null, s))
+      }else {
+        return cljs.core.list.call(null, f.call(null))
+      }
+    }, null)
+  };
+  var reductions__3 = function(f, init, coll) {
+    return cljs.core.cons.call(null, init, new cljs.core.LazySeq(null, false, function() {
+      var temp__4092__auto__ = cljs.core.seq.call(null, coll);
+      if(temp__4092__auto__) {
+        var s = temp__4092__auto__;
+        return reductions.call(null, f, f.call(null, init, cljs.core.first.call(null, s)), cljs.core.rest.call(null, s))
+      }else {
+        return null
+      }
+    }, null))
+  };
+  reductions = function(f, init, coll) {
+    switch(arguments.length) {
+      case 2:
+        return reductions__2.call(this, f, init);
+      case 3:
+        return reductions__3.call(this, f, init, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  reductions.cljs$core$IFn$_invoke$arity$2 = reductions__2;
+  reductions.cljs$core$IFn$_invoke$arity$3 = reductions__3;
+  return reductions
+}();
+cljs.core.juxt = function() {
+  var juxt = null;
+  var juxt__1 = function(f) {
+    return function() {
+      var G__4071 = null;
+      var G__4071__0 = function() {
+        return cljs.core.vector.call(null, f.call(null))
+      };
+      var G__4071__1 = function(x) {
+        return cljs.core.vector.call(null, f.call(null, x))
+      };
+      var G__4071__2 = function(x, y) {
+        return cljs.core.vector.call(null, f.call(null, x, y))
+      };
+      var G__4071__3 = function(x, y, z) {
+        return cljs.core.vector.call(null, f.call(null, x, y, z))
+      };
+      var G__4071__4 = function() {
+        var G__4072__delegate = function(x, y, z, args) {
+          return cljs.core.vector.call(null, cljs.core.apply.call(null, f, x, y, z, args))
+        };
+        var G__4072 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__4072__delegate.call(this, x, y, z, args)
+        };
+        G__4072.cljs$lang$maxFixedArity = 3;
+        G__4072.cljs$lang$applyTo = function(arglist__4073) {
+          var x = cljs.core.first(arglist__4073);
+          arglist__4073 = cljs.core.next(arglist__4073);
+          var y = cljs.core.first(arglist__4073);
+          arglist__4073 = cljs.core.next(arglist__4073);
+          var z = cljs.core.first(arglist__4073);
+          var args = cljs.core.rest(arglist__4073);
+          return G__4072__delegate(x, y, z, args)
+        };
+        G__4072.cljs$core$IFn$_invoke$arity$variadic = G__4072__delegate;
+        return G__4072
+      }();
+      G__4071 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__4071__0.call(this);
+          case 1:
+            return G__4071__1.call(this, x);
+          case 2:
+            return G__4071__2.call(this, x, y);
+          case 3:
+            return G__4071__3.call(this, x, y, z);
+          default:
+            return G__4071__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__4071.cljs$lang$maxFixedArity = 3;
+      G__4071.cljs$lang$applyTo = G__4071__4.cljs$lang$applyTo;
+      return G__4071
+    }()
+  };
+  var juxt__2 = function(f, g) {
+    return function() {
+      var G__4074 = null;
+      var G__4074__0 = function() {
+        return cljs.core.vector.call(null, f.call(null), g.call(null))
+      };
+      var G__4074__1 = function(x) {
+        return cljs.core.vector.call(null, f.call(null, x), g.call(null, x))
+      };
+      var G__4074__2 = function(x, y) {
+        return cljs.core.vector.call(null, f.call(null, x, y), g.call(null, x, y))
+      };
+      var G__4074__3 = function(x, y, z) {
+        return cljs.core.vector.call(null, f.call(null, x, y, z), g.call(null, x, y, z))
+      };
+      var G__4074__4 = function() {
+        var G__4075__delegate = function(x, y, z, args) {
+          return cljs.core.vector.call(null, cljs.core.apply.call(null, f, x, y, z, args), cljs.core.apply.call(null, g, x, y, z, args))
+        };
+        var G__4075 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__4075__delegate.call(this, x, y, z, args)
+        };
+        G__4075.cljs$lang$maxFixedArity = 3;
+        G__4075.cljs$lang$applyTo = function(arglist__4076) {
+          var x = cljs.core.first(arglist__4076);
+          arglist__4076 = cljs.core.next(arglist__4076);
+          var y = cljs.core.first(arglist__4076);
+          arglist__4076 = cljs.core.next(arglist__4076);
+          var z = cljs.core.first(arglist__4076);
+          var args = cljs.core.rest(arglist__4076);
+          return G__4075__delegate(x, y, z, args)
+        };
+        G__4075.cljs$core$IFn$_invoke$arity$variadic = G__4075__delegate;
+        return G__4075
+      }();
+      G__4074 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__4074__0.call(this);
+          case 1:
+            return G__4074__1.call(this, x);
+          case 2:
+            return G__4074__2.call(this, x, y);
+          case 3:
+            return G__4074__3.call(this, x, y, z);
+          default:
+            return G__4074__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__4074.cljs$lang$maxFixedArity = 3;
+      G__4074.cljs$lang$applyTo = G__4074__4.cljs$lang$applyTo;
+      return G__4074
+    }()
+  };
+  var juxt__3 = function(f, g, h) {
+    return function() {
+      var G__4077 = null;
+      var G__4077__0 = function() {
+        return cljs.core.vector.call(null, f.call(null), g.call(null), h.call(null))
+      };
+      var G__4077__1 = function(x) {
+        return cljs.core.vector.call(null, f.call(null, x), g.call(null, x), h.call(null, x))
+      };
+      var G__4077__2 = function(x, y) {
+        return cljs.core.vector.call(null, f.call(null, x, y), g.call(null, x, y), h.call(null, x, y))
+      };
+      var G__4077__3 = function(x, y, z) {
+        return cljs.core.vector.call(null, f.call(null, x, y, z), g.call(null, x, y, z), h.call(null, x, y, z))
+      };
+      var G__4077__4 = function() {
+        var G__4078__delegate = function(x, y, z, args) {
+          return cljs.core.vector.call(null, cljs.core.apply.call(null, f, x, y, z, args), cljs.core.apply.call(null, g, x, y, z, args), cljs.core.apply.call(null, h, x, y, z, args))
+        };
+        var G__4078 = function(x, y, z, var_args) {
+          var args = null;
+          if(arguments.length > 3) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+          }
+          return G__4078__delegate.call(this, x, y, z, args)
+        };
+        G__4078.cljs$lang$maxFixedArity = 3;
+        G__4078.cljs$lang$applyTo = function(arglist__4079) {
+          var x = cljs.core.first(arglist__4079);
+          arglist__4079 = cljs.core.next(arglist__4079);
+          var y = cljs.core.first(arglist__4079);
+          arglist__4079 = cljs.core.next(arglist__4079);
+          var z = cljs.core.first(arglist__4079);
+          var args = cljs.core.rest(arglist__4079);
+          return G__4078__delegate(x, y, z, args)
+        };
+        G__4078.cljs$core$IFn$_invoke$arity$variadic = G__4078__delegate;
+        return G__4078
+      }();
+      G__4077 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__4077__0.call(this);
+          case 1:
+            return G__4077__1.call(this, x);
+          case 2:
+            return G__4077__2.call(this, x, y);
+          case 3:
+            return G__4077__3.call(this, x, y, z);
+          default:
+            return G__4077__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__4077.cljs$lang$maxFixedArity = 3;
+      G__4077.cljs$lang$applyTo = G__4077__4.cljs$lang$applyTo;
+      return G__4077
+    }()
+  };
+  var juxt__4 = function() {
+    var G__4080__delegate = function(f, g, h, fs) {
+      var fs__$1 = cljs.core.list_STAR_.call(null, f, g, h, fs);
+      return function() {
+        var G__4081 = null;
+        var G__4081__0 = function() {
+          return cljs.core.reduce.call(null, function(p1__4061_SHARP_, p2__4062_SHARP_) {
+            return cljs.core.conj.call(null, p1__4061_SHARP_, p2__4062_SHARP_.call(null))
+          }, cljs.core.PersistentVector.EMPTY, fs__$1)
+        };
+        var G__4081__1 = function(x) {
+          return cljs.core.reduce.call(null, function(p1__4063_SHARP_, p2__4064_SHARP_) {
+            return cljs.core.conj.call(null, p1__4063_SHARP_, p2__4064_SHARP_.call(null, x))
+          }, cljs.core.PersistentVector.EMPTY, fs__$1)
+        };
+        var G__4081__2 = function(x, y) {
+          return cljs.core.reduce.call(null, function(p1__4065_SHARP_, p2__4066_SHARP_) {
+            return cljs.core.conj.call(null, p1__4065_SHARP_, p2__4066_SHARP_.call(null, x, y))
+          }, cljs.core.PersistentVector.EMPTY, fs__$1)
+        };
+        var G__4081__3 = function(x, y, z) {
+          return cljs.core.reduce.call(null, function(p1__4067_SHARP_, p2__4068_SHARP_) {
+            return cljs.core.conj.call(null, p1__4067_SHARP_, p2__4068_SHARP_.call(null, x, y, z))
+          }, cljs.core.PersistentVector.EMPTY, fs__$1)
+        };
+        var G__4081__4 = function() {
+          var G__4082__delegate = function(x, y, z, args) {
+            return cljs.core.reduce.call(null, function(p1__4069_SHARP_, p2__4070_SHARP_) {
+              return cljs.core.conj.call(null, p1__4069_SHARP_, cljs.core.apply.call(null, p2__4070_SHARP_, x, y, z, args))
+            }, cljs.core.PersistentVector.EMPTY, fs__$1)
+          };
+          var G__4082 = function(x, y, z, var_args) {
+            var args = null;
+            if(arguments.length > 3) {
+              args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+            }
+            return G__4082__delegate.call(this, x, y, z, args)
+          };
+          G__4082.cljs$lang$maxFixedArity = 3;
+          G__4082.cljs$lang$applyTo = function(arglist__4083) {
+            var x = cljs.core.first(arglist__4083);
+            arglist__4083 = cljs.core.next(arglist__4083);
+            var y = cljs.core.first(arglist__4083);
+            arglist__4083 = cljs.core.next(arglist__4083);
+            var z = cljs.core.first(arglist__4083);
+            var args = cljs.core.rest(arglist__4083);
+            return G__4082__delegate(x, y, z, args)
+          };
+          G__4082.cljs$core$IFn$_invoke$arity$variadic = G__4082__delegate;
+          return G__4082
+        }();
+        G__4081 = function(x, y, z, var_args) {
+          var args = var_args;
+          switch(arguments.length) {
+            case 0:
+              return G__4081__0.call(this);
+            case 1:
+              return G__4081__1.call(this, x);
+            case 2:
+              return G__4081__2.call(this, x, y);
+            case 3:
+              return G__4081__3.call(this, x, y, z);
+            default:
+              return G__4081__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3))
+          }
+          throw new Error("Invalid arity: " + arguments.length);
+        };
+        G__4081.cljs$lang$maxFixedArity = 3;
+        G__4081.cljs$lang$applyTo = G__4081__4.cljs$lang$applyTo;
+        return G__4081
+      }()
+    };
+    var G__4080 = function(f, g, h, var_args) {
+      var fs = null;
+      if(arguments.length > 3) {
+        fs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0)
+      }
+      return G__4080__delegate.call(this, f, g, h, fs)
+    };
+    G__4080.cljs$lang$maxFixedArity = 3;
+    G__4080.cljs$lang$applyTo = function(arglist__4084) {
+      var f = cljs.core.first(arglist__4084);
+      arglist__4084 = cljs.core.next(arglist__4084);
+      var g = cljs.core.first(arglist__4084);
+      arglist__4084 = cljs.core.next(arglist__4084);
+      var h = cljs.core.first(arglist__4084);
+      var fs = cljs.core.rest(arglist__4084);
+      return G__4080__delegate(f, g, h, fs)
+    };
+    G__4080.cljs$core$IFn$_invoke$arity$variadic = G__4080__delegate;
+    return G__4080
+  }();
+  juxt = function(f, g, h, var_args) {
+    var fs = var_args;
+    switch(arguments.length) {
+      case 1:
+        return juxt__1.call(this, f);
+      case 2:
+        return juxt__2.call(this, f, g);
+      case 3:
+        return juxt__3.call(this, f, g, h);
+      default:
+        return juxt__4.cljs$core$IFn$_invoke$arity$variadic(f, g, h, cljs.core.array_seq(arguments, 3))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  juxt.cljs$lang$maxFixedArity = 3;
+  juxt.cljs$lang$applyTo = juxt__4.cljs$lang$applyTo;
+  juxt.cljs$core$IFn$_invoke$arity$1 = juxt__1;
+  juxt.cljs$core$IFn$_invoke$arity$2 = juxt__2;
+  juxt.cljs$core$IFn$_invoke$arity$3 = juxt__3;
+  juxt.cljs$core$IFn$_invoke$arity$variadic = juxt__4.cljs$core$IFn$_invoke$arity$variadic;
+  return juxt
+}();
+cljs.core.dorun = function() {
+  var dorun = null;
+  var dorun__1 = function(coll) {
+    while(true) {
+      if(cljs.core.seq.call(null, coll)) {
+        var G__4085 = cljs.core.next.call(null, coll);
+        coll = G__4085;
+        continue
+      }else {
+        return null
+      }
+      break
+    }
+  };
+  var dorun__2 = function(n, coll) {
+    while(true) {
+      if(cljs.core.truth_(function() {
+        var and__3941__auto__ = cljs.core.seq.call(null, coll);
+        if(and__3941__auto__) {
+          return n > 0
+        }else {
+          return and__3941__auto__
+        }
+      }())) {
+        var G__4086 = n - 1;
+        var G__4087 = cljs.core.next.call(null, coll);
+        n = G__4086;
+        coll = G__4087;
+        continue
+      }else {
+        return null
+      }
+      break
+    }
+  };
+  dorun = function(n, coll) {
+    switch(arguments.length) {
+      case 1:
+        return dorun__1.call(this, n);
+      case 2:
+        return dorun__2.call(this, n, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  dorun.cljs$core$IFn$_invoke$arity$1 = dorun__1;
+  dorun.cljs$core$IFn$_invoke$arity$2 = dorun__2;
+  return dorun
+}();
+cljs.core.doall = function() {
+  var doall = null;
+  var doall__1 = function(coll) {
+    cljs.core.dorun.call(null, coll);
+    return coll
+  };
+  var doall__2 = function(n, coll) {
+    cljs.core.dorun.call(null, n, coll);
+    return coll
+  };
+  doall = function(n, coll) {
+    switch(arguments.length) {
+      case 1:
+        return doall__1.call(this, n);
+      case 2:
+        return doall__2.call(this, n, coll)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  doall.cljs$core$IFn$_invoke$arity$1 = doall__1;
+  doall.cljs$core$IFn$_invoke$arity$2 = doall__2;
+  return doall
+}();
+cljs.core.regexp_QMARK_ = function regexp_QMARK_(o) {
+  return o instanceof RegExp
+};
+cljs.core.re_matches = function re_matches(re, s) {
+  var matches = re.exec(s);
+  if(cljs.core._EQ_.call(null, cljs.core.first.call(null, matches), s)) {
+    if(cljs.core.count.call(null, matches) === 1) {
+      return cljs.core.first.call(null, matches)
+    }else {
+      return cljs.core.vec.call(null, matches)
+    }
+  }else {
+    return null
+  }
+};
+cljs.core.re_find = function re_find(re, s) {
+  var matches = re.exec(s);
+  if(matches == null) {
+    return null
+  }else {
+    if(cljs.core.count.call(null, matches) === 1) {
+      return cljs.core.first.call(null, matches)
+    }else {
+      return cljs.core.vec.call(null, matches)
+    }
+  }
+};
+cljs.core.re_seq = function re_seq(re, s) {
+  var match_data = cljs.core.re_find.call(null, re, s);
+  var match_idx = s.search(re);
+  var match_str = cljs.core.coll_QMARK_.call(null, match_data) ? cljs.core.first.call(null, match_data) : match_data;
+  var post_match = cljs.core.subs.call(null, s, match_idx + cljs.core.count.call(null, match_str));
+  if(cljs.core.truth_(match_data)) {
+    return new cljs.core.LazySeq(null, false, function() {
+      return cljs.core.cons.call(null, match_data, re_seq.call(null, re, post_match))
+    }, null)
+  }else {
+    return null
+  }
+};
+cljs.core.re_pattern = function re_pattern(s) {
+  var vec__4089 = cljs.core.re_find.call(null, /^(?:\(\?([idmsux]*)\))?(.*)/, s);
+  var _ = cljs.core.nth.call(null, vec__4089, 0, null);
+  var flags = cljs.core.nth.call(null, vec__4089, 1, null);
+  var pattern = cljs.core.nth.call(null, vec__4089, 2, null);
+  return new RegExp(pattern, flags)
+};
+cljs.core.pr_sequential_writer = function pr_sequential_writer(writer, print_one, begin, sep, end, opts, coll) {
+  cljs.core._write.call(null, writer, begin);
+  if(cljs.core.seq.call(null, coll)) {
+    print_one.call(null, cljs.core.first.call(null, coll), writer, opts)
+  }else {
+  }
+  var seq__4094_4098 = cljs.core.seq.call(null, cljs.core.next.call(null, coll));
+  var chunk__4095_4099 = null;
+  var count__4096_4100 = 0;
+  var i__4097_4101 = 0;
+  while(true) {
+    if(i__4097_4101 < count__4096_4100) {
+      var o_4102 = cljs.core._nth.call(null, chunk__4095_4099, i__4097_4101);
+      cljs.core._write.call(null, writer, sep);
+      print_one.call(null, o_4102, writer, opts);
+      var G__4103 = seq__4094_4098;
+      var G__4104 = chunk__4095_4099;
+      var G__4105 = count__4096_4100;
+      var G__4106 = i__4097_4101 + 1;
+      seq__4094_4098 = G__4103;
+      chunk__4095_4099 = G__4104;
+      count__4096_4100 = G__4105;
+      i__4097_4101 = G__4106;
+      continue
+    }else {
+      var temp__4092__auto___4107 = cljs.core.seq.call(null, seq__4094_4098);
+      if(temp__4092__auto___4107) {
+        var seq__4094_4108__$1 = temp__4092__auto___4107;
+        if(cljs.core.chunked_seq_QMARK_.call(null, seq__4094_4108__$1)) {
+          var c__3073__auto___4109 = cljs.core.chunk_first.call(null, seq__4094_4108__$1);
+          var G__4110 = cljs.core.chunk_rest.call(null, seq__4094_4108__$1);
+          var G__4111 = c__3073__auto___4109;
+          var G__4112 = cljs.core.count.call(null, c__3073__auto___4109);
+          var G__4113 = 0;
+          seq__4094_4098 = G__4110;
+          chunk__4095_4099 = G__4111;
+          count__4096_4100 = G__4112;
+          i__4097_4101 = G__4113;
+          continue
+        }else {
+          var o_4114 = cljs.core.first.call(null, seq__4094_4108__$1);
+          cljs.core._write.call(null, writer, sep);
+          print_one.call(null, o_4114, writer, opts);
+          var G__4115 = cljs.core.next.call(null, seq__4094_4108__$1);
+          var G__4116 = null;
+          var G__4117 = 0;
+          var G__4118 = 0;
+          seq__4094_4098 = G__4115;
+          chunk__4095_4099 = G__4116;
+          count__4096_4100 = G__4117;
+          i__4097_4101 = G__4118;
+          continue
+        }
+      }else {
+      }
+    }
+    break
+  }
+  return cljs.core._write.call(null, writer, end)
+};
+cljs.core.write_all = function() {
+  var write_all__delegate = function(writer, ss) {
+    var seq__4123 = cljs.core.seq.call(null, ss);
+    var chunk__4124 = null;
+    var count__4125 = 0;
+    var i__4126 = 0;
+    while(true) {
+      if(i__4126 < count__4125) {
+        var s = cljs.core._nth.call(null, chunk__4124, i__4126);
+        cljs.core._write.call(null, writer, s);
+        var G__4127 = seq__4123;
+        var G__4128 = chunk__4124;
+        var G__4129 = count__4125;
+        var G__4130 = i__4126 + 1;
+        seq__4123 = G__4127;
+        chunk__4124 = G__4128;
+        count__4125 = G__4129;
+        i__4126 = G__4130;
+        continue
+      }else {
+        var temp__4092__auto__ = cljs.core.seq.call(null, seq__4123);
+        if(temp__4092__auto__) {
+          var seq__4123__$1 = temp__4092__auto__;
+          if(cljs.core.chunked_seq_QMARK_.call(null, seq__4123__$1)) {
+            var c__3073__auto__ = cljs.core.chunk_first.call(null, seq__4123__$1);
+            var G__4131 = cljs.core.chunk_rest.call(null, seq__4123__$1);
+            var G__4132 = c__3073__auto__;
+            var G__4133 = cljs.core.count.call(null, c__3073__auto__);
+            var G__4134 = 0;
+            seq__4123 = G__4131;
+            chunk__4124 = G__4132;
+            count__4125 = G__4133;
+            i__4126 = G__4134;
+            continue
+          }else {
+            var s = cljs.core.first.call(null, seq__4123__$1);
+            cljs.core._write.call(null, writer, s);
+            var G__4135 = cljs.core.next.call(null, seq__4123__$1);
+            var G__4136 = null;
+            var G__4137 = 0;
+            var G__4138 = 0;
+            seq__4123 = G__4135;
+            chunk__4124 = G__4136;
+            count__4125 = G__4137;
+            i__4126 = G__4138;
+            continue
+          }
+        }else {
+          return null
+        }
+      }
+      break
+    }
+  };
+  var write_all = function(writer, var_args) {
+    var ss = null;
+    if(arguments.length > 1) {
+      ss = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return write_all__delegate.call(this, writer, ss)
+  };
+  write_all.cljs$lang$maxFixedArity = 1;
+  write_all.cljs$lang$applyTo = function(arglist__4139) {
+    var writer = cljs.core.first(arglist__4139);
+    var ss = cljs.core.rest(arglist__4139);
+    return write_all__delegate(writer, ss)
+  };
+  write_all.cljs$core$IFn$_invoke$arity$variadic = write_all__delegate;
+  return write_all
+}();
+cljs.core.string_print = function string_print(x) {
+  cljs.core._STAR_print_fn_STAR_.call(null, x);
+  return null
+};
+cljs.core.flush = function flush() {
+  return null
+};
+cljs.core.char_escapes = {'"':'\\"', "\\":"\\\\", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t"};
+cljs.core.quote_string = function quote_string(s) {
+  return[cljs.core.str('"'), cljs.core.str(s.replace(RegExp('[\\\\"\b\f\n\r\t]', "g"), function(match) {
+    return cljs.core.char_escapes[match]
+  })), cljs.core.str('"')].join("")
+};
+cljs.core.pr_writer = function pr_writer(obj, writer, opts) {
+  if(obj == null) {
+    return cljs.core._write.call(null, writer, "nil")
+  }else {
+    if(void 0 === obj) {
+      return cljs.core._write.call(null, writer, "#<undefined>")
+    }else {
+      if("\ufdd0:else") {
+        if(cljs.core.truth_(function() {
+          var and__3941__auto__ = cljs.core.get.call(null, opts, "\ufdd0:meta");
+          if(cljs.core.truth_(and__3941__auto__)) {
+            var and__3941__auto____$1 = function() {
+              var G__4142 = obj;
+              if(G__4142) {
+                if(function() {
+                  var or__3943__auto__ = G__4142.cljs$lang$protocol_mask$partition0$ & 131072;
+                  if(or__3943__auto__) {
+                    return or__3943__auto__
+                  }else {
+                    return G__4142.cljs$core$IMeta$
+                  }
+                }()) {
+                  return true
+                }else {
+                  if(!G__4142.cljs$lang$protocol_mask$partition0$) {
+                    return cljs.core.type_satisfies_.call(null, cljs.core.IMeta, G__4142)
+                  }else {
+                    return false
+                  }
+                }
+              }else {
+                return cljs.core.type_satisfies_.call(null, cljs.core.IMeta, G__4142)
+              }
+            }();
+            if(cljs.core.truth_(and__3941__auto____$1)) {
+              return cljs.core.meta.call(null, obj)
+            }else {
+              return and__3941__auto____$1
+            }
+          }else {
+            return and__3941__auto__
+          }
+        }())) {
+          cljs.core._write.call(null, writer, "^");
+          pr_writer.call(null, cljs.core.meta.call(null, obj), writer, opts);
+          cljs.core._write.call(null, writer, " ")
+        }else {
+        }
+        if(obj == null) {
+          return cljs.core._write.call(null, writer, "nil")
+        }else {
+          if(obj.cljs$lang$type) {
+            return obj.cljs$lang$ctorPrWriter(obj, writer, opts)
+          }else {
+            if(function() {
+              var G__4143 = obj;
+              if(G__4143) {
+                if(function() {
+                  var or__3943__auto__ = G__4143.cljs$lang$protocol_mask$partition0$ & 2147483648;
+                  if(or__3943__auto__) {
+                    return or__3943__auto__
+                  }else {
+                    return G__4143.cljs$core$IPrintWithWriter$
+                  }
+                }()) {
+                  return true
+                }else {
+                  return false
+                }
+              }else {
+                return false
+              }
+            }()) {
+              return cljs.core._pr_writer.call(null, obj, writer, opts)
+            }else {
+              if(function() {
+                var or__3943__auto__ = cljs.core.type.call(null, obj) === Boolean;
+                if(or__3943__auto__) {
+                  return or__3943__auto__
+                }else {
+                  return typeof obj === "number"
+                }
+              }()) {
+                return cljs.core._write.call(null, writer, [cljs.core.str(obj)].join(""))
+              }else {
+                if(obj instanceof Array) {
+                  return cljs.core.pr_sequential_writer.call(null, writer, pr_writer, "#<Array [", ", ", "]>", opts, obj)
+                }else {
+                  if(goog.isString(obj)) {
+                    if(cljs.core.keyword_QMARK_.call(null, obj)) {
+                      cljs.core._write.call(null, writer, ":");
+                      var temp__4092__auto___4144 = cljs.core.namespace.call(null, obj);
+                      if(cljs.core.truth_(temp__4092__auto___4144)) {
+                        var nspc_4145 = temp__4092__auto___4144;
+                        cljs.core.write_all.call(null, writer, [cljs.core.str(nspc_4145)].join(""), "/")
+                      }else {
+                      }
+                      return cljs.core._write.call(null, writer, cljs.core.name.call(null, obj))
+                    }else {
+                      if(obj instanceof cljs.core.Symbol) {
+                        var temp__4092__auto___4146 = cljs.core.namespace.call(null, obj);
+                        if(cljs.core.truth_(temp__4092__auto___4146)) {
+                          var nspc_4147 = temp__4092__auto___4146;
+                          cljs.core.write_all.call(null, writer, [cljs.core.str(nspc_4147)].join(""), "/")
+                        }else {
+                        }
+                        return cljs.core._write.call(null, writer, cljs.core.name.call(null, obj))
+                      }else {
+                        if("\ufdd0:else") {
+                          if(cljs.core.truth_((new cljs.core.Keyword("\ufdd0:readably")).call(null, opts))) {
+                            return cljs.core._write.call(null, writer, cljs.core.quote_string.call(null, obj))
+                          }else {
+                            return cljs.core._write.call(null, writer, obj)
+                          }
+                        }else {
+                          return null
+                        }
+                      }
+                    }
+                  }else {
+                    if(cljs.core.fn_QMARK_.call(null, obj)) {
+                      return cljs.core.write_all.call(null, writer, "#<", [cljs.core.str(obj)].join(""), ">")
+                    }else {
+                      if(obj instanceof Date) {
+                        var normalize = function(n, len) {
+                          var ns = [cljs.core.str(n)].join("");
+                          while(true) {
+                            if(cljs.core.count.call(null, ns) < len) {
+                              var G__4148 = [cljs.core.str("0"), cljs.core.str(ns)].join("");
+                              ns = G__4148;
+                              continue
+                            }else {
+                              return ns
+                            }
+                            break
+                          }
+                        };
+                        return cljs.core.write_all.call(null, writer, '#inst "', [cljs.core.str(obj.getUTCFullYear())].join(""), "-", normalize.call(null, obj.getUTCMonth() + 1, 2), "-", normalize.call(null, obj.getUTCDate(), 2), "T", normalize.call(null, obj.getUTCHours(), 2), ":", normalize.call(null, obj.getUTCMinutes(), 2), ":", normalize.call(null, obj.getUTCSeconds(), 2), ".", normalize.call(null, obj.getUTCMilliseconds(), 3), "-", '00:00"')
+                      }else {
+                        if(cljs.core.truth_(cljs.core.regexp_QMARK_.call(null, obj))) {
+                          return cljs.core.write_all.call(null, writer, '#"', obj.source, '"')
+                        }else {
+                          if("\ufdd0:else") {
+                            return cljs.core.write_all.call(null, writer, "#<", [cljs.core.str(obj)].join(""), ">")
+                          }else {
+                            return null
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }else {
+        return null
+      }
+    }
+  }
+};
+cljs.core.pr_seq_writer = function pr_seq_writer(objs, writer, opts) {
+  cljs.core.pr_writer.call(null, cljs.core.first.call(null, objs), writer, opts);
+  var seq__4153 = cljs.core.seq.call(null, cljs.core.next.call(null, objs));
+  var chunk__4154 = null;
+  var count__4155 = 0;
+  var i__4156 = 0;
+  while(true) {
+    if(i__4156 < count__4155) {
+      var obj = cljs.core._nth.call(null, chunk__4154, i__4156);
+      cljs.core._write.call(null, writer, " ");
+      cljs.core.pr_writer.call(null, obj, writer, opts);
+      var G__4157 = seq__4153;
+      var G__4158 = chunk__4154;
+      var G__4159 = count__4155;
+      var G__4160 = i__4156 + 1;
+      seq__4153 = G__4157;
+      chunk__4154 = G__4158;
+      count__4155 = G__4159;
+      i__4156 = G__4160;
+      continue
+    }else {
+      var temp__4092__auto__ = cljs.core.seq.call(null, seq__4153);
+      if(temp__4092__auto__) {
+        var seq__4153__$1 = temp__4092__auto__;
+        if(cljs.core.chunked_seq_QMARK_.call(null, seq__4153__$1)) {
+          var c__3073__auto__ = cljs.core.chunk_first.call(null, seq__4153__$1);
+          var G__4161 = cljs.core.chunk_rest.call(null, seq__4153__$1);
+          var G__4162 = c__3073__auto__;
+          var G__4163 = cljs.core.count.call(null, c__3073__auto__);
+          var G__4164 = 0;
+          seq__4153 = G__4161;
+          chunk__4154 = G__4162;
+          count__4155 = G__4163;
+          i__4156 = G__4164;
+          continue
+        }else {
+          var obj = cljs.core.first.call(null, seq__4153__$1);
+          cljs.core._write.call(null, writer, " ");
+          cljs.core.pr_writer.call(null, obj, writer, opts);
+          var G__4165 = cljs.core.next.call(null, seq__4153__$1);
+          var G__4166 = null;
+          var G__4167 = 0;
+          var G__4168 = 0;
+          seq__4153 = G__4165;
+          chunk__4154 = G__4166;
+          count__4155 = G__4167;
+          i__4156 = G__4168;
+          continue
+        }
+      }else {
+        return null
+      }
+    }
+    break
+  }
+};
+cljs.core.pr_sb_with_opts = function pr_sb_with_opts(objs, opts) {
+  var sb = new goog.string.StringBuffer;
+  var writer = new cljs.core.StringBufferWriter(sb);
+  cljs.core.pr_seq_writer.call(null, objs, writer, opts);
+  cljs.core._flush.call(null, writer);
+  return sb
+};
+cljs.core.pr_str_with_opts = function pr_str_with_opts(objs, opts) {
+  if(cljs.core.empty_QMARK_.call(null, objs)) {
+    return""
+  }else {
+    return[cljs.core.str(cljs.core.pr_sb_with_opts.call(null, objs, opts))].join("")
+  }
+};
+cljs.core.prn_str_with_opts = function prn_str_with_opts(objs, opts) {
+  if(cljs.core.empty_QMARK_.call(null, objs)) {
+    return"\n"
+  }else {
+    var sb = cljs.core.pr_sb_with_opts.call(null, objs, opts);
+    sb.append("\n");
+    return[cljs.core.str(sb)].join("")
+  }
+};
+cljs.core.pr_with_opts = function pr_with_opts(objs, opts) {
+  return cljs.core.string_print.call(null, cljs.core.pr_str_with_opts.call(null, objs, opts))
+};
+cljs.core.newline = function newline(opts) {
+  cljs.core.string_print.call(null, "\n");
+  if(cljs.core.truth_(cljs.core.get.call(null, opts, "\ufdd0:flush-on-newline"))) {
+    return cljs.core.flush.call(null)
+  }else {
+    return null
+  }
+};
+cljs.core.pr_str = function() {
+  var pr_str__delegate = function(objs) {
+    return cljs.core.pr_str_with_opts.call(null, objs, cljs.core.pr_opts.call(null))
+  };
+  var pr_str = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return pr_str__delegate.call(this, objs)
+  };
+  pr_str.cljs$lang$maxFixedArity = 0;
+  pr_str.cljs$lang$applyTo = function(arglist__4169) {
+    var objs = cljs.core.seq(arglist__4169);
+    return pr_str__delegate(objs)
+  };
+  pr_str.cljs$core$IFn$_invoke$arity$variadic = pr_str__delegate;
+  return pr_str
+}();
+cljs.core.prn_str = function() {
+  var prn_str__delegate = function(objs) {
+    return cljs.core.prn_str_with_opts.call(null, objs, cljs.core.pr_opts.call(null))
+  };
+  var prn_str = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return prn_str__delegate.call(this, objs)
+  };
+  prn_str.cljs$lang$maxFixedArity = 0;
+  prn_str.cljs$lang$applyTo = function(arglist__4170) {
+    var objs = cljs.core.seq(arglist__4170);
+    return prn_str__delegate(objs)
+  };
+  prn_str.cljs$core$IFn$_invoke$arity$variadic = prn_str__delegate;
+  return prn_str
+}();
+cljs.core.pr = function() {
+  var pr__delegate = function(objs) {
+    return cljs.core.pr_with_opts.call(null, objs, cljs.core.pr_opts.call(null))
+  };
+  var pr = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return pr__delegate.call(this, objs)
+  };
+  pr.cljs$lang$maxFixedArity = 0;
+  pr.cljs$lang$applyTo = function(arglist__4171) {
+    var objs = cljs.core.seq(arglist__4171);
+    return pr__delegate(objs)
+  };
+  pr.cljs$core$IFn$_invoke$arity$variadic = pr__delegate;
+  return pr
+}();
+cljs.core.print = function() {
+  var cljs_core_print__delegate = function(objs) {
+    return cljs.core.pr_with_opts.call(null, objs, cljs.core.assoc.call(null, cljs.core.pr_opts.call(null), "\ufdd0:readably", false))
+  };
+  var cljs_core_print = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return cljs_core_print__delegate.call(this, objs)
+  };
+  cljs_core_print.cljs$lang$maxFixedArity = 0;
+  cljs_core_print.cljs$lang$applyTo = function(arglist__4172) {
+    var objs = cljs.core.seq(arglist__4172);
+    return cljs_core_print__delegate(objs)
+  };
+  cljs_core_print.cljs$core$IFn$_invoke$arity$variadic = cljs_core_print__delegate;
+  return cljs_core_print
+}();
+cljs.core.print_str = function() {
+  var print_str__delegate = function(objs) {
+    return cljs.core.pr_str_with_opts.call(null, objs, cljs.core.assoc.call(null, cljs.core.pr_opts.call(null), "\ufdd0:readably", false))
+  };
+  var print_str = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return print_str__delegate.call(this, objs)
+  };
+  print_str.cljs$lang$maxFixedArity = 0;
+  print_str.cljs$lang$applyTo = function(arglist__4173) {
+    var objs = cljs.core.seq(arglist__4173);
+    return print_str__delegate(objs)
+  };
+  print_str.cljs$core$IFn$_invoke$arity$variadic = print_str__delegate;
+  return print_str
+}();
+cljs.core.println = function() {
+  var println__delegate = function(objs) {
+    cljs.core.pr_with_opts.call(null, objs, cljs.core.assoc.call(null, cljs.core.pr_opts.call(null), "\ufdd0:readably", false));
+    return cljs.core.newline.call(null, cljs.core.pr_opts.call(null))
+  };
+  var println = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return println__delegate.call(this, objs)
+  };
+  println.cljs$lang$maxFixedArity = 0;
+  println.cljs$lang$applyTo = function(arglist__4174) {
+    var objs = cljs.core.seq(arglist__4174);
+    return println__delegate(objs)
+  };
+  println.cljs$core$IFn$_invoke$arity$variadic = println__delegate;
+  return println
+}();
+cljs.core.println_str = function() {
+  var println_str__delegate = function(objs) {
+    return cljs.core.prn_str_with_opts.call(null, objs, cljs.core.assoc.call(null, cljs.core.pr_opts.call(null), "\ufdd0:readably", false))
+  };
+  var println_str = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return println_str__delegate.call(this, objs)
+  };
+  println_str.cljs$lang$maxFixedArity = 0;
+  println_str.cljs$lang$applyTo = function(arglist__4175) {
+    var objs = cljs.core.seq(arglist__4175);
+    return println_str__delegate(objs)
+  };
+  println_str.cljs$core$IFn$_invoke$arity$variadic = println_str__delegate;
+  return println_str
+}();
+cljs.core.prn = function() {
+  var prn__delegate = function(objs) {
+    cljs.core.pr_with_opts.call(null, objs, cljs.core.pr_opts.call(null));
+    return cljs.core.newline.call(null, cljs.core.pr_opts.call(null))
+  };
+  var prn = function(var_args) {
+    var objs = null;
+    if(arguments.length > 0) {
+      objs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+    }
+    return prn__delegate.call(this, objs)
+  };
+  prn.cljs$lang$maxFixedArity = 0;
+  prn.cljs$lang$applyTo = function(arglist__4176) {
+    var objs = cljs.core.seq(arglist__4176);
+    return prn__delegate(objs)
+  };
+  prn.cljs$core$IFn$_invoke$arity$variadic = prn__delegate;
+  return prn
+}();
+cljs.core.printf = function() {
+  var printf__delegate = function(fmt, args) {
+    return cljs.core.print.call(null, cljs.core.apply.call(null, cljs.core.format, fmt, args))
+  };
+  var printf = function(fmt, var_args) {
+    var args = null;
+    if(arguments.length > 1) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return printf__delegate.call(this, fmt, args)
+  };
+  printf.cljs$lang$maxFixedArity = 1;
+  printf.cljs$lang$applyTo = function(arglist__4177) {
+    var fmt = cljs.core.first(arglist__4177);
+    var args = cljs.core.rest(arglist__4177);
+    return printf__delegate(fmt, args)
+  };
+  printf.cljs$core$IFn$_invoke$arity$variadic = printf__delegate;
+  return printf
+}();
+cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll)
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var pr_pair = function(keyval) {
+    return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "", " ", "", opts, keyval)
+  };
+  return cljs.core.pr_sequential_writer.call(null, writer, pr_pair, "{", ", ", "}", opts, coll)
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var pr_pair = function(keyval) {
+    return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "", " ", "", opts, keyval)
+  };
+  return cljs.core.pr_sequential_writer.call(null, writer, pr_pair, "{", ", ", "}", opts, coll)
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#queue [", " ", "]", opts, cljs.core.seq.call(null, coll))
+};
+cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#{", " ", "}", opts, coll)
+};
+cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll)
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var pr_pair = function(keyval) {
+    return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "", " ", "", opts, keyval)
+  };
+  return cljs.core.pr_sequential_writer.call(null, writer, pr_pair, "{", ", ", "}", opts, coll)
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#{", " ", "}", opts, coll)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll)
+};
+cljs.core.List.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.List.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core._write.call(null, writer, "()")
+};
+cljs.core.BlackNode.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.BlackNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll)
+};
+cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.Range.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.Range.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var pr_pair = function(keyval) {
+    return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "", " ", "", opts, keyval)
+  };
+  return cljs.core.pr_sequential_writer.call(null, writer, pr_pair, "{", ", ", "}", opts, coll)
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll)
+};
+cljs.core.PersistentVector.prototype.cljs$core$IComparable$ = true;
+cljs.core.PersistentVector.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
+  return cljs.core.compare_indexed.call(null, x, y)
+};
+cljs.core.Subvec.prototype.cljs$core$IComparable$ = true;
+cljs.core.Subvec.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
+  return cljs.core.compare_indexed.call(null, x, y)
+};
+goog.provide("cljs.core.Atom");
+cljs.core.Atom = function(state, meta, validator, watches) {
+  this.state = state;
+  this.meta = meta;
+  this.validator = validator;
+  this.watches = watches;
+  this.cljs$lang$protocol_mask$partition0$ = 2153938944;
+  this.cljs$lang$protocol_mask$partition1$ = 2
+};
+cljs.core.Atom.cljs$lang$type = true;
+cljs.core.Atom.cljs$lang$ctorStr = "cljs.core/Atom";
+cljs.core.Atom.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Atom")
+};
+cljs.core.Atom.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
+  var self__ = this;
+  return goog.getUid(this$)
+};
+cljs.core.Atom.prototype.cljs$core$IWatchable$_notify_watches$arity$3 = function(this$, oldval, newval) {
+  var self__ = this;
+  var seq__4178 = cljs.core.seq.call(null, self__.watches);
+  var chunk__4179 = null;
+  var count__4180 = 0;
+  var i__4181 = 0;
+  while(true) {
+    if(i__4181 < count__4180) {
+      var vec__4182 = cljs.core._nth.call(null, chunk__4179, i__4181);
+      var key = cljs.core.nth.call(null, vec__4182, 0, null);
+      var f = cljs.core.nth.call(null, vec__4182, 1, null);
+      f.call(null, key, this$, oldval, newval);
+      var G__4184 = seq__4178;
+      var G__4185 = chunk__4179;
+      var G__4186 = count__4180;
+      var G__4187 = i__4181 + 1;
+      seq__4178 = G__4184;
+      chunk__4179 = G__4185;
+      count__4180 = G__4186;
+      i__4181 = G__4187;
+      continue
+    }else {
+      var temp__4092__auto__ = cljs.core.seq.call(null, seq__4178);
+      if(temp__4092__auto__) {
+        var seq__4178__$1 = temp__4092__auto__;
+        if(cljs.core.chunked_seq_QMARK_.call(null, seq__4178__$1)) {
+          var c__3073__auto__ = cljs.core.chunk_first.call(null, seq__4178__$1);
+          var G__4188 = cljs.core.chunk_rest.call(null, seq__4178__$1);
+          var G__4189 = c__3073__auto__;
+          var G__4190 = cljs.core.count.call(null, c__3073__auto__);
+          var G__4191 = 0;
+          seq__4178 = G__4188;
+          chunk__4179 = G__4189;
+          count__4180 = G__4190;
+          i__4181 = G__4191;
+          continue
+        }else {
+          var vec__4183 = cljs.core.first.call(null, seq__4178__$1);
+          var key = cljs.core.nth.call(null, vec__4183, 0, null);
+          var f = cljs.core.nth.call(null, vec__4183, 1, null);
+          f.call(null, key, this$, oldval, newval);
+          var G__4192 = cljs.core.next.call(null, seq__4178__$1);
+          var G__4193 = null;
+          var G__4194 = 0;
+          var G__4195 = 0;
+          seq__4178 = G__4192;
+          chunk__4179 = G__4193;
+          count__4180 = G__4194;
+          i__4181 = G__4195;
+          continue
+        }
+      }else {
+        return null
+      }
+    }
+    break
+  }
+};
+cljs.core.Atom.prototype.cljs$core$IWatchable$_add_watch$arity$3 = function(this$, key, f) {
+  var self__ = this;
+  return this$.watches = cljs.core.assoc.call(null, self__.watches, key, f)
+};
+cljs.core.Atom.prototype.cljs$core$IWatchable$_remove_watch$arity$2 = function(this$, key) {
+  var self__ = this;
+  return this$.watches = cljs.core.dissoc.call(null, self__.watches, key)
+};
+cljs.core.Atom.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(a, writer, opts) {
+  var self__ = this;
+  cljs.core._write.call(null, writer, "#<Atom: ");
+  cljs.core.pr_writer.call(null, self__.state, writer, opts);
+  return cljs.core._write.call(null, writer, ">")
+};
+cljs.core.Atom.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
+  var self__ = this;
+  return self__.meta
+};
+cljs.core.Atom.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
+  var self__ = this;
+  return self__.state
+};
+cljs.core.Atom.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
+  var self__ = this;
+  return o === other
+};
+cljs.core.atom = function() {
+  var atom = null;
+  var atom__1 = function(x) {
+    return new cljs.core.Atom(x, null, null, null)
+  };
+  var atom__2 = function() {
+    var G__4199__delegate = function(x, p__4196) {
+      var map__4198 = p__4196;
+      var map__4198__$1 = cljs.core.seq_QMARK_.call(null, map__4198) ? cljs.core.apply.call(null, cljs.core.hash_map, map__4198) : map__4198;
+      var validator = cljs.core.get.call(null, map__4198__$1, "\ufdd0:validator");
+      var meta = cljs.core.get.call(null, map__4198__$1, "\ufdd0:meta");
+      return new cljs.core.Atom(x, meta, validator, null)
+    };
+    var G__4199 = function(x, var_args) {
+      var p__4196 = null;
+      if(arguments.length > 1) {
+        p__4196 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+      }
+      return G__4199__delegate.call(this, x, p__4196)
+    };
+    G__4199.cljs$lang$maxFixedArity = 1;
+    G__4199.cljs$lang$applyTo = function(arglist__4200) {
+      var x = cljs.core.first(arglist__4200);
+      var p__4196 = cljs.core.rest(arglist__4200);
+      return G__4199__delegate(x, p__4196)
+    };
+    G__4199.cljs$core$IFn$_invoke$arity$variadic = G__4199__delegate;
+    return G__4199
+  }();
+  atom = function(x, var_args) {
+    var p__4196 = var_args;
+    switch(arguments.length) {
+      case 1:
+        return atom__1.call(this, x);
+      default:
+        return atom__2.cljs$core$IFn$_invoke$arity$variadic(x, cljs.core.array_seq(arguments, 1))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  atom.cljs$lang$maxFixedArity = 1;
+  atom.cljs$lang$applyTo = atom__2.cljs$lang$applyTo;
+  atom.cljs$core$IFn$_invoke$arity$1 = atom__1;
+  atom.cljs$core$IFn$_invoke$arity$variadic = atom__2.cljs$core$IFn$_invoke$arity$variadic;
+  return atom
+}();
+cljs.core.reset_BANG_ = function reset_BANG_(a, new_value) {
+  var temp__4092__auto___4201 = a.validator;
+  if(cljs.core.truth_(temp__4092__auto___4201)) {
+    var validate_4202 = temp__4092__auto___4201;
+    if(cljs.core.truth_(validate_4202.call(null, new_value))) {
+    }else {
+      throw new Error([cljs.core.str("Assert failed: "), cljs.core.str("Validator rejected reference state"), cljs.core.str("\n"), cljs.core.str(cljs.core.pr_str.call(null, cljs.core.with_meta(cljs.core.list(new cljs.core.Symbol(null, "validate", "validate", 1233162959, null), new cljs.core.Symbol(null, "new-value", "new-value", 972165309, null)), cljs.core.hash_map("\ufdd0:line", 6673, "\ufdd0:column", 13))))].join(""));
+    }
+  }else {
+  }
+  var old_value_4203 = a.state;
+  a.state = new_value;
+  cljs.core._notify_watches.call(null, a, old_value_4203, new_value);
+  return new_value
+};
+cljs.core.swap_BANG_ = function() {
+  var swap_BANG_ = null;
+  var swap_BANG___2 = function(a, f) {
+    return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state))
+  };
+  var swap_BANG___3 = function(a, f, x) {
+    return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state, x))
+  };
+  var swap_BANG___4 = function(a, f, x, y) {
+    return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state, x, y))
+  };
+  var swap_BANG___5 = function(a, f, x, y, z) {
+    return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state, x, y, z))
+  };
+  var swap_BANG___6 = function() {
+    var G__4204__delegate = function(a, f, x, y, z, more) {
+      return cljs.core.reset_BANG_.call(null, a, cljs.core.apply.call(null, f, a.state, x, y, z, more))
+    };
+    var G__4204 = function(a, f, x, y, z, var_args) {
+      var more = null;
+      if(arguments.length > 5) {
+        more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 5), 0)
+      }
+      return G__4204__delegate.call(this, a, f, x, y, z, more)
+    };
+    G__4204.cljs$lang$maxFixedArity = 5;
+    G__4204.cljs$lang$applyTo = function(arglist__4205) {
+      var a = cljs.core.first(arglist__4205);
+      arglist__4205 = cljs.core.next(arglist__4205);
+      var f = cljs.core.first(arglist__4205);
+      arglist__4205 = cljs.core.next(arglist__4205);
+      var x = cljs.core.first(arglist__4205);
+      arglist__4205 = cljs.core.next(arglist__4205);
+      var y = cljs.core.first(arglist__4205);
+      arglist__4205 = cljs.core.next(arglist__4205);
+      var z = cljs.core.first(arglist__4205);
+      var more = cljs.core.rest(arglist__4205);
+      return G__4204__delegate(a, f, x, y, z, more)
+    };
+    G__4204.cljs$core$IFn$_invoke$arity$variadic = G__4204__delegate;
+    return G__4204
+  }();
+  swap_BANG_ = function(a, f, x, y, z, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 2:
+        return swap_BANG___2.call(this, a, f);
+      case 3:
+        return swap_BANG___3.call(this, a, f, x);
+      case 4:
+        return swap_BANG___4.call(this, a, f, x, y);
+      case 5:
+        return swap_BANG___5.call(this, a, f, x, y, z);
+      default:
+        return swap_BANG___6.cljs$core$IFn$_invoke$arity$variadic(a, f, x, y, z, cljs.core.array_seq(arguments, 5))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  swap_BANG_.cljs$lang$maxFixedArity = 5;
+  swap_BANG_.cljs$lang$applyTo = swap_BANG___6.cljs$lang$applyTo;
+  swap_BANG_.cljs$core$IFn$_invoke$arity$2 = swap_BANG___2;
+  swap_BANG_.cljs$core$IFn$_invoke$arity$3 = swap_BANG___3;
+  swap_BANG_.cljs$core$IFn$_invoke$arity$4 = swap_BANG___4;
+  swap_BANG_.cljs$core$IFn$_invoke$arity$5 = swap_BANG___5;
+  swap_BANG_.cljs$core$IFn$_invoke$arity$variadic = swap_BANG___6.cljs$core$IFn$_invoke$arity$variadic;
+  return swap_BANG_
+}();
+cljs.core.compare_and_set_BANG_ = function compare_and_set_BANG_(a, oldval, newval) {
+  if(cljs.core._EQ_.call(null, a.state, oldval)) {
+    cljs.core.reset_BANG_.call(null, a, newval);
+    return true
+  }else {
+    return false
+  }
+};
+cljs.core.deref = function deref(o) {
+  return cljs.core._deref.call(null, o)
+};
+cljs.core.set_validator_BANG_ = function set_validator_BANG_(iref, val) {
+  return iref.validator = val
+};
+cljs.core.get_validator = function get_validator(iref) {
+  return iref.validator
+};
+cljs.core.alter_meta_BANG_ = function() {
+  var alter_meta_BANG___delegate = function(iref, f, args) {
+    return iref.meta = cljs.core.apply.call(null, f, iref.meta, args)
+  };
+  var alter_meta_BANG_ = function(iref, f, var_args) {
+    var args = null;
+    if(arguments.length > 2) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0)
+    }
+    return alter_meta_BANG___delegate.call(this, iref, f, args)
+  };
+  alter_meta_BANG_.cljs$lang$maxFixedArity = 2;
+  alter_meta_BANG_.cljs$lang$applyTo = function(arglist__4206) {
+    var iref = cljs.core.first(arglist__4206);
+    arglist__4206 = cljs.core.next(arglist__4206);
+    var f = cljs.core.first(arglist__4206);
+    var args = cljs.core.rest(arglist__4206);
+    return alter_meta_BANG___delegate(iref, f, args)
+  };
+  alter_meta_BANG_.cljs$core$IFn$_invoke$arity$variadic = alter_meta_BANG___delegate;
+  return alter_meta_BANG_
+}();
+cljs.core.reset_meta_BANG_ = function reset_meta_BANG_(iref, m) {
+  return iref.meta = m
+};
+cljs.core.add_watch = function add_watch(iref, key, f) {
+  return cljs.core._add_watch.call(null, iref, key, f)
+};
+cljs.core.remove_watch = function remove_watch(iref, key) {
+  return cljs.core._remove_watch.call(null, iref, key)
+};
+cljs.core.gensym_counter = null;
+cljs.core.gensym = function() {
+  var gensym = null;
+  var gensym__0 = function() {
+    return gensym.call(null, "G__")
+  };
+  var gensym__1 = function(prefix_string) {
+    if(cljs.core.gensym_counter == null) {
+      cljs.core.gensym_counter = cljs.core.atom.call(null, 0)
+    }else {
+    }
+    return cljs.core.symbol.call(null, [cljs.core.str(prefix_string), cljs.core.str(cljs.core.swap_BANG_.call(null, cljs.core.gensym_counter, cljs.core.inc))].join(""))
+  };
+  gensym = function(prefix_string) {
+    switch(arguments.length) {
+      case 0:
+        return gensym__0.call(this);
+      case 1:
+        return gensym__1.call(this, prefix_string)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  gensym.cljs$core$IFn$_invoke$arity$0 = gensym__0;
+  gensym.cljs$core$IFn$_invoke$arity$1 = gensym__1;
+  return gensym
+}();
+cljs.core.fixture1 = 1;
+cljs.core.fixture2 = 2;
+goog.provide("cljs.core.Delay");
+cljs.core.Delay = function(state, f) {
+  this.state = state;
+  this.f = f;
+  this.cljs$lang$protocol_mask$partition1$ = 1;
+  this.cljs$lang$protocol_mask$partition0$ = 32768
+};
+cljs.core.Delay.cljs$lang$type = true;
+cljs.core.Delay.cljs$lang$ctorStr = "cljs.core/Delay";
+cljs.core.Delay.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/Delay")
+};
+cljs.core.Delay.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = function(d) {
+  var self__ = this;
+  return(new cljs.core.Keyword("\ufdd0:done")).call(null, cljs.core.deref.call(null, self__.state))
+};
+cljs.core.Delay.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
+  var self__ = this;
+  return(new cljs.core.Keyword("\ufdd0:value")).call(null, cljs.core.swap_BANG_.call(null, self__.state, function(p__4207) {
+    var map__4208 = p__4207;
+    var map__4208__$1 = cljs.core.seq_QMARK_.call(null, map__4208) ? cljs.core.apply.call(null, cljs.core.hash_map, map__4208) : map__4208;
+    var curr_state = map__4208__$1;
+    var done = cljs.core.get.call(null, map__4208__$1, "\ufdd0:done");
+    if(cljs.core.truth_(done)) {
+      return curr_state
+    }else {
+      return cljs.core.PersistentArrayMap.fromArray(["\ufdd0:done", true, "\ufdd0:value", self__.f.call(null)], true)
+    }
+  }))
+};
+cljs.core.delay_QMARK_ = function delay_QMARK_(x) {
+  return x instanceof cljs.core.Delay
+};
+cljs.core.force = function force(x) {
+  if(cljs.core.delay_QMARK_.call(null, x)) {
+    return cljs.core.deref.call(null, x)
+  }else {
+    return x
+  }
+};
+cljs.core.realized_QMARK_ = function realized_QMARK_(d) {
+  return cljs.core._realized_QMARK_.call(null, d)
+};
+cljs.core.IEncodeJS = {};
+cljs.core._clj__GT_js = function _clj__GT_js(x) {
+  if(function() {
+    var and__3941__auto__ = x;
+    if(and__3941__auto__) {
+      return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x)
+  }else {
+    var x__2942__auto__ = x == null ? null : x;
+    return function() {
+      var or__3943__auto__ = cljs.core._clj__GT_js[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._clj__GT_js["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IEncodeJS.-clj->js", x);
+        }
+      }
+    }().call(null, x)
+  }
+};
+cljs.core._key__GT_js = function _key__GT_js(x) {
+  if(function() {
+    var and__3941__auto__ = x;
+    if(and__3941__auto__) {
+      return x.cljs$core$IEncodeJS$_key__GT_js$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x)
+  }else {
+    var x__2942__auto__ = x == null ? null : x;
+    return function() {
+      var or__3943__auto__ = cljs.core._key__GT_js[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._key__GT_js["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IEncodeJS.-key->js", x);
+        }
+      }
+    }().call(null, x)
+  }
+};
+cljs.core.key__GT_js = function key__GT_js(k) {
+  if(function() {
+    var G__4210 = k;
+    if(G__4210) {
+      if(cljs.core.truth_(function() {
+        var or__3943__auto__ = null;
+        if(cljs.core.truth_(or__3943__auto__)) {
+          return or__3943__auto__
+        }else {
+          return G__4210.cljs$core$IEncodeJS$
+        }
+      }())) {
+        return true
+      }else {
+        if(!G__4210.cljs$lang$protocol_mask$partition$) {
+          return cljs.core.type_satisfies_.call(null, cljs.core.IEncodeJS, G__4210)
+        }else {
+          return false
+        }
+      }
+    }else {
+      return cljs.core.type_satisfies_.call(null, cljs.core.IEncodeJS, G__4210)
+    }
+  }()) {
+    return cljs.core._clj__GT_js.call(null, k)
+  }else {
+    if(function() {
+      var or__3943__auto__ = cljs.core.string_QMARK_.call(null, k);
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = typeof k === "number";
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          var or__3943__auto____$2 = cljs.core.keyword_QMARK_.call(null, k);
+          if(or__3943__auto____$2) {
+            return or__3943__auto____$2
+          }else {
+            return k instanceof cljs.core.Symbol
+          }
+        }
+      }
+    }()) {
+      return cljs.core.clj__GT_js.call(null, k)
+    }else {
+      return cljs.core.pr_str.call(null, k)
+    }
+  }
+};
+cljs.core.clj__GT_js = function clj__GT_js(x) {
+  if(x == null) {
+    return null
+  }else {
+    if(function() {
+      var G__4218 = x;
+      if(G__4218) {
+        if(cljs.core.truth_(function() {
+          var or__3943__auto__ = null;
+          if(cljs.core.truth_(or__3943__auto__)) {
+            return or__3943__auto__
+          }else {
+            return G__4218.cljs$core$IEncodeJS$
+          }
+        }())) {
+          return true
+        }else {
+          if(!G__4218.cljs$lang$protocol_mask$partition$) {
+            return cljs.core.type_satisfies_.call(null, cljs.core.IEncodeJS, G__4218)
+          }else {
+            return false
+          }
+        }
+      }else {
+        return cljs.core.type_satisfies_.call(null, cljs.core.IEncodeJS, G__4218)
+      }
+    }()) {
+      return cljs.core._clj__GT_js.call(null, x)
+    }else {
+      if(cljs.core.keyword_QMARK_.call(null, x)) {
+        return cljs.core.name.call(null, x)
+      }else {
+        if(x instanceof cljs.core.Symbol) {
+          return[cljs.core.str(x)].join("")
+        }else {
+          if(cljs.core.map_QMARK_.call(null, x)) {
+            var m = {};
+            var seq__4219_4225 = cljs.core.seq.call(null, x);
+            var chunk__4220_4226 = null;
+            var count__4221_4227 = 0;
+            var i__4222_4228 = 0;
+            while(true) {
+              if(i__4222_4228 < count__4221_4227) {
+                var vec__4223_4229 = cljs.core._nth.call(null, chunk__4220_4226, i__4222_4228);
+                var k_4230 = cljs.core.nth.call(null, vec__4223_4229, 0, null);
+                var v_4231 = cljs.core.nth.call(null, vec__4223_4229, 1, null);
+                m[cljs.core.key__GT_js.call(null, k_4230)] = clj__GT_js.call(null, v_4231);
+                var G__4232 = seq__4219_4225;
+                var G__4233 = chunk__4220_4226;
+                var G__4234 = count__4221_4227;
+                var G__4235 = i__4222_4228 + 1;
+                seq__4219_4225 = G__4232;
+                chunk__4220_4226 = G__4233;
+                count__4221_4227 = G__4234;
+                i__4222_4228 = G__4235;
+                continue
+              }else {
+                var temp__4092__auto___4236 = cljs.core.seq.call(null, seq__4219_4225);
+                if(temp__4092__auto___4236) {
+                  var seq__4219_4237__$1 = temp__4092__auto___4236;
+                  if(cljs.core.chunked_seq_QMARK_.call(null, seq__4219_4237__$1)) {
+                    var c__3073__auto___4238 = cljs.core.chunk_first.call(null, seq__4219_4237__$1);
+                    var G__4239 = cljs.core.chunk_rest.call(null, seq__4219_4237__$1);
+                    var G__4240 = c__3073__auto___4238;
+                    var G__4241 = cljs.core.count.call(null, c__3073__auto___4238);
+                    var G__4242 = 0;
+                    seq__4219_4225 = G__4239;
+                    chunk__4220_4226 = G__4240;
+                    count__4221_4227 = G__4241;
+                    i__4222_4228 = G__4242;
+                    continue
+                  }else {
+                    var vec__4224_4243 = cljs.core.first.call(null, seq__4219_4237__$1);
+                    var k_4244 = cljs.core.nth.call(null, vec__4224_4243, 0, null);
+                    var v_4245 = cljs.core.nth.call(null, vec__4224_4243, 1, null);
+                    m[cljs.core.key__GT_js.call(null, k_4244)] = clj__GT_js.call(null, v_4245);
+                    var G__4246 = cljs.core.next.call(null, seq__4219_4237__$1);
+                    var G__4247 = null;
+                    var G__4248 = 0;
+                    var G__4249 = 0;
+                    seq__4219_4225 = G__4246;
+                    chunk__4220_4226 = G__4247;
+                    count__4221_4227 = G__4248;
+                    i__4222_4228 = G__4249;
+                    continue
+                  }
+                }else {
+                }
+              }
+              break
+            }
+            return m
+          }else {
+            if(cljs.core.coll_QMARK_.call(null, x)) {
+              return cljs.core.apply.call(null, cljs.core.array, cljs.core.map.call(null, clj__GT_js, x))
+            }else {
+              if("\ufdd0:else") {
+                return x
+              }else {
+                return null
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.IEncodeClojure = {};
+cljs.core._js__GT_clj = function _js__GT_clj(x, options) {
+  if(function() {
+    var and__3941__auto__ = x;
+    if(and__3941__auto__) {
+      return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x, options)
+  }else {
+    var x__2942__auto__ = x == null ? null : x;
+    return function() {
+      var or__3943__auto__ = cljs.core._js__GT_clj[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._js__GT_clj["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IEncodeClojure.-js->clj", x);
+        }
+      }
+    }().call(null, x, options)
+  }
+};
+cljs.core.js__GT_clj = function() {
+  var js__GT_clj = null;
+  var js__GT_clj__1 = function(x) {
+    return js__GT_clj.call(null, x, cljs.core.PersistentArrayMap.fromArray(["\ufdd0:keywordize-keys", false], true))
+  };
+  var js__GT_clj__2 = function() {
+    var G__4270__delegate = function(x, opts) {
+      if(function() {
+        var G__4260 = cljs.core.IEncodeClojure;
+        if(G__4260) {
+          if(cljs.core.truth_(function() {
+            var or__3943__auto__ = null;
+            if(cljs.core.truth_(or__3943__auto__)) {
+              return or__3943__auto__
+            }else {
+              return G__4260.cljs$core$x$
+            }
+          }())) {
+            return true
+          }else {
+            if(!G__4260.cljs$lang$protocol_mask$partition$) {
+              return cljs.core.type_satisfies_.call(null, x, G__4260)
+            }else {
+              return false
+            }
+          }
+        }else {
+          return cljs.core.type_satisfies_.call(null, x, G__4260)
+        }
+      }()) {
+        return cljs.core._js__GT_clj.call(null, x, cljs.core.apply.call(null, cljs.core.array_map, opts))
+      }else {
+        if(cljs.core.seq.call(null, opts)) {
+          var map__4261 = opts;
+          var map__4261__$1 = cljs.core.seq_QMARK_.call(null, map__4261) ? cljs.core.apply.call(null, cljs.core.hash_map, map__4261) : map__4261;
+          var keywordize_keys = cljs.core.get.call(null, map__4261__$1, "\ufdd0:keywordize-keys");
+          var keyfn = cljs.core.truth_(keywordize_keys) ? cljs.core.keyword : cljs.core.str;
+          var f = function(map__4261, map__4261__$1, keywordize_keys, keyfn) {
+            return function thisfn(x__$1) {
+              if(cljs.core.seq_QMARK_.call(null, x__$1)) {
+                return cljs.core.doall.call(null, cljs.core.map.call(null, thisfn, x__$1))
+              }else {
+                if(cljs.core.coll_QMARK_.call(null, x__$1)) {
+                  return cljs.core.into.call(null, cljs.core.empty.call(null, x__$1), cljs.core.map.call(null, thisfn, x__$1))
+                }else {
+                  if(x__$1 instanceof Array) {
+                    return cljs.core.vec.call(null, cljs.core.map.call(null, thisfn, x__$1))
+                  }else {
+                    if(cljs.core.type.call(null, x__$1) === Object) {
+                      return cljs.core.into.call(null, cljs.core.ObjMap.EMPTY, function() {
+                        var iter__3042__auto__ = function(map__4261, map__4261__$1, keywordize_keys, keyfn) {
+                          return function iter__4266(s__4267) {
+                            return new cljs.core.LazySeq(null, false, function(map__4261, map__4261__$1, keywordize_keys, keyfn) {
+                              return function() {
+                                var s__4267__$1 = s__4267;
+                                while(true) {
+                                  var temp__4092__auto__ = cljs.core.seq.call(null, s__4267__$1);
+                                  if(temp__4092__auto__) {
+                                    var s__4267__$2 = temp__4092__auto__;
+                                    if(cljs.core.chunked_seq_QMARK_.call(null, s__4267__$2)) {
+                                      var c__3040__auto__ = cljs.core.chunk_first.call(null, s__4267__$2);
+                                      var size__3041__auto__ = cljs.core.count.call(null, c__3040__auto__);
+                                      var b__4269 = cljs.core.chunk_buffer.call(null, size__3041__auto__);
+                                      if(function() {
+                                        var i__4268 = 0;
+                                        while(true) {
+                                          if(i__4268 < size__3041__auto__) {
+                                            var k = cljs.core._nth.call(null, c__3040__auto__, i__4268);
+                                            cljs.core.chunk_append.call(null, b__4269, cljs.core.PersistentVector.fromArray([keyfn.call(null, k), thisfn.call(null, x__$1[k])], true));
+                                            var G__4271 = i__4268 + 1;
+                                            i__4268 = G__4271;
+                                            continue
+                                          }else {
+                                            return true
+                                          }
+                                          break
+                                        }
+                                      }()) {
+                                        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__4269), iter__4266.call(null, cljs.core.chunk_rest.call(null, s__4267__$2)))
+                                      }else {
+                                        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__4269), null)
+                                      }
+                                    }else {
+                                      var k = cljs.core.first.call(null, s__4267__$2);
+                                      return cljs.core.cons.call(null, cljs.core.PersistentVector.fromArray([keyfn.call(null, k), thisfn.call(null, x__$1[k])], true), iter__4266.call(null, cljs.core.rest.call(null, s__4267__$2)))
+                                    }
+                                  }else {
+                                    return null
+                                  }
+                                  break
+                                }
+                              }
+                            }(map__4261, map__4261__$1, keywordize_keys, keyfn), null)
+                          }
+                        }(map__4261, map__4261__$1, keywordize_keys, keyfn);
+                        return iter__3042__auto__.call(null, cljs.core.js_keys.call(null, x__$1))
+                      }())
+                    }else {
+                      if("\ufdd0:else") {
+                        return x__$1
+                      }else {
+                        return null
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }(map__4261, map__4261__$1, keywordize_keys, keyfn);
+          return f.call(null, x)
+        }else {
+          return null
+        }
+      }
+    };
+    var G__4270 = function(x, var_args) {
+      var opts = null;
+      if(arguments.length > 1) {
+        opts = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+      }
+      return G__4270__delegate.call(this, x, opts)
+    };
+    G__4270.cljs$lang$maxFixedArity = 1;
+    G__4270.cljs$lang$applyTo = function(arglist__4272) {
+      var x = cljs.core.first(arglist__4272);
+      var opts = cljs.core.rest(arglist__4272);
+      return G__4270__delegate(x, opts)
+    };
+    G__4270.cljs$core$IFn$_invoke$arity$variadic = G__4270__delegate;
+    return G__4270
+  }();
+  js__GT_clj = function(x, var_args) {
+    var opts = var_args;
+    switch(arguments.length) {
+      case 1:
+        return js__GT_clj__1.call(this, x);
+      default:
+        return js__GT_clj__2.cljs$core$IFn$_invoke$arity$variadic(x, cljs.core.array_seq(arguments, 1))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  js__GT_clj.cljs$lang$maxFixedArity = 1;
+  js__GT_clj.cljs$lang$applyTo = js__GT_clj__2.cljs$lang$applyTo;
+  js__GT_clj.cljs$core$IFn$_invoke$arity$1 = js__GT_clj__1;
+  js__GT_clj.cljs$core$IFn$_invoke$arity$variadic = js__GT_clj__2.cljs$core$IFn$_invoke$arity$variadic;
+  return js__GT_clj
+}();
+cljs.core.memoize = function memoize(f) {
+  var mem = cljs.core.atom.call(null, cljs.core.ObjMap.EMPTY);
+  return function() {
+    var G__4273__delegate = function(args) {
+      var temp__4090__auto__ = cljs.core.get.call(null, cljs.core.deref.call(null, mem), args);
+      if(cljs.core.truth_(temp__4090__auto__)) {
+        var v = temp__4090__auto__;
+        return v
+      }else {
+        var ret = cljs.core.apply.call(null, f, args);
+        cljs.core.swap_BANG_.call(null, mem, cljs.core.assoc, args, ret);
+        return ret
+      }
+    };
+    var G__4273 = function(var_args) {
+      var args = null;
+      if(arguments.length > 0) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0)
+      }
+      return G__4273__delegate.call(this, args)
+    };
+    G__4273.cljs$lang$maxFixedArity = 0;
+    G__4273.cljs$lang$applyTo = function(arglist__4274) {
+      var args = cljs.core.seq(arglist__4274);
+      return G__4273__delegate(args)
+    };
+    G__4273.cljs$core$IFn$_invoke$arity$variadic = G__4273__delegate;
+    return G__4273
+  }()
+};
+cljs.core.trampoline = function() {
+  var trampoline = null;
+  var trampoline__1 = function(f) {
+    while(true) {
+      var ret = f.call(null);
+      if(cljs.core.fn_QMARK_.call(null, ret)) {
+        var G__4275 = ret;
+        f = G__4275;
+        continue
+      }else {
+        return ret
+      }
+      break
+    }
+  };
+  var trampoline__2 = function() {
+    var G__4276__delegate = function(f, args) {
+      return trampoline.call(null, function() {
+        return cljs.core.apply.call(null, f, args)
+      })
+    };
+    var G__4276 = function(f, var_args) {
+      var args = null;
+      if(arguments.length > 1) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+      }
+      return G__4276__delegate.call(this, f, args)
+    };
+    G__4276.cljs$lang$maxFixedArity = 1;
+    G__4276.cljs$lang$applyTo = function(arglist__4277) {
+      var f = cljs.core.first(arglist__4277);
+      var args = cljs.core.rest(arglist__4277);
+      return G__4276__delegate(f, args)
+    };
+    G__4276.cljs$core$IFn$_invoke$arity$variadic = G__4276__delegate;
+    return G__4276
+  }();
+  trampoline = function(f, var_args) {
+    var args = var_args;
+    switch(arguments.length) {
+      case 1:
+        return trampoline__1.call(this, f);
+      default:
+        return trampoline__2.cljs$core$IFn$_invoke$arity$variadic(f, cljs.core.array_seq(arguments, 1))
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  trampoline.cljs$lang$maxFixedArity = 1;
+  trampoline.cljs$lang$applyTo = trampoline__2.cljs$lang$applyTo;
+  trampoline.cljs$core$IFn$_invoke$arity$1 = trampoline__1;
+  trampoline.cljs$core$IFn$_invoke$arity$variadic = trampoline__2.cljs$core$IFn$_invoke$arity$variadic;
+  return trampoline
+}();
+cljs.core.rand = function() {
+  var rand = null;
+  var rand__0 = function() {
+    return rand.call(null, 1)
+  };
+  var rand__1 = function(n) {
+    return Math.random.call(null) * n
+  };
+  rand = function(n) {
+    switch(arguments.length) {
+      case 0:
+        return rand__0.call(this);
+      case 1:
+        return rand__1.call(this, n)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  rand.cljs$core$IFn$_invoke$arity$0 = rand__0;
+  rand.cljs$core$IFn$_invoke$arity$1 = rand__1;
+  return rand
+}();
+cljs.core.rand_int = function rand_int(n) {
+  return Math.floor.call(null, Math.random.call(null) * n)
+};
+cljs.core.rand_nth = function rand_nth(coll) {
+  return cljs.core.nth.call(null, coll, cljs.core.rand_int.call(null, cljs.core.count.call(null, coll)))
+};
+cljs.core.group_by = function group_by(f, coll) {
+  return cljs.core.reduce.call(null, function(ret, x) {
+    var k = f.call(null, x);
+    return cljs.core.assoc.call(null, ret, k, cljs.core.conj.call(null, cljs.core.get.call(null, ret, k, cljs.core.PersistentVector.EMPTY), x))
+  }, cljs.core.ObjMap.EMPTY, coll)
+};
+cljs.core.make_hierarchy = function make_hierarchy() {
+  return cljs.core.PersistentArrayMap.fromArray(["\ufdd0:parents", cljs.core.ObjMap.EMPTY, "\ufdd0:descendants", cljs.core.ObjMap.EMPTY, "\ufdd0:ancestors", cljs.core.ObjMap.EMPTY], true)
+};
+cljs.core._global_hierarchy = null;
+cljs.core.get_global_hierarchy = function get_global_hierarchy() {
+  if(cljs.core._global_hierarchy == null) {
+    cljs.core._global_hierarchy = cljs.core.atom.call(null, cljs.core.make_hierarchy.call(null))
+  }else {
+  }
+  return cljs.core._global_hierarchy
+};
+cljs.core.swap_global_hierarchy_BANG_ = function() {
+  var swap_global_hierarchy_BANG___delegate = function(f, args) {
+    return cljs.core.apply.call(null, cljs.core.swap_BANG_, cljs.core.get_global_hierarchy.call(null), f, args)
+  };
+  var swap_global_hierarchy_BANG_ = function(f, var_args) {
+    var args = null;
+    if(arguments.length > 1) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return swap_global_hierarchy_BANG___delegate.call(this, f, args)
+  };
+  swap_global_hierarchy_BANG_.cljs$lang$maxFixedArity = 1;
+  swap_global_hierarchy_BANG_.cljs$lang$applyTo = function(arglist__4278) {
+    var f = cljs.core.first(arglist__4278);
+    var args = cljs.core.rest(arglist__4278);
+    return swap_global_hierarchy_BANG___delegate(f, args)
+  };
+  swap_global_hierarchy_BANG_.cljs$core$IFn$_invoke$arity$variadic = swap_global_hierarchy_BANG___delegate;
+  return swap_global_hierarchy_BANG_
+}();
+cljs.core.isa_QMARK_ = function() {
+  var isa_QMARK_ = null;
+  var isa_QMARK___2 = function(child, parent) {
+    return isa_QMARK_.call(null, cljs.core.deref.call(null, cljs.core.get_global_hierarchy.call(null)), child, parent)
+  };
+  var isa_QMARK___3 = function(h, child, parent) {
+    var or__3943__auto__ = cljs.core._EQ_.call(null, child, parent);
+    if(or__3943__auto__) {
+      return or__3943__auto__
+    }else {
+      var or__3943__auto____$1 = cljs.core.contains_QMARK_.call(null, (new cljs.core.Keyword("\ufdd0:ancestors")).call(null, h).call(null, child), parent);
+      if(or__3943__auto____$1) {
+        return or__3943__auto____$1
+      }else {
+        var and__3941__auto__ = cljs.core.vector_QMARK_.call(null, parent);
+        if(and__3941__auto__) {
+          var and__3941__auto____$1 = cljs.core.vector_QMARK_.call(null, child);
+          if(and__3941__auto____$1) {
+            var and__3941__auto____$2 = cljs.core.count.call(null, parent) === cljs.core.count.call(null, child);
+            if(and__3941__auto____$2) {
+              var ret = true;
+              var i = 0;
+              while(true) {
+                if(function() {
+                  var or__3943__auto____$2 = cljs.core.not.call(null, ret);
+                  if(or__3943__auto____$2) {
+                    return or__3943__auto____$2
+                  }else {
+                    return i === cljs.core.count.call(null, parent)
+                  }
+                }()) {
+                  return ret
+                }else {
+                  var G__4279 = isa_QMARK_.call(null, h, child.call(null, i), parent.call(null, i));
+                  var G__4280 = i + 1;
+                  ret = G__4279;
+                  i = G__4280;
+                  continue
+                }
+                break
+              }
+            }else {
+              return and__3941__auto____$2
+            }
+          }else {
+            return and__3941__auto____$1
+          }
+        }else {
+          return and__3941__auto__
+        }
+      }
+    }
+  };
+  isa_QMARK_ = function(h, child, parent) {
+    switch(arguments.length) {
+      case 2:
+        return isa_QMARK___2.call(this, h, child);
+      case 3:
+        return isa_QMARK___3.call(this, h, child, parent)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  isa_QMARK_.cljs$core$IFn$_invoke$arity$2 = isa_QMARK___2;
+  isa_QMARK_.cljs$core$IFn$_invoke$arity$3 = isa_QMARK___3;
+  return isa_QMARK_
+}();
+cljs.core.parents = function() {
+  var parents = null;
+  var parents__1 = function(tag) {
+    return parents.call(null, cljs.core.deref.call(null, cljs.core.get_global_hierarchy.call(null)), tag)
+  };
+  var parents__2 = function(h, tag) {
+    return cljs.core.not_empty.call(null, cljs.core.get.call(null, (new cljs.core.Keyword("\ufdd0:parents")).call(null, h), tag))
+  };
+  parents = function(h, tag) {
+    switch(arguments.length) {
+      case 1:
+        return parents__1.call(this, h);
+      case 2:
+        return parents__2.call(this, h, tag)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  parents.cljs$core$IFn$_invoke$arity$1 = parents__1;
+  parents.cljs$core$IFn$_invoke$arity$2 = parents__2;
+  return parents
+}();
+cljs.core.ancestors = function() {
+  var ancestors = null;
+  var ancestors__1 = function(tag) {
+    return ancestors.call(null, cljs.core.deref.call(null, cljs.core.get_global_hierarchy.call(null)), tag)
+  };
+  var ancestors__2 = function(h, tag) {
+    return cljs.core.not_empty.call(null, cljs.core.get.call(null, (new cljs.core.Keyword("\ufdd0:ancestors")).call(null, h), tag))
+  };
+  ancestors = function(h, tag) {
+    switch(arguments.length) {
+      case 1:
+        return ancestors__1.call(this, h);
+      case 2:
+        return ancestors__2.call(this, h, tag)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  ancestors.cljs$core$IFn$_invoke$arity$1 = ancestors__1;
+  ancestors.cljs$core$IFn$_invoke$arity$2 = ancestors__2;
+  return ancestors
+}();
+cljs.core.descendants = function() {
+  var descendants = null;
+  var descendants__1 = function(tag) {
+    return descendants.call(null, cljs.core.deref.call(null, cljs.core.get_global_hierarchy.call(null)), tag)
+  };
+  var descendants__2 = function(h, tag) {
+    return cljs.core.not_empty.call(null, cljs.core.get.call(null, (new cljs.core.Keyword("\ufdd0:descendants")).call(null, h), tag))
+  };
+  descendants = function(h, tag) {
+    switch(arguments.length) {
+      case 1:
+        return descendants__1.call(this, h);
+      case 2:
+        return descendants__2.call(this, h, tag)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  descendants.cljs$core$IFn$_invoke$arity$1 = descendants__1;
+  descendants.cljs$core$IFn$_invoke$arity$2 = descendants__2;
+  return descendants
+}();
+cljs.core.derive = function() {
+  var derive = null;
+  var derive__2 = function(tag, parent) {
+    if(cljs.core.truth_(cljs.core.namespace.call(null, parent))) {
+    }else {
+      throw new Error([cljs.core.str("Assert failed: "), cljs.core.str(cljs.core.pr_str.call(null, cljs.core.with_meta(cljs.core.list(new cljs.core.Symbol(null, "namespace", "namespace", -388313324, null), new cljs.core.Symbol(null, "parent", "parent", 1659011683, null)), cljs.core.hash_map("\ufdd0:line", 7014, "\ufdd0:column", 12))))].join(""));
+    }
+    cljs.core.swap_global_hierarchy_BANG_.call(null, derive, tag, parent);
+    return null
+  };
+  var derive__3 = function(h, tag, parent) {
+    if(cljs.core.not_EQ_.call(null, tag, parent)) {
+    }else {
+      throw new Error([cljs.core.str("Assert failed: "), cljs.core.str(cljs.core.pr_str.call(null, cljs.core.with_meta(cljs.core.list(new cljs.core.Symbol(null, "not=", "not=", -1637144189, null), new cljs.core.Symbol(null, "tag", "tag", -1640416941, null), new cljs.core.Symbol(null, "parent", "parent", 1659011683, null)), cljs.core.hash_map("\ufdd0:line", 7018, "\ufdd0:column", 12))))].join(""));
+    }
+    var tp = (new cljs.core.Keyword("\ufdd0:parents")).call(null, h);
+    var td = (new cljs.core.Keyword("\ufdd0:descendants")).call(null, h);
+    var ta = (new cljs.core.Keyword("\ufdd0:ancestors")).call(null, h);
+    var tf = function(tp, td, ta) {
+      return function(m, source, sources, target, targets) {
+        return cljs.core.reduce.call(null, function(tp, td, ta) {
+          return function(ret, k) {
+            return cljs.core.assoc.call(null, ret, k, cljs.core.reduce.call(null, cljs.core.conj, cljs.core.get.call(null, targets, k, cljs.core.PersistentHashSet.EMPTY), cljs.core.cons.call(null, target, targets.call(null, target))))
+          }
+        }(tp, td, ta), m, cljs.core.cons.call(null, source, sources.call(null, source)))
+      }
+    }(tp, td, ta);
+    var or__3943__auto__ = cljs.core.contains_QMARK_.call(null, tp.call(null, tag), parent) ? null : function() {
+      if(cljs.core.contains_QMARK_.call(null, ta.call(null, tag), parent)) {
+        throw new Error([cljs.core.str(tag), cljs.core.str("already has"), cljs.core.str(parent), cljs.core.str("as ancestor")].join(""));
+      }else {
+      }
+      if(cljs.core.contains_QMARK_.call(null, ta.call(null, parent), tag)) {
+        throw new Error([cljs.core.str("Cyclic derivation:"), cljs.core.str(parent), cljs.core.str("has"), cljs.core.str(tag), cljs.core.str("as ancestor")].join(""));
+      }else {
+      }
+      return cljs.core.PersistentArrayMap.fromArray(["\ufdd0:parents", cljs.core.assoc.call(null, (new cljs.core.Keyword("\ufdd0:parents")).call(null, h), tag, cljs.core.conj.call(null, cljs.core.get.call(null, tp, tag, cljs.core.PersistentHashSet.EMPTY), parent)), "\ufdd0:ancestors", tf.call(null, (new cljs.core.Keyword("\ufdd0:ancestors")).call(null, h), tag, td, parent, ta), "\ufdd0:descendants", tf.call(null, (new cljs.core.Keyword("\ufdd0:descendants")).call(null, h), parent, ta, tag, td)], 
+      true)
+    }();
+    if(cljs.core.truth_(or__3943__auto__)) {
+      return or__3943__auto__
+    }else {
+      return h
+    }
+  };
+  derive = function(h, tag, parent) {
+    switch(arguments.length) {
+      case 2:
+        return derive__2.call(this, h, tag);
+      case 3:
+        return derive__3.call(this, h, tag, parent)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  derive.cljs$core$IFn$_invoke$arity$2 = derive__2;
+  derive.cljs$core$IFn$_invoke$arity$3 = derive__3;
+  return derive
+}();
+cljs.core.underive = function() {
+  var underive = null;
+  var underive__2 = function(tag, parent) {
+    cljs.core.swap_global_hierarchy_BANG_.call(null, underive, tag, parent);
+    return null
+  };
+  var underive__3 = function(h, tag, parent) {
+    var parentMap = (new cljs.core.Keyword("\ufdd0:parents")).call(null, h);
+    var childsParents = cljs.core.truth_(parentMap.call(null, tag)) ? cljs.core.disj.call(null, parentMap.call(null, tag), parent) : cljs.core.PersistentHashSet.EMPTY;
+    var newParents = cljs.core.truth_(cljs.core.not_empty.call(null, childsParents)) ? cljs.core.assoc.call(null, parentMap, tag, childsParents) : cljs.core.dissoc.call(null, parentMap, tag);
+    var deriv_seq = cljs.core.flatten.call(null, cljs.core.map.call(null, function(parentMap, childsParents, newParents) {
+      return function(p1__4281_SHARP_) {
+        return cljs.core.cons.call(null, cljs.core.first.call(null, p1__4281_SHARP_), cljs.core.interpose.call(null, cljs.core.first.call(null, p1__4281_SHARP_), cljs.core.second.call(null, p1__4281_SHARP_)))
+      }
+    }(parentMap, childsParents, newParents), cljs.core.seq.call(null, newParents)));
+    if(cljs.core.contains_QMARK_.call(null, parentMap.call(null, tag), parent)) {
+      return cljs.core.reduce.call(null, function(p1__4282_SHARP_, p2__4283_SHARP_) {
+        return cljs.core.apply.call(null, cljs.core.derive, p1__4282_SHARP_, p2__4283_SHARP_)
+      }, cljs.core.make_hierarchy.call(null), cljs.core.partition.call(null, 2, deriv_seq))
+    }else {
+      return h
+    }
+  };
+  underive = function(h, tag, parent) {
+    switch(arguments.length) {
+      case 2:
+        return underive__2.call(this, h, tag);
+      case 3:
+        return underive__3.call(this, h, tag, parent)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  underive.cljs$core$IFn$_invoke$arity$2 = underive__2;
+  underive.cljs$core$IFn$_invoke$arity$3 = underive__3;
+  return underive
+}();
+cljs.core.reset_cache = function reset_cache(method_cache, method_table, cached_hierarchy, hierarchy) {
+  cljs.core.swap_BANG_.call(null, method_cache, function(_) {
+    return cljs.core.deref.call(null, method_table)
+  });
+  return cljs.core.swap_BANG_.call(null, cached_hierarchy, function(_) {
+    return cljs.core.deref.call(null, hierarchy)
+  })
+};
+cljs.core.prefers_STAR_ = function prefers_STAR_(x, y, prefer_table) {
+  var xprefs = cljs.core.deref.call(null, prefer_table).call(null, x);
+  var or__3943__auto__ = cljs.core.truth_(function() {
+    var and__3941__auto__ = xprefs;
+    if(cljs.core.truth_(and__3941__auto__)) {
+      return xprefs.call(null, y)
+    }else {
+      return and__3941__auto__
+    }
+  }()) ? true : null;
+  if(cljs.core.truth_(or__3943__auto__)) {
+    return or__3943__auto__
+  }else {
+    var or__3943__auto____$1 = function() {
+      var ps = cljs.core.parents.call(null, y);
+      while(true) {
+        if(cljs.core.count.call(null, ps) > 0) {
+          if(cljs.core.truth_(prefers_STAR_.call(null, x, cljs.core.first.call(null, ps), prefer_table))) {
+          }else {
+          }
+          var G__4284 = cljs.core.rest.call(null, ps);
+          ps = G__4284;
+          continue
+        }else {
+          return null
+        }
+        break
+      }
+    }();
+    if(cljs.core.truth_(or__3943__auto____$1)) {
+      return or__3943__auto____$1
+    }else {
+      var or__3943__auto____$2 = function() {
+        var ps = cljs.core.parents.call(null, x);
+        while(true) {
+          if(cljs.core.count.call(null, ps) > 0) {
+            if(cljs.core.truth_(prefers_STAR_.call(null, cljs.core.first.call(null, ps), y, prefer_table))) {
+            }else {
+            }
+            var G__4285 = cljs.core.rest.call(null, ps);
+            ps = G__4285;
+            continue
+          }else {
+            return null
+          }
+          break
+        }
+      }();
+      if(cljs.core.truth_(or__3943__auto____$2)) {
+        return or__3943__auto____$2
+      }else {
+        return false
+      }
+    }
+  }
+};
+cljs.core.dominates = function dominates(x, y, prefer_table) {
+  var or__3943__auto__ = cljs.core.prefers_STAR_.call(null, x, y, prefer_table);
+  if(cljs.core.truth_(or__3943__auto__)) {
+    return or__3943__auto__
+  }else {
+    return cljs.core.isa_QMARK_.call(null, x, y)
+  }
+};
+cljs.core.find_and_cache_best_method = function find_and_cache_best_method(name, dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy) {
+  var best_entry = cljs.core.reduce.call(null, function(be, p__4288) {
+    var vec__4289 = p__4288;
+    var k = cljs.core.nth.call(null, vec__4289, 0, null);
+    var _ = cljs.core.nth.call(null, vec__4289, 1, null);
+    var e = vec__4289;
+    if(cljs.core.isa_QMARK_.call(null, cljs.core.deref.call(null, hierarchy), dispatch_val, k)) {
+      var be2 = cljs.core.truth_(function() {
+        var or__3943__auto__ = be == null;
+        if(or__3943__auto__) {
+          return or__3943__auto__
+        }else {
+          return cljs.core.dominates.call(null, k, cljs.core.first.call(null, be), prefer_table)
+        }
+      }()) ? e : be;
+      if(cljs.core.truth_(cljs.core.dominates.call(null, cljs.core.first.call(null, be2), k, prefer_table))) {
+      }else {
+        throw new Error([cljs.core.str("Multiple methods in multimethod '"), cljs.core.str(name), cljs.core.str("' match dispatch value: "), cljs.core.str(dispatch_val), cljs.core.str(" -> "), cljs.core.str(k), cljs.core.str(" and "), cljs.core.str(cljs.core.first.call(null, be2)), cljs.core.str(", and neither is preferred")].join(""));
+      }
+      return be2
+    }else {
+      return be
+    }
+  }, null, cljs.core.deref.call(null, method_table));
+  if(cljs.core.truth_(best_entry)) {
+    if(cljs.core._EQ_.call(null, cljs.core.deref.call(null, cached_hierarchy), cljs.core.deref.call(null, hierarchy))) {
+      cljs.core.swap_BANG_.call(null, method_cache, cljs.core.assoc, dispatch_val, cljs.core.second.call(null, best_entry));
+      return cljs.core.second.call(null, best_entry)
+    }else {
+      cljs.core.reset_cache.call(null, method_cache, method_table, cached_hierarchy, hierarchy);
+      return find_and_cache_best_method.call(null, name, dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy)
+    }
+  }else {
+    return null
+  }
+};
+cljs.core.IMultiFn = {};
+cljs.core._reset = function _reset(mf) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_reset$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_reset$arity$1(mf)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._reset[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._reset["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-reset", mf);
+        }
+      }
+    }().call(null, mf)
+  }
+};
+cljs.core._add_method = function _add_method(mf, dispatch_val, method) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_add_method$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_add_method$arity$3(mf, dispatch_val, method)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._add_method[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._add_method["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-add-method", mf);
+        }
+      }
+    }().call(null, mf, dispatch_val, method)
+  }
+};
+cljs.core._remove_method = function _remove_method(mf, dispatch_val) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_remove_method$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf, dispatch_val)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._remove_method[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._remove_method["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-remove-method", mf);
+        }
+      }
+    }().call(null, mf, dispatch_val)
+  }
+};
+cljs.core._prefer_method = function _prefer_method(mf, dispatch_val, dispatch_val_y) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_prefer_method$arity$3
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf, dispatch_val, dispatch_val_y)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._prefer_method[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._prefer_method["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-prefer-method", mf);
+        }
+      }
+    }().call(null, mf, dispatch_val, dispatch_val_y)
+  }
+};
+cljs.core._get_method = function _get_method(mf, dispatch_val) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_get_method$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_get_method$arity$2(mf, dispatch_val)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._get_method[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._get_method["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-get-method", mf);
+        }
+      }
+    }().call(null, mf, dispatch_val)
+  }
+};
+cljs.core._methods = function _methods(mf) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_methods$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_methods$arity$1(mf)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._methods[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._methods["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-methods", mf);
+        }
+      }
+    }().call(null, mf)
+  }
+};
+cljs.core._prefers = function _prefers(mf) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_prefers$arity$1
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_prefers$arity$1(mf)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._prefers[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._prefers["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-prefers", mf);
+        }
+      }
+    }().call(null, mf)
+  }
+};
+cljs.core._dispatch = function _dispatch(mf, args) {
+  if(function() {
+    var and__3941__auto__ = mf;
+    if(and__3941__auto__) {
+      return mf.cljs$core$IMultiFn$_dispatch$arity$2
+    }else {
+      return and__3941__auto__
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_dispatch$arity$2(mf, args)
+  }else {
+    var x__2942__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3943__auto__ = cljs.core._dispatch[goog.typeOf(x__2942__auto__)];
+      if(or__3943__auto__) {
+        return or__3943__auto__
+      }else {
+        var or__3943__auto____$1 = cljs.core._dispatch["_"];
+        if(or__3943__auto____$1) {
+          return or__3943__auto____$1
+        }else {
+          throw cljs.core.missing_protocol.call(null, "IMultiFn.-dispatch", mf);
+        }
+      }
+    }().call(null, mf, args)
+  }
+};
+cljs.core.do_dispatch = function do_dispatch(mf, dispatch_fn, args) {
+  var dispatch_val = cljs.core.apply.call(null, dispatch_fn, args);
+  var target_fn = cljs.core._get_method.call(null, mf, dispatch_val);
+  if(cljs.core.truth_(target_fn)) {
+  }else {
+    throw new Error([cljs.core.str("No method in multimethod '"), cljs.core.str(cljs.core.name), cljs.core.str("' for dispatch value: "), cljs.core.str(dispatch_val)].join(""));
+  }
+  return cljs.core.apply.call(null, target_fn, args)
+};
+goog.provide("cljs.core.MultiFn");
+cljs.core.MultiFn = function(name, dispatch_fn, default_dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy) {
+  this.name = name;
+  this.dispatch_fn = dispatch_fn;
+  this.default_dispatch_val = default_dispatch_val;
+  this.hierarchy = hierarchy;
+  this.method_table = method_table;
+  this.prefer_table = prefer_table;
+  this.method_cache = method_cache;
+  this.cached_hierarchy = cached_hierarchy;
+  this.cljs$lang$protocol_mask$partition0$ = 4194304;
+  this.cljs$lang$protocol_mask$partition1$ = 256
+};
+cljs.core.MultiFn.cljs$lang$type = true;
+cljs.core.MultiFn.cljs$lang$ctorStr = "cljs.core/MultiFn";
+cljs.core.MultiFn.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/MultiFn")
+};
+cljs.core.MultiFn.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
+  var self__ = this;
+  return goog.getUid(this$)
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_reset$arity$1 = function(mf) {
+  var self__ = this;
+  cljs.core.swap_BANG_.call(null, self__.method_table, function(mf__$1) {
+    return cljs.core.ObjMap.EMPTY
+  });
+  cljs.core.swap_BANG_.call(null, self__.method_cache, function(mf__$1) {
+    return cljs.core.ObjMap.EMPTY
+  });
+  cljs.core.swap_BANG_.call(null, self__.prefer_table, function(mf__$1) {
+    return cljs.core.ObjMap.EMPTY
+  });
+  cljs.core.swap_BANG_.call(null, self__.cached_hierarchy, function(mf__$1) {
+    return null
+  });
+  return mf
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_add_method$arity$3 = function(mf, dispatch_val, method) {
+  var self__ = this;
+  cljs.core.swap_BANG_.call(null, self__.method_table, cljs.core.assoc, dispatch_val, method);
+  cljs.core.reset_cache.call(null, self__.method_cache, self__.method_table, self__.cached_hierarchy, self__.hierarchy);
+  return mf
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_remove_method$arity$2 = function(mf, dispatch_val) {
+  var self__ = this;
+  cljs.core.swap_BANG_.call(null, self__.method_table, cljs.core.dissoc, dispatch_val);
+  cljs.core.reset_cache.call(null, self__.method_cache, self__.method_table, self__.cached_hierarchy, self__.hierarchy);
+  return mf
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_get_method$arity$2 = function(mf, dispatch_val) {
+  var self__ = this;
+  if(cljs.core._EQ_.call(null, cljs.core.deref.call(null, self__.cached_hierarchy), cljs.core.deref.call(null, self__.hierarchy))) {
+  }else {
+    cljs.core.reset_cache.call(null, self__.method_cache, self__.method_table, self__.cached_hierarchy, self__.hierarchy)
+  }
+  var temp__4090__auto__ = cljs.core.deref.call(null, self__.method_cache).call(null, dispatch_val);
+  if(cljs.core.truth_(temp__4090__auto__)) {
+    var target_fn = temp__4090__auto__;
+    return target_fn
+  }else {
+    var temp__4090__auto____$1 = cljs.core.find_and_cache_best_method.call(null, self__.name, dispatch_val, self__.hierarchy, self__.method_table, self__.prefer_table, self__.method_cache, self__.cached_hierarchy);
+    if(cljs.core.truth_(temp__4090__auto____$1)) {
+      var target_fn = temp__4090__auto____$1;
+      return target_fn
+    }else {
+      return cljs.core.deref.call(null, self__.method_table).call(null, self__.default_dispatch_val)
+    }
+  }
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_prefer_method$arity$3 = function(mf, dispatch_val_x, dispatch_val_y) {
+  var self__ = this;
+  if(cljs.core.truth_(cljs.core.prefers_STAR_.call(null, dispatch_val_x, dispatch_val_y, self__.prefer_table))) {
+    throw new Error([cljs.core.str("Preference conflict in multimethod '"), cljs.core.str(self__.name), cljs.core.str("': "), cljs.core.str(dispatch_val_y), cljs.core.str(" is already preferred to "), cljs.core.str(dispatch_val_x)].join(""));
+  }else {
+  }
+  cljs.core.swap_BANG_.call(null, self__.prefer_table, function(old) {
+    return cljs.core.assoc.call(null, old, dispatch_val_x, cljs.core.conj.call(null, cljs.core.get.call(null, old, dispatch_val_x, cljs.core.PersistentHashSet.EMPTY), dispatch_val_y))
+  });
+  return cljs.core.reset_cache.call(null, self__.method_cache, self__.method_table, self__.cached_hierarchy, self__.hierarchy)
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_methods$arity$1 = function(mf) {
+  var self__ = this;
+  return cljs.core.deref.call(null, self__.method_table)
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_prefers$arity$1 = function(mf) {
+  var self__ = this;
+  return cljs.core.deref.call(null, self__.prefer_table)
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_dispatch$arity$2 = function(mf, args) {
+  var self__ = this;
+  return cljs.core.do_dispatch.call(null, mf, self__.dispatch_fn, args)
+};
+cljs.core.MultiFn.prototype.call = function() {
+  var G__4290__delegate = function(_, args) {
+    var self = this;
+    return cljs.core._dispatch.call(null, self, args)
+  };
+  var G__4290 = function(_, var_args) {
+    var args = null;
+    if(arguments.length > 1) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0)
+    }
+    return G__4290__delegate.call(this, _, args)
+  };
+  G__4290.cljs$lang$maxFixedArity = 1;
+  G__4290.cljs$lang$applyTo = function(arglist__4291) {
+    var _ = cljs.core.first(arglist__4291);
+    var args = cljs.core.rest(arglist__4291);
+    return G__4290__delegate(_, args)
+  };
+  G__4290.cljs$core$IFn$_invoke$arity$variadic = G__4290__delegate;
+  return G__4290
+}();
+cljs.core.MultiFn.prototype.apply = function(_, args) {
+  var self = this;
+  return cljs.core._dispatch.call(null, self, args)
+};
+cljs.core.remove_all_methods = function remove_all_methods(multifn) {
+  return cljs.core._reset.call(null, multifn)
+};
+cljs.core.remove_method = function remove_method(multifn, dispatch_val) {
+  return cljs.core._remove_method.call(null, multifn, dispatch_val)
+};
+cljs.core.prefer_method = function prefer_method(multifn, dispatch_val_x, dispatch_val_y) {
+  return cljs.core._prefer_method.call(null, multifn, dispatch_val_x, dispatch_val_y)
+};
+cljs.core.methods$ = function methods$(multifn) {
+  return cljs.core._methods.call(null, multifn)
+};
+cljs.core.get_method = function get_method(multifn, dispatch_val) {
+  return cljs.core._get_method.call(null, multifn, dispatch_val)
+};
+cljs.core.prefers = function prefers(multifn) {
+  return cljs.core._prefers.call(null, multifn)
+};
+goog.provide("cljs.core.UUID");
+cljs.core.UUID = function(uuid) {
+  this.uuid = uuid;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 2153775104
+};
+cljs.core.UUID.cljs$lang$type = true;
+cljs.core.UUID.cljs$lang$ctorStr = "cljs.core/UUID";
+cljs.core.UUID.cljs$lang$ctorPrWriter = function(this__2882__auto__, writer__2883__auto__, opt__2884__auto__) {
+  return cljs.core._write.call(null, writer__2883__auto__, "cljs.core/UUID")
+};
+cljs.core.UUID.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
+  var self__ = this;
+  return goog.string.hashCode(cljs.core.pr_str.call(null, this$))
+};
+cljs.core.UUID.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(_, writer, ___$1) {
+  var self__ = this;
+  return cljs.core._write.call(null, writer, [cljs.core.str('#uuid "'), cljs.core.str(self__.uuid), cljs.core.str('"')].join(""))
+};
+cljs.core.UUID.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(_, other) {
+  var self__ = this;
+  var and__3941__auto__ = other instanceof cljs.core.UUID;
+  if(and__3941__auto__) {
+    return self__.uuid === other.uuid
+  }else {
+    return and__3941__auto__
+  }
+};
+goog.provide("cljs.core.ExceptionInfo");
+cljs.core.ExceptionInfo = function(message, data, cause) {
+  this.message = message;
+  this.data = data;
+  this.cause = cause
+};
+cljs.core.ExceptionInfo.cljs$lang$type = true;
+cljs.core.ExceptionInfo.cljs$lang$ctorStr = "cljs.core/ExceptionInfo";
+cljs.core.ExceptionInfo.cljs$lang$ctorPrWriter = function(this__2885__auto__, writer__2886__auto__, opts__2887__auto__) {
+  return cljs.core._write.call(null, writer__2886__auto__, "cljs.core/ExceptionInfo")
+};
+cljs.core.ExceptionInfo.prototype = new Error;
+cljs.core.ExceptionInfo.prototype.constructor = cljs.core.ExceptionInfo;
+cljs.core.ex_info = function() {
+  var ex_info = null;
+  var ex_info__2 = function(msg, map) {
+    return new cljs.core.ExceptionInfo(msg, map, null)
+  };
+  var ex_info__3 = function(msg, map, cause) {
+    return new cljs.core.ExceptionInfo(msg, map, cause)
+  };
+  ex_info = function(msg, map, cause) {
+    switch(arguments.length) {
+      case 2:
+        return ex_info__2.call(this, msg, map);
+      case 3:
+        return ex_info__3.call(this, msg, map, cause)
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  ex_info.cljs$core$IFn$_invoke$arity$2 = ex_info__2;
+  ex_info.cljs$core$IFn$_invoke$arity$3 = ex_info__3;
+  return ex_info
+}();
+cljs.core.ex_data = function ex_data(ex) {
+  if(ex instanceof cljs.core.ExceptionInfo) {
+    return ex.data
+  }else {
+    return null
+  }
+};
+cljs.core.ex_message = function ex_message(ex) {
+  if(ex instanceof Error) {
+    return ex.message
+  }else {
+    return null
+  }
+};
+cljs.core.ex_cause = function ex_cause(ex) {
+  if(ex instanceof cljs.core.ExceptionInfo) {
+    return ex.cause
+  }else {
+    return null
+  }
+};
+cljs.core.comparator = function comparator(pred) {
+  return function(x, y) {
+    if(cljs.core.truth_(pred.call(null, x, y))) {
+      return-1
+    }else {
+      if(cljs.core.truth_(pred.call(null, y, x))) {
+        return 1
+      }else {
+        if("\ufdd0:else") {
+          return 0
+        }else {
+          return null
+        }
+      }
+    }
+  }
+};
+cljs.core.special_symbol_QMARK_ = function special_symbol_QMARK_(x) {
+  return cljs.core.contains_QMARK_.call(null, cljs.core.set([new cljs.core.Symbol(null, "deftype*", "deftype*", -978581244, null), new cljs.core.Symbol(null, "new", "new", -1640422567, null), new cljs.core.Symbol(null, "try*", "try*", -1636962424, null), new cljs.core.Symbol(null, "quote", "quote", -1532577739, null), new cljs.core.Symbol(null, "&", "&", -1640531489, null), new cljs.core.Symbol(null, "set!", "set!", -1637004872, null), new cljs.core.Symbol(null, "recur", "recur", -1532142362, null), 
+  new cljs.core.Symbol(null, ".", ".", -1640531481, null), new cljs.core.Symbol(null, "ns", "ns", -1640528002, null), new cljs.core.Symbol(null, "do", "do", -1640528316, null), new cljs.core.Symbol(null, "fn*", "fn*", -1640430053, null), new cljs.core.Symbol(null, "throw", "throw", -1530191713, null), new cljs.core.Symbol(null, "letfn*", "letfn*", 1548249632, null), new cljs.core.Symbol(null, "js*", "js*", -1640426054, null), new cljs.core.Symbol(null, "defrecord*", "defrecord*", 774272013, null), 
+  new cljs.core.Symbol(null, "let*", "let*", -1637213400, null), new cljs.core.Symbol(null, "loop*", "loop*", -1537374273, null), new cljs.core.Symbol(null, "if", "if", -1640528170, null), new cljs.core.Symbol(null, "def", "def", -1640432194, null)]), x)
+};
+goog.provide("grub_client.core");
+goog.require("cljs.core");
+alert("Hello from ClojureScript!");
diff --git a/src-clj/grub/core.clj b/src-clj/grub/core.clj
new file mode 100644
index 0000000..1c23be0
--- /dev/null
+++ b/src-clj/grub/core.clj
@@ -0,0 +1,31 @@
+(ns grub.core
+  (:use [org.httpkit.server :only [run-server]])
+  (:require [ring.middleware.reload :as reload]
+            [compojure.handler :only [site]]
+            [compojure.core :only [defroutes GET POST]]))
+
+(defroutes routes
+  (GET "/" [] "handling-page")
+  (GET "/save" [] handler)     ;; websocket
+  (route/not-found "<p>Page not found.</p>")) ;; all other, return 404
+
+(defn -main [& args] ;; entry point, lein run will pick up and start from here
+  (let [handler (if (in-dev? args)
+                  (reload/wrap-reload (site #'routes)) ;; only reload when dev
+                  (site routes))]
+    (run-server handler {:port 8080})))
+
+(comment
+(defn async-handler [ring-request]
+  (with-channel ring-request channel
+    (if (websocket? channel)
+      (println "WebSocket channel")
+      (println "HTTP channel"))
+    (on-receive channel (fn [data]
+                          (send! channel data)))
+    (send! channel {:status 200
+                    :headers {"Content-Type" "text/plain"}
+                    :body    "Long polling?"})))
+
+(run-server async-handler {:port 8080})
+)
diff --git a/src-cljs/grub_client/core.cljs b/src-cljs/grub_client/core.cljs
new file mode 100644
index 0000000..6aa7ee1
--- /dev/null
+++ b/src-cljs/grub_client/core.cljs
@@ -0,0 +1,3 @@
+(ns grub-client.core)
+
+(js/alert "Hello from ClojureScript!")
diff --git a/test/grub/core_test.clj b/test/grub/core_test.clj
new file mode 100644
index 0000000..1f7207c
--- /dev/null
+++ b/test/grub/core_test.clj
@@ -0,0 +1,7 @@
+(ns grub.core-test
+  (:use clojure.test
+        grub.core))
+
+(deftest a-test
+  (testing "FIXME, I fail."
+    (is (= 0 1))))