From 68d2c39a619f7e0b3246f602a6856c1011c95f82 Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Tue, 14 Jan 2014 23:43:08 +1100
Subject: [PATCH 01/39] --core.cljs added red winning example board

--draw.cljs
added winner

--index.html
added winner div

--ball.cljs
added function find-winner
---
 resources/index.html       |  6 +++---
 src/nonaga/core.cljs       | 18 ++++++++++++++++++
 src/nonaga/draw.cljs       | 11 +++++++++++
 src/nonaga/rules/ball.cljs | 34 +++++++++++++++++++++++++++++++++-
 4 files changed, 65 insertions(+), 4 deletions(-)

diff --git a/resources/index.html b/resources/index.html
index 30a72c5..8f35b2f 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -22,6 +22,9 @@
       }
       #instructions {
         text-align: center;
+      }
+	  #game_resolve {
+        text-align: center;
       }
       #content {
         border: 1px solid #AAA;
@@ -52,9 +55,6 @@
 
       <p>A player wins when any of their marbles touches both other marbles.</p>
 
-      <p>
-        <em>The current implementation does not detect wins.</em>
-      </p>
     </div>
     <script src="js/react-0.8.0.js"></script>
     <script src="js/main.js"></script>
diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 89a2f05..08ca7c7 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -43,6 +43,24 @@
      [0 2]
        
                      [3 0]}})
+					 
+(def red-wins
+  {:rings
+    #{   [1 4] [2 4] [3 4]  
+       [0 3] [1 3] [2 3] [3 3]
+     [0 2] [1 2] [2 2] [3 2] [4 2] 
+       [0 1] [1 1] [2 1] [3 1] 
+         [1 0] [2 0] [3 0]}
+  
+   :red
+    #{   [1 4] [2 4] [3 4]   }
+  
+   :blue
+    #{                 
+						 [3 3]	
+     [0 2]
+       
+                     [3 0]}})			 
 
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index bc100b8..3d0e31f 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -156,6 +156,15 @@
 (defmethod instructions :ring-selected [[type color source]]
   (str (color-name color) " selects where to move the ring."))
 
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
 (def board
   (create-class
     "getInitialState"
@@ -171,6 +180,8 @@
                  (div {}
                       (p {:id "instructions"}
                          (instructions (:event state)))      
+					  (p {:id "game_resolve"}
+                         (game-resolve state))
                       (svg {:width 480 :height 480}
                            (draw-rings this state)
                            (draw-potential-rings this state)
diff --git a/src/nonaga/rules/ball.cljs b/src/nonaga/rules/ball.cljs
index c6171d8..d0b11e9 100644
--- a/src/nonaga/rules/ball.cljs
+++ b/src/nonaga/rules/ball.cljs
@@ -1,5 +1,5 @@
 (ns nonaga.rules.ball
-  (:use [nonaga.rules.coord :only [directions]]))
+  (:use [nonaga.rules.coord :only [directions neighbours]]))
 
 (defn invalid-space? [{:keys [rings red blue]} coord]
   (not (and (rings coord)
@@ -12,6 +12,38 @@
           :when (invalid-space? board (direction step))]
       step)))
 
+(defn find-winner [{:keys [rings red blue]}]
+	(let 
+		[
+			allconnected
+			(fn [marble-color] 
+				(> 
+					(count 
+						(reduce clojure.set/union
+							(for [coord marble-color coord' marble-color] 
+								(clojure.set/intersection 
+									#{coord}
+									(neighbours coord')
+								)
+							)
+						)
+					)
+					2
+				)
+			)
+		]
+		(
+			if (allconnected red)
+			:red 
+			(
+				if (allconnected blue)
+				:blue 
+				nil
+			)
+		)
+	)
+)
+	  
 (defn valid-destinations [board coord]
   (disj (into #{} (map (partial move board coord) directions)) coord))
 

From e8475a8d6987245d5d3831ea0605e8c709f353fc Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Thu, 16 Jan 2014 21:51:05 +1100
Subject: [PATCH 02/39] will only highlight rings with double gaps

---
 src/nonaga/rules/coord.cljs       |  4 ++++
 src/nonaga/rules/rings.cljs       | 19 ++++++++++++++++---
 test/nonaga/rules/rings_test.cljs | 19 +++++++++++++++++--
 3 files changed, 37 insertions(+), 5 deletions(-)

diff --git a/src/nonaga/rules/coord.cljs b/src/nonaga/rules/coord.cljs
index 720859c..c3e27a3 100644
--- a/src/nonaga/rules/coord.cljs
+++ b/src/nonaga/rules/coord.cljs
@@ -10,6 +10,9 @@
 (def directions
   [nw ne e se sw w])
 
+(def side-by-side-directions
+  [[nw ne] [ne e] [e se] [se sw] [sw w] [w nw]])
+
 (def neighbouring-directions
   {nw [ne w]  ne [nw e]
    w  [nw sw] e  [ne se]
@@ -29,3 +32,4 @@
 (defn tag-with-distance [destination source]
   [(distance source destination) source])
 
+
diff --git a/src/nonaga/rules/rings.cljs b/src/nonaga/rules/rings.cljs
index 39234da..7fe8c4c 100644
--- a/src/nonaga/rules/rings.cljs
+++ b/src/nonaga/rules/rings.cljs
@@ -1,7 +1,7 @@
 (ns nonaga.rules.rings
   (:require [clojure.set :refer [difference intersection]])
   (:use [nonaga.rules.coord :only [neighbours neighbouring-directions
-                                   tag-with-distance]]))
+                                   tag-with-distance side-by-side-directions]]))
 
 (defn valid-slide? [rings coord direction]
   (let [sliding-into-ring? (rings (direction coord))
@@ -50,10 +50,23 @@
         slidables  (filter (partial can-move-to? rings source) availables)]
     (set slidables)))
 
-; To be able to be moved must have At least a gap of two
+(defn has-double-gap? [rings coord]
+  (->
+    (->>
+      ((->> side-by-side-directions
+            (map (partial apply juxt))
+            (apply juxt))
+       coord)
+      (map set)
+      (map (partial intersection rings))
+      (filter empty?)
+      empty?
+      not)))
+
 (defn can-be-moved? [{:keys [rings red blue]} coord]
   (let [num-neighbours (count (intersection (neighbours coord) rings))]
     (and (rings coord)
          (not (or (red coord) (blue coord)))
-         (< num-neighbours 5))))
+         (< num-neighbours 5)
+         (has-double-gap? rings coord))))
 
diff --git a/test/nonaga/rules/rings_test.cljs b/test/nonaga/rules/rings_test.cljs
index 29da1a3..c71a01c 100644
--- a/test/nonaga/rules/rings_test.cljs
+++ b/test/nonaga/rules/rings_test.cljs
@@ -2,8 +2,9 @@
   (:require-macros [cemerick.cljs.test :refer (deftest is are)])
   (:use [nonaga.core :only [initial-game]]
         [nonaga.rules.rings :only [valid-slide? valid-slides can-move-to?
-                                   valid-destinations can-be-moved?]]
-        [nonaga.rules.coord :only [nw ne e se sw w]] )
+                                   valid-destinations can-be-moved? has-double-gap?]]
+        [nonaga.rules.coord :only [nw ne e se sw w]]
+        [clojure.set :only [difference intersection]])
   (:require [cemerick.cljs.test :as t]))
 
 (def board-with-gap
@@ -83,3 +84,17 @@
   (is (can-be-moved? initial-game [2 4]))
   (is (not (can-be-moved? initial-game [2 2])))) 
 
+
+(def one-each-way
+  {:rings
+    #{   [1 4]       [3 4]  
+             [1 3] [2 3] [3 3]
+     [0 2] [1 2] [2 2] [3 2] [4 2] 
+       [0 1] [1 1] [2 1] [3 1] 
+         [1 0] [2 0] [3 0]}})
+
+(deftest has-double-gap?-test
+  (is (has-double-gap?      initial-game [1 4]))
+  (is (not (has-double-gap? initial-game [2 2])))
+  (is (not (has-double-gap? one-each-way [1 3]))))
+

From c934b09a824317bababd833bdd8a8e0a05019ad0 Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Tue, 14 Jan 2014 23:43:08 +1100
Subject: [PATCH 03/39] --core.cljs added red winning example board

--draw.cljs
added winner

--index.html
added winner div

--ball.cljs
added function find-winner
---
 resources/index.html       |  6 +++---
 src/nonaga/core.cljs       | 18 ++++++++++++++++++
 src/nonaga/draw.cljs       | 11 +++++++++++
 src/nonaga/rules/ball.cljs | 34 +++++++++++++++++++++++++++++++++-
 4 files changed, 65 insertions(+), 4 deletions(-)

diff --git a/resources/index.html b/resources/index.html
index 30a72c5..8f35b2f 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -22,6 +22,9 @@
       }
       #instructions {
         text-align: center;
+      }
+	  #game_resolve {
+        text-align: center;
       }
       #content {
         border: 1px solid #AAA;
@@ -52,9 +55,6 @@
 
       <p>A player wins when any of their marbles touches both other marbles.</p>
 
-      <p>
-        <em>The current implementation does not detect wins.</em>
-      </p>
     </div>
     <script src="js/react-0.8.0.js"></script>
     <script src="js/main.js"></script>
diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 89a2f05..08ca7c7 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -43,6 +43,24 @@
      [0 2]
        
                      [3 0]}})
+					 
+(def red-wins
+  {:rings
+    #{   [1 4] [2 4] [3 4]  
+       [0 3] [1 3] [2 3] [3 3]
+     [0 2] [1 2] [2 2] [3 2] [4 2] 
+       [0 1] [1 1] [2 1] [3 1] 
+         [1 0] [2 0] [3 0]}
+  
+   :red
+    #{   [1 4] [2 4] [3 4]   }
+  
+   :blue
+    #{                 
+						 [3 3]	
+     [0 2]
+       
+                     [3 0]}})			 
 
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index bc100b8..3d0e31f 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -156,6 +156,15 @@
 (defmethod instructions :ring-selected [[type color source]]
   (str (color-name color) " selects where to move the ring."))
 
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
 (def board
   (create-class
     "getInitialState"
@@ -171,6 +180,8 @@
                  (div {}
                       (p {:id "instructions"}
                          (instructions (:event state)))      
+					  (p {:id "game_resolve"}
+                         (game-resolve state))
                       (svg {:width 480 :height 480}
                            (draw-rings this state)
                            (draw-potential-rings this state)
diff --git a/src/nonaga/rules/ball.cljs b/src/nonaga/rules/ball.cljs
index c6171d8..d0b11e9 100644
--- a/src/nonaga/rules/ball.cljs
+++ b/src/nonaga/rules/ball.cljs
@@ -1,5 +1,5 @@
 (ns nonaga.rules.ball
-  (:use [nonaga.rules.coord :only [directions]]))
+  (:use [nonaga.rules.coord :only [directions neighbours]]))
 
 (defn invalid-space? [{:keys [rings red blue]} coord]
   (not (and (rings coord)
@@ -12,6 +12,38 @@
           :when (invalid-space? board (direction step))]
       step)))
 
+(defn find-winner [{:keys [rings red blue]}]
+	(let 
+		[
+			allconnected
+			(fn [marble-color] 
+				(> 
+					(count 
+						(reduce clojure.set/union
+							(for [coord marble-color coord' marble-color] 
+								(clojure.set/intersection 
+									#{coord}
+									(neighbours coord')
+								)
+							)
+						)
+					)
+					2
+				)
+			)
+		]
+		(
+			if (allconnected red)
+			:red 
+			(
+				if (allconnected blue)
+				:blue 
+				nil
+			)
+		)
+	)
+)
+	  
 (defn valid-destinations [board coord]
   (disj (into #{} (map (partial move board coord) directions)) coord))
 

From 3ac5ff6a8d492b7c3db6f6e7b27f34e591549ff5 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Mon, 20 Jan 2014 17:34:15 +1100
Subject: [PATCH 04/39] setup test file with output to pre

---
 project.clj            |     4 +-
 resources/js/test.js   | 25504 +++++++++++++++++++++++++++++++++++++++
 resources/test.html    |    17 +
 test/nonaga/setup.cljs |     9 +
 4 files changed, 25532 insertions(+), 2 deletions(-)
 create mode 100644 resources/js/test.js
 create mode 100644 resources/test.html
 create mode 100644 test/nonaga/setup.cljs

diff --git a/project.clj b/project.clj
index 5ac8713..658751f 100644
--- a/project.clj
+++ b/project.clj
@@ -16,10 +16,10 @@
                                         :optimizations :whitespace
                                         :pretty-print true}}
                        :test {:source-paths ["src" "test"]
-                              :compiler {:output-to "target/cljs/unit-test.js"
+                              :compiler {:output-to "resources/js/test.js"
                                          :optimizations :whitespace
                                          :pretty-print true}}}
               :test-commands {"unit" ["phantomjs" :runner 
                                       "window.literal_js_was_evaluated=true"
-                                      "target/cljs/unit-test.js"]}})
+                                      "resources/js/test.js"]}})
 
diff --git a/resources/js/test.js b/resources/js/test.js
new file mode 100644
index 0000000..cf8008f
--- /dev/null
+++ b/resources/js/test.js
@@ -0,0 +1,25504 @@
+var CLOSURE_NO_DEPS = true;
+var COMPILED = false;
+var goog = goog || {};
+goog.global = this;
+goog.DEBUG = true;
+goog.LOCALE = "en";
+goog.TRUSTED_SITE = true;
+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;
+      if (doc.readyState == "complete") {
+        var isDeps = /\bdeps.js$/.test(src);
+        if (isDeps) {
+          return false;
+        } else {
+          throw Error('Cannot write "' + src + '" after document load');
+        }
+      }
+      doc.write('\x3cscript type\x3d"text/javascript" src\x3d"' + src + '"\x3e\x3c/' + "script\x3e");
+      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.random() * 1E9 >>> 0);
+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 = goog.TRUSTED_SITE && 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_ \x3d 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.getMsgWithFallback = function(a, b) {
+  return a;
+};
+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 ? "\x3cbr /\x3e" : "\x3cbr\x3e");
+};
+goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
+  if (opt_isLikelyToContainHtmlChars) {
+    return str.replace(goog.string.amperRe_, "\x26amp;").replace(goog.string.ltRe_, "\x26lt;").replace(goog.string.gtRe_, "\x26gt;").replace(goog.string.quotRe_, "\x26quot;");
+  } else {
+    if (!goog.string.allRe_.test(str)) {
+      return str;
+    }
+    if (str.indexOf("\x26") != -1) {
+      str = str.replace(goog.string.amperRe_, "\x26amp;");
+    }
+    if (str.indexOf("\x3c") != -1) {
+      str = str.replace(goog.string.ltRe_, "\x26lt;");
+    }
+    if (str.indexOf("\x3e") != -1) {
+      str = str.replace(goog.string.gtRe_, "\x26gt;");
+    }
+    if (str.indexOf('"') != -1) {
+      str = str.replace(goog.string.quotRe_, "\x26quot;");
+    }
+    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, "\x26")) {
+    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 = {"\x26amp;":"\x26", "\x26lt;":"\x3c", "\x26gt;":"\x3e", "\x26quot;":'"'};
+  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 "\x26";
+      case "lt":
+        return "\x3c";
+      case "gt":
+        return "\x3e";
+      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, " \x26#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 = goog.TRUSTED_SITE;
+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.count = function(arr, f, opt_obj) {
+  var count = 0;
+  goog.array.forEach(arr, function(element, index, arr) {
+    if (f.call(opt_obj, element, index, arr)) {
+      ++count;
+    }
+  }, opt_obj);
+  return count;
+};
+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)) && Object.prototype.hasOwnProperty.call(arr2, "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.toObject = function(arr, keyFunc, opt_obj) {
+  var ret = {};
+  goog.array.forEach(arr, function(element, index) {
+    ret[keyFunc.call(opt_obj, element, index, arr)] = element;
+  });
+  return ret;
+};
+goog.array.range = function(startOrEnd, opt_end, opt_step) {
+  var array = [];
+  var start = 0;
+  var end = startOrEnd;
+  var step = opt_step || 1;
+  if (opt_end !== undefined) {
+    start = startOrEnd;
+    end = opt_end;
+  }
+  if (step * (end - start) < 0) {
+    return[];
+  }
+  if (step > 0) {
+    for (var i = start;i < end;i += step) {
+      array.push(i);
+    }
+  } else {
+    for (var i = start;i > end;i += step) {
+      array.push(i);
+    }
+  }
+  return array;
+};
+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.object.createImmutableView = function(obj) {
+  var result = obj;
+  if (Object.isFrozen && !Object.isFrozen(obj)) {
+    result = Object.create(obj);
+    Object.freeze(result);
+  }
+  return result;
+};
+goog.object.isImmutableView = function(obj) {
+  return!!Object.isFrozen && Object.isFrozen(obj);
+};
+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.array");
+goog.require("goog.object");
+goog.require("goog.object");
+goog.require("goog.string.StringBuffer");
+goog.require("goog.string.StringBuffer");
+goog.require("goog.string");
+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;
+};
+cljs.core._STAR_flush_on_newline_STAR_ = true;
+cljs.core._STAR_print_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._STAR_print_length_STAR_ = null;
+cljs.core._STAR_print_level_STAR_ = null;
+cljs.core.pr_opts = function pr_opts() {
+  return new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null, "flush-on-newline", "flush-on-newline", 4338025857), cljs.core._STAR_flush_on_newline_STAR_, new cljs.core.Keyword(null, "readably", "readably", 4441712502), cljs.core._STAR_print_readably_STAR_, new cljs.core.Keyword(null, "meta", "meta", 1017252215), cljs.core._STAR_print_meta_STAR_, new cljs.core.Keyword(null, "dup", "dup", 1014004081), cljs.core._STAR_print_dup_STAR_, new cljs.core.Keyword(null, "print-length", "print-length", 
+  3960797560), cljs.core._STAR_print_length_STAR_], null);
+};
+cljs.core.enable_console_print_BANG_ = function enable_console_print_BANG_() {
+  cljs.core._STAR_print_newline_STAR_ = false;
+  return cljs.core._STAR_print_fn_STAR_ = function() {
+    var G__6957__delegate = function(args) {
+      return console.log.apply(console, cljs.core.into_array.call(null, args));
+    };
+    var G__6957 = function(var_args) {
+      var args = null;
+      if (arguments.length > 0) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+      }
+      return G__6957__delegate.call(this, args);
+    };
+    G__6957.cljs$lang$maxFixedArity = 0;
+    G__6957.cljs$lang$applyTo = function(arglist__6958) {
+      var args = cljs.core.seq(arglist__6958);
+      return G__6957__delegate(args);
+    };
+    G__6957.cljs$core$IFn$_invoke$arity$variadic = G__6957__delegate;
+    return G__6957;
+  }();
+};
+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.object_QMARK_ = function object_QMARK_(x) {
+  if (!(x == null)) {
+    return x.constructor === Object;
+  } else {
+    return false;
+  }
+};
+cljs.core.string_QMARK_ = function string_QMARK_(x) {
+  return goog.isString(x);
+};
+cljs.core.native_satisfies_QMARK_ = function native_satisfies_QMARK_(p, x) {
+  var x__$1 = x == null ? null : x;
+  if (p[goog.typeOf(x__$1)]) {
+    return true;
+  } else {
+    if (p["_"]) {
+      return true;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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__3396__auto__ = ty;
+    if (cljs.core.truth_(and__3396__auto__)) {
+      return ty.cljs$lang$type;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) ? ty.cljs$lang$ctorStr : goog.typeOf(obj);
+  return new Error(["No protocol method ", proto, " defined for type ", ty__$1, ": ", obj].join(""));
+};
+cljs.core.type__GT_str = function type__GT_str(ty) {
+  var temp__4090__auto__ = ty.cljs$lang$ctorStr;
+  if (cljs.core.truth_(temp__4090__auto__)) {
+    var s = temp__4090__auto__;
+    return s;
+  } else {
+    return[cljs.core.str(ty)].join("");
+  }
+};
+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.aclone = function aclone(arr) {
+  var len = arr.length;
+  var new_arr = new Array(len);
+  var n__4232__auto___6959 = len;
+  var i_6960 = 0;
+  while (true) {
+    if (i_6960 < n__4232__auto___6959) {
+      new_arr[i_6960] = arr[i_6960];
+      var G__6961 = i_6960 + 1;
+      i_6960 = G__6961;
+      continue;
+    } else {
+    }
+    break;
+  }
+  return new_arr;
+};
+cljs.core.array = function array(var_args) {
+  return Array.prototype.slice.call(arguments);
+};
+cljs.core.aget = function() {
+  var aget = null;
+  var aget__2 = function(array, i) {
+    return array[i];
+  };
+  var aget__3 = function() {
+    var G__6962__delegate = function(array, i, idxs) {
+      return cljs.core.apply.call(null, aget, aget.call(null, array, i), idxs);
+    };
+    var G__6962 = 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__6962__delegate.call(this, array, i, idxs);
+    };
+    G__6962.cljs$lang$maxFixedArity = 2;
+    G__6962.cljs$lang$applyTo = function(arglist__6963) {
+      var array = cljs.core.first(arglist__6963);
+      arglist__6963 = cljs.core.next(arglist__6963);
+      var i = cljs.core.first(arglist__6963);
+      var idxs = cljs.core.rest(arglist__6963);
+      return G__6962__delegate(array, i, idxs);
+    };
+    G__6962.cljs$core$IFn$_invoke$arity$variadic = G__6962__delegate;
+    return G__6962;
+  }();
+  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() {
+  var aset = null;
+  var aset__3 = function(array, i, val) {
+    return array[i] = val;
+  };
+  var aset__4 = function() {
+    var G__6964__delegate = function(array, idx, idx2, idxv) {
+      return cljs.core.apply.call(null, aset, array[idx], idx2, idxv);
+    };
+    var G__6964 = function(array, idx, idx2, var_args) {
+      var idxv = null;
+      if (arguments.length > 3) {
+        idxv = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0);
+      }
+      return G__6964__delegate.call(this, array, idx, idx2, idxv);
+    };
+    G__6964.cljs$lang$maxFixedArity = 3;
+    G__6964.cljs$lang$applyTo = function(arglist__6965) {
+      var array = cljs.core.first(arglist__6965);
+      arglist__6965 = cljs.core.next(arglist__6965);
+      var idx = cljs.core.first(arglist__6965);
+      arglist__6965 = cljs.core.next(arglist__6965);
+      var idx2 = cljs.core.first(arglist__6965);
+      var idxv = cljs.core.rest(arglist__6965);
+      return G__6964__delegate(array, idx, idx2, idxv);
+    };
+    G__6964.cljs$core$IFn$_invoke$arity$variadic = G__6964__delegate;
+    return G__6964;
+  }();
+  aset = function(array, idx, idx2, var_args) {
+    var idxv = var_args;
+    switch(arguments.length) {
+      case 3:
+        return aset__3.call(this, array, idx, idx2);
+      default:
+        return aset__4.cljs$core$IFn$_invoke$arity$variadic(array, idx, idx2, cljs.core.array_seq(arguments, 3));
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  aset.cljs$lang$maxFixedArity = 3;
+  aset.cljs$lang$applyTo = aset__4.cljs$lang$applyTo;
+  aset.cljs$core$IFn$_invoke$arity$3 = aset__3;
+  aset.cljs$core$IFn$_invoke$arity$variadic = aset__4.cljs$core$IFn$_invoke$arity$variadic;
+  return aset;
+}();
+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 = function() {
+  var obj6967 = {};
+  return obj6967;
+}();
+cljs.core.IFn = function() {
+  var obj6969 = {};
+  return obj6969;
+}();
+cljs.core._invoke = function() {
+  var _invoke = null;
+  var _invoke__1 = function(this$) {
+    if (function() {
+      var and__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$1;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$1(this$);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$2;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$2(this$, a);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$3;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$3(this$, a, b);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$4;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$4(this$, a, b, c);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$5;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$6;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$6(this$, a, b, c, d, e);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$7;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$7(this$, a, b, c, d, e, f);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$8;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$8(this$, a, b, c, d, e, f, g);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$9;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$9(this$, a, b, c, d, e, f, g, h);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$10;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$10(this$, a, b, c, d, e, f, g, h, i);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$11;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$11(this$, a, b, c, d, e, f, g, h, i, j);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$12;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return this$.cljs$core$IFn$_invoke$arity$12(this$, a, b, c, d, e, f, g, h, i, j, k);
+    } else {
+      var x__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$13;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$14;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$15;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$16;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$17;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$18;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$19;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$20;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = this$;
+      if (and__3396__auto__) {
+        return this$.cljs$core$IFn$_invoke$arity$21;
+      } else {
+        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
+      return function() {
+        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._invoke["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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 = function() {
+  var obj6971 = {};
+  return obj6971;
+}();
+cljs.core._count = function _count(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ICounted$_count$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ICounted$_count$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._count[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._count["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ICounted.-count", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.IEmptyableCollection = function() {
+  var obj6973 = {};
+  return obj6973;
+}();
+cljs.core._empty = function _empty(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IEmptyableCollection$_empty$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._empty[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._empty["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IEmptyableCollection.-empty", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.ICollection = function() {
+  var obj6975 = {};
+  return obj6975;
+}();
+cljs.core._conj = function _conj(coll, o) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ICollection$_conj$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ICollection$_conj$arity$2(coll, o);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._conj[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._conj["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ICollection.-conj", coll);
+        }
+      }
+    }().call(null, coll, o);
+  }
+};
+cljs.core.IIndexed = function() {
+  var obj6977 = {};
+  return obj6977;
+}();
+cljs.core._nth = function() {
+  var _nth = null;
+  var _nth__2 = function(coll, n) {
+    if (function() {
+      var and__3396__auto__ = coll;
+      if (and__3396__auto__) {
+        return coll.cljs$core$IIndexed$_nth$arity$2;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return coll.cljs$core$IIndexed$_nth$arity$2(coll, n);
+    } else {
+      var x__4011__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3408__auto__ = cljs.core._nth[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._nth["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = coll;
+      if (and__3396__auto__) {
+        return coll.cljs$core$IIndexed$_nth$arity$3;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return coll.cljs$core$IIndexed$_nth$arity$3(coll, n, not_found);
+    } else {
+      var x__4011__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3408__auto__ = cljs.core._nth[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._nth["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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 = function() {
+  var obj6979 = {};
+  return obj6979;
+}();
+cljs.core.ISeq = function() {
+  var obj6981 = {};
+  return obj6981;
+}();
+cljs.core._first = function _first(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISeq$_first$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISeq$_first$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._first[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._first["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISeq$_rest$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISeq$_rest$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._rest[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._rest["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ISeq.-rest", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.INext = function() {
+  var obj6983 = {};
+  return obj6983;
+}();
+cljs.core._next = function _next(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$INext$_next$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$INext$_next$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._next[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._next["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "INext.-next", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.ILookup = function() {
+  var obj6985 = {};
+  return obj6985;
+}();
+cljs.core._lookup = function() {
+  var _lookup = null;
+  var _lookup__2 = function(o, k) {
+    if (function() {
+      var and__3396__auto__ = o;
+      if (and__3396__auto__) {
+        return o.cljs$core$ILookup$_lookup$arity$2;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return o.cljs$core$ILookup$_lookup$arity$2(o, k);
+    } else {
+      var x__4011__auto__ = o == null ? null : o;
+      return function() {
+        var or__3408__auto__ = cljs.core._lookup[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._lookup["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = o;
+      if (and__3396__auto__) {
+        return o.cljs$core$ILookup$_lookup$arity$3;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return o.cljs$core$ILookup$_lookup$arity$3(o, k, not_found);
+    } else {
+      var x__4011__auto__ = o == null ? null : o;
+      return function() {
+        var or__3408__auto__ = cljs.core._lookup[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._lookup["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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 = function() {
+  var obj6987 = {};
+  return obj6987;
+}();
+cljs.core._contains_key_QMARK_ = function _contains_key_QMARK_(coll, k) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll, k);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._contains_key_QMARK_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._contains_key_QMARK_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IAssociative$_assoc$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, k, v);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._assoc[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._assoc["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IAssociative.-assoc", coll);
+        }
+      }
+    }().call(null, coll, k, v);
+  }
+};
+cljs.core.IMap = function() {
+  var obj6989 = {};
+  return obj6989;
+}();
+cljs.core._dissoc = function _dissoc(coll, k) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IMap$_dissoc$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IMap$_dissoc$arity$2(coll, k);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._dissoc[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._dissoc["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IMap.-dissoc", coll);
+        }
+      }
+    }().call(null, coll, k);
+  }
+};
+cljs.core.IMapEntry = function() {
+  var obj6991 = {};
+  return obj6991;
+}();
+cljs.core._key = function _key(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IMapEntry$_key$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IMapEntry$_key$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._key[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._key["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IMapEntry$_val$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IMapEntry$_val$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._val[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._val["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IMapEntry.-val", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.ISet = function() {
+  var obj6993 = {};
+  return obj6993;
+}();
+cljs.core._disjoin = function _disjoin(coll, v) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISet$_disjoin$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISet$_disjoin$arity$2(coll, v);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._disjoin[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._disjoin["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ISet.-disjoin", coll);
+        }
+      }
+    }().call(null, coll, v);
+  }
+};
+cljs.core.IStack = function() {
+  var obj6995 = {};
+  return obj6995;
+}();
+cljs.core._peek = function _peek(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IStack$_peek$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IStack$_peek$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._peek[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._peek["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IStack$_pop$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IStack$_pop$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._pop[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._pop["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IStack.-pop", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.IVector = function() {
+  var obj6997 = {};
+  return obj6997;
+}();
+cljs.core._assoc_n = function _assoc_n(coll, n, val) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IVector$_assoc_n$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IVector$_assoc_n$arity$3(coll, n, val);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._assoc_n[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._assoc_n["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IVector.-assoc-n", coll);
+        }
+      }
+    }().call(null, coll, n, val);
+  }
+};
+cljs.core.IDeref = function() {
+  var obj6999 = {};
+  return obj6999;
+}();
+cljs.core._deref = function _deref(o) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IDeref$_deref$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IDeref$_deref$arity$1(o);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._deref[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._deref["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IDeref.-deref", o);
+        }
+      }
+    }().call(null, o);
+  }
+};
+cljs.core.IDerefWithTimeout = function() {
+  var obj7001 = {};
+  return obj7001;
+}();
+cljs.core._deref_with_timeout = function _deref_with_timeout(o, msec, timeout_val) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o, msec, timeout_val);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._deref_with_timeout[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._deref_with_timeout["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IDerefWithTimeout.-deref-with-timeout", o);
+        }
+      }
+    }().call(null, o, msec, timeout_val);
+  }
+};
+cljs.core.IMeta = function() {
+  var obj7003 = {};
+  return obj7003;
+}();
+cljs.core._meta = function _meta(o) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IMeta$_meta$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IMeta$_meta$arity$1(o);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._meta[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._meta["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IMeta.-meta", o);
+        }
+      }
+    }().call(null, o);
+  }
+};
+cljs.core.IWithMeta = function() {
+  var obj7005 = {};
+  return obj7005;
+}();
+cljs.core._with_meta = function _with_meta(o, meta) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IWithMeta$_with_meta$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IWithMeta$_with_meta$arity$2(o, meta);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._with_meta[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._with_meta["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IWithMeta.-with-meta", o);
+        }
+      }
+    }().call(null, o, meta);
+  }
+};
+cljs.core.IReduce = function() {
+  var obj7007 = {};
+  return obj7007;
+}();
+cljs.core._reduce = function() {
+  var _reduce = null;
+  var _reduce__2 = function(coll, f) {
+    if (function() {
+      var and__3396__auto__ = coll;
+      if (and__3396__auto__) {
+        return coll.cljs$core$IReduce$_reduce$arity$2;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return coll.cljs$core$IReduce$_reduce$arity$2(coll, f);
+    } else {
+      var x__4011__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3408__auto__ = cljs.core._reduce[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._reduce["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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__3396__auto__ = coll;
+      if (and__3396__auto__) {
+        return coll.cljs$core$IReduce$_reduce$arity$3;
+      } else {
+        return and__3396__auto__;
+      }
+    }()) {
+      return coll.cljs$core$IReduce$_reduce$arity$3(coll, f, start);
+    } else {
+      var x__4011__auto__ = coll == null ? null : coll;
+      return function() {
+        var or__3408__auto__ = cljs.core._reduce[goog.typeOf(x__4011__auto__)];
+        if (or__3408__auto__) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = cljs.core._reduce["_"];
+          if (or__3408__auto____$1) {
+            return or__3408__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 = function() {
+  var obj7009 = {};
+  return obj7009;
+}();
+cljs.core._kv_reduce = function _kv_reduce(coll, f, init) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IKVReduce$_kv_reduce$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll, f, init);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._kv_reduce[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._kv_reduce["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IKVReduce.-kv-reduce", coll);
+        }
+      }
+    }().call(null, coll, f, init);
+  }
+};
+cljs.core.IEquiv = function() {
+  var obj7011 = {};
+  return obj7011;
+}();
+cljs.core._equiv = function _equiv(o, other) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IEquiv$_equiv$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IEquiv$_equiv$arity$2(o, other);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._equiv[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._equiv["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IEquiv.-equiv", o);
+        }
+      }
+    }().call(null, o, other);
+  }
+};
+cljs.core.IHash = function() {
+  var obj7013 = {};
+  return obj7013;
+}();
+cljs.core._hash = function _hash(o) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IHash$_hash$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IHash$_hash$arity$1(o);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._hash[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._hash["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IHash.-hash", o);
+        }
+      }
+    }().call(null, o);
+  }
+};
+cljs.core.ISeqable = function() {
+  var obj7015 = {};
+  return obj7015;
+}();
+cljs.core._seq = function _seq(o) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$ISeqable$_seq$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$ISeqable$_seq$arity$1(o);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._seq[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._seq["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ISeqable.-seq", o);
+        }
+      }
+    }().call(null, o);
+  }
+};
+cljs.core.ISequential = function() {
+  var obj7017 = {};
+  return obj7017;
+}();
+cljs.core.IList = function() {
+  var obj7019 = {};
+  return obj7019;
+}();
+cljs.core.IRecord = function() {
+  var obj7021 = {};
+  return obj7021;
+}();
+cljs.core.IReversible = function() {
+  var obj7023 = {};
+  return obj7023;
+}();
+cljs.core._rseq = function _rseq(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IReversible$_rseq$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IReversible$_rseq$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._rseq[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._rseq["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IReversible.-rseq", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.ISorted = function() {
+  var obj7025 = {};
+  return obj7025;
+}();
+cljs.core._sorted_seq = function _sorted_seq(coll, ascending_QMARK_) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISorted$_sorted_seq$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll, ascending_QMARK_);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._sorted_seq[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._sorted_seq["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISorted$_sorted_seq_from$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll, k, ascending_QMARK_);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._sorted_seq_from[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._sorted_seq_from["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISorted$_entry_key$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_entry_key$arity$2(coll, entry);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._entry_key[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._entry_key["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$ISorted$_comparator$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$ISorted$_comparator$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._comparator[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._comparator["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ISorted.-comparator", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.IWriter = function() {
+  var obj7027 = {};
+  return obj7027;
+}();
+cljs.core._write = function _write(writer, s) {
+  if (function() {
+    var and__3396__auto__ = writer;
+    if (and__3396__auto__) {
+      return writer.cljs$core$IWriter$_write$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return writer.cljs$core$IWriter$_write$arity$2(writer, s);
+  } else {
+    var x__4011__auto__ = writer == null ? null : writer;
+    return function() {
+      var or__3408__auto__ = cljs.core._write[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._write["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = writer;
+    if (and__3396__auto__) {
+      return writer.cljs$core$IWriter$_flush$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return writer.cljs$core$IWriter$_flush$arity$1(writer);
+  } else {
+    var x__4011__auto__ = writer == null ? null : writer;
+    return function() {
+      var or__3408__auto__ = cljs.core._flush[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._flush["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IWriter.-flush", writer);
+        }
+      }
+    }().call(null, writer);
+  }
+};
+cljs.core.IPrintWithWriter = function() {
+  var obj7029 = {};
+  return obj7029;
+}();
+cljs.core._pr_writer = function _pr_writer(o, writer, opts) {
+  if (function() {
+    var and__3396__auto__ = o;
+    if (and__3396__auto__) {
+      return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o, writer, opts);
+  } else {
+    var x__4011__auto__ = o == null ? null : o;
+    return function() {
+      var or__3408__auto__ = cljs.core._pr_writer[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._pr_writer["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IPrintWithWriter.-pr-writer", o);
+        }
+      }
+    }().call(null, o, writer, opts);
+  }
+};
+cljs.core.IPending = function() {
+  var obj7031 = {};
+  return obj7031;
+}();
+cljs.core._realized_QMARK_ = function _realized_QMARK_(d) {
+  if (function() {
+    var and__3396__auto__ = d;
+    if (and__3396__auto__) {
+      return d.cljs$core$IPending$_realized_QMARK_$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return d.cljs$core$IPending$_realized_QMARK_$arity$1(d);
+  } else {
+    var x__4011__auto__ = d == null ? null : d;
+    return function() {
+      var or__3408__auto__ = cljs.core._realized_QMARK_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._realized_QMARK_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IPending.-realized?", d);
+        }
+      }
+    }().call(null, d);
+  }
+};
+cljs.core.IWatchable = function() {
+  var obj7033 = {};
+  return obj7033;
+}();
+cljs.core._notify_watches = function _notify_watches(this$, oldval, newval) {
+  if (function() {
+    var and__3396__auto__ = this$;
+    if (and__3396__auto__) {
+      return this$.cljs$core$IWatchable$_notify_watches$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$, oldval, newval);
+  } else {
+    var x__4011__auto__ = this$ == null ? null : this$;
+    return function() {
+      var or__3408__auto__ = cljs.core._notify_watches[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._notify_watches["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = this$;
+    if (and__3396__auto__) {
+      return this$.cljs$core$IWatchable$_add_watch$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return this$.cljs$core$IWatchable$_add_watch$arity$3(this$, key, f);
+  } else {
+    var x__4011__auto__ = this$ == null ? null : this$;
+    return function() {
+      var or__3408__auto__ = cljs.core._add_watch[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._add_watch["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = this$;
+    if (and__3396__auto__) {
+      return this$.cljs$core$IWatchable$_remove_watch$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$, key);
+  } else {
+    var x__4011__auto__ = this$ == null ? null : this$;
+    return function() {
+      var or__3408__auto__ = cljs.core._remove_watch[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._remove_watch["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IWatchable.-remove-watch", this$);
+        }
+      }
+    }().call(null, this$, key);
+  }
+};
+cljs.core.IEditableCollection = function() {
+  var obj7035 = {};
+  return obj7035;
+}();
+cljs.core._as_transient = function _as_transient(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IEditableCollection$_as_transient$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._as_transient[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._as_transient["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IEditableCollection.-as-transient", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.ITransientCollection = function() {
+  var obj7037 = {};
+  return obj7037;
+}();
+cljs.core._conj_BANG_ = function _conj_BANG_(tcoll, val) {
+  if (function() {
+    var and__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll, val);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._conj_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._conj_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._persistent_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._persistent_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ITransientCollection.-persistent!", tcoll);
+        }
+      }
+    }().call(null, tcoll);
+  }
+};
+cljs.core.ITransientAssociative = function() {
+  var obj7039 = {};
+  return obj7039;
+}();
+cljs.core._assoc_BANG_ = function _assoc_BANG_(tcoll, key, val) {
+  if (function() {
+    var and__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll, key, val);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._assoc_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._assoc_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ITransientAssociative.-assoc!", tcoll);
+        }
+      }
+    }().call(null, tcoll, key, val);
+  }
+};
+cljs.core.ITransientMap = function() {
+  var obj7041 = {};
+  return obj7041;
+}();
+cljs.core._dissoc_BANG_ = function _dissoc_BANG_(tcoll, key) {
+  if (function() {
+    var and__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll, key);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._dissoc_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._dissoc_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ITransientMap.-dissoc!", tcoll);
+        }
+      }
+    }().call(null, tcoll, key);
+  }
+};
+cljs.core.ITransientVector = function() {
+  var obj7043 = {};
+  return obj7043;
+}();
+cljs.core._assoc_n_BANG_ = function _assoc_n_BANG_(tcoll, n, val) {
+  if (function() {
+    var and__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll, n, val);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._assoc_n_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._assoc_n_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._pop_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._pop_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ITransientVector.-pop!", tcoll);
+        }
+      }
+    }().call(null, tcoll);
+  }
+};
+cljs.core.ITransientSet = function() {
+  var obj7045 = {};
+  return obj7045;
+}();
+cljs.core._disjoin_BANG_ = function _disjoin_BANG_(tcoll, v) {
+  if (function() {
+    var and__3396__auto__ = tcoll;
+    if (and__3396__auto__) {
+      return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll, v);
+  } else {
+    var x__4011__auto__ = tcoll == null ? null : tcoll;
+    return function() {
+      var or__3408__auto__ = cljs.core._disjoin_BANG_[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._disjoin_BANG_["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "ITransientSet.-disjoin!", tcoll);
+        }
+      }
+    }().call(null, tcoll, v);
+  }
+};
+cljs.core.IComparable = function() {
+  var obj7047 = {};
+  return obj7047;
+}();
+cljs.core._compare = function _compare(x, y) {
+  if (function() {
+    var and__3396__auto__ = x;
+    if (and__3396__auto__) {
+      return x.cljs$core$IComparable$_compare$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return x.cljs$core$IComparable$_compare$arity$2(x, y);
+  } else {
+    var x__4011__auto__ = x == null ? null : x;
+    return function() {
+      var or__3408__auto__ = cljs.core._compare[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._compare["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IComparable.-compare", x);
+        }
+      }
+    }().call(null, x, y);
+  }
+};
+cljs.core.IChunk = function() {
+  var obj7049 = {};
+  return obj7049;
+}();
+cljs.core._drop_first = function _drop_first(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IChunk$_drop_first$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IChunk$_drop_first$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._drop_first[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._drop_first["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IChunk.-drop-first", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.IChunkedSeq = function() {
+  var obj7051 = {};
+  return obj7051;
+}();
+cljs.core._chunked_first = function _chunked_first(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._chunked_first[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._chunked_first["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._chunked_rest[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._chunked_rest["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IChunkedSeq.-chunked-rest", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.IChunkedNext = function() {
+  var obj7053 = {};
+  return obj7053;
+}();
+cljs.core._chunked_next = function _chunked_next(coll) {
+  if (function() {
+    var and__3396__auto__ = coll;
+    if (and__3396__auto__) {
+      return coll.cljs$core$IChunkedNext$_chunked_next$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll);
+  } else {
+    var x__4011__auto__ = coll == null ? null : coll;
+    return function() {
+      var or__3408__auto__ = cljs.core._chunked_next[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._chunked_next["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IChunkedNext.-chunked-next", coll);
+        }
+      }
+    }().call(null, coll);
+  }
+};
+cljs.core.INamed = function() {
+  var obj7055 = {};
+  return obj7055;
+}();
+cljs.core._name = function _name(x) {
+  if (function() {
+    var and__3396__auto__ = x;
+    if (and__3396__auto__) {
+      return x.cljs$core$INamed$_name$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return x.cljs$core$INamed$_name$arity$1(x);
+  } else {
+    var x__4011__auto__ = x == null ? null : x;
+    return function() {
+      var or__3408__auto__ = cljs.core._name[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._name["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = x;
+    if (and__3396__auto__) {
+      return x.cljs$core$INamed$_namespace$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return x.cljs$core$INamed$_namespace$arity$1(x);
+  } else {
+    var x__4011__auto__ = x == null ? null : x;
+    return function() {
+      var or__3408__auto__ = cljs.core._namespace[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._namespace["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "INamed.-namespace", x);
+        }
+      }
+    }().call(null, x);
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/StringBufferWriter");
+};
+cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_write$arity$2 = function(_, s) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.sb.append(s);
+};
+cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_flush$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return null;
+};
+cljs.core.__GT_StringBufferWriter = function __GT_StringBufferWriter(sb) {
+  return new cljs.core.StringBufferWriter(sb);
+};
+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;
+};
+cljs.core.hash_symbol = function hash_symbol(sym) {
+  return cljs.core.hash_combine.call(null, cljs.core.hash.call(null, sym.ns), cljs.core.hash.call(null, sym.name));
+};
+cljs.core.compare_symbols = function compare_symbols(a, b) {
+  if (cljs.core.truth_(cljs.core._EQ_.call(null, a, b))) {
+    return 0;
+  } else {
+    if (cljs.core.truth_(function() {
+      var and__3396__auto__ = cljs.core.not.call(null, a.ns);
+      if (and__3396__auto__) {
+        return b.ns;
+      } else {
+        return and__3396__auto__;
+      }
+    }())) {
+      return-1;
+    } else {
+      if (cljs.core.truth_(a.ns)) {
+        if (cljs.core.not.call(null, b.ns)) {
+          return 1;
+        } else {
+          var nsc = cljs.core.compare.call(null, a.ns, b.ns);
+          if (nsc === 0) {
+            return cljs.core.compare.call(null, a.name, b.name);
+          } else {
+            return nsc;
+          }
+        }
+      } else {
+        if (new cljs.core.Keyword(null, "default", "default", 2558708147)) {
+          return cljs.core.compare.call(null, a.name, b.name);
+        } else {
+          return null;
+        }
+      }
+    }
+  }
+};
+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$partition0$ = 2154168321;
+  this.cljs$lang$protocol_mask$partition1$ = 4096;
+};
+cljs.core.Symbol.cljs$lang$type = true;
+cljs.core.Symbol.cljs$lang$ctorStr = "cljs.core/Symbol";
+cljs.core.Symbol.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Symbol");
+};
+cljs.core.Symbol.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(o, writer, _) {
+  var self__ = this;
+  var o__$1 = this;
+  return cljs.core._write.call(null, writer, self__.str);
+};
+cljs.core.Symbol.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.name;
+};
+cljs.core.Symbol.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.ns;
+};
+cljs.core.Symbol.prototype.cljs$core$IHash$_hash$arity$1 = function(sym) {
+  var self__ = this;
+  var sym__$1 = this;
+  var h__3819__auto__ = self__._hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_symbol.call(null, sym__$1);
+    self__._hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.Symbol.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_, new_meta) {
+  var self__ = this;
+  var ___$1 = 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;
+  var ___$1 = this;
+  return self__._meta;
+};
+cljs.core.Symbol.prototype.call = function() {
+  var G__7057 = null;
+  var G__7057__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__7057__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__7057 = function(self__, coll, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7057__2.call(this, self__, coll);
+      case 3:
+        return G__7057__3.call(this, self__, coll, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7057;
+}();
+cljs.core.Symbol.prototype.apply = function(self__, args7056) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7056)));
+};
+cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$1 = function(coll) {
+  var self__ = this;
+  var sym = this;
+  return cljs.core._lookup.call(null, coll, sym, null);
+};
+cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$2 = function(coll, not_found) {
+  var self__ = this;
+  var sym = this;
+  return cljs.core._lookup.call(null, coll, sym, not_found);
+};
+cljs.core.Symbol.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(_, other) {
+  var self__ = this;
+  var ___$1 = 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.__GT_Symbol = function __GT_Symbol(ns, name, str, _hash, _meta) {
+  return new cljs.core.Symbol(ns, name, str, _hash, _meta);
+};
+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, null, 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__7059 = coll;
+      if (G__7059) {
+        var bit__4027__auto__ = G__7059.cljs$lang$protocol_mask$partition0$ & 8388608;
+        if (bit__4027__auto__ || G__7059.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 (typeof coll === "string") {
+          if (coll.length === 0) {
+            return null;
+          } else {
+            return new cljs.core.IndexedSeq(coll, 0);
+          }
+        } else {
+          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, coll)) {
+            return cljs.core._seq.call(null, coll);
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              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__7061 = coll;
+      if (G__7061) {
+        var bit__4027__auto__ = G__7061.cljs$lang$protocol_mask$partition0$ & 64;
+        if (bit__4027__auto__ || G__7061.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__7063 = coll;
+      if (G__7063) {
+        var bit__4027__auto__ = G__7063.cljs$lang$protocol_mask$partition0$ & 64;
+        if (bit__4027__auto__ || G__7063.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) {
+        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__7065 = coll;
+      if (G__7065) {
+        var bit__4027__auto__ = G__7065.cljs$lang$protocol_mask$partition0$ & 128;
+        if (bit__4027__auto__ || G__7065.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) {
+    if (x == null) {
+      return y == null;
+    } else {
+      return x === y || cljs.core._equiv.call(null, x, y);
+    }
+  };
+  var _EQ___3 = function() {
+    var G__7066__delegate = function(x, y, more) {
+      while (true) {
+        if (_EQ_.call(null, x, y)) {
+          if (cljs.core.next.call(null, more)) {
+            var G__7067 = y;
+            var G__7068 = cljs.core.first.call(null, more);
+            var G__7069 = cljs.core.next.call(null, more);
+            x = G__7067;
+            y = G__7068;
+            more = G__7069;
+            continue;
+          } else {
+            return _EQ_.call(null, y, cljs.core.first.call(null, more));
+          }
+        } else {
+          return false;
+        }
+        break;
+      }
+    };
+    var G__7066 = 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__7066__delegate.call(this, x, y, more);
+    };
+    G__7066.cljs$lang$maxFixedArity = 2;
+    G__7066.cljs$lang$applyTo = function(arglist__7070) {
+      var x = cljs.core.first(arglist__7070);
+      arglist__7070 = cljs.core.next(arglist__7070);
+      var y = cljs.core.first(arglist__7070);
+      var more = cljs.core.rest(arglist__7070);
+      return G__7066__delegate(x, y, more);
+    };
+    G__7066.cljs$core$IFn$_invoke$arity$variadic = G__7066__delegate;
+    return G__7066;
+  }();
+  _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.ICounted["null"] = true;
+cljs.core._count["null"] = function(_) {
+  return 0;
+};
+Date.prototype.cljs$core$IEquiv$ = true;
+Date.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
+  var o__$1 = this;
+  return other instanceof Date && o__$1.toString() === other.toString();
+};
+cljs.core.IEquiv["number"] = true;
+cljs.core._equiv["number"] = function(x, o) {
+  return x === o;
+};
+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;
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Reduced");
+};
+cljs.core.Reduced.prototype.cljs$core$IDeref$_deref$arity$1 = function(o) {
+  var self__ = this;
+  var o__$1 = this;
+  return self__.val;
+};
+cljs.core.__GT_Reduced = function __GT_Reduced(val) {
+  return new cljs.core.Reduced(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__7071 = nval;
+            var G__7072 = n + 1;
+            val = G__7071;
+            n = G__7072;
+            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__7073 = nval;
+          var G__7074 = n + 1;
+          val__$1 = G__7073;
+          n = G__7074;
+          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__7075 = nval;
+          var G__7076 = n + 1;
+          val__$1 = G__7075;
+          n = G__7076;
+          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__7077 = nval;
+            var G__7078 = n + 1;
+            val = G__7077;
+            n = G__7078;
+            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__7079 = nval;
+          var G__7080 = n + 1;
+          val__$1 = G__7079;
+          n = G__7080;
+          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__7081 = nval;
+          var G__7082 = n + 1;
+          val__$1 = G__7081;
+          n = G__7082;
+          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__7084 = x;
+  if (G__7084) {
+    var bit__4034__auto__ = G__7084.cljs$lang$protocol_mask$partition0$ & 2;
+    if (bit__4034__auto__ || G__7084.cljs$core$ICounted$) {
+      return true;
+    } else {
+      if (!G__7084.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, G__7084);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, G__7084);
+  }
+};
+cljs.core.indexed_QMARK_ = function indexed_QMARK_(x) {
+  var G__7086 = x;
+  if (G__7086) {
+    var bit__4034__auto__ = G__7086.cljs$lang$protocol_mask$partition0$ & 16;
+    if (bit__4034__auto__ || G__7086.cljs$core$IIndexed$) {
+      return true;
+    } else {
+      if (!G__7086.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, G__7086);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, G__7086);
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/IndexedSeq");
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.hash_coll.call(null, coll__$1);
+};
+cljs.core.IndexedSeq.prototype.cljs$core$INext$_next$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var c = cljs.core._count.call(null, coll__$1);
+  if (c > 0) {
+    return new cljs.core.RSeq(coll__$1, c - 1, null);
+  } else {
+    return null;
+  }
+};
+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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var this$__$1 = this;
+  return this$__$1;
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.arr.length - self__.i;
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.arr[self__.i];
+};
+cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  if (self__.i + 1 < self__.arr.length) {
+    return new cljs.core.IndexedSeq(self__.arr, self__.i + 1);
+  } else {
+    return cljs.core.List.EMPTY;
+  }
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  var coll__$1 = 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 coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.List.EMPTY;
+};
+cljs.core.__GT_IndexedSeq = function __GT_IndexedSeq(arr, i) {
+  return new cljs.core.IndexedSeq(arr, i);
+};
+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.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$ = 32374862;
+};
+cljs.core.RSeq.cljs$lang$type = true;
+cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq";
+cljs.core.RSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/RSeq");
+};
+cljs.core.RSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.hash_coll.call(null, coll__$1);
+};
+cljs.core.RSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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$IReduce$_reduce$arity$2 = function(col, f) {
+  var self__ = this;
+  var col__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, col__$1);
+};
+cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(col, f, start) {
+  var self__ = this;
+  var col__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, col__$1);
+};
+cljs.core.RSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.RSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.i + 1;
+};
+cljs.core.RSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  if (self__.i > 0) {
+    return new cljs.core.RSeq(self__.ci, self__.i - 1, null);
+  } else {
+    return null;
+  }
+};
+cljs.core.RSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.RSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.RSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_RSeq = function __GT_RSeq(ci, i, meta) {
+  return new cljs.core.RSeq(ci, i, 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__7087 = sn;
+      s = G__7087;
+      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._conj.call(null, cljs.core.List.EMPTY, x);
+    }
+  };
+  var conj__3 = function() {
+    var G__7088__delegate = function(coll, x, xs) {
+      while (true) {
+        if (cljs.core.truth_(xs)) {
+          var G__7089 = conj.call(null, coll, x);
+          var G__7090 = cljs.core.first.call(null, xs);
+          var G__7091 = cljs.core.next.call(null, xs);
+          coll = G__7089;
+          x = G__7090;
+          xs = G__7091;
+          continue;
+        } else {
+          return conj.call(null, coll, x);
+        }
+        break;
+      }
+    };
+    var G__7088 = 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__7088__delegate.call(this, coll, x, xs);
+    };
+    G__7088.cljs$lang$maxFixedArity = 2;
+    G__7088.cljs$lang$applyTo = function(arglist__7092) {
+      var coll = cljs.core.first(arglist__7092);
+      arglist__7092 = cljs.core.next(arglist__7092);
+      var x = cljs.core.first(arglist__7092);
+      var xs = cljs.core.rest(arglist__7092);
+      return G__7088__delegate(coll, x, xs);
+    };
+    G__7088.cljs$core$IFn$_invoke$arity$variadic = G__7088__delegate;
+    return G__7088;
+  }();
+  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) {
+  if (coll == null) {
+    return null;
+  } else {
+    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__7093 = cljs.core.next.call(null, s);
+      var G__7094 = acc + 1;
+      s = G__7093;
+      acc = G__7094;
+      continue;
+    }
+    break;
+  }
+};
+cljs.core.count = function count(coll) {
+  if (!(coll == null)) {
+    if (function() {
+      var G__7096 = coll;
+      if (G__7096) {
+        var bit__4027__auto__ = G__7096.cljs$lang$protocol_mask$partition0$ & 2;
+        if (bit__4027__auto__ || G__7096.cljs$core$ICounted$) {
+          return true;
+        } else {
+          return false;
+        }
+      } else {
+        return false;
+      }
+    }()) {
+      return cljs.core._count.call(null, coll);
+    } else {
+      if (coll instanceof Array) {
+        return coll.length;
+      } else {
+        if (typeof coll === "string") {
+          return coll.length;
+        } else {
+          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, coll)) {
+            return cljs.core._count.call(null, coll);
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              return cljs.core.accumulating_seq_count.call(null, coll);
+            } else {
+              return null;
+            }
+          }
+        }
+      }
+    }
+  } else {
+    return 0;
+  }
+};
+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__7097 = cljs.core.next.call(null, coll);
+              var G__7098 = n - 1;
+              coll = G__7097;
+              n = G__7098;
+              continue;
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                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__7099 = cljs.core.next.call(null, coll);
+              var G__7100 = n - 1;
+              var G__7101 = not_found;
+              coll = G__7099;
+              n = G__7100;
+              not_found = G__7101;
+              continue;
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                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__7106 = coll;
+        if (G__7106) {
+          var bit__4027__auto__ = G__7106.cljs$lang$protocol_mask$partition0$ & 16;
+          if (bit__4027__auto__ || G__7106.cljs$core$IIndexed$) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      }()) {
+        return cljs.core._nth.call(null, coll, n);
+      } else {
+        if (coll instanceof Array) {
+          if (n < coll.length) {
+            return coll[n];
+          } else {
+            return null;
+          }
+        } else {
+          if (typeof coll === "string") {
+            if (n < coll.length) {
+              return coll[n];
+            } else {
+              return null;
+            }
+          } else {
+            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, coll)) {
+              return cljs.core._nth.call(null, coll, n);
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                if (function() {
+                  var G__7107 = coll;
+                  if (G__7107) {
+                    var bit__4034__auto__ = G__7107.cljs$lang$protocol_mask$partition0$ & 64;
+                    if (bit__4034__auto__ || G__7107.cljs$core$ISeq$) {
+                      return true;
+                    } else {
+                      if (!G__7107.cljs$lang$protocol_mask$partition0$) {
+                        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7107);
+                      } else {
+                        return false;
+                      }
+                    }
+                  } else {
+                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7107);
+                  }
+                }()) {
+                  return cljs.core.linear_traversal_nth.call(null, coll, n);
+                } else {
+                  throw new Error([cljs.core.str("nth not supported on this type "), cljs.core.str(cljs.core.type__GT_str.call(null, cljs.core.type.call(null, coll)))].join(""));
+                }
+              } else {
+                return null;
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  var nth__3 = function(coll, n, not_found) {
+    if (!(coll == null)) {
+      if (function() {
+        var G__7108 = coll;
+        if (G__7108) {
+          var bit__4027__auto__ = G__7108.cljs$lang$protocol_mask$partition0$ & 16;
+          if (bit__4027__auto__ || G__7108.cljs$core$IIndexed$) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return false;
+        }
+      }()) {
+        return cljs.core._nth.call(null, coll, n, not_found);
+      } else {
+        if (coll instanceof Array) {
+          if (n < coll.length) {
+            return coll[n];
+          } else {
+            return not_found;
+          }
+        } else {
+          if (typeof coll === "string") {
+            if (n < coll.length) {
+              return coll[n];
+            } else {
+              return not_found;
+            }
+          } else {
+            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, coll)) {
+              return cljs.core._nth.call(null, coll, n);
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                if (function() {
+                  var G__7109 = coll;
+                  if (G__7109) {
+                    var bit__4034__auto__ = G__7109.cljs$lang$protocol_mask$partition0$ & 64;
+                    if (bit__4034__auto__ || G__7109.cljs$core$ISeq$) {
+                      return true;
+                    } else {
+                      if (!G__7109.cljs$lang$protocol_mask$partition0$) {
+                        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7109);
+                      } else {
+                        return false;
+                      }
+                    }
+                  } else {
+                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7109);
+                  }
+                }()) {
+                  return cljs.core.linear_traversal_nth.call(null, coll, n, not_found);
+                } else {
+                  throw new Error([cljs.core.str("nth not supported on this type "), cljs.core.str(cljs.core.type__GT_str.call(null, cljs.core.type.call(null, coll)))].join(""));
+                }
+              } 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__7112 = o;
+        if (G__7112) {
+          var bit__4027__auto__ = G__7112.cljs$lang$protocol_mask$partition0$ & 256;
+          if (bit__4027__auto__ || G__7112.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 (typeof o === "string") {
+            if (k < o.length) {
+              return o[k];
+            } else {
+              return null;
+            }
+          } else {
+            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, o)) {
+              return cljs.core._lookup.call(null, o, k);
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                return null;
+              } else {
+                return null;
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  var get__3 = function(o, k, not_found) {
+    if (!(o == null)) {
+      if (function() {
+        var G__7113 = o;
+        if (G__7113) {
+          var bit__4027__auto__ = G__7113.cljs$lang$protocol_mask$partition0$ & 256;
+          if (bit__4027__auto__ || G__7113.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 (typeof o === "string") {
+            if (k < o.length) {
+              return o[k];
+            } else {
+              return not_found;
+            }
+          } else {
+            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, o)) {
+              return cljs.core._lookup.call(null, o, k, not_found);
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                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.PersistentHashMap.fromArrays.call(null, [k], [v]);
+    }
+  };
+  var assoc__4 = function() {
+    var G__7114__delegate = function(coll, k, v, kvs) {
+      while (true) {
+        var ret = assoc.call(null, coll, k, v);
+        if (cljs.core.truth_(kvs)) {
+          var G__7115 = ret;
+          var G__7116 = cljs.core.first.call(null, kvs);
+          var G__7117 = cljs.core.second.call(null, kvs);
+          var G__7118 = cljs.core.nnext.call(null, kvs);
+          coll = G__7115;
+          k = G__7116;
+          v = G__7117;
+          kvs = G__7118;
+          continue;
+        } else {
+          return ret;
+        }
+        break;
+      }
+    };
+    var G__7114 = 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__7114__delegate.call(this, coll, k, v, kvs);
+    };
+    G__7114.cljs$lang$maxFixedArity = 3;
+    G__7114.cljs$lang$applyTo = function(arglist__7119) {
+      var coll = cljs.core.first(arglist__7119);
+      arglist__7119 = cljs.core.next(arglist__7119);
+      var k = cljs.core.first(arglist__7119);
+      arglist__7119 = cljs.core.next(arglist__7119);
+      var v = cljs.core.first(arglist__7119);
+      var kvs = cljs.core.rest(arglist__7119);
+      return G__7114__delegate(coll, k, v, kvs);
+    };
+    G__7114.cljs$core$IFn$_invoke$arity$variadic = G__7114__delegate;
+    return G__7114;
+  }();
+  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) {
+    if (coll == null) {
+      return null;
+    } else {
+      return cljs.core._dissoc.call(null, coll, k);
+    }
+  };
+  var dissoc__3 = function() {
+    var G__7120__delegate = function(coll, k, ks) {
+      while (true) {
+        if (coll == null) {
+          return null;
+        } else {
+          var ret = dissoc.call(null, coll, k);
+          if (cljs.core.truth_(ks)) {
+            var G__7121 = ret;
+            var G__7122 = cljs.core.first.call(null, ks);
+            var G__7123 = cljs.core.next.call(null, ks);
+            coll = G__7121;
+            k = G__7122;
+            ks = G__7123;
+            continue;
+          } else {
+            return ret;
+          }
+        }
+        break;
+      }
+    };
+    var G__7120 = 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__7120__delegate.call(this, coll, k, ks);
+    };
+    G__7120.cljs$lang$maxFixedArity = 2;
+    G__7120.cljs$lang$applyTo = function(arglist__7124) {
+      var coll = cljs.core.first(arglist__7124);
+      arglist__7124 = cljs.core.next(arglist__7124);
+      var k = cljs.core.first(arglist__7124);
+      var ks = cljs.core.rest(arglist__7124);
+      return G__7120__delegate(coll, k, ks);
+    };
+    G__7120.cljs$core$IFn$_invoke$arity$variadic = G__7120__delegate;
+    return G__7120;
+  }();
+  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__3408__auto__ = goog.isFunction(f);
+  if (or__3408__auto__) {
+    return or__3408__auto__;
+  } else {
+    var G__7128 = f;
+    if (G__7128) {
+      var bit__4034__auto__ = null;
+      if (cljs.core.truth_(function() {
+        var or__3408__auto____$1 = bit__4034__auto__;
+        if (cljs.core.truth_(or__3408__auto____$1)) {
+          return or__3408__auto____$1;
+        } else {
+          return G__7128.cljs$core$Fn$;
+        }
+      }())) {
+        return true;
+      } else {
+        if (!G__7128.cljs$lang$protocol_mask$partition$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.Fn, G__7128);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.Fn, G__7128);
+    }
+  }
+};
+cljs.core.with_meta = function with_meta(o, meta) {
+  if (cljs.core.fn_QMARK_.call(null, o) && !function() {
+    var G__7136 = o;
+    if (G__7136) {
+      var bit__4034__auto__ = G__7136.cljs$lang$protocol_mask$partition0$ & 262144;
+      if (bit__4034__auto__ || G__7136.cljs$core$IWithMeta$) {
+        return true;
+      } else {
+        if (!G__7136.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IWithMeta, G__7136);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IWithMeta, G__7136);
+    }
+  }()) {
+    return with_meta.call(null, function() {
+      if (typeof cljs.core.t7137 !== "undefined") {
+      } else {
+        cljs.core.t7137 = function(meta, o, with_meta, meta7138) {
+          this.meta = meta;
+          this.o = o;
+          this.with_meta = with_meta;
+          this.meta7138 = meta7138;
+          this.cljs$lang$protocol_mask$partition1$ = 0;
+          this.cljs$lang$protocol_mask$partition0$ = 393217;
+        };
+        cljs.core.t7137.cljs$lang$type = true;
+        cljs.core.t7137.cljs$lang$ctorStr = "cljs.core/t7137";
+        cljs.core.t7137.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+          return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/t7137");
+        };
+        cljs.core.t7137.prototype.call = function() {
+          var G__7141__delegate = function(self__, args) {
+            var self____$1 = this;
+            var _ = self____$1;
+            return cljs.core.apply.call(null, self__.o, args);
+          };
+          var G__7141 = 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__7141__delegate.call(this, self__, args);
+          };
+          G__7141.cljs$lang$maxFixedArity = 1;
+          G__7141.cljs$lang$applyTo = function(arglist__7142) {
+            var self__ = cljs.core.first(arglist__7142);
+            var args = cljs.core.rest(arglist__7142);
+            return G__7141__delegate(self__, args);
+          };
+          G__7141.cljs$core$IFn$_invoke$arity$variadic = G__7141__delegate;
+          return G__7141;
+        }();
+        cljs.core.t7137.prototype.apply = function(self__, args7140) {
+          var self__ = this;
+          var self____$1 = this;
+          return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7140)));
+        };
+        cljs.core.t7137.prototype.cljs$core$IFn$_invoke$arity$2 = function() {
+          var G__7143__delegate = function(args) {
+            var _ = this;
+            return cljs.core.apply.call(null, self__.o, args);
+          };
+          var G__7143 = function(var_args) {
+            var self__ = this;
+            var args = null;
+            if (arguments.length > 0) {
+              args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+            }
+            return G__7143__delegate.call(this, args);
+          };
+          G__7143.cljs$lang$maxFixedArity = 0;
+          G__7143.cljs$lang$applyTo = function(arglist__7144) {
+            var args = cljs.core.seq(arglist__7144);
+            return G__7143__delegate(args);
+          };
+          G__7143.cljs$core$IFn$_invoke$arity$variadic = G__7143__delegate;
+          return G__7143;
+        }();
+        cljs.core.t7137.prototype.cljs$core$Fn$ = true;
+        cljs.core.t7137.prototype.cljs$core$IMeta$_meta$arity$1 = function(_7139) {
+          var self__ = this;
+          var _7139__$1 = this;
+          return self__.meta7138;
+        };
+        cljs.core.t7137.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_7139, meta7138__$1) {
+          var self__ = this;
+          var _7139__$1 = this;
+          return new cljs.core.t7137(self__.meta, self__.o, self__.with_meta, meta7138__$1);
+        };
+        cljs.core.__GT_t7137 = function __GT_t7137(meta__$1, o__$1, with_meta__$1, meta7138) {
+          return new cljs.core.t7137(meta__$1, o__$1, with_meta__$1, meta7138);
+        };
+      }
+      return new cljs.core.t7137(meta, o, with_meta, null);
+    }(), meta);
+  } else {
+    if (o == null) {
+      return null;
+    } else {
+      return cljs.core._with_meta.call(null, o, meta);
+    }
+  }
+};
+cljs.core.meta = function meta(o) {
+  if (function() {
+    var and__3396__auto__ = !(o == null);
+    if (and__3396__auto__) {
+      var G__7148 = o;
+      if (G__7148) {
+        var bit__4034__auto__ = G__7148.cljs$lang$protocol_mask$partition0$ & 131072;
+        if (bit__4034__auto__ || G__7148.cljs$core$IMeta$) {
+          return true;
+        } else {
+          if (!G__7148.cljs$lang$protocol_mask$partition0$) {
+            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7148);
+          } else {
+            return false;
+          }
+        }
+      } else {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7148);
+      }
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return cljs.core._meta.call(null, o);
+  } else {
+    return null;
+  }
+};
+cljs.core.peek = function peek(coll) {
+  if (coll == null) {
+    return null;
+  } else {
+    return cljs.core._peek.call(null, coll);
+  }
+};
+cljs.core.pop = function pop(coll) {
+  if (coll == null) {
+    return null;
+  } else {
+    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) {
+    if (coll == null) {
+      return null;
+    } else {
+      return cljs.core._disjoin.call(null, coll, k);
+    }
+  };
+  var disj__3 = function() {
+    var G__7149__delegate = function(coll, k, ks) {
+      while (true) {
+        if (coll == null) {
+          return null;
+        } else {
+          var ret = disj.call(null, coll, k);
+          if (cljs.core.truth_(ks)) {
+            var G__7150 = ret;
+            var G__7151 = cljs.core.first.call(null, ks);
+            var G__7152 = cljs.core.next.call(null, ks);
+            coll = G__7150;
+            k = G__7151;
+            ks = G__7152;
+            continue;
+          } else {
+            return ret;
+          }
+        }
+        break;
+      }
+    };
+    var G__7149 = 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__7149__delegate.call(this, coll, k, ks);
+    };
+    G__7149.cljs$lang$maxFixedArity = 2;
+    G__7149.cljs$lang$applyTo = function(arglist__7153) {
+      var coll = cljs.core.first(arglist__7153);
+      arglist__7153 = cljs.core.next(arglist__7153);
+      var k = cljs.core.first(arglist__7153);
+      var ks = cljs.core.rest(arglist__7153);
+      return G__7149__delegate(coll, k, ks);
+    };
+    G__7149.cljs$core$IFn$_invoke$arity$variadic = G__7149__delegate;
+    return G__7149;
+  }();
+  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 = function() {
+  var obj7155 = {};
+  return obj7155;
+}();
+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 = function() {
+      var obj7159 = {};
+      return obj7159;
+    }();
+    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 hash(o) {
+  if (function() {
+    var G__7161 = o;
+    if (G__7161) {
+      var bit__4027__auto__ = G__7161.cljs$lang$protocol_mask$partition0$ & 4194304;
+      if (bit__4027__auto__ || G__7161.cljs$core$IHash$) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }()) {
+    return cljs.core._hash.call(null, o);
+  } else {
+    if (typeof o === "number") {
+      return Math.floor(o) % 2147483647;
+    } else {
+      if (o === true) {
+        return 1;
+      } else {
+        if (o === false) {
+          return 0;
+        } else {
+          if (typeof o === "string") {
+            return cljs.core.check_string_hash_cache.call(null, o);
+          } else {
+            if (o == null) {
+              return 0;
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                return cljs.core._hash.call(null, o);
+              } else {
+                return null;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.empty_QMARK_ = function empty_QMARK_(coll) {
+  return coll == null || 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__7163 = x;
+    if (G__7163) {
+      var bit__4034__auto__ = G__7163.cljs$lang$protocol_mask$partition0$ & 8;
+      if (bit__4034__auto__ || G__7163.cljs$core$ICollection$) {
+        return true;
+      } else {
+        if (!G__7163.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICollection, G__7163);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICollection, G__7163);
+    }
+  }
+};
+cljs.core.set_QMARK_ = function set_QMARK_(x) {
+  if (x == null) {
+    return false;
+  } else {
+    var G__7165 = x;
+    if (G__7165) {
+      var bit__4034__auto__ = G__7165.cljs$lang$protocol_mask$partition0$ & 4096;
+      if (bit__4034__auto__ || G__7165.cljs$core$ISet$) {
+        return true;
+      } else {
+        if (!G__7165.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISet, G__7165);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISet, G__7165);
+    }
+  }
+};
+cljs.core.associative_QMARK_ = function associative_QMARK_(x) {
+  var G__7167 = x;
+  if (G__7167) {
+    var bit__4034__auto__ = G__7167.cljs$lang$protocol_mask$partition0$ & 512;
+    if (bit__4034__auto__ || G__7167.cljs$core$IAssociative$) {
+      return true;
+    } else {
+      if (!G__7167.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IAssociative, G__7167);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IAssociative, G__7167);
+  }
+};
+cljs.core.sequential_QMARK_ = function sequential_QMARK_(x) {
+  var G__7169 = x;
+  if (G__7169) {
+    var bit__4034__auto__ = G__7169.cljs$lang$protocol_mask$partition0$ & 16777216;
+    if (bit__4034__auto__ || G__7169.cljs$core$ISequential$) {
+      return true;
+    } else {
+      if (!G__7169.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISequential, G__7169);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISequential, G__7169);
+  }
+};
+cljs.core.sorted_QMARK_ = function sorted_QMARK_(x) {
+  var G__7171 = x;
+  if (G__7171) {
+    var bit__4034__auto__ = G__7171.cljs$lang$protocol_mask$partition0$ & 268435456;
+    if (bit__4034__auto__ || G__7171.cljs$core$ISorted$) {
+      return true;
+    } else {
+      if (!G__7171.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISorted, G__7171);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISorted, G__7171);
+  }
+};
+cljs.core.reduceable_QMARK_ = function reduceable_QMARK_(x) {
+  var G__7173 = x;
+  if (G__7173) {
+    var bit__4034__auto__ = G__7173.cljs$lang$protocol_mask$partition0$ & 524288;
+    if (bit__4034__auto__ || G__7173.cljs$core$IReduce$) {
+      return true;
+    } else {
+      if (!G__7173.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, G__7173);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, G__7173);
+  }
+};
+cljs.core.map_QMARK_ = function map_QMARK_(x) {
+  if (x == null) {
+    return false;
+  } else {
+    var G__7175 = x;
+    if (G__7175) {
+      var bit__4034__auto__ = G__7175.cljs$lang$protocol_mask$partition0$ & 1024;
+      if (bit__4034__auto__ || G__7175.cljs$core$IMap$) {
+        return true;
+      } else {
+        if (!G__7175.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMap, G__7175);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMap, G__7175);
+    }
+  }
+};
+cljs.core.vector_QMARK_ = function vector_QMARK_(x) {
+  var G__7177 = x;
+  if (G__7177) {
+    var bit__4034__auto__ = G__7177.cljs$lang$protocol_mask$partition0$ & 16384;
+    if (bit__4034__auto__ || G__7177.cljs$core$IVector$) {
+      return true;
+    } else {
+      if (!G__7177.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IVector, G__7177);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IVector, G__7177);
+  }
+};
+cljs.core.chunked_seq_QMARK_ = function chunked_seq_QMARK_(x) {
+  var G__7179 = x;
+  if (G__7179) {
+    var bit__4027__auto__ = G__7179.cljs$lang$protocol_mask$partition1$ & 512;
+    if (bit__4027__auto__ || G__7179.cljs$core$IChunkedSeq$) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
+};
+cljs.core.js_obj = function() {
+  var js_obj = null;
+  var js_obj__0 = function() {
+    var obj7183 = {};
+    return obj7183;
+  };
+  var js_obj__1 = function() {
+    var G__7184__delegate = function(keyvals) {
+      return cljs.core.apply.call(null, goog.object.create, keyvals);
+    };
+    var G__7184 = function(var_args) {
+      var keyvals = null;
+      if (arguments.length > 0) {
+        keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+      }
+      return G__7184__delegate.call(this, keyvals);
+    };
+    G__7184.cljs$lang$maxFixedArity = 0;
+    G__7184.cljs$lang$applyTo = function(arglist__7185) {
+      var keyvals = cljs.core.seq(arglist__7185);
+      return G__7184__delegate(keyvals);
+    };
+    G__7184.cljs$core$IFn$_invoke$arity$variadic = G__7184__delegate;
+    return G__7184;
+  }();
+  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__7186 = i__$1 + 1;
+      var G__7187 = j__$1 + 1;
+      var G__7188 = len__$1 - 1;
+      i__$1 = G__7186;
+      j__$1 = G__7187;
+      len__$1 = G__7188;
+      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__7189 = i__$1 - 1;
+      var G__7190 = j__$1 - 1;
+      var G__7191 = len__$1 - 1;
+      i__$1 = G__7189;
+      j__$1 = G__7190;
+      len__$1 = G__7191;
+      continue;
+    }
+    break;
+  }
+};
+cljs.core.lookup_sentinel = function() {
+  var obj7193 = {};
+  return obj7193;
+}();
+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__7195 = s;
+    if (G__7195) {
+      var bit__4034__auto__ = G__7195.cljs$lang$protocol_mask$partition0$ & 64;
+      if (bit__4034__auto__ || G__7195.cljs$core$ISeq$) {
+        return true;
+      } else {
+        if (!G__7195.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7195);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7195);
+    }
+  }
+};
+cljs.core.seqable_QMARK_ = function seqable_QMARK_(s) {
+  var G__7197 = s;
+  if (G__7197) {
+    var bit__4034__auto__ = G__7197.cljs$lang$protocol_mask$partition0$ & 8388608;
+    if (bit__4034__auto__ || G__7197.cljs$core$ISeqable$) {
+      return true;
+    } else {
+      if (!G__7197.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__7197);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__7197);
+  }
+};
+cljs.core.boolean$ = function boolean$(x) {
+  if (cljs.core.truth_(x)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+cljs.core.ifn_QMARK_ = function ifn_QMARK_(f) {
+  var or__3408__auto__ = cljs.core.fn_QMARK_.call(null, f);
+  if (or__3408__auto__) {
+    return or__3408__auto__;
+  } else {
+    var G__7201 = f;
+    if (G__7201) {
+      var bit__4034__auto__ = G__7201.cljs$lang$protocol_mask$partition0$ & 1;
+      if (bit__4034__auto__ || G__7201.cljs$core$IFn$) {
+        return true;
+      } else {
+        if (!G__7201.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IFn, G__7201);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IFn, G__7201);
+    }
+  }
+};
+cljs.core.integer_QMARK_ = function integer_QMARK_(n) {
+  return typeof n === "number" && (!isNaN(n) && (!(n === Infinity) && parseFloat(n) === parseInt(n, 10)));
+};
+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 (!(coll == null) && (cljs.core.associative_QMARK_.call(null, coll) && cljs.core.contains_QMARK_.call(null, coll, k))) {
+    return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k, cljs.core.get.call(null, coll, k)], null);
+  } 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__7202__delegate = function(x, y, more) {
+      if (!cljs.core._EQ_.call(null, x, y)) {
+        var s = cljs.core.PersistentHashSet.fromArray([y, x], 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__7203 = cljs.core.conj.call(null, s, x__$1);
+              var G__7204 = etc;
+              s = G__7203;
+              xs = G__7204;
+              continue;
+            }
+          } else {
+            return true;
+          }
+          break;
+        }
+      } else {
+        return false;
+      }
+    };
+    var G__7202 = 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__7202__delegate.call(this, x, y, more);
+    };
+    G__7202.cljs$lang$maxFixedArity = 2;
+    G__7202.cljs$lang$applyTo = function(arglist__7205) {
+      var x = cljs.core.first(arglist__7205);
+      arglist__7205 = cljs.core.next(arglist__7205);
+      var y = cljs.core.first(arglist__7205);
+      var more = cljs.core.rest(arglist__7205);
+      return G__7202__delegate(x, y, more);
+    };
+    G__7202.cljs$core$IFn$_invoke$arity$variadic = G__7202__delegate;
+    return G__7202;
+  }();
+  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.sequence = function sequence(coll) {
+  if (cljs.core.seq_QMARK_.call(null, coll)) {
+    return coll;
+  } else {
+    var or__3408__auto__ = cljs.core.seq.call(null, coll);
+    if (or__3408__auto__) {
+      return or__3408__auto__;
+    } else {
+      return cljs.core.List.EMPTY;
+    }
+  }
+};
+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__7207 = x;
+            if (G__7207) {
+              var bit__4027__auto__ = G__7207.cljs$lang$protocol_mask$partition1$ & 2048;
+              if (bit__4027__auto__ || G__7207.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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+            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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (d === 0 && n + 1 < len) {
+        var G__7208 = xs;
+        var G__7209 = ys;
+        var G__7210 = len;
+        var G__7211 = n + 1;
+        xs = G__7208;
+        ys = G__7209;
+        len = G__7210;
+        n = G__7211;
+        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__7212 = nval;
+          var G__7213 = cljs.core.next.call(null, coll__$1);
+          val__$1 = G__7212;
+          coll__$1 = G__7213;
+          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__7216 = coll;
+      if (G__7216) {
+        var bit__4027__auto__ = G__7216.cljs$lang$protocol_mask$partition0$ & 524288;
+        if (bit__4027__auto__ || G__7216.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 (typeof coll === "string") {
+          return cljs.core.array_reduce.call(null, coll, f);
+        } else {
+          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, coll)) {
+            return cljs.core._reduce.call(null, coll, f);
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              return cljs.core.seq_reduce.call(null, f, coll);
+            } else {
+              return null;
+            }
+          }
+        }
+      }
+    }
+  };
+  var reduce__3 = function(f, val, coll) {
+    if (function() {
+      var G__7217 = coll;
+      if (G__7217) {
+        var bit__4027__auto__ = G__7217.cljs$lang$protocol_mask$partition0$ & 524288;
+        if (bit__4027__auto__ || G__7217.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 (typeof coll === "string") {
+          return cljs.core.array_reduce.call(null, coll, f, val);
+        } else {
+          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, coll)) {
+            return cljs.core._reduce.call(null, coll, f, val);
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              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) {
+  if (!(coll == null)) {
+    return cljs.core._kv_reduce.call(null, coll, f, init);
+  } else {
+    return 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__7218__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _PLUS_, x + y, more);
+    };
+    var G__7218 = 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__7218__delegate.call(this, x, y, more);
+    };
+    G__7218.cljs$lang$maxFixedArity = 2;
+    G__7218.cljs$lang$applyTo = function(arglist__7219) {
+      var x = cljs.core.first(arglist__7219);
+      arglist__7219 = cljs.core.next(arglist__7219);
+      var y = cljs.core.first(arglist__7219);
+      var more = cljs.core.rest(arglist__7219);
+      return G__7218__delegate(x, y, more);
+    };
+    G__7218.cljs$core$IFn$_invoke$arity$variadic = G__7218__delegate;
+    return G__7218;
+  }();
+  _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__7220__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _, x - y, more);
+    };
+    var G__7220 = 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__7220__delegate.call(this, x, y, more);
+    };
+    G__7220.cljs$lang$maxFixedArity = 2;
+    G__7220.cljs$lang$applyTo = function(arglist__7221) {
+      var x = cljs.core.first(arglist__7221);
+      arglist__7221 = cljs.core.next(arglist__7221);
+      var y = cljs.core.first(arglist__7221);
+      var more = cljs.core.rest(arglist__7221);
+      return G__7220__delegate(x, y, more);
+    };
+    G__7220.cljs$core$IFn$_invoke$arity$variadic = G__7220__delegate;
+    return G__7220;
+  }();
+  _ = 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__7222__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _STAR_, x * y, more);
+    };
+    var G__7222 = 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__7222__delegate.call(this, x, y, more);
+    };
+    G__7222.cljs$lang$maxFixedArity = 2;
+    G__7222.cljs$lang$applyTo = function(arglist__7223) {
+      var x = cljs.core.first(arglist__7223);
+      arglist__7223 = cljs.core.next(arglist__7223);
+      var y = cljs.core.first(arglist__7223);
+      var more = cljs.core.rest(arglist__7223);
+      return G__7222__delegate(x, y, more);
+    };
+    G__7222.cljs$core$IFn$_invoke$arity$variadic = G__7222__delegate;
+    return G__7222;
+  }();
+  _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__7224__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, _SLASH_, _SLASH_.call(null, x, y), more);
+    };
+    var G__7224 = 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__7224__delegate.call(this, x, y, more);
+    };
+    G__7224.cljs$lang$maxFixedArity = 2;
+    G__7224.cljs$lang$applyTo = function(arglist__7225) {
+      var x = cljs.core.first(arglist__7225);
+      arglist__7225 = cljs.core.next(arglist__7225);
+      var y = cljs.core.first(arglist__7225);
+      var more = cljs.core.rest(arglist__7225);
+      return G__7224__delegate(x, y, more);
+    };
+    G__7224.cljs$core$IFn$_invoke$arity$variadic = G__7224__delegate;
+    return G__7224;
+  }();
+  _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__7226__delegate = function(x, y, more) {
+      while (true) {
+        if (x < y) {
+          if (cljs.core.next.call(null, more)) {
+            var G__7227 = y;
+            var G__7228 = cljs.core.first.call(null, more);
+            var G__7229 = cljs.core.next.call(null, more);
+            x = G__7227;
+            y = G__7228;
+            more = G__7229;
+            continue;
+          } else {
+            return y < cljs.core.first.call(null, more);
+          }
+        } else {
+          return false;
+        }
+        break;
+      }
+    };
+    var G__7226 = 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__7226__delegate.call(this, x, y, more);
+    };
+    G__7226.cljs$lang$maxFixedArity = 2;
+    G__7226.cljs$lang$applyTo = function(arglist__7230) {
+      var x = cljs.core.first(arglist__7230);
+      arglist__7230 = cljs.core.next(arglist__7230);
+      var y = cljs.core.first(arglist__7230);
+      var more = cljs.core.rest(arglist__7230);
+      return G__7226__delegate(x, y, more);
+    };
+    G__7226.cljs$core$IFn$_invoke$arity$variadic = G__7226__delegate;
+    return G__7226;
+  }();
+  _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__7231__delegate = function(x, y, more) {
+      while (true) {
+        if (x <= y) {
+          if (cljs.core.next.call(null, more)) {
+            var G__7232 = y;
+            var G__7233 = cljs.core.first.call(null, more);
+            var G__7234 = cljs.core.next.call(null, more);
+            x = G__7232;
+            y = G__7233;
+            more = G__7234;
+            continue;
+          } else {
+            return y <= cljs.core.first.call(null, more);
+          }
+        } else {
+          return false;
+        }
+        break;
+      }
+    };
+    var G__7231 = 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__7231__delegate.call(this, x, y, more);
+    };
+    G__7231.cljs$lang$maxFixedArity = 2;
+    G__7231.cljs$lang$applyTo = function(arglist__7235) {
+      var x = cljs.core.first(arglist__7235);
+      arglist__7235 = cljs.core.next(arglist__7235);
+      var y = cljs.core.first(arglist__7235);
+      var more = cljs.core.rest(arglist__7235);
+      return G__7231__delegate(x, y, more);
+    };
+    G__7231.cljs$core$IFn$_invoke$arity$variadic = G__7231__delegate;
+    return G__7231;
+  }();
+  _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__7236__delegate = function(x, y, more) {
+      while (true) {
+        if (x > y) {
+          if (cljs.core.next.call(null, more)) {
+            var G__7237 = y;
+            var G__7238 = cljs.core.first.call(null, more);
+            var G__7239 = cljs.core.next.call(null, more);
+            x = G__7237;
+            y = G__7238;
+            more = G__7239;
+            continue;
+          } else {
+            return y > cljs.core.first.call(null, more);
+          }
+        } else {
+          return false;
+        }
+        break;
+      }
+    };
+    var G__7236 = 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__7236__delegate.call(this, x, y, more);
+    };
+    G__7236.cljs$lang$maxFixedArity = 2;
+    G__7236.cljs$lang$applyTo = function(arglist__7240) {
+      var x = cljs.core.first(arglist__7240);
+      arglist__7240 = cljs.core.next(arglist__7240);
+      var y = cljs.core.first(arglist__7240);
+      var more = cljs.core.rest(arglist__7240);
+      return G__7236__delegate(x, y, more);
+    };
+    G__7236.cljs$core$IFn$_invoke$arity$variadic = G__7236__delegate;
+    return G__7236;
+  }();
+  _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__7241__delegate = function(x, y, more) {
+      while (true) {
+        if (x >= y) {
+          if (cljs.core.next.call(null, more)) {
+            var G__7242 = y;
+            var G__7243 = cljs.core.first.call(null, more);
+            var G__7244 = cljs.core.next.call(null, more);
+            x = G__7242;
+            y = G__7243;
+            more = G__7244;
+            continue;
+          } else {
+            return y >= cljs.core.first.call(null, more);
+          }
+        } else {
+          return false;
+        }
+        break;
+      }
+    };
+    var G__7241 = 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__7241__delegate.call(this, x, y, more);
+    };
+    G__7241.cljs$lang$maxFixedArity = 2;
+    G__7241.cljs$lang$applyTo = function(arglist__7245) {
+      var x = cljs.core.first(arglist__7245);
+      arglist__7245 = cljs.core.next(arglist__7245);
+      var y = cljs.core.first(arglist__7245);
+      var more = cljs.core.rest(arglist__7245);
+      return G__7241__delegate(x, y, more);
+    };
+    G__7241.cljs$core$IFn$_invoke$arity$variadic = G__7241__delegate;
+    return G__7241;
+  }();
+  _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) {
+    var x__3715__auto__ = x;
+    var y__3716__auto__ = y;
+    return x__3715__auto__ > y__3716__auto__ ? x__3715__auto__ : y__3716__auto__;
+  };
+  var max__3 = function() {
+    var G__7246__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, max, function() {
+        var x__3715__auto__ = x;
+        var y__3716__auto__ = y;
+        return x__3715__auto__ > y__3716__auto__ ? x__3715__auto__ : y__3716__auto__;
+      }(), more);
+    };
+    var G__7246 = 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__7246__delegate.call(this, x, y, more);
+    };
+    G__7246.cljs$lang$maxFixedArity = 2;
+    G__7246.cljs$lang$applyTo = function(arglist__7247) {
+      var x = cljs.core.first(arglist__7247);
+      arglist__7247 = cljs.core.next(arglist__7247);
+      var y = cljs.core.first(arglist__7247);
+      var more = cljs.core.rest(arglist__7247);
+      return G__7246__delegate(x, y, more);
+    };
+    G__7246.cljs$core$IFn$_invoke$arity$variadic = G__7246__delegate;
+    return G__7246;
+  }();
+  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) {
+    var x__3722__auto__ = x;
+    var y__3723__auto__ = y;
+    return x__3722__auto__ < y__3723__auto__ ? x__3722__auto__ : y__3723__auto__;
+  };
+  var min__3 = function() {
+    var G__7248__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, min, function() {
+        var x__3722__auto__ = x;
+        var y__3723__auto__ = y;
+        return x__3722__auto__ < y__3723__auto__ ? x__3722__auto__ : y__3723__auto__;
+      }(), more);
+    };
+    var G__7248 = 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__7248__delegate.call(this, x, y, more);
+    };
+    G__7248.cljs$lang$maxFixedArity = 2;
+    G__7248.cljs$lang$applyTo = function(arglist__7249) {
+      var x = cljs.core.first(arglist__7249);
+      arglist__7249 = cljs.core.next(arglist__7249);
+      var y = cljs.core.first(arglist__7249);
+      var more = cljs.core.rest(arglist__7249);
+      return G__7248__delegate(x, y, more);
+    };
+    G__7248.cljs$core$IFn$_invoke$arity$variadic = G__7248__delegate;
+    return G__7248;
+  }();
+  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 (typeof x === "string" && x.length === 1) {
+      return x;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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__7250__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_add, x + y, more);
+    };
+    var G__7250 = 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__7250__delegate.call(this, x, y, more);
+    };
+    G__7250.cljs$lang$maxFixedArity = 2;
+    G__7250.cljs$lang$applyTo = function(arglist__7251) {
+      var x = cljs.core.first(arglist__7251);
+      arglist__7251 = cljs.core.next(arglist__7251);
+      var y = cljs.core.first(arglist__7251);
+      var more = cljs.core.rest(arglist__7251);
+      return G__7250__delegate(x, y, more);
+    };
+    G__7250.cljs$core$IFn$_invoke$arity$variadic = G__7250__delegate;
+    return G__7250;
+  }();
+  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__7252__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_add_int, x + y, more);
+    };
+    var G__7252 = 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__7252__delegate.call(this, x, y, more);
+    };
+    G__7252.cljs$lang$maxFixedArity = 2;
+    G__7252.cljs$lang$applyTo = function(arglist__7253) {
+      var x = cljs.core.first(arglist__7253);
+      arglist__7253 = cljs.core.next(arglist__7253);
+      var y = cljs.core.first(arglist__7253);
+      var more = cljs.core.rest(arglist__7253);
+      return G__7252__delegate(x, y, more);
+    };
+    G__7252.cljs$core$IFn$_invoke$arity$variadic = G__7252__delegate;
+    return G__7252;
+  }();
+  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__7254__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_divide_int, unchecked_divide_int.call(null, x, y), more);
+    };
+    var G__7254 = 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__7254__delegate.call(this, x, y, more);
+    };
+    G__7254.cljs$lang$maxFixedArity = 2;
+    G__7254.cljs$lang$applyTo = function(arglist__7255) {
+      var x = cljs.core.first(arglist__7255);
+      arglist__7255 = cljs.core.next(arglist__7255);
+      var y = cljs.core.first(arglist__7255);
+      var more = cljs.core.rest(arglist__7255);
+      return G__7254__delegate(x, y, more);
+    };
+    G__7254.cljs$core$IFn$_invoke$arity$variadic = G__7254__delegate;
+    return G__7254;
+  }();
+  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__7256__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_multiply, x * y, more);
+    };
+    var G__7256 = 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__7256__delegate.call(this, x, y, more);
+    };
+    G__7256.cljs$lang$maxFixedArity = 2;
+    G__7256.cljs$lang$applyTo = function(arglist__7257) {
+      var x = cljs.core.first(arglist__7257);
+      arglist__7257 = cljs.core.next(arglist__7257);
+      var y = cljs.core.first(arglist__7257);
+      var more = cljs.core.rest(arglist__7257);
+      return G__7256__delegate(x, y, more);
+    };
+    G__7256.cljs$core$IFn$_invoke$arity$variadic = G__7256__delegate;
+    return G__7256;
+  }();
+  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__7258__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_multiply_int, x * y, more);
+    };
+    var G__7258 = 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__7258__delegate.call(this, x, y, more);
+    };
+    G__7258.cljs$lang$maxFixedArity = 2;
+    G__7258.cljs$lang$applyTo = function(arglist__7259) {
+      var x = cljs.core.first(arglist__7259);
+      arglist__7259 = cljs.core.next(arglist__7259);
+      var y = cljs.core.first(arglist__7259);
+      var more = cljs.core.rest(arglist__7259);
+      return G__7258__delegate(x, y, more);
+    };
+    G__7258.cljs$core$IFn$_invoke$arity$variadic = G__7258__delegate;
+    return G__7258;
+  }();
+  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__7260__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_substract, x - y, more);
+    };
+    var G__7260 = 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__7260__delegate.call(this, x, y, more);
+    };
+    G__7260.cljs$lang$maxFixedArity = 2;
+    G__7260.cljs$lang$applyTo = function(arglist__7261) {
+      var x = cljs.core.first(arglist__7261);
+      arglist__7261 = cljs.core.next(arglist__7261);
+      var y = cljs.core.first(arglist__7261);
+      var more = cljs.core.rest(arglist__7261);
+      return G__7260__delegate(x, y, more);
+    };
+    G__7260.cljs$core$IFn$_invoke$arity$variadic = G__7260__delegate;
+    return G__7260;
+  }();
+  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__7262__delegate = function(x, y, more) {
+      return cljs.core.reduce.call(null, unchecked_substract_int, x - y, more);
+    };
+    var G__7262 = 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__7262__delegate.call(this, x, y, more);
+    };
+    G__7262.cljs$lang$maxFixedArity = 2;
+    G__7262.cljs$lang$applyTo = function(arglist__7263) {
+      var x = cljs.core.first(arglist__7263);
+      arglist__7263 = cljs.core.next(arglist__7263);
+      var y = cljs.core.first(arglist__7263);
+      var more = cljs.core.rest(arglist__7263);
+      return G__7262__delegate(x, y, more);
+    };
+    G__7262.cljs$core$IFn$_invoke$arity$variadic = G__7262__delegate;
+    return G__7262;
+  }();
+  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.unsigned_bit_shift_right = function unsigned_bit_shift_right(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__7264__delegate = function(x, y, more) {
+      while (true) {
+        if (_EQ__EQ_.call(null, x, y)) {
+          if (cljs.core.next.call(null, more)) {
+            var G__7265 = y;
+            var G__7266 = cljs.core.first.call(null, more);
+            var G__7267 = cljs.core.next.call(null, more);
+            x = G__7265;
+            y = G__7266;
+            more = G__7267;
+            continue;
+          } else {
+            return _EQ__EQ_.call(null, y, cljs.core.first.call(null, more));
+          }
+        } else {
+          return false;
+        }
+        break;
+      }
+    };
+    var G__7264 = 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__7264__delegate.call(this, x, y, more);
+    };
+    G__7264.cljs$lang$maxFixedArity = 2;
+    G__7264.cljs$lang$applyTo = function(arglist__7268) {
+      var x = cljs.core.first(arglist__7268);
+      arglist__7268 = cljs.core.next(arglist__7268);
+      var y = cljs.core.first(arglist__7268);
+      var more = cljs.core.rest(arglist__7268);
+      return G__7264__delegate(x, y, more);
+    };
+    G__7264.cljs$core$IFn$_invoke$arity$variadic = G__7264__delegate;
+    return G__7264;
+  }();
+  _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 (xs && n__$1 > 0) {
+      var G__7269 = n__$1 - 1;
+      var G__7270 = cljs.core.next.call(null, xs);
+      n__$1 = G__7269;
+      xs = G__7270;
+      continue;
+    } else {
+      return xs;
+    }
+    break;
+  }
+};
+cljs.core.str = function() {
+  var str = null;
+  var str__0 = function() {
+    return "";
+  };
+  var str__1 = function(x) {
+    if (x == null) {
+      return "";
+    } else {
+      return x.toString();
+    }
+  };
+  var str__2 = function() {
+    var G__7271__delegate = function(x, ys) {
+      var sb = new goog.string.StringBuffer(str.call(null, x));
+      var more = ys;
+      while (true) {
+        if (cljs.core.truth_(more)) {
+          var G__7272 = sb.append(str.call(null, cljs.core.first.call(null, more)));
+          var G__7273 = cljs.core.next.call(null, more);
+          sb = G__7272;
+          more = G__7273;
+          continue;
+        } else {
+          return sb.toString();
+        }
+        break;
+      }
+    };
+    var G__7271 = 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__7271__delegate.call(this, x, ys);
+    };
+    G__7271.cljs$lang$maxFixedArity = 1;
+    G__7271.cljs$lang$applyTo = function(arglist__7274) {
+      var x = cljs.core.first(arglist__7274);
+      var ys = cljs.core.rest(arglist__7274);
+      return G__7271__delegate(x, ys);
+    };
+    G__7271.cljs$core$IFn$_invoke$arity$variadic = G__7271__delegate;
+    return G__7271;
+  }();
+  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.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__7275 = cljs.core.next.call(null, xs);
+            var G__7276 = cljs.core.next.call(null, ys);
+            xs = G__7275;
+            ys = G__7276;
+            continue;
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              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) {
+  if (cljs.core.seq.call(null, coll)) {
+    var res = cljs.core.hash.call(null, cljs.core.first.call(null, coll));
+    var s = cljs.core.next.call(null, coll);
+    while (true) {
+      if (s == null) {
+        return res;
+      } else {
+        var G__7277 = cljs.core.hash_combine.call(null, res, cljs.core.hash.call(null, cljs.core.first.call(null, s)));
+        var G__7278 = cljs.core.next.call(null, s);
+        res = G__7277;
+        s = G__7278;
+        continue;
+      }
+      break;
+    }
+  } else {
+    return 0;
+  }
+};
+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__7279 = (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__7280 = cljs.core.next.call(null, s);
+      h = G__7279;
+      s = G__7280;
+      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__7281 = (h + cljs.core.hash.call(null, e)) % 4503599627370496;
+      var G__7282 = cljs.core.next.call(null, s__$1);
+      h = G__7281;
+      s__$1 = G__7282;
+      continue;
+    } else {
+      return h;
+    }
+    break;
+  }
+};
+cljs.core.extend_object_BANG_ = function extend_object_BANG_(obj, fn_map) {
+  var seq__7289_7295 = cljs.core.seq.call(null, fn_map);
+  var chunk__7290_7296 = null;
+  var count__7291_7297 = 0;
+  var i__7292_7298 = 0;
+  while (true) {
+    if (i__7292_7298 < count__7291_7297) {
+      var vec__7293_7299 = cljs.core._nth.call(null, chunk__7290_7296, i__7292_7298);
+      var key_name_7300 = cljs.core.nth.call(null, vec__7293_7299, 0, null);
+      var f_7301 = cljs.core.nth.call(null, vec__7293_7299, 1, null);
+      var str_name_7302 = cljs.core.name.call(null, key_name_7300);
+      obj[str_name_7302] = f_7301;
+      var G__7303 = seq__7289_7295;
+      var G__7304 = chunk__7290_7296;
+      var G__7305 = count__7291_7297;
+      var G__7306 = i__7292_7298 + 1;
+      seq__7289_7295 = G__7303;
+      chunk__7290_7296 = G__7304;
+      count__7291_7297 = G__7305;
+      i__7292_7298 = G__7306;
+      continue;
+    } else {
+      var temp__4092__auto___7307 = cljs.core.seq.call(null, seq__7289_7295);
+      if (temp__4092__auto___7307) {
+        var seq__7289_7308__$1 = temp__4092__auto___7307;
+        if (cljs.core.chunked_seq_QMARK_.call(null, seq__7289_7308__$1)) {
+          var c__4132__auto___7309 = cljs.core.chunk_first.call(null, seq__7289_7308__$1);
+          var G__7310 = cljs.core.chunk_rest.call(null, seq__7289_7308__$1);
+          var G__7311 = c__4132__auto___7309;
+          var G__7312 = cljs.core.count.call(null, c__4132__auto___7309);
+          var G__7313 = 0;
+          seq__7289_7295 = G__7310;
+          chunk__7290_7296 = G__7311;
+          count__7291_7297 = G__7312;
+          i__7292_7298 = G__7313;
+          continue;
+        } else {
+          var vec__7294_7314 = cljs.core.first.call(null, seq__7289_7308__$1);
+          var key_name_7315 = cljs.core.nth.call(null, vec__7294_7314, 0, null);
+          var f_7316 = cljs.core.nth.call(null, vec__7294_7314, 1, null);
+          var str_name_7317 = cljs.core.name.call(null, key_name_7315);
+          obj[str_name_7317] = f_7316;
+          var G__7318 = cljs.core.next.call(null, seq__7289_7308__$1);
+          var G__7319 = null;
+          var G__7320 = 0;
+          var G__7321 = 0;
+          seq__7289_7295 = G__7318;
+          chunk__7290_7296 = G__7319;
+          count__7291_7297 = G__7320;
+          i__7292_7298 = G__7321;
+          continue;
+        }
+      } else {
+      }
+    }
+    break;
+  }
+  return obj;
+};
+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$ = 65937646;
+};
+cljs.core.List.cljs$lang$type = true;
+cljs.core.List.cljs$lang$ctorStr = "cljs.core/List";
+cljs.core.List.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/List");
+};
+cljs.core.List.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.List.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return new cljs.core.List(self__.meta, o, coll__$1, 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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.List.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.List.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.count;
+};
+cljs.core.List.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.first;
+};
+cljs.core.List.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._rest.call(null, coll__$1);
+};
+cljs.core.List.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.first;
+};
+cljs.core.List.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.List.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.List.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.List.EMPTY;
+};
+cljs.core.__GT_List = function __GT_List(meta, first, rest, count, __hash) {
+  return new cljs.core.List(meta, first, rest, count, __hash);
+};
+cljs.core.EmptyList = function(meta) {
+  this.meta = meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 65937614;
+};
+cljs.core.EmptyList.cljs$lang$type = true;
+cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList";
+cljs.core.EmptyList.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/EmptyList");
+};
+cljs.core.EmptyList.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return 0;
+};
+cljs.core.EmptyList.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return null;
+};
+cljs.core.EmptyList.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = 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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.EmptyList.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return null;
+};
+cljs.core.EmptyList.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return 0;
+};
+cljs.core.EmptyList.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return null;
+};
+cljs.core.EmptyList.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  throw new Error("Can't pop empty list");
+};
+cljs.core.EmptyList.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return null;
+};
+cljs.core.EmptyList.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.List.EMPTY;
+};
+cljs.core.EmptyList.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.EmptyList.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.EmptyList(meta__$1);
+};
+cljs.core.EmptyList.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.EmptyList.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.__GT_EmptyList = function __GT_EmptyList(meta) {
+  return new cljs.core.EmptyList(meta);
+};
+cljs.core.List.EMPTY = new cljs.core.EmptyList(null);
+cljs.core.reversible_QMARK_ = function reversible_QMARK_(coll) {
+  var G__7323 = coll;
+  if (G__7323) {
+    var bit__4034__auto__ = G__7323.cljs$lang$protocol_mask$partition0$ & 134217728;
+    if (bit__4034__auto__ || G__7323.cljs$core$IReversible$) {
+      return true;
+    } else {
+      if (!G__7323.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReversible, G__7323);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReversible, G__7323);
+  }
+};
+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.i === 0 ? 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__7324 = cljs.core._next.call(null, xs__$1);
+          xs__$1 = G__7324;
+          continue;
+        } else {
+          return arr;
+        }
+        break;
+      }
+    }();
+    var i = arr.length;
+    var r = cljs.core.List.EMPTY;
+    while (true) {
+      if (i > 0) {
+        var G__7325 = i - 1;
+        var G__7326 = cljs.core._conj.call(null, r, arr[i - 1]);
+        i = G__7325;
+        r = G__7326;
+        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__7327) {
+    var xs = cljs.core.seq(arglist__7327);
+    return list__delegate(xs);
+  };
+  list.cljs$core$IFn$_invoke$arity$variadic = list__delegate;
+  return list;
+}();
+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$ = 65929452;
+};
+cljs.core.Cons.cljs$lang$type = true;
+cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons";
+cljs.core.Cons.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Cons");
+};
+cljs.core.Cons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.Cons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return new cljs.core.Cons(null, o, coll__$1, 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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.Cons.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.Cons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.first;
+};
+cljs.core.Cons.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.Cons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.Cons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_Cons = function __GT_Cons(meta, first, rest, __hash) {
+  return new cljs.core.Cons(meta, first, rest, __hash);
+};
+cljs.core.cons = function cons(x, coll) {
+  if (function() {
+    var or__3408__auto__ = coll == null;
+    if (or__3408__auto__) {
+      return or__3408__auto__;
+    } else {
+      var G__7331 = coll;
+      if (G__7331) {
+        var bit__4027__auto__ = G__7331.cljs$lang$protocol_mask$partition0$ & 64;
+        if (bit__4027__auto__ || G__7331.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__7333 = x;
+  if (G__7333) {
+    var bit__4034__auto__ = G__7333.cljs$lang$protocol_mask$partition0$ & 33554432;
+    if (bit__4034__auto__ || G__7333.cljs$core$IList$) {
+      return true;
+    } else {
+      if (!G__7333.cljs$lang$protocol_mask$partition0$) {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IList, G__7333);
+      } else {
+        return false;
+      }
+    }
+  } else {
+    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IList, G__7333);
+  }
+};
+cljs.core.Keyword = function(ns, name, fqn, _hash) {
+  this.ns = ns;
+  this.name = name;
+  this.fqn = fqn;
+  this._hash = _hash;
+  this.cljs$lang$protocol_mask$partition0$ = 2153775105;
+  this.cljs$lang$protocol_mask$partition1$ = 4096;
+};
+cljs.core.Keyword.cljs$lang$type = true;
+cljs.core.Keyword.cljs$lang$ctorStr = "cljs.core/Keyword";
+cljs.core.Keyword.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Keyword");
+};
+cljs.core.Keyword.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(o, writer, _) {
+  var self__ = this;
+  var o__$1 = this;
+  return cljs.core._write.call(null, writer, [cljs.core.str(":"), cljs.core.str(self__.fqn)].join(""));
+};
+cljs.core.Keyword.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.name;
+};
+cljs.core.Keyword.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.ns;
+};
+cljs.core.Keyword.prototype.cljs$core$IHash$_hash$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  if (self__._hash == null) {
+    self__._hash = cljs.core.hash_combine.call(null, cljs.core.hash.call(null, self__.ns), cljs.core.hash.call(null, self__.name)) + 2654435769;
+    return self__._hash;
+  } else {
+    return self__._hash;
+  }
+};
+cljs.core.Keyword.prototype.call = function() {
+  var G__7335 = null;
+  var G__7335__2 = function(self__, coll) {
+    var self__ = this;
+    var self____$1 = this;
+    var kw = self____$1;
+    return cljs.core.get.call(null, coll, kw);
+  };
+  var G__7335__3 = function(self__, coll, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var kw = self____$1;
+    return cljs.core.get.call(null, coll, kw, not_found);
+  };
+  G__7335 = function(self__, coll, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7335__2.call(this, self__, coll);
+      case 3:
+        return G__7335__3.call(this, self__, coll, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7335;
+}();
+cljs.core.Keyword.prototype.apply = function(self__, args7334) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7334)));
+};
+cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$1 = function(coll) {
+  var self__ = this;
+  var kw = this;
+  return cljs.core.get.call(null, coll, kw);
+};
+cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$2 = function(coll, not_found) {
+  var self__ = this;
+  var kw = this;
+  return cljs.core.get.call(null, coll, kw, not_found);
+};
+cljs.core.Keyword.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(_, other) {
+  var self__ = this;
+  var ___$1 = this;
+  if (other instanceof cljs.core.Keyword) {
+    return self__.fqn === other.fqn;
+  } else {
+    return false;
+  }
+};
+cljs.core.Keyword.prototype.toString = function() {
+  var self__ = this;
+  var _ = this;
+  return[cljs.core.str(":"), cljs.core.str(self__.fqn)].join("");
+};
+cljs.core.__GT_Keyword = function __GT_Keyword(ns, name, fqn, _hash) {
+  return new cljs.core.Keyword(ns, name, fqn, _hash);
+};
+cljs.core.keyword_QMARK_ = function keyword_QMARK_(x) {
+  return x instanceof cljs.core.Keyword;
+};
+cljs.core.keyword_identical_QMARK_ = function keyword_identical_QMARK_(x, y) {
+  if (x === y) {
+    return true;
+  } else {
+    if (x instanceof cljs.core.Keyword && y instanceof cljs.core.Keyword) {
+      return x.fqn === y.fqn;
+    } else {
+      return false;
+    }
+  }
+};
+cljs.core.namespace = function namespace(x) {
+  if (function() {
+    var G__7337 = x;
+    if (G__7337) {
+      var bit__4027__auto__ = G__7337.cljs$lang$protocol_mask$partition1$ & 4096;
+      if (bit__4027__auto__ || G__7337.cljs$core$INamed$) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }()) {
+    return cljs.core._namespace.call(null, x);
+  } else {
+    throw new Error([cljs.core.str("Doesn't support namespace: "), cljs.core.str(x)].join(""));
+  }
+};
+cljs.core.keyword = function() {
+  var keyword = null;
+  var keyword__1 = function(name) {
+    if (name instanceof cljs.core.Keyword) {
+      return name;
+    } else {
+      if (name instanceof cljs.core.Symbol) {
+        return new cljs.core.Keyword(cljs.core.namespace.call(null, name), cljs.core.name.call(null, name), name.str, null);
+      } else {
+        if (typeof name === "string") {
+          var parts = name.split("/");
+          if (parts.length === 2) {
+            return new cljs.core.Keyword(parts[0], parts[1], name, null);
+          } else {
+            return new cljs.core.Keyword(null, parts[0], name, null);
+          }
+        } else {
+          return null;
+        }
+      }
+    }
+  };
+  var keyword__2 = function(ns, name) {
+    return new cljs.core.Keyword(ns, name, [cljs.core.str(cljs.core.truth_(ns) ? [cljs.core.str(ns), cljs.core.str("/")].join("") : null), cljs.core.str(name)].join(""), null);
+  };
+  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.LazySeq = function(meta, fn, s, __hash) {
+  this.meta = meta;
+  this.fn = fn;
+  this.s = s;
+  this.__hash = __hash;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32374988;
+};
+cljs.core.LazySeq.cljs$lang$type = true;
+cljs.core.LazySeq.cljs$lang$ctorStr = "cljs.core/LazySeq";
+cljs.core.LazySeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/LazySeq");
+};
+cljs.core.LazySeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  cljs.core._seq.call(null, coll__$1);
+  if (self__.s == null) {
+    return null;
+  } else {
+    return cljs.core.next.call(null, self__.s);
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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.sval = function() {
+  var self__ = this;
+  var coll = this;
+  if (self__.fn == null) {
+    return self__.s;
+  } else {
+    self__.s = self__.fn.call(null);
+    self__.fn = null;
+    return self__.s;
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.LazySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  coll__$1.sval();
+  if (self__.s == null) {
+    return null;
+  } else {
+    var ls = self__.s;
+    while (true) {
+      if (ls instanceof cljs.core.LazySeq) {
+        var G__7338 = ls.sval();
+        ls = G__7338;
+        continue;
+      } else {
+        self__.s = ls;
+        return cljs.core.seq.call(null, self__.s);
+      }
+      break;
+    }
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  cljs.core._seq.call(null, coll__$1);
+  if (self__.s == null) {
+    return null;
+  } else {
+    return cljs.core.first.call(null, self__.s);
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  cljs.core._seq.call(null, coll__$1);
+  if (!(self__.s == null)) {
+    return cljs.core.rest.call(null, self__.s);
+  } else {
+    return cljs.core.List.EMPTY;
+  }
+};
+cljs.core.LazySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.LazySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.LazySeq(meta__$1, self__.fn, self__.s, self__.__hash);
+};
+cljs.core.LazySeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.LazySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_LazySeq = function __GT_LazySeq(meta, fn, s, __hash) {
+  return new cljs.core.LazySeq(meta, fn, s, __hash);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ChunkBuffer");
+};
+cljs.core.ChunkBuffer.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = 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.__GT_ChunkBuffer = function __GT_ChunkBuffer(buf, end) {
+  return new cljs.core.ChunkBuffer(buf, end);
+};
+cljs.core.chunk_buffer = function chunk_buffer(capacity) {
+  return new cljs.core.ChunkBuffer(new Array(capacity), 0);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ArrayChunk");
+};
+cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  if (i >= 0 && i < self__.end - self__.off) {
+    return self__.arr[self__.off + i];
+  } else {
+    return not_found;
+  }
+};
+cljs.core.ArrayChunk.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.end - self__.off;
+};
+cljs.core.__GT_ArrayChunk = function __GT_ArrayChunk(arr, off, end) {
+  return new cljs.core.ArrayChunk(arr, off, end);
+};
+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;
+}();
+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$ = 31850732;
+  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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ChunkedCons");
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.ChunkedCons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 {
+    var more__$1 = cljs.core._seq.call(null, self__.more);
+    if (more__$1 == null) {
+      return null;
+    } else {
+      return more__$1;
+    }
+  }
+};
+cljs.core.ChunkedCons.prototype.cljs$core$ICollection$_conj$arity$2 = function(this$, o) {
+  var self__ = this;
+  var this$__$1 = this;
+  return cljs.core.cons.call(null, o, this$__$1);
+};
+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;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, m) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.chunk;
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.more == null) {
+    return cljs.core.List.EMPTY;
+  } else {
+    return self__.more;
+  }
+};
+cljs.core.__GT_ChunkedCons = function __GT_ChunkedCons(chunk, more, meta, __hash) {
+  return new cljs.core.ChunkedCons(chunk, more, meta, __hash);
+};
+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__7340 = s;
+    if (G__7340) {
+      var bit__4027__auto__ = G__7340.cljs$lang$protocol_mask$partition1$ & 1024;
+      if (bit__4027__auto__ || G__7340.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__7341 = cljs.core.next.call(null, s__$1);
+      s__$1 = G__7341;
+      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_7342 = 0;
+  var xs_7343 = cljs.core.seq.call(null, coll);
+  while (true) {
+    if (xs_7343) {
+      ret[i_7342] = cljs.core.to_array.call(null, cljs.core.first.call(null, xs_7343));
+      var G__7344 = i_7342 + 1;
+      var G__7345 = cljs.core.next.call(null, xs_7343);
+      i_7342 = G__7344;
+      xs_7343 = G__7345;
+      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 {
+      return cljs.core.into_array.call(null, size_or_seq);
+    }
+  };
+  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 (s__$1 && i < size) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__7346 = i + 1;
+          var G__7347 = cljs.core.next.call(null, s__$1);
+          i = G__7346;
+          s__$1 = G__7347;
+          continue;
+        } else {
+          return a;
+        }
+        break;
+      }
+    } else {
+      var n__4232__auto___7348 = size;
+      var i_7349 = 0;
+      while (true) {
+        if (i_7349 < n__4232__auto___7348) {
+          a[i_7349] = init_val_or_seq;
+          var G__7350 = i_7349 + 1;
+          i_7349 = G__7350;
+          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 {
+      return cljs.core.into_array.call(null, size_or_seq);
+    }
+  };
+  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 (s__$1 && i < size) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__7351 = i + 1;
+          var G__7352 = cljs.core.next.call(null, s__$1);
+          i = G__7351;
+          s__$1 = G__7352;
+          continue;
+        } else {
+          return a;
+        }
+        break;
+      }
+    } else {
+      var n__4232__auto___7353 = size;
+      var i_7354 = 0;
+      while (true) {
+        if (i_7354 < n__4232__auto___7353) {
+          a[i_7354] = init_val_or_seq;
+          var G__7355 = i_7354 + 1;
+          i_7354 = G__7355;
+          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 {
+      return cljs.core.into_array.call(null, size_or_seq);
+    }
+  };
+  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 (s__$1 && i < size) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__7356 = i + 1;
+          var G__7357 = cljs.core.next.call(null, s__$1);
+          i = G__7356;
+          s__$1 = G__7357;
+          continue;
+        } else {
+          return a;
+        }
+        break;
+      }
+    } else {
+      var n__4232__auto___7358 = size;
+      var i_7359 = 0;
+      while (true) {
+        if (i_7359 < n__4232__auto___7358) {
+          a[i_7359] = init_val_or_seq;
+          var G__7360 = i_7359 + 1;
+          i_7359 = G__7360;
+          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 {
+      return cljs.core.into_array.call(null, size_or_seq);
+    }
+  };
+  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 (s__$1 && i < size) {
+          a[i] = cljs.core.first.call(null, s__$1);
+          var G__7361 = i + 1;
+          var G__7362 = cljs.core.next.call(null, s__$1);
+          i = G__7361;
+          s__$1 = G__7362;
+          continue;
+        } else {
+          return a;
+        }
+        break;
+      }
+    } else {
+      var n__4232__auto___7363 = size;
+      var i_7364 = 0;
+      while (true) {
+        if (i_7364 < n__4232__auto___7363) {
+          a[i_7364] = init_val_or_seq;
+          var G__7365 = i_7364 + 1;
+          i_7364 = G__7365;
+          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 (i > 0 && cljs.core.seq.call(null, s__$1)) {
+        var G__7366 = cljs.core.next.call(null, s__$1);
+        var G__7367 = i - 1;
+        var G__7368 = sum + 1;
+        s__$1 = G__7366;
+        i = G__7367;
+        sum = G__7368;
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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, function() {
+      return null;
+    }, null, null);
+  };
+  var concat__1 = function(x) {
+    return new cljs.core.LazySeq(null, function() {
+      return x;
+    }, null, null);
+  };
+  var concat__2 = function(x, y) {
+    return new cljs.core.LazySeq(null, 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, null);
+  };
+  var concat__3 = function() {
+    var G__7369__delegate = function(x, y, zs) {
+      var cat = function cat(xys, zs__$1) {
+        return new cljs.core.LazySeq(null, 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, null);
+      };
+      return cat.call(null, concat.call(null, x, y), zs);
+    };
+    var G__7369 = 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__7369__delegate.call(this, x, y, zs);
+    };
+    G__7369.cljs$lang$maxFixedArity = 2;
+    G__7369.cljs$lang$applyTo = function(arglist__7370) {
+      var x = cljs.core.first(arglist__7370);
+      arglist__7370 = cljs.core.next(arglist__7370);
+      var y = cljs.core.first(arglist__7370);
+      var zs = cljs.core.rest(arglist__7370);
+      return G__7369__delegate(x, y, zs);
+    };
+    G__7369.cljs$core$IFn$_invoke$arity$variadic = G__7369__delegate;
+    return G__7369;
+  }();
+  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__7371__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__7371 = 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__7371__delegate.call(this, a, b, c, d, more);
+    };
+    G__7371.cljs$lang$maxFixedArity = 4;
+    G__7371.cljs$lang$applyTo = function(arglist__7372) {
+      var a = cljs.core.first(arglist__7372);
+      arglist__7372 = cljs.core.next(arglist__7372);
+      var b = cljs.core.first(arglist__7372);
+      arglist__7372 = cljs.core.next(arglist__7372);
+      var c = cljs.core.first(arglist__7372);
+      arglist__7372 = cljs.core.next(arglist__7372);
+      var d = cljs.core.first(arglist__7372);
+      var more = cljs.core.rest(arglist__7372);
+      return G__7371__delegate(a, b, c, d, more);
+    };
+    G__7371.cljs$core$IFn$_invoke$arity$variadic = G__7371__delegate;
+    return G__7371;
+  }();
+  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__7373__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__7373 = 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__7373__delegate.call(this, f, a, b, c, d, args);
+    };
+    G__7373.cljs$lang$maxFixedArity = 5;
+    G__7373.cljs$lang$applyTo = function(arglist__7374) {
+      var f = cljs.core.first(arglist__7374);
+      arglist__7374 = cljs.core.next(arglist__7374);
+      var a = cljs.core.first(arglist__7374);
+      arglist__7374 = cljs.core.next(arglist__7374);
+      var b = cljs.core.first(arglist__7374);
+      arglist__7374 = cljs.core.next(arglist__7374);
+      var c = cljs.core.first(arglist__7374);
+      arglist__7374 = cljs.core.next(arglist__7374);
+      var d = cljs.core.first(arglist__7374);
+      var args = cljs.core.rest(arglist__7374);
+      return G__7373__delegate(f, a, b, c, d, args);
+    };
+    G__7373.cljs$core$IFn$_invoke$arity$variadic = G__7373__delegate;
+    return G__7373;
+  }();
+  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 = null;
+  var vary_meta__2 = function(obj, f) {
+    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj)));
+  };
+  var vary_meta__3 = function(obj, f, a) {
+    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a));
+  };
+  var vary_meta__4 = function(obj, f, a, b) {
+    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a, b));
+  };
+  var vary_meta__5 = function(obj, f, a, b, c) {
+    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a, b, c));
+  };
+  var vary_meta__6 = function(obj, f, a, b, c, d) {
+    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a, b, c, d));
+  };
+  var vary_meta__7 = function() {
+    var G__7375__delegate = function(obj, f, a, b, c, d, args) {
+      return cljs.core.with_meta.call(null, obj, cljs.core.apply.call(null, f, cljs.core.meta.call(null, obj), a, b, c, d, args));
+    };
+    var G__7375 = function(obj, f, a, b, c, d, var_args) {
+      var args = null;
+      if (arguments.length > 6) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 6), 0);
+      }
+      return G__7375__delegate.call(this, obj, f, a, b, c, d, args);
+    };
+    G__7375.cljs$lang$maxFixedArity = 6;
+    G__7375.cljs$lang$applyTo = function(arglist__7376) {
+      var obj = cljs.core.first(arglist__7376);
+      arglist__7376 = cljs.core.next(arglist__7376);
+      var f = cljs.core.first(arglist__7376);
+      arglist__7376 = cljs.core.next(arglist__7376);
+      var a = cljs.core.first(arglist__7376);
+      arglist__7376 = cljs.core.next(arglist__7376);
+      var b = cljs.core.first(arglist__7376);
+      arglist__7376 = cljs.core.next(arglist__7376);
+      var c = cljs.core.first(arglist__7376);
+      arglist__7376 = cljs.core.next(arglist__7376);
+      var d = cljs.core.first(arglist__7376);
+      var args = cljs.core.rest(arglist__7376);
+      return G__7375__delegate(obj, f, a, b, c, d, args);
+    };
+    G__7375.cljs$core$IFn$_invoke$arity$variadic = G__7375__delegate;
+    return G__7375;
+  }();
+  vary_meta = function(obj, f, a, b, c, d, var_args) {
+    var args = var_args;
+    switch(arguments.length) {
+      case 2:
+        return vary_meta__2.call(this, obj, f);
+      case 3:
+        return vary_meta__3.call(this, obj, f, a);
+      case 4:
+        return vary_meta__4.call(this, obj, f, a, b);
+      case 5:
+        return vary_meta__5.call(this, obj, f, a, b, c);
+      case 6:
+        return vary_meta__6.call(this, obj, f, a, b, c, d);
+      default:
+        return vary_meta__7.cljs$core$IFn$_invoke$arity$variadic(obj, f, a, b, c, d, cljs.core.array_seq(arguments, 6));
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  vary_meta.cljs$lang$maxFixedArity = 6;
+  vary_meta.cljs$lang$applyTo = vary_meta__7.cljs$lang$applyTo;
+  vary_meta.cljs$core$IFn$_invoke$arity$2 = vary_meta__2;
+  vary_meta.cljs$core$IFn$_invoke$arity$3 = vary_meta__3;
+  vary_meta.cljs$core$IFn$_invoke$arity$4 = vary_meta__4;
+  vary_meta.cljs$core$IFn$_invoke$arity$5 = vary_meta__5;
+  vary_meta.cljs$core$IFn$_invoke$arity$6 = vary_meta__6;
+  vary_meta.cljs$core$IFn$_invoke$arity$variadic = vary_meta__7.cljs$core$IFn$_invoke$arity$variadic;
+  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__7377__delegate = function(x, y, more) {
+      return cljs.core.not.call(null, cljs.core.apply.call(null, cljs.core._EQ_, x, y, more));
+    };
+    var G__7377 = 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__7377__delegate.call(this, x, y, more);
+    };
+    G__7377.cljs$lang$maxFixedArity = 2;
+    G__7377.cljs$lang$applyTo = function(arglist__7378) {
+      var x = cljs.core.first(arglist__7378);
+      arglist__7378 = cljs.core.next(arglist__7378);
+      var y = cljs.core.first(arglist__7378);
+      var more = cljs.core.rest(arglist__7378);
+      return G__7377__delegate(x, y, more);
+    };
+    G__7377.cljs$core$IFn$_invoke$arity$variadic = G__7377__delegate;
+    return G__7377;
+  }();
+  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__7379 = pred;
+        var G__7380 = cljs.core.next.call(null, coll);
+        pred = G__7379;
+        coll = G__7380;
+        continue;
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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__3408__auto__ = pred.call(null, cljs.core.first.call(null, coll));
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        var G__7381 = pred;
+        var G__7382 = cljs.core.next.call(null, coll);
+        pred = G__7381;
+        coll = G__7382;
+        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__7383 = null;
+    var G__7383__0 = function() {
+      return cljs.core.not.call(null, f.call(null));
+    };
+    var G__7383__1 = function(x) {
+      return cljs.core.not.call(null, f.call(null, x));
+    };
+    var G__7383__2 = function(x, y) {
+      return cljs.core.not.call(null, f.call(null, x, y));
+    };
+    var G__7383__3 = function() {
+      var G__7384__delegate = function(x, y, zs) {
+        return cljs.core.not.call(null, cljs.core.apply.call(null, f, x, y, zs));
+      };
+      var G__7384 = 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__7384__delegate.call(this, x, y, zs);
+      };
+      G__7384.cljs$lang$maxFixedArity = 2;
+      G__7384.cljs$lang$applyTo = function(arglist__7385) {
+        var x = cljs.core.first(arglist__7385);
+        arglist__7385 = cljs.core.next(arglist__7385);
+        var y = cljs.core.first(arglist__7385);
+        var zs = cljs.core.rest(arglist__7385);
+        return G__7384__delegate(x, y, zs);
+      };
+      G__7384.cljs$core$IFn$_invoke$arity$variadic = G__7384__delegate;
+      return G__7384;
+    }();
+    G__7383 = function(x, y, var_args) {
+      var zs = var_args;
+      switch(arguments.length) {
+        case 0:
+          return G__7383__0.call(this);
+        case 1:
+          return G__7383__1.call(this, x);
+        case 2:
+          return G__7383__2.call(this, x, y);
+        default:
+          return G__7383__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2));
+      }
+      throw new Error("Invalid arity: " + arguments.length);
+    };
+    G__7383.cljs$lang$maxFixedArity = 2;
+    G__7383.cljs$lang$applyTo = G__7383__3.cljs$lang$applyTo;
+    return G__7383;
+  }();
+};
+cljs.core.constantly = function constantly(x) {
+  return function() {
+    var G__7386__delegate = function(args) {
+      return x;
+    };
+    var G__7386 = function(var_args) {
+      var args = null;
+      if (arguments.length > 0) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+      }
+      return G__7386__delegate.call(this, args);
+    };
+    G__7386.cljs$lang$maxFixedArity = 0;
+    G__7386.cljs$lang$applyTo = function(arglist__7387) {
+      var args = cljs.core.seq(arglist__7387);
+      return G__7386__delegate(args);
+    };
+    G__7386.cljs$core$IFn$_invoke$arity$variadic = G__7386__delegate;
+    return G__7386;
+  }();
+};
+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__7388 = null;
+      var G__7388__0 = function() {
+        return f.call(null, g.call(null));
+      };
+      var G__7388__1 = function(x) {
+        return f.call(null, g.call(null, x));
+      };
+      var G__7388__2 = function(x, y) {
+        return f.call(null, g.call(null, x, y));
+      };
+      var G__7388__3 = function(x, y, z) {
+        return f.call(null, g.call(null, x, y, z));
+      };
+      var G__7388__4 = function() {
+        var G__7389__delegate = function(x, y, z, args) {
+          return f.call(null, cljs.core.apply.call(null, g, x, y, z, args));
+        };
+        var G__7389 = 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__7389__delegate.call(this, x, y, z, args);
+        };
+        G__7389.cljs$lang$maxFixedArity = 3;
+        G__7389.cljs$lang$applyTo = function(arglist__7390) {
+          var x = cljs.core.first(arglist__7390);
+          arglist__7390 = cljs.core.next(arglist__7390);
+          var y = cljs.core.first(arglist__7390);
+          arglist__7390 = cljs.core.next(arglist__7390);
+          var z = cljs.core.first(arglist__7390);
+          var args = cljs.core.rest(arglist__7390);
+          return G__7389__delegate(x, y, z, args);
+        };
+        G__7389.cljs$core$IFn$_invoke$arity$variadic = G__7389__delegate;
+        return G__7389;
+      }();
+      G__7388 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__7388__0.call(this);
+          case 1:
+            return G__7388__1.call(this, x);
+          case 2:
+            return G__7388__2.call(this, x, y);
+          case 3:
+            return G__7388__3.call(this, x, y, z);
+          default:
+            return G__7388__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7388.cljs$lang$maxFixedArity = 3;
+      G__7388.cljs$lang$applyTo = G__7388__4.cljs$lang$applyTo;
+      return G__7388;
+    }();
+  };
+  var comp__3 = function(f, g, h) {
+    return function() {
+      var G__7391 = null;
+      var G__7391__0 = function() {
+        return f.call(null, g.call(null, h.call(null)));
+      };
+      var G__7391__1 = function(x) {
+        return f.call(null, g.call(null, h.call(null, x)));
+      };
+      var G__7391__2 = function(x, y) {
+        return f.call(null, g.call(null, h.call(null, x, y)));
+      };
+      var G__7391__3 = function(x, y, z) {
+        return f.call(null, g.call(null, h.call(null, x, y, z)));
+      };
+      var G__7391__4 = function() {
+        var G__7392__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__7392 = 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__7392__delegate.call(this, x, y, z, args);
+        };
+        G__7392.cljs$lang$maxFixedArity = 3;
+        G__7392.cljs$lang$applyTo = function(arglist__7393) {
+          var x = cljs.core.first(arglist__7393);
+          arglist__7393 = cljs.core.next(arglist__7393);
+          var y = cljs.core.first(arglist__7393);
+          arglist__7393 = cljs.core.next(arglist__7393);
+          var z = cljs.core.first(arglist__7393);
+          var args = cljs.core.rest(arglist__7393);
+          return G__7392__delegate(x, y, z, args);
+        };
+        G__7392.cljs$core$IFn$_invoke$arity$variadic = G__7392__delegate;
+        return G__7392;
+      }();
+      G__7391 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__7391__0.call(this);
+          case 1:
+            return G__7391__1.call(this, x);
+          case 2:
+            return G__7391__2.call(this, x, y);
+          case 3:
+            return G__7391__3.call(this, x, y, z);
+          default:
+            return G__7391__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7391.cljs$lang$maxFixedArity = 3;
+      G__7391.cljs$lang$applyTo = G__7391__4.cljs$lang$applyTo;
+      return G__7391;
+    }();
+  };
+  var comp__4 = function() {
+    var G__7394__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__7395__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__7396 = cljs.core.first.call(null, fs__$2).call(null, ret);
+              var G__7397 = cljs.core.next.call(null, fs__$2);
+              ret = G__7396;
+              fs__$2 = G__7397;
+              continue;
+            } else {
+              return ret;
+            }
+            break;
+          }
+        };
+        var G__7395 = function(var_args) {
+          var args = null;
+          if (arguments.length > 0) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+          }
+          return G__7395__delegate.call(this, args);
+        };
+        G__7395.cljs$lang$maxFixedArity = 0;
+        G__7395.cljs$lang$applyTo = function(arglist__7398) {
+          var args = cljs.core.seq(arglist__7398);
+          return G__7395__delegate(args);
+        };
+        G__7395.cljs$core$IFn$_invoke$arity$variadic = G__7395__delegate;
+        return G__7395;
+      }();
+    };
+    var G__7394 = 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__7394__delegate.call(this, f1, f2, f3, fs);
+    };
+    G__7394.cljs$lang$maxFixedArity = 3;
+    G__7394.cljs$lang$applyTo = function(arglist__7399) {
+      var f1 = cljs.core.first(arglist__7399);
+      arglist__7399 = cljs.core.next(arglist__7399);
+      var f2 = cljs.core.first(arglist__7399);
+      arglist__7399 = cljs.core.next(arglist__7399);
+      var f3 = cljs.core.first(arglist__7399);
+      var fs = cljs.core.rest(arglist__7399);
+      return G__7394__delegate(f1, f2, f3, fs);
+    };
+    G__7394.cljs$core$IFn$_invoke$arity$variadic = G__7394__delegate;
+    return G__7394;
+  }();
+  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__1 = function(f) {
+    return f;
+  };
+  var partial__2 = function(f, arg1) {
+    return function() {
+      var G__7400__delegate = function(args) {
+        return cljs.core.apply.call(null, f, arg1, args);
+      };
+      var G__7400 = function(var_args) {
+        var args = null;
+        if (arguments.length > 0) {
+          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+        }
+        return G__7400__delegate.call(this, args);
+      };
+      G__7400.cljs$lang$maxFixedArity = 0;
+      G__7400.cljs$lang$applyTo = function(arglist__7401) {
+        var args = cljs.core.seq(arglist__7401);
+        return G__7400__delegate(args);
+      };
+      G__7400.cljs$core$IFn$_invoke$arity$variadic = G__7400__delegate;
+      return G__7400;
+    }();
+  };
+  var partial__3 = function(f, arg1, arg2) {
+    return function() {
+      var G__7402__delegate = function(args) {
+        return cljs.core.apply.call(null, f, arg1, arg2, args);
+      };
+      var G__7402 = function(var_args) {
+        var args = null;
+        if (arguments.length > 0) {
+          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+        }
+        return G__7402__delegate.call(this, args);
+      };
+      G__7402.cljs$lang$maxFixedArity = 0;
+      G__7402.cljs$lang$applyTo = function(arglist__7403) {
+        var args = cljs.core.seq(arglist__7403);
+        return G__7402__delegate(args);
+      };
+      G__7402.cljs$core$IFn$_invoke$arity$variadic = G__7402__delegate;
+      return G__7402;
+    }();
+  };
+  var partial__4 = function(f, arg1, arg2, arg3) {
+    return function() {
+      var G__7404__delegate = function(args) {
+        return cljs.core.apply.call(null, f, arg1, arg2, arg3, args);
+      };
+      var G__7404 = function(var_args) {
+        var args = null;
+        if (arguments.length > 0) {
+          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+        }
+        return G__7404__delegate.call(this, args);
+      };
+      G__7404.cljs$lang$maxFixedArity = 0;
+      G__7404.cljs$lang$applyTo = function(arglist__7405) {
+        var args = cljs.core.seq(arglist__7405);
+        return G__7404__delegate(args);
+      };
+      G__7404.cljs$core$IFn$_invoke$arity$variadic = G__7404__delegate;
+      return G__7404;
+    }();
+  };
+  var partial__5 = function() {
+    var G__7406__delegate = function(f, arg1, arg2, arg3, more) {
+      return function() {
+        var G__7407__delegate = function(args) {
+          return cljs.core.apply.call(null, f, arg1, arg2, arg3, cljs.core.concat.call(null, more, args));
+        };
+        var G__7407 = function(var_args) {
+          var args = null;
+          if (arguments.length > 0) {
+            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+          }
+          return G__7407__delegate.call(this, args);
+        };
+        G__7407.cljs$lang$maxFixedArity = 0;
+        G__7407.cljs$lang$applyTo = function(arglist__7408) {
+          var args = cljs.core.seq(arglist__7408);
+          return G__7407__delegate(args);
+        };
+        G__7407.cljs$core$IFn$_invoke$arity$variadic = G__7407__delegate;
+        return G__7407;
+      }();
+    };
+    var G__7406 = 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__7406__delegate.call(this, f, arg1, arg2, arg3, more);
+    };
+    G__7406.cljs$lang$maxFixedArity = 4;
+    G__7406.cljs$lang$applyTo = function(arglist__7409) {
+      var f = cljs.core.first(arglist__7409);
+      arglist__7409 = cljs.core.next(arglist__7409);
+      var arg1 = cljs.core.first(arglist__7409);
+      arglist__7409 = cljs.core.next(arglist__7409);
+      var arg2 = cljs.core.first(arglist__7409);
+      arglist__7409 = cljs.core.next(arglist__7409);
+      var arg3 = cljs.core.first(arglist__7409);
+      var more = cljs.core.rest(arglist__7409);
+      return G__7406__delegate(f, arg1, arg2, arg3, more);
+    };
+    G__7406.cljs$core$IFn$_invoke$arity$variadic = G__7406__delegate;
+    return G__7406;
+  }();
+  partial = function(f, arg1, arg2, arg3, var_args) {
+    var more = var_args;
+    switch(arguments.length) {
+      case 1:
+        return partial__1.call(this, f);
+      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$1 = partial__1;
+  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__7410 = null;
+      var G__7410__1 = function(a) {
+        return f.call(null, a == null ? x : a);
+      };
+      var G__7410__2 = function(a, b) {
+        return f.call(null, a == null ? x : a, b);
+      };
+      var G__7410__3 = function(a, b, c) {
+        return f.call(null, a == null ? x : a, b, c);
+      };
+      var G__7410__4 = function() {
+        var G__7411__delegate = function(a, b, c, ds) {
+          return cljs.core.apply.call(null, f, a == null ? x : a, b, c, ds);
+        };
+        var G__7411 = 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__7411__delegate.call(this, a, b, c, ds);
+        };
+        G__7411.cljs$lang$maxFixedArity = 3;
+        G__7411.cljs$lang$applyTo = function(arglist__7412) {
+          var a = cljs.core.first(arglist__7412);
+          arglist__7412 = cljs.core.next(arglist__7412);
+          var b = cljs.core.first(arglist__7412);
+          arglist__7412 = cljs.core.next(arglist__7412);
+          var c = cljs.core.first(arglist__7412);
+          var ds = cljs.core.rest(arglist__7412);
+          return G__7411__delegate(a, b, c, ds);
+        };
+        G__7411.cljs$core$IFn$_invoke$arity$variadic = G__7411__delegate;
+        return G__7411;
+      }();
+      G__7410 = function(a, b, c, var_args) {
+        var ds = var_args;
+        switch(arguments.length) {
+          case 1:
+            return G__7410__1.call(this, a);
+          case 2:
+            return G__7410__2.call(this, a, b);
+          case 3:
+            return G__7410__3.call(this, a, b, c);
+          default:
+            return G__7410__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7410.cljs$lang$maxFixedArity = 3;
+      G__7410.cljs$lang$applyTo = G__7410__4.cljs$lang$applyTo;
+      return G__7410;
+    }();
+  };
+  var fnil__3 = function(f, x, y) {
+    return function() {
+      var G__7413 = null;
+      var G__7413__2 = function(a, b) {
+        return f.call(null, a == null ? x : a, b == null ? y : b);
+      };
+      var G__7413__3 = function(a, b, c) {
+        return f.call(null, a == null ? x : a, b == null ? y : b, c);
+      };
+      var G__7413__4 = function() {
+        var G__7414__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__7414 = 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__7414__delegate.call(this, a, b, c, ds);
+        };
+        G__7414.cljs$lang$maxFixedArity = 3;
+        G__7414.cljs$lang$applyTo = function(arglist__7415) {
+          var a = cljs.core.first(arglist__7415);
+          arglist__7415 = cljs.core.next(arglist__7415);
+          var b = cljs.core.first(arglist__7415);
+          arglist__7415 = cljs.core.next(arglist__7415);
+          var c = cljs.core.first(arglist__7415);
+          var ds = cljs.core.rest(arglist__7415);
+          return G__7414__delegate(a, b, c, ds);
+        };
+        G__7414.cljs$core$IFn$_invoke$arity$variadic = G__7414__delegate;
+        return G__7414;
+      }();
+      G__7413 = function(a, b, c, var_args) {
+        var ds = var_args;
+        switch(arguments.length) {
+          case 2:
+            return G__7413__2.call(this, a, b);
+          case 3:
+            return G__7413__3.call(this, a, b, c);
+          default:
+            return G__7413__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7413.cljs$lang$maxFixedArity = 3;
+      G__7413.cljs$lang$applyTo = G__7413__4.cljs$lang$applyTo;
+      return G__7413;
+    }();
+  };
+  var fnil__4 = function(f, x, y, z) {
+    return function() {
+      var G__7416 = null;
+      var G__7416__2 = function(a, b) {
+        return f.call(null, a == null ? x : a, b == null ? y : b);
+      };
+      var G__7416__3 = function(a, b, c) {
+        return f.call(null, a == null ? x : a, b == null ? y : b, c == null ? z : c);
+      };
+      var G__7416__4 = function() {
+        var G__7417__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__7417 = 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__7417__delegate.call(this, a, b, c, ds);
+        };
+        G__7417.cljs$lang$maxFixedArity = 3;
+        G__7417.cljs$lang$applyTo = function(arglist__7418) {
+          var a = cljs.core.first(arglist__7418);
+          arglist__7418 = cljs.core.next(arglist__7418);
+          var b = cljs.core.first(arglist__7418);
+          arglist__7418 = cljs.core.next(arglist__7418);
+          var c = cljs.core.first(arglist__7418);
+          var ds = cljs.core.rest(arglist__7418);
+          return G__7417__delegate(a, b, c, ds);
+        };
+        G__7417.cljs$core$IFn$_invoke$arity$variadic = G__7417__delegate;
+        return G__7417;
+      }();
+      G__7416 = function(a, b, c, var_args) {
+        var ds = var_args;
+        switch(arguments.length) {
+          case 2:
+            return G__7416__2.call(this, a, b);
+          case 3:
+            return G__7416__3.call(this, a, b, c);
+          default:
+            return G__7416__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7416.cljs$lang$maxFixedArity = 3;
+      G__7416.cljs$lang$applyTo = G__7416__4.cljs$lang$applyTo;
+      return G__7416;
+    }();
+  };
+  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, 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__4232__auto___7419 = size;
+          var i_7420 = 0;
+          while (true) {
+            if (i_7420 < n__4232__auto___7419) {
+              cljs.core.chunk_append.call(null, b, f.call(null, idx + i_7420, cljs.core._nth.call(null, c, i_7420)));
+              var G__7421 = i_7420 + 1;
+              i_7420 = G__7421;
+              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, null);
+  };
+  return mapi.call(null, 0, coll);
+};
+cljs.core.keep = function keep(f, coll) {
+  return new cljs.core.LazySeq(null, 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__4232__auto___7422 = size;
+        var i_7423 = 0;
+        while (true) {
+          if (i_7423 < n__4232__auto___7422) {
+            var x_7424 = f.call(null, cljs.core._nth.call(null, c, i_7423));
+            if (x_7424 == null) {
+            } else {
+              cljs.core.chunk_append.call(null, b, x_7424);
+            }
+            var G__7425 = i_7423 + 1;
+            i_7423 = G__7425;
+            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, null);
+};
+cljs.core.keep_indexed = function keep_indexed(f, coll) {
+  var keepi = function keepi(idx, coll__$1) {
+    return new cljs.core.LazySeq(null, 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__4232__auto___7426 = size;
+          var i_7427 = 0;
+          while (true) {
+            if (i_7427 < n__4232__auto___7426) {
+              var x_7428 = f.call(null, idx + i_7427, cljs.core._nth.call(null, c, i_7427));
+              if (x_7428 == null) {
+              } else {
+                cljs.core.chunk_append.call(null, b, x_7428);
+              }
+              var G__7429 = i_7427 + 1;
+              i_7427 = G__7429;
+              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, 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__3396__auto__ = p.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            return p.call(null, y);
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep1__3 = function(x, y, z) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3396__auto__ = p.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = p.call(null, y);
+            if (cljs.core.truth_(and__3396__auto____$1)) {
+              return p.call(null, z);
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep1__4 = function() {
+        var G__7436__delegate = function(x, y, z, args) {
+          return cljs.core.boolean$.call(null, ep1.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, p, args));
+        };
+        var G__7436 = 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__7436__delegate.call(this, x, y, z, args);
+        };
+        G__7436.cljs$lang$maxFixedArity = 3;
+        G__7436.cljs$lang$applyTo = function(arglist__7437) {
+          var x = cljs.core.first(arglist__7437);
+          arglist__7437 = cljs.core.next(arglist__7437);
+          var y = cljs.core.first(arglist__7437);
+          arglist__7437 = cljs.core.next(arglist__7437);
+          var z = cljs.core.first(arglist__7437);
+          var args = cljs.core.rest(arglist__7437);
+          return G__7436__delegate(x, y, z, args);
+        };
+        G__7436.cljs$core$IFn$_invoke$arity$variadic = G__7436__delegate;
+        return G__7436;
+      }();
+      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__3396__auto__ = p1.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            return p2.call(null, x);
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep2__2 = function(x, y) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3396__auto__ = p1.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = p1.call(null, y);
+            if (cljs.core.truth_(and__3396__auto____$1)) {
+              var and__3396__auto____$2 = p2.call(null, x);
+              if (cljs.core.truth_(and__3396__auto____$2)) {
+                return p2.call(null, y);
+              } else {
+                return and__3396__auto____$2;
+              }
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep2__3 = function(x, y, z) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3396__auto__ = p1.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = p1.call(null, y);
+            if (cljs.core.truth_(and__3396__auto____$1)) {
+              var and__3396__auto____$2 = p1.call(null, z);
+              if (cljs.core.truth_(and__3396__auto____$2)) {
+                var and__3396__auto____$3 = p2.call(null, x);
+                if (cljs.core.truth_(and__3396__auto____$3)) {
+                  var and__3396__auto____$4 = p2.call(null, y);
+                  if (cljs.core.truth_(and__3396__auto____$4)) {
+                    return p2.call(null, z);
+                  } else {
+                    return and__3396__auto____$4;
+                  }
+                } else {
+                  return and__3396__auto____$3;
+                }
+              } else {
+                return and__3396__auto____$2;
+              }
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep2__4 = function() {
+        var G__7438__delegate = function(x, y, z, args) {
+          return cljs.core.boolean$.call(null, ep2.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, function(p1__7430_SHARP_) {
+            var and__3396__auto__ = p1.call(null, p1__7430_SHARP_);
+            if (cljs.core.truth_(and__3396__auto__)) {
+              return p2.call(null, p1__7430_SHARP_);
+            } else {
+              return and__3396__auto__;
+            }
+          }, args));
+        };
+        var G__7438 = 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__7438__delegate.call(this, x, y, z, args);
+        };
+        G__7438.cljs$lang$maxFixedArity = 3;
+        G__7438.cljs$lang$applyTo = function(arglist__7439) {
+          var x = cljs.core.first(arglist__7439);
+          arglist__7439 = cljs.core.next(arglist__7439);
+          var y = cljs.core.first(arglist__7439);
+          arglist__7439 = cljs.core.next(arglist__7439);
+          var z = cljs.core.first(arglist__7439);
+          var args = cljs.core.rest(arglist__7439);
+          return G__7438__delegate(x, y, z, args);
+        };
+        G__7438.cljs$core$IFn$_invoke$arity$variadic = G__7438__delegate;
+        return G__7438;
+      }();
+      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__3396__auto__ = p1.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = p2.call(null, x);
+            if (cljs.core.truth_(and__3396__auto____$1)) {
+              return p3.call(null, x);
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep3__2 = function(x, y) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3396__auto__ = p1.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = p2.call(null, x);
+            if (cljs.core.truth_(and__3396__auto____$1)) {
+              var and__3396__auto____$2 = p3.call(null, x);
+              if (cljs.core.truth_(and__3396__auto____$2)) {
+                var and__3396__auto____$3 = p1.call(null, y);
+                if (cljs.core.truth_(and__3396__auto____$3)) {
+                  var and__3396__auto____$4 = p2.call(null, y);
+                  if (cljs.core.truth_(and__3396__auto____$4)) {
+                    return p3.call(null, y);
+                  } else {
+                    return and__3396__auto____$4;
+                  }
+                } else {
+                  return and__3396__auto____$3;
+                }
+              } else {
+                return and__3396__auto____$2;
+              }
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep3__3 = function(x, y, z) {
+        return cljs.core.boolean$.call(null, function() {
+          var and__3396__auto__ = p1.call(null, x);
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = p2.call(null, x);
+            if (cljs.core.truth_(and__3396__auto____$1)) {
+              var and__3396__auto____$2 = p3.call(null, x);
+              if (cljs.core.truth_(and__3396__auto____$2)) {
+                var and__3396__auto____$3 = p1.call(null, y);
+                if (cljs.core.truth_(and__3396__auto____$3)) {
+                  var and__3396__auto____$4 = p2.call(null, y);
+                  if (cljs.core.truth_(and__3396__auto____$4)) {
+                    var and__3396__auto____$5 = p3.call(null, y);
+                    if (cljs.core.truth_(and__3396__auto____$5)) {
+                      var and__3396__auto____$6 = p1.call(null, z);
+                      if (cljs.core.truth_(and__3396__auto____$6)) {
+                        var and__3396__auto____$7 = p2.call(null, z);
+                        if (cljs.core.truth_(and__3396__auto____$7)) {
+                          return p3.call(null, z);
+                        } else {
+                          return and__3396__auto____$7;
+                        }
+                      } else {
+                        return and__3396__auto____$6;
+                      }
+                    } else {
+                      return and__3396__auto____$5;
+                    }
+                  } else {
+                    return and__3396__auto____$4;
+                  }
+                } else {
+                  return and__3396__auto____$3;
+                }
+              } else {
+                return and__3396__auto____$2;
+              }
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__auto__;
+          }
+        }());
+      };
+      var ep3__4 = function() {
+        var G__7440__delegate = function(x, y, z, args) {
+          return cljs.core.boolean$.call(null, ep3.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, function(p1__7431_SHARP_) {
+            var and__3396__auto__ = p1.call(null, p1__7431_SHARP_);
+            if (cljs.core.truth_(and__3396__auto__)) {
+              var and__3396__auto____$1 = p2.call(null, p1__7431_SHARP_);
+              if (cljs.core.truth_(and__3396__auto____$1)) {
+                return p3.call(null, p1__7431_SHARP_);
+              } else {
+                return and__3396__auto____$1;
+              }
+            } else {
+              return and__3396__auto__;
+            }
+          }, args));
+        };
+        var G__7440 = 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__7440__delegate.call(this, x, y, z, args);
+        };
+        G__7440.cljs$lang$maxFixedArity = 3;
+        G__7440.cljs$lang$applyTo = function(arglist__7441) {
+          var x = cljs.core.first(arglist__7441);
+          arglist__7441 = cljs.core.next(arglist__7441);
+          var y = cljs.core.first(arglist__7441);
+          arglist__7441 = cljs.core.next(arglist__7441);
+          var z = cljs.core.first(arglist__7441);
+          var args = cljs.core.rest(arglist__7441);
+          return G__7440__delegate(x, y, z, args);
+        };
+        G__7440.cljs$core$IFn$_invoke$arity$variadic = G__7440__delegate;
+        return G__7440;
+      }();
+      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__7442__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__7432_SHARP_) {
+            return p1__7432_SHARP_.call(null, x);
+          }, ps__$1);
+        };
+        var epn__2 = function(x, y) {
+          return cljs.core.every_QMARK_.call(null, function(p1__7433_SHARP_) {
+            var and__3396__auto__ = p1__7433_SHARP_.call(null, x);
+            if (cljs.core.truth_(and__3396__auto__)) {
+              return p1__7433_SHARP_.call(null, y);
+            } else {
+              return and__3396__auto__;
+            }
+          }, ps__$1);
+        };
+        var epn__3 = function(x, y, z) {
+          return cljs.core.every_QMARK_.call(null, function(p1__7434_SHARP_) {
+            var and__3396__auto__ = p1__7434_SHARP_.call(null, x);
+            if (cljs.core.truth_(and__3396__auto__)) {
+              var and__3396__auto____$1 = p1__7434_SHARP_.call(null, y);
+              if (cljs.core.truth_(and__3396__auto____$1)) {
+                return p1__7434_SHARP_.call(null, z);
+              } else {
+                return and__3396__auto____$1;
+              }
+            } else {
+              return and__3396__auto__;
+            }
+          }, ps__$1);
+        };
+        var epn__4 = function() {
+          var G__7443__delegate = function(x, y, z, args) {
+            return cljs.core.boolean$.call(null, epn.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, function(p1__7435_SHARP_) {
+              return cljs.core.every_QMARK_.call(null, p1__7435_SHARP_, args);
+            }, ps__$1));
+          };
+          var G__7443 = 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__7443__delegate.call(this, x, y, z, args);
+          };
+          G__7443.cljs$lang$maxFixedArity = 3;
+          G__7443.cljs$lang$applyTo = function(arglist__7444) {
+            var x = cljs.core.first(arglist__7444);
+            arglist__7444 = cljs.core.next(arglist__7444);
+            var y = cljs.core.first(arglist__7444);
+            arglist__7444 = cljs.core.next(arglist__7444);
+            var z = cljs.core.first(arglist__7444);
+            var args = cljs.core.rest(arglist__7444);
+            return G__7443__delegate(x, y, z, args);
+          };
+          G__7443.cljs$core$IFn$_invoke$arity$variadic = G__7443__delegate;
+          return G__7443;
+        }();
+        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__7442 = 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__7442__delegate.call(this, p1, p2, p3, ps);
+    };
+    G__7442.cljs$lang$maxFixedArity = 3;
+    G__7442.cljs$lang$applyTo = function(arglist__7445) {
+      var p1 = cljs.core.first(arglist__7445);
+      arglist__7445 = cljs.core.next(arglist__7445);
+      var p2 = cljs.core.first(arglist__7445);
+      arglist__7445 = cljs.core.next(arglist__7445);
+      var p3 = cljs.core.first(arglist__7445);
+      var ps = cljs.core.rest(arglist__7445);
+      return G__7442__delegate(p1, p2, p3, ps);
+    };
+    G__7442.cljs$core$IFn$_invoke$arity$variadic = G__7442__delegate;
+    return G__7442;
+  }();
+  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__3408__auto__ = p.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          return p.call(null, y);
+        }
+      };
+      var sp1__3 = function(x, y, z) {
+        var or__3408__auto__ = p.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = p.call(null, y);
+          if (cljs.core.truth_(or__3408__auto____$1)) {
+            return or__3408__auto____$1;
+          } else {
+            return p.call(null, z);
+          }
+        }
+      };
+      var sp1__4 = function() {
+        var G__7452__delegate = function(x, y, z, args) {
+          var or__3408__auto__ = sp1.call(null, x, y, z);
+          if (cljs.core.truth_(or__3408__auto__)) {
+            return or__3408__auto__;
+          } else {
+            return cljs.core.some.call(null, p, args);
+          }
+        };
+        var G__7452 = 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__7452__delegate.call(this, x, y, z, args);
+        };
+        G__7452.cljs$lang$maxFixedArity = 3;
+        G__7452.cljs$lang$applyTo = function(arglist__7453) {
+          var x = cljs.core.first(arglist__7453);
+          arglist__7453 = cljs.core.next(arglist__7453);
+          var y = cljs.core.first(arglist__7453);
+          arglist__7453 = cljs.core.next(arglist__7453);
+          var z = cljs.core.first(arglist__7453);
+          var args = cljs.core.rest(arglist__7453);
+          return G__7452__delegate(x, y, z, args);
+        };
+        G__7452.cljs$core$IFn$_invoke$arity$variadic = G__7452__delegate;
+        return G__7452;
+      }();
+      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__3408__auto__ = p1.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          return p2.call(null, x);
+        }
+      };
+      var sp2__2 = function(x, y) {
+        var or__3408__auto__ = p1.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = p1.call(null, y);
+          if (cljs.core.truth_(or__3408__auto____$1)) {
+            return or__3408__auto____$1;
+          } else {
+            var or__3408__auto____$2 = p2.call(null, x);
+            if (cljs.core.truth_(or__3408__auto____$2)) {
+              return or__3408__auto____$2;
+            } else {
+              return p2.call(null, y);
+            }
+          }
+        }
+      };
+      var sp2__3 = function(x, y, z) {
+        var or__3408__auto__ = p1.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = p1.call(null, y);
+          if (cljs.core.truth_(or__3408__auto____$1)) {
+            return or__3408__auto____$1;
+          } else {
+            var or__3408__auto____$2 = p1.call(null, z);
+            if (cljs.core.truth_(or__3408__auto____$2)) {
+              return or__3408__auto____$2;
+            } else {
+              var or__3408__auto____$3 = p2.call(null, x);
+              if (cljs.core.truth_(or__3408__auto____$3)) {
+                return or__3408__auto____$3;
+              } else {
+                var or__3408__auto____$4 = p2.call(null, y);
+                if (cljs.core.truth_(or__3408__auto____$4)) {
+                  return or__3408__auto____$4;
+                } else {
+                  return p2.call(null, z);
+                }
+              }
+            }
+          }
+        }
+      };
+      var sp2__4 = function() {
+        var G__7454__delegate = function(x, y, z, args) {
+          var or__3408__auto__ = sp2.call(null, x, y, z);
+          if (cljs.core.truth_(or__3408__auto__)) {
+            return or__3408__auto__;
+          } else {
+            return cljs.core.some.call(null, function(p1__7446_SHARP_) {
+              var or__3408__auto____$1 = p1.call(null, p1__7446_SHARP_);
+              if (cljs.core.truth_(or__3408__auto____$1)) {
+                return or__3408__auto____$1;
+              } else {
+                return p2.call(null, p1__7446_SHARP_);
+              }
+            }, args);
+          }
+        };
+        var G__7454 = 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__7454__delegate.call(this, x, y, z, args);
+        };
+        G__7454.cljs$lang$maxFixedArity = 3;
+        G__7454.cljs$lang$applyTo = function(arglist__7455) {
+          var x = cljs.core.first(arglist__7455);
+          arglist__7455 = cljs.core.next(arglist__7455);
+          var y = cljs.core.first(arglist__7455);
+          arglist__7455 = cljs.core.next(arglist__7455);
+          var z = cljs.core.first(arglist__7455);
+          var args = cljs.core.rest(arglist__7455);
+          return G__7454__delegate(x, y, z, args);
+        };
+        G__7454.cljs$core$IFn$_invoke$arity$variadic = G__7454__delegate;
+        return G__7454;
+      }();
+      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__3408__auto__ = p1.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = p2.call(null, x);
+          if (cljs.core.truth_(or__3408__auto____$1)) {
+            return or__3408__auto____$1;
+          } else {
+            return p3.call(null, x);
+          }
+        }
+      };
+      var sp3__2 = function(x, y) {
+        var or__3408__auto__ = p1.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = p2.call(null, x);
+          if (cljs.core.truth_(or__3408__auto____$1)) {
+            return or__3408__auto____$1;
+          } else {
+            var or__3408__auto____$2 = p3.call(null, x);
+            if (cljs.core.truth_(or__3408__auto____$2)) {
+              return or__3408__auto____$2;
+            } else {
+              var or__3408__auto____$3 = p1.call(null, y);
+              if (cljs.core.truth_(or__3408__auto____$3)) {
+                return or__3408__auto____$3;
+              } else {
+                var or__3408__auto____$4 = p2.call(null, y);
+                if (cljs.core.truth_(or__3408__auto____$4)) {
+                  return or__3408__auto____$4;
+                } else {
+                  return p3.call(null, y);
+                }
+              }
+            }
+          }
+        }
+      };
+      var sp3__3 = function(x, y, z) {
+        var or__3408__auto__ = p1.call(null, x);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          var or__3408__auto____$1 = p2.call(null, x);
+          if (cljs.core.truth_(or__3408__auto____$1)) {
+            return or__3408__auto____$1;
+          } else {
+            var or__3408__auto____$2 = p3.call(null, x);
+            if (cljs.core.truth_(or__3408__auto____$2)) {
+              return or__3408__auto____$2;
+            } else {
+              var or__3408__auto____$3 = p1.call(null, y);
+              if (cljs.core.truth_(or__3408__auto____$3)) {
+                return or__3408__auto____$3;
+              } else {
+                var or__3408__auto____$4 = p2.call(null, y);
+                if (cljs.core.truth_(or__3408__auto____$4)) {
+                  return or__3408__auto____$4;
+                } else {
+                  var or__3408__auto____$5 = p3.call(null, y);
+                  if (cljs.core.truth_(or__3408__auto____$5)) {
+                    return or__3408__auto____$5;
+                  } else {
+                    var or__3408__auto____$6 = p1.call(null, z);
+                    if (cljs.core.truth_(or__3408__auto____$6)) {
+                      return or__3408__auto____$6;
+                    } else {
+                      var or__3408__auto____$7 = p2.call(null, z);
+                      if (cljs.core.truth_(or__3408__auto____$7)) {
+                        return or__3408__auto____$7;
+                      } else {
+                        return p3.call(null, z);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      var sp3__4 = function() {
+        var G__7456__delegate = function(x, y, z, args) {
+          var or__3408__auto__ = sp3.call(null, x, y, z);
+          if (cljs.core.truth_(or__3408__auto__)) {
+            return or__3408__auto__;
+          } else {
+            return cljs.core.some.call(null, function(p1__7447_SHARP_) {
+              var or__3408__auto____$1 = p1.call(null, p1__7447_SHARP_);
+              if (cljs.core.truth_(or__3408__auto____$1)) {
+                return or__3408__auto____$1;
+              } else {
+                var or__3408__auto____$2 = p2.call(null, p1__7447_SHARP_);
+                if (cljs.core.truth_(or__3408__auto____$2)) {
+                  return or__3408__auto____$2;
+                } else {
+                  return p3.call(null, p1__7447_SHARP_);
+                }
+              }
+            }, args);
+          }
+        };
+        var G__7456 = 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__7456__delegate.call(this, x, y, z, args);
+        };
+        G__7456.cljs$lang$maxFixedArity = 3;
+        G__7456.cljs$lang$applyTo = function(arglist__7457) {
+          var x = cljs.core.first(arglist__7457);
+          arglist__7457 = cljs.core.next(arglist__7457);
+          var y = cljs.core.first(arglist__7457);
+          arglist__7457 = cljs.core.next(arglist__7457);
+          var z = cljs.core.first(arglist__7457);
+          var args = cljs.core.rest(arglist__7457);
+          return G__7456__delegate(x, y, z, args);
+        };
+        G__7456.cljs$core$IFn$_invoke$arity$variadic = G__7456__delegate;
+        return G__7456;
+      }();
+      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__7458__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__7448_SHARP_) {
+            return p1__7448_SHARP_.call(null, x);
+          }, ps__$1);
+        };
+        var spn__2 = function(x, y) {
+          return cljs.core.some.call(null, function(p1__7449_SHARP_) {
+            var or__3408__auto__ = p1__7449_SHARP_.call(null, x);
+            if (cljs.core.truth_(or__3408__auto__)) {
+              return or__3408__auto__;
+            } else {
+              return p1__7449_SHARP_.call(null, y);
+            }
+          }, ps__$1);
+        };
+        var spn__3 = function(x, y, z) {
+          return cljs.core.some.call(null, function(p1__7450_SHARP_) {
+            var or__3408__auto__ = p1__7450_SHARP_.call(null, x);
+            if (cljs.core.truth_(or__3408__auto__)) {
+              return or__3408__auto__;
+            } else {
+              var or__3408__auto____$1 = p1__7450_SHARP_.call(null, y);
+              if (cljs.core.truth_(or__3408__auto____$1)) {
+                return or__3408__auto____$1;
+              } else {
+                return p1__7450_SHARP_.call(null, z);
+              }
+            }
+          }, ps__$1);
+        };
+        var spn__4 = function() {
+          var G__7459__delegate = function(x, y, z, args) {
+            var or__3408__auto__ = spn.call(null, x, y, z);
+            if (cljs.core.truth_(or__3408__auto__)) {
+              return or__3408__auto__;
+            } else {
+              return cljs.core.some.call(null, function(p1__7451_SHARP_) {
+                return cljs.core.some.call(null, p1__7451_SHARP_, args);
+              }, ps__$1);
+            }
+          };
+          var G__7459 = 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__7459__delegate.call(this, x, y, z, args);
+          };
+          G__7459.cljs$lang$maxFixedArity = 3;
+          G__7459.cljs$lang$applyTo = function(arglist__7460) {
+            var x = cljs.core.first(arglist__7460);
+            arglist__7460 = cljs.core.next(arglist__7460);
+            var y = cljs.core.first(arglist__7460);
+            arglist__7460 = cljs.core.next(arglist__7460);
+            var z = cljs.core.first(arglist__7460);
+            var args = cljs.core.rest(arglist__7460);
+            return G__7459__delegate(x, y, z, args);
+          };
+          G__7459.cljs$core$IFn$_invoke$arity$variadic = G__7459__delegate;
+          return G__7459;
+        }();
+        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__7458 = 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__7458__delegate.call(this, p1, p2, p3, ps);
+    };
+    G__7458.cljs$lang$maxFixedArity = 3;
+    G__7458.cljs$lang$applyTo = function(arglist__7461) {
+      var p1 = cljs.core.first(arglist__7461);
+      arglist__7461 = cljs.core.next(arglist__7461);
+      var p2 = cljs.core.first(arglist__7461);
+      arglist__7461 = cljs.core.next(arglist__7461);
+      var p3 = cljs.core.first(arglist__7461);
+      var ps = cljs.core.rest(arglist__7461);
+      return G__7458__delegate(p1, p2, p3, ps);
+    };
+    G__7458.cljs$core$IFn$_invoke$arity$variadic = G__7458__delegate;
+    return G__7458;
+  }();
+  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, 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__4232__auto___7463 = size;
+          var i_7464 = 0;
+          while (true) {
+            if (i_7464 < n__4232__auto___7463) {
+              cljs.core.chunk_append.call(null, b, f.call(null, cljs.core._nth.call(null, c, i_7464)));
+              var G__7465 = i_7464 + 1;
+              i_7464 = G__7465;
+              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, null);
+  };
+  var map__3 = function(f, c1, c2) {
+    return new cljs.core.LazySeq(null, function() {
+      var s1 = cljs.core.seq.call(null, c1);
+      var s2 = cljs.core.seq.call(null, c2);
+      if (s1 && s2) {
+        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, null);
+  };
+  var map__4 = function(f, c1, c2, c3) {
+    return new cljs.core.LazySeq(null, 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 (s1 && (s2 && s3)) {
+        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, null);
+  };
+  var map__5 = function() {
+    var G__7466__delegate = function(f, c1, c2, c3, colls) {
+      var step = function step(cs) {
+        return new cljs.core.LazySeq(null, 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, null);
+      };
+      return map.call(null, function(p1__7462_SHARP_) {
+        return cljs.core.apply.call(null, f, p1__7462_SHARP_);
+      }, step.call(null, cljs.core.conj.call(null, colls, c3, c2, c1)));
+    };
+    var G__7466 = 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__7466__delegate.call(this, f, c1, c2, c3, colls);
+    };
+    G__7466.cljs$lang$maxFixedArity = 4;
+    G__7466.cljs$lang$applyTo = function(arglist__7467) {
+      var f = cljs.core.first(arglist__7467);
+      arglist__7467 = cljs.core.next(arglist__7467);
+      var c1 = cljs.core.first(arglist__7467);
+      arglist__7467 = cljs.core.next(arglist__7467);
+      var c2 = cljs.core.first(arglist__7467);
+      arglist__7467 = cljs.core.next(arglist__7467);
+      var c3 = cljs.core.first(arglist__7467);
+      var colls = cljs.core.rest(arglist__7467);
+      return G__7466__delegate(f, c1, c2, c3, colls);
+    };
+    G__7466.cljs$core$IFn$_invoke$arity$variadic = G__7466__delegate;
+    return G__7466;
+  }();
+  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, 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, 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 (n__$1 > 0 && s) {
+        var G__7468 = n__$1 - 1;
+        var G__7469 = cljs.core.rest.call(null, s);
+        n__$1 = G__7468;
+        coll__$1 = G__7469;
+        continue;
+      } else {
+        return s;
+      }
+      break;
+    }
+  };
+  return new cljs.core.LazySeq(null, function() {
+    return step.call(null, n, coll);
+  }, null, 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__7470 = cljs.core.next.call(null, s);
+      var G__7471 = cljs.core.next.call(null, lead);
+      s = G__7470;
+      lead = G__7471;
+      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__3396__auto__ = s;
+        if (and__3396__auto__) {
+          return pred__$1.call(null, cljs.core.first.call(null, s));
+        } else {
+          return and__3396__auto__;
+        }
+      }())) {
+        var G__7472 = pred__$1;
+        var G__7473 = cljs.core.rest.call(null, s);
+        pred__$1 = G__7472;
+        coll__$1 = G__7473;
+        continue;
+      } else {
+        return s;
+      }
+      break;
+    }
+  };
+  return new cljs.core.LazySeq(null, function() {
+    return step.call(null, pred, coll);
+  }, null, null);
+};
+cljs.core.cycle = function cycle(coll) {
+  return new cljs.core.LazySeq(null, 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, null);
+};
+cljs.core.split_at = function split_at(n, coll) {
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take.call(null, n, coll), cljs.core.drop.call(null, n, coll)], null);
+};
+cljs.core.repeat = function() {
+  var repeat = null;
+  var repeat__1 = function(x) {
+    return new cljs.core.LazySeq(null, function() {
+      return cljs.core.cons.call(null, x, repeat.call(null, x));
+    }, null, 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, function() {
+      return cljs.core.cons.call(null, f.call(null), repeatedly.call(null, f));
+    }, null, 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, function() {
+    return iterate.call(null, f, f.call(null, x));
+  }, null, null));
+};
+cljs.core.interleave = function() {
+  var interleave = null;
+  var interleave__2 = function(c1, c2) {
+    return new cljs.core.LazySeq(null, function() {
+      var s1 = cljs.core.seq.call(null, c1);
+      var s2 = cljs.core.seq.call(null, c2);
+      if (s1 && s2) {
+        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, null);
+  };
+  var interleave__3 = function() {
+    var G__7474__delegate = function(c1, c2, colls) {
+      return new cljs.core.LazySeq(null, 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, null);
+    };
+    var G__7474 = 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__7474__delegate.call(this, c1, c2, colls);
+    };
+    G__7474.cljs$lang$maxFixedArity = 2;
+    G__7474.cljs$lang$applyTo = function(arglist__7475) {
+      var c1 = cljs.core.first(arglist__7475);
+      arglist__7475 = cljs.core.next(arglist__7475);
+      var c2 = cljs.core.first(arglist__7475);
+      var colls = cljs.core.rest(arglist__7475);
+      return G__7474__delegate(c1, c2, colls);
+    };
+    G__7474.cljs$core$IFn$_invoke$arity$variadic = G__7474__delegate;
+    return G__7474;
+  }();
+  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, 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, 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__7476__delegate = function(f, coll, colls) {
+      return cljs.core.flatten1.call(null, cljs.core.apply.call(null, cljs.core.map, f, coll, colls));
+    };
+    var G__7476 = 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__7476__delegate.call(this, f, coll, colls);
+    };
+    G__7476.cljs$lang$maxFixedArity = 2;
+    G__7476.cljs$lang$applyTo = function(arglist__7477) {
+      var f = cljs.core.first(arglist__7477);
+      arglist__7477 = cljs.core.next(arglist__7477);
+      var coll = cljs.core.first(arglist__7477);
+      var colls = cljs.core.rest(arglist__7477);
+      return G__7476__delegate(f, coll, colls);
+    };
+    G__7476.cljs$core$IFn$_invoke$arity$variadic = G__7476__delegate;
+    return G__7476;
+  }();
+  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, 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__4232__auto___7478 = size;
+        var i_7479 = 0;
+        while (true) {
+          if (i_7479 < n__4232__auto___7478) {
+            if (cljs.core.truth_(pred.call(null, cljs.core._nth.call(null, c, i_7479)))) {
+              cljs.core.chunk_append.call(null, b, cljs.core._nth.call(null, c, i_7479));
+            } else {
+            }
+            var G__7480 = i_7479 + 1;
+            i_7479 = G__7480;
+            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, 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, 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, null);
+  };
+  return walk.call(null, root);
+};
+cljs.core.flatten = function flatten(x) {
+  return cljs.core.filter.call(null, function(p1__7481_SHARP_) {
+    return!cljs.core.sequential_QMARK_.call(null, p1__7481_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__7483 = to;
+      if (G__7483) {
+        var bit__4027__auto__ = G__7483.cljs$lang$protocol_mask$partition1$ & 4;
+        if (bit__4027__auto__ || G__7483.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__7484__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__7484 = 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__7484__delegate.call(this, f, c1, c2, c3, colls);
+    };
+    G__7484.cljs$lang$maxFixedArity = 4;
+    G__7484.cljs$lang$applyTo = function(arglist__7485) {
+      var f = cljs.core.first(arglist__7485);
+      arglist__7485 = cljs.core.next(arglist__7485);
+      var c1 = cljs.core.first(arglist__7485);
+      arglist__7485 = cljs.core.next(arglist__7485);
+      var c2 = cljs.core.first(arglist__7485);
+      arglist__7485 = cljs.core.next(arglist__7485);
+      var c3 = cljs.core.first(arglist__7485);
+      var colls = cljs.core.rest(arglist__7485);
+      return G__7484__delegate(f, c1, c2, c3, colls);
+    };
+    G__7484.cljs$core$IFn$_invoke$arity$variadic = G__7484__delegate;
+    return G__7484;
+  }();
+  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, 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, null);
+  };
+  var partition__4 = function(n, step, pad, coll) {
+    return new cljs.core.LazySeq(null, 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._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, n, cljs.core.concat.call(null, p, pad)));
+        }
+      } else {
+        return null;
+      }
+    }, 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__7487 = m__$1;
+          if (G__7487) {
+            var bit__4034__auto__ = G__7487.cljs$lang$protocol_mask$partition0$ & 256;
+            if (bit__4034__auto__ || G__7487.cljs$core$ILookup$) {
+              return true;
+            } else {
+              if (!G__7487.cljs$lang$protocol_mask$partition0$) {
+                return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, G__7487);
+              } else {
+                return false;
+              }
+            }
+          } else {
+            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, G__7487);
+          }
+        }()) {
+          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__7488 = sentinel;
+            var G__7489 = m__$2;
+            var G__7490 = cljs.core.next.call(null, ks__$1);
+            sentinel = G__7488;
+            m__$1 = G__7489;
+            ks__$1 = G__7490;
+            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__7491, v) {
+  var vec__7493 = p__7491;
+  var k = cljs.core.nth.call(null, vec__7493, 0, null);
+  var ks = cljs.core.nthnext.call(null, vec__7493, 1);
+  if (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__7494, f) {
+    var vec__7504 = p__7494;
+    var k = cljs.core.nth.call(null, vec__7504, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__7504, 1);
+    if (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__7495, f, a) {
+    var vec__7505 = p__7495;
+    var k = cljs.core.nth.call(null, vec__7505, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__7505, 1);
+    if (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__7496, f, a, b) {
+    var vec__7506 = p__7496;
+    var k = cljs.core.nth.call(null, vec__7506, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__7506, 1);
+    if (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__7497, f, a, b, c) {
+    var vec__7507 = p__7497;
+    var k = cljs.core.nth.call(null, vec__7507, 0, null);
+    var ks = cljs.core.nthnext.call(null, vec__7507, 1);
+    if (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__7509__delegate = function(m, p__7498, f, a, b, c, args) {
+      var vec__7508 = p__7498;
+      var k = cljs.core.nth.call(null, vec__7508, 0, null);
+      var ks = cljs.core.nthnext.call(null, vec__7508, 1);
+      if (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__7509 = function(m, p__7498, 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__7509__delegate.call(this, m, p__7498, f, a, b, c, args);
+    };
+    G__7509.cljs$lang$maxFixedArity = 6;
+    G__7509.cljs$lang$applyTo = function(arglist__7510) {
+      var m = cljs.core.first(arglist__7510);
+      arglist__7510 = cljs.core.next(arglist__7510);
+      var p__7498 = cljs.core.first(arglist__7510);
+      arglist__7510 = cljs.core.next(arglist__7510);
+      var f = cljs.core.first(arglist__7510);
+      arglist__7510 = cljs.core.next(arglist__7510);
+      var a = cljs.core.first(arglist__7510);
+      arglist__7510 = cljs.core.next(arglist__7510);
+      var b = cljs.core.first(arglist__7510);
+      arglist__7510 = cljs.core.next(arglist__7510);
+      var c = cljs.core.first(arglist__7510);
+      var args = cljs.core.rest(arglist__7510);
+      return G__7509__delegate(m, p__7498, f, a, b, c, args);
+    };
+    G__7509.cljs$core$IFn$_invoke$arity$variadic = G__7509__delegate;
+    return G__7509;
+  }();
+  update_in = function(m, p__7498, f, a, b, c, var_args) {
+    var args = var_args;
+    switch(arguments.length) {
+      case 3:
+        return update_in__3.call(this, m, p__7498, f);
+      case 4:
+        return update_in__4.call(this, m, p__7498, f, a);
+      case 5:
+        return update_in__5.call(this, m, p__7498, f, a, b);
+      case 6:
+        return update_in__6.call(this, m, p__7498, f, a, b, c);
+      default:
+        return update_in__7.cljs$core$IFn$_invoke$arity$variadic(m, p__7498, 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;
+}();
+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__3955__auto__, writer__3956__auto__, opts__3957__auto__) {
+  return cljs.core._write.call(null, writer__3956__auto__, "cljs.core/VectorNode");
+};
+cljs.core.__GT_VectorNode = function __GT_VectorNode(edit, arr) {
+  return new cljs.core.VectorNode(edit, arr);
+};
+cljs.core.pv_fresh_node = function pv_fresh_node(edit) {
+  return new cljs.core.VectorNode(edit, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]);
+};
+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, cljs.core.aclone.call(null, node.arr));
+};
+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__7511 = ll - 5;
+      var G__7512 = r;
+      ll = G__7511;
+      ret = G__7512;
+      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.vector_index_out_of_bounds = function vector_index_out_of_bounds(i, cnt) {
+  throw new Error([cljs.core.str("No item "), cljs.core.str(i), cljs.core.str(" in vector of length "), cljs.core.str(cnt)].join(""));
+};
+cljs.core.array_for = function array_for(pv, i) {
+  if (0 <= i && i < pv.cnt) {
+    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__7513 = cljs.core.pv_aget.call(null, node, i >>> level & 31);
+          var G__7514 = level - 5;
+          node = G__7513;
+          level = G__7514;
+          continue;
+        } else {
+          return node.arr;
+        }
+        break;
+      }
+    }
+  } else {
+    return cljs.core.vector_index_out_of_bounds.call(null, i, pv.cnt);
+  }
+};
+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 (new_child == null && subidx === 0) {
+      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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        var ret = cljs.core.pv_clone_node.call(null, node);
+        cljs.core.pv_aset.call(null, ret, subidx, null);
+        return ret;
+      } else {
+        return null;
+      }
+    }
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentVector");
+};
+cljs.core.PersistentVector.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, k, null);
+};
+cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, k, not_found);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (0 <= k && k < self__.cnt) {
+    if (cljs.core.tail_off.call(null, coll__$1) <= k) {
+      var new_tail = cljs.core.aclone.call(null, self__.tail);
+      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__$1, self__.shift, self__.root, k, v), self__.tail, null);
+    }
+  } else {
+    if (k === self__.cnt) {
+      return cljs.core._conj.call(null, coll__$1, v);
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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__7516 = null;
+  var G__7516__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
+  };
+  var G__7516__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
+  };
+  G__7516 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7516__2.call(this, self__, k);
+      case 3:
+        return G__7516__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7516;
+}();
+cljs.core.PersistentVector.prototype.apply = function(self__, args7515) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7515)));
+};
+cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(v, f, init) {
+  var self__ = this;
+  var v__$1 = this;
+  var step_init = [0, init];
+  var i = 0;
+  while (true) {
+    if (i < self__.cnt) {
+      var arr = cljs.core.array_for.call(null, v__$1, 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__7517 = j + 1;
+              var G__7518 = init__$2;
+              j = G__7517;
+              init__$1 = G__7518;
+              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__7519 = i + step_init[0];
+        i = G__7519;
+        continue;
+      }
+    } else {
+      return step_init[1];
+    }
+    break;
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.cnt - cljs.core.tail_off.call(null, coll__$1) < 32) {
+    var len = self__.tail.length;
+    var new_tail = new Array(len + 1);
+    var n__4232__auto___7520 = len;
+    var i_7521 = 0;
+    while (true) {
+      if (i_7521 < n__4232__auto___7520) {
+        new_tail[i_7521] = self__.tail[i_7521];
+        var G__7522 = i_7521 + 1;
+        i_7521 = G__7522;
+        continue;
+      } else {
+      }
+      break;
+    }
+    new_tail[len] = 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__$1, 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;
+  var coll__$1 = this;
+  if (self__.cnt > 0) {
+    return new cljs.core.RSeq(coll__$1, self__.cnt - 1, null);
+  } else {
+    return null;
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_key$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, 0);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_val$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, 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;
+  var v__$1 = this;
+  return cljs.core.ci_reduce.call(null, v__$1, f);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$3 = function(v, f, start) {
+  var self__ = this;
+  var v__$1 = this;
+  return cljs.core.ci_reduce.call(null, v__$1, f, start);
+};
+cljs.core.PersistentVector.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.cnt === 0) {
+    return null;
+  } else {
+    if (self__.cnt < 32) {
+      return cljs.core.array_seq.call(null, self__.tail);
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return cljs.core.chunked_seq.call(null, coll__$1, 0, 0);
+      } else {
+        return null;
+      }
+    }
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.cnt;
+};
+cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.cnt > 0) {
+    return cljs.core._nth.call(null, coll__$1, self__.cnt - 1);
+  } else {
+    return null;
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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__$1)) {
+        return new cljs.core.PersistentVector(self__.meta, self__.cnt - 1, self__.shift, self__.root, self__.tail.slice(0, -1), null);
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var new_tail = cljs.core.array_for.call(null, coll__$1, self__.cnt - 2);
+          var nr = cljs.core.pop_tail.call(null, coll__$1, self__.shift, self__.root);
+          var new_root = nr == null ? cljs.core.PersistentVector.EMPTY_NODE : nr;
+          var cnt_1 = self__.cnt - 1;
+          if (5 < self__.shift && cljs.core.pv_aget.call(null, new_root, 1) == null) {
+            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;
+  var coll__$1 = this;
+  return cljs.core._assoc.call(null, coll__$1, n, val);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.array_for.call(null, coll__$1, n)[n & 31];
+};
+cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (0 <= n && n < self__.cnt) {
+    return cljs.core._nth.call(null, coll__$1, n);
+  } else {
+    return not_found;
+  }
+};
+cljs.core.PersistentVector.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta);
+};
+cljs.core.__GT_PersistentVector = function __GT_PersistentVector(meta, cnt, shift, root, tail, __hash) {
+  return new cljs.core.PersistentVector(meta, cnt, shift, root, tail, __hash);
+};
+cljs.core.PersistentVector.EMPTY_NODE = new cljs.core.VectorNode(null, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]);
+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 : cljs.core.aclone.call(null, xs);
+  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__7523 = i + 1;
+        var G__7524 = cljs.core.conj_BANG_.call(null, out, xs__$1[i]);
+        i = G__7523;
+        out = G__7524;
+        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) {
+    if (args instanceof cljs.core.IndexedSeq && args.i === 0) {
+      return cljs.core.PersistentVector.fromArray.call(null, args.arr, true);
+    } else {
+      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__7525) {
+    var args = cljs.core.seq(arglist__7525);
+    return vector__delegate(args);
+  };
+  vector.cljs$core$IFn$_invoke$arity$variadic = vector__delegate;
+  return vector;
+}();
+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$ = 32243948;
+  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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ChunkedSeq");
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 cljs.core._chunked_next.call(null, coll__$1);
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.ci_reduce.call(null, cljs.core.subvec.call(null, self__.vec, self__.i + self__.off, cljs.core.count.call(null, self__.vec)), f);
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.ci_reduce.call(null, cljs.core.subvec.call(null, self__.vec, self__.i + self__.off, cljs.core.count.call(null, self__.vec)), f, start);
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.node[self__.off];
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 cljs.core._chunked_rest.call(null, coll__$1);
+  }
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, m) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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 coll__$1 = 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.__GT_ChunkedSeq = function __GT_ChunkedSeq(vec, node, i, off, meta, __hash) {
+  return new cljs.core.ChunkedSeq(vec, node, i, off, meta, __hash);
+};
+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;
+}();
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Subvec");
+};
+cljs.core.Subvec.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, k, null);
+};
+cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, k, not_found);
+};
+cljs.core.Subvec.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, key, val) {
+  var self__ = this;
+  var coll__$1 = 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, function() {
+    var x__3715__auto__ = self__.end;
+    var y__3716__auto__ = v_pos + 1;
+    return x__3715__auto__ > y__3716__auto__ ? x__3715__auto__ : y__3716__auto__;
+  }(), null);
+};
+cljs.core.Subvec.prototype.call = function() {
+  var G__7527 = null;
+  var G__7527__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
+  };
+  var G__7527__3 = function(self__, k, not_found) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
+  };
+  G__7527 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7527__2.call(this, self__, k);
+      case 3:
+        return G__7527__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7527;
+}();
+cljs.core.Subvec.prototype.apply = function(self__, args7526) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7526)));
+};
+cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
+};
+cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
+};
+cljs.core.Subvec.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.ci_reduce.call(null, coll__$1, f);
+};
+cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start__$1) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.ci_reduce.call(null, coll__$1, f, start__$1);
+};
+cljs.core.Subvec.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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, function() {
+        return subvec_seq.call(null, i + 1);
+      }, null, null));
+    }
+  };
+  return subvec_seq.call(null, self__.start);
+};
+cljs.core.Subvec.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.end - self__.start;
+};
+cljs.core.Subvec.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core._assoc.call(null, coll__$1, n, val);
+};
+cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (n < 0 || self__.end <= self__.start + n) {
+    return cljs.core.vector_index_out_of_bounds.call(null, n, self__.end - self__.start);
+  } else {
+    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;
+  var coll__$1 = this;
+  if (n < 0 || self__.end <= self__.start + n) {
+    return not_found;
+  } else {
+    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;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta);
+};
+cljs.core.__GT_Subvec = function __GT_Subvec(meta, v, start, end, __hash) {
+  return new cljs.core.Subvec(meta, v, start, end, __hash);
+};
+cljs.core.build_subvec = function build_subvec(meta, v, start, end, __hash) {
+  while (true) {
+    if (v instanceof cljs.core.Subvec) {
+      var G__7528 = meta;
+      var G__7529 = v.v;
+      var G__7530 = v.start + start;
+      var G__7531 = v.start + end;
+      var G__7532 = __hash;
+      meta = G__7528;
+      v = G__7529;
+      start = G__7530;
+      end = G__7531;
+      __hash = G__7532;
+      continue;
+    } else {
+      var c = cljs.core.count.call(null, v);
+      if (start < 0 || (end < 0 || (start > c || 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, cljs.core.aclone.call(null, node.arr));
+  }
+};
+cljs.core.tv_editable_root = function tv_editable_root(node) {
+  return new cljs.core.VectorNode(function() {
+    var obj7536 = {};
+    return obj7536;
+  }(), cljs.core.aclone.call(null, node.arr));
+};
+cljs.core.tv_editable_tail = function tv_editable_tail(tl) {
+  var ret = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
+  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 (new_child == null && subidx === 0) {
+      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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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 (0 <= i && i < tv.cnt) {
+    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__7537 = cljs.core.tv_ensure_editable.call(null, root.edit, cljs.core.pv_aget.call(null, node, i >>> level & 31));
+          var G__7538 = level - 5;
+          node = G__7537;
+          level = G__7538;
+          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(""));
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientVector");
+};
+cljs.core.TransientVector.prototype.call = function() {
+  var G__7540 = null;
+  var G__7540__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7540__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(null, k, not_found);
+  };
+  G__7540 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7540__2.call(this, self__, k);
+      case 3:
+        return G__7540__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7540;
+}();
+cljs.core.TransientVector.prototype.apply = function(self__, args7539) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7539)));
+};
+cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, k, null);
+};
+cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._nth.call(null, coll__$1, k, not_found);
+};
+cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.root.edit) {
+    return cljs.core.array_for.call(null, coll__$1, 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;
+  var coll__$1 = this;
+  if (0 <= n && n < self__.cnt) {
+    return cljs.core._nth.call(null, coll__$1, n);
+  } else {
+    return not_found;
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var tcoll__$1 = this;
+  if (self__.root.edit) {
+    if (0 <= n && n < self__.cnt) {
+      if (cljs.core.tail_off.call(null, tcoll__$1) <= n) {
+        self__.tail[n & 31] = val;
+        return tcoll__$1;
+      } 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__$1;
+      }
+    } else {
+      if (n === self__.cnt) {
+        return cljs.core._conj_BANG_.call(null, tcoll__$1, val);
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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;
+  var tcoll__$1 = 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__$1;
+      } else {
+        if ((self__.cnt - 1 & 31) > 0) {
+          self__.cnt = self__.cnt - 1;
+          return tcoll__$1;
+        } else {
+          if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+            var new_tail = cljs.core.editable_array_for.call(null, tcoll__$1, self__.cnt - 2);
+            var new_root = function() {
+              var nr = cljs.core.tv_pop_tail.call(null, tcoll__$1, self__.shift, self__.root);
+              if (!(nr == null)) {
+                return nr;
+              } else {
+                return new cljs.core.VectorNode(self__.root.edit, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]);
+              }
+            }();
+            if (5 < self__.shift && cljs.core.pv_aget.call(null, new_root, 1) == null) {
+              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__$1;
+            } else {
+              self__.root = new_root;
+              self__.cnt = self__.cnt - 1;
+              self__.tail = new_tail;
+              return tcoll__$1;
+            }
+          } 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;
+  var tcoll__$1 = this;
+  return cljs.core._assoc_n_BANG_.call(null, tcoll__$1, key, val);
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  if (self__.root.edit) {
+    if (self__.cnt - cljs.core.tail_off.call(null, tcoll__$1) < 32) {
+      self__.tail[self__.cnt & 31] = o;
+      self__.cnt = self__.cnt + 1;
+      return tcoll__$1;
+    } else {
+      var tail_node = new cljs.core.VectorNode(self__.root.edit, self__.tail);
+      var new_tail = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
+      new_tail[0] = o;
+      self__.tail = new_tail;
+      if (self__.cnt >>> 5 > 1 << self__.shift) {
+        var new_root_array = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
+        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__$1;
+      } else {
+        var new_root = cljs.core.tv_push_tail.call(null, tcoll__$1, self__.shift, self__.root, tail_node);
+        self__.root = new_root;
+        self__.cnt = self__.cnt + 1;
+        return tcoll__$1;
+      }
+    }
+  } else {
+    throw new Error("conj! after persistent!");
+  }
+};
+cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  if (self__.root.edit) {
+    self__.root.edit = null;
+    var len = self__.cnt - cljs.core.tail_off.call(null, tcoll__$1);
+    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");
+  }
+};
+cljs.core.__GT_TransientVector = function __GT_TransientVector(cnt, shift, root, tail) {
+  return new cljs.core.TransientVector(cnt, shift, root, tail);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentQueueSeq");
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 coll__$1 = 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 cljs.core._empty.call(null, coll__$1);
+    } 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentQueueSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_PersistentQueueSeq = function __GT_PersistentQueueSeq(meta, front, rear, __hash) {
+  return new cljs.core.PersistentQueueSeq(meta, front, rear, __hash);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentQueue");
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = 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__3408__auto__ = self__.rear;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__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 coll__$1 = this;
+  var rear__$1 = cljs.core.seq.call(null, self__.rear);
+  if (cljs.core.truth_(function() {
+    var or__3408__auto__ = self__.front;
+    if (cljs.core.truth_(or__3408__auto__)) {
+      return or__3408__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;
+  var coll__$1 = this;
+  return self__.count;
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.first.call(null, self__.front);
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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__$1;
+  }
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.first.call(null, self__.front);
+};
+cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.rest.call(null, cljs.core.seq.call(null, coll__$1));
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.PersistentQueue.EMPTY;
+};
+cljs.core.__GT_PersistentQueue = function __GT_PersistentQueue(meta, count, front, rear, __hash) {
+  return new cljs.core.PersistentQueue(meta, count, front, rear, __hash);
+};
+cljs.core.PersistentQueue.EMPTY = new cljs.core.PersistentQueue(null, 0, null, cljs.core.PersistentVector.EMPTY, 0);
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/NeverEquiv");
+};
+cljs.core.NeverEquiv.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
+  var self__ = this;
+  var o__$1 = this;
+  return false;
+};
+cljs.core.__GT_NeverEquiv = function __GT_NeverEquiv() {
+  return new cljs.core.NeverEquiv;
+};
+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__7541 = i + incr;
+        i = G__7541;
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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__7542 = i + 1;
+      var G__7543 = cljs.core.assoc_BANG_.call(null, out, k__$1, so[k__$1]);
+      i = G__7542;
+      out = G__7543;
+      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 = function() {
+    var obj7547 = {};
+    return obj7547;
+  }();
+  var l = ks.length;
+  var i_7548 = 0;
+  while (true) {
+    if (i_7548 < l) {
+      var k_7549 = ks[i_7548];
+      new_obj[k_7549] = obj[k_7549];
+      var G__7550 = i_7548 + 1;
+      i_7548 = G__7550;
+      continue;
+    } else {
+    }
+    break;
+  }
+  return new_obj;
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ObjMap");
+};
+cljs.core.ObjMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.transient$.call(null, cljs.core.into.call(null, cljs.core.PersistentHashMap.EMPTY, coll__$1));
+};
+cljs.core.ObjMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._lookup.call(null, coll__$1, k, null);
+};
+cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (goog.isString(k) && !(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
+    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;
+  var coll__$1 = this;
+  if (goog.isString(k)) {
+    if (self__.update_count > cljs.core.ObjMap.HASHMAP_THRESHOLD || self__.keys.length >= cljs.core.ObjMap.HASHMAP_THRESHOLD) {
+      return cljs.core.obj_map__GT_hash_map.call(null, coll__$1, 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 = cljs.core.aclone.call(null, self__.keys);
+        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__$1, k, v);
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (goog.isString(k) && !(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+cljs.core.ObjMap.prototype.call = function() {
+  var G__7553 = null;
+  var G__7553__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7553__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(null, k, not_found);
+  };
+  G__7553 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7553__2.call(this, self__, k);
+      case 3:
+        return G__7553__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7553;
+}();
+cljs.core.ObjMap.prototype.apply = function(self__, args7552) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7552)));
+};
+cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var coll__$1 = 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__7554 = cljs.core.rest.call(null, keys__$1);
+        var G__7555 = init__$2;
+        keys__$1 = G__7554;
+        init__$1 = G__7555;
+        continue;
+      }
+    } else {
+      return init__$1;
+    }
+    break;
+  }
+};
+cljs.core.ObjMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (cljs.core.vector_QMARK_.call(null, entry)) {
+    return cljs.core._assoc.call(null, coll__$1, 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__$1, 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;
+  var coll__$1 = this;
+  if (self__.keys.length > 0) {
+    return cljs.core.map.call(null, function(p1__7551_SHARP_) {
+      return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p1__7551_SHARP_, self__.strobj[p1__7551_SHARP_]], null);
+    }, 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;
+  var coll__$1 = this;
+  return self__.keys.length;
+};
+cljs.core.ObjMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_map.call(null, coll__$1, other);
+};
+cljs.core.ObjMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.ObjMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  if (goog.isString(k) && !(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
+    var new_keys = cljs.core.aclone.call(null, self__.keys);
+    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__$1;
+  }
+};
+cljs.core.__GT_ObjMap = function __GT_ObjMap(meta, keys, strobj, update_count, __hash) {
+  return new cljs.core.ObjMap(meta, keys, strobj, update_count, __hash);
+};
+cljs.core.ObjMap.EMPTY = new cljs.core.ObjMap(null, [], function() {
+  var obj7557 = {};
+  return obj7557;
+}(), 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var G__7558 = i + 2;
+          i = G__7558;
+          continue;
+        } else {
+          return null;
+        }
+      }
+    }
+    break;
+  }
+};
+cljs.core.array_map_index_of_keyword_QMARK_ = function array_map_index_of_keyword_QMARK_(arr, m, k) {
+  var len = arr.length;
+  var kstr = k.fqn;
+  var i = 0;
+  while (true) {
+    if (len <= i) {
+      return-1;
+    } else {
+      if (function() {
+        var k_SINGLEQUOTE_ = arr[i];
+        return k_SINGLEQUOTE_ instanceof cljs.core.Keyword && kstr === k_SINGLEQUOTE_.fqn;
+      }()) {
+        return i;
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var G__7559 = i + 2;
+          i = G__7559;
+          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];
+        return k_SINGLEQUOTE_ instanceof cljs.core.Symbol && kstr === k_SINGLEQUOTE_.str;
+      }()) {
+        return i;
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var G__7560 = i + 2;
+          i = G__7560;
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var G__7561 = i + 2;
+          i = G__7561;
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var G__7562 = i + 2;
+          i = G__7562;
+          continue;
+        } else {
+          return null;
+        }
+      }
+    }
+    break;
+  }
+};
+cljs.core.array_map_index_of = function array_map_index_of(m, k) {
+  var arr = m.arr;
+  if (k instanceof cljs.core.Keyword) {
+    return cljs.core.array_map_index_of_keyword_QMARK_.call(null, arr, m, k);
+  } else {
+    if (goog.isString(k) || 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+            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_7563 = 0;
+  while (true) {
+    if (i_7563 < l) {
+      narr[i_7563] = arr[i_7563];
+      var G__7564 = i_7563 + 1;
+      i_7563 = G__7564;
+      continue;
+    } else {
+    }
+    break;
+  }
+  narr[l] = k;
+  narr[l + 1] = v;
+  return narr;
+};
+cljs.core.PersistentArrayMapSeq = function(arr, i, _meta) {
+  this.arr = arr;
+  this.i = i;
+  this._meta = _meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32374990;
+};
+cljs.core.PersistentArrayMapSeq.cljs$lang$type = true;
+cljs.core.PersistentArrayMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentArrayMapSeq";
+cljs.core.PersistentArrayMapSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentArrayMapSeq");
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.hash_coll.call(null, coll__$1);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.i < self__.arr.length - 2) {
+    return new cljs.core.PersistentArrayMapSeq(self__.arr, self__.i + 2, self__._meta);
+  } else {
+    return null;
+  }
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+cljs.core.PersistentArrayMapSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return(self__.arr.length - self__.i) / 2;
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.arr[self__.i], self__.arr[self__.i + 1]], null);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.i < self__.arr.length - 2) {
+    return new cljs.core.PersistentArrayMapSeq(self__.arr, self__.i + 2, self__._meta);
+  } else {
+    return cljs.core.List.EMPTY;
+  }
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.PersistentArrayMapSeq(self__.arr, self__.i, new_meta);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__._meta;
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__._meta);
+};
+cljs.core.__GT_PersistentArrayMapSeq = function __GT_PersistentArrayMapSeq(arr, i, _meta) {
+  return new cljs.core.PersistentArrayMapSeq(arr, i, _meta);
+};
+cljs.core.persistent_array_map_seq = function persistent_array_map_seq(arr, i, _meta) {
+  if (i <= arr.length - 2) {
+    return new cljs.core.PersistentArrayMapSeq(arr, i, _meta);
+  } else {
+    return null;
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentArrayMap");
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.TransientArrayMap(function() {
+    var obj7567 = {};
+    return obj7567;
+  }(), self__.arr.length, cljs.core.aclone.call(null, self__.arr));
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._lookup.call(null, coll__$1, k, null);
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  var idx = cljs.core.array_map_index_of.call(null, coll__$1, 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 coll__$1 = this;
+  var idx = cljs.core.array_map_index_of.call(null, coll__$1, k);
+  if (idx === -1) {
+    if (self__.cnt < cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
+      var arr__$1 = cljs.core.array_map_extend_kv.call(null, coll__$1, 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__$1), k, v), self__.meta);
+    }
+  } else {
+    if (v === self__.arr[idx + 1]) {
+      return coll__$1;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        var arr__$1 = function() {
+          var G__7568 = cljs.core.aclone.call(null, self__.arr);
+          G__7568[idx + 1] = v;
+          return G__7568;
+        }();
+        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;
+  var coll__$1 = this;
+  return!(cljs.core.array_map_index_of.call(null, coll__$1, k) === -1);
+};
+cljs.core.PersistentArrayMap.prototype.call = function() {
+  var G__7569 = null;
+  var G__7569__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7569__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(null, k, not_found);
+  };
+  G__7569 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7569__2.call(this, self__, k);
+      case 3:
+        return G__7569__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7569;
+}();
+cljs.core.PersistentArrayMap.prototype.apply = function(self__, args7565) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7565)));
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var coll__$1 = 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__7570 = i + 2;
+        var G__7571 = init__$2;
+        i = G__7570;
+        init__$1 = G__7571;
+        continue;
+      }
+    } else {
+      return init__$1;
+    }
+    break;
+  }
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (cljs.core.vector_QMARK_.call(null, entry)) {
+    return cljs.core._assoc.call(null, coll__$1, 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__$1, 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;
+  var coll__$1 = this;
+  return cljs.core.persistent_array_map_seq.call(null, self__.arr, 0, null);
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.cnt;
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_map.call(null, coll__$1, other);
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 coll__$1 = this;
+  var idx = cljs.core.array_map_index_of.call(null, coll__$1, k);
+  if (idx >= 0) {
+    var len = self__.arr.length;
+    var new_len = len - 2;
+    if (new_len === 0) {
+      return cljs.core._empty.call(null, coll__$1);
+    } 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__7572 = s + 2;
+            var G__7573 = d;
+            s = G__7572;
+            d = G__7573;
+            continue;
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              new_arr[d] = self__.arr[s];
+              new_arr[d + 1] = self__.arr[s + 1];
+              var G__7574 = s + 2;
+              var G__7575 = d + 2;
+              s = G__7574;
+              d = G__7575;
+              continue;
+            } else {
+              return null;
+            }
+          }
+        }
+        break;
+      }
+    }
+  } else {
+    return coll__$1;
+  }
+};
+cljs.core.__GT_PersistentArrayMap = function __GT_PersistentArrayMap(meta, cnt, arr, __hash) {
+  return new cljs.core.PersistentArrayMap(meta, cnt, arr, __hash);
+};
+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, no_check) {
+  var arr__$1 = no_clone ? arr : cljs.core.aclone.call(null, arr);
+  if (no_check) {
+    var cnt = arr__$1.length / 2;
+    return new cljs.core.PersistentArrayMap(null, cnt, arr__$1, null);
+  } else {
+    var len = arr__$1.length;
+    var i = 0;
+    var ret = cljs.core.transient$.call(null, cljs.core.PersistentArrayMap.EMPTY);
+    while (true) {
+      if (i < len) {
+        var G__7576 = i + 2;
+        var G__7577 = cljs.core._assoc_BANG_.call(null, ret, arr__$1[i], arr__$1[i + 1]);
+        i = G__7576;
+        ret = G__7577;
+        continue;
+      } else {
+        return cljs.core._persistent_BANG_.call(null, ret);
+      }
+      break;
+    }
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientArrayMap");
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = function(tcoll, key) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  if (cljs.core.truth_(self__.editable_QMARK_)) {
+    var idx = cljs.core.array_map_index_of.call(null, tcoll__$1, key);
+    if (idx >= 0) {
+      self__.arr[idx] = self__.arr[self__.len - 2];
+      self__.arr[idx + 1] = self__.arr[self__.len - 1];
+      var G__7578_7580 = self__.arr;
+      G__7578_7580.pop();
+      G__7578_7580.pop();
+      self__.len = self__.len - 2;
+    } else {
+    }
+    return tcoll__$1;
+  } 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;
+  var tcoll__$1 = this;
+  if (cljs.core.truth_(self__.editable_QMARK_)) {
+    var idx = cljs.core.array_map_index_of.call(null, tcoll__$1, 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__$1;
+      } 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__$1;
+      } else {
+        self__.arr[idx + 1] = val;
+        return tcoll__$1;
+      }
+    }
+  } else {
+    throw new Error("assoc! after persistent!");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  if (cljs.core.truth_(self__.editable_QMARK_)) {
+    if (function() {
+      var G__7579 = o;
+      if (G__7579) {
+        var bit__4034__auto__ = G__7579.cljs$lang$protocol_mask$partition0$ & 2048;
+        if (bit__4034__auto__ || G__7579.cljs$core$IMapEntry$) {
+          return true;
+        } else {
+          if (!G__7579.cljs$lang$protocol_mask$partition0$) {
+            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7579);
+          } else {
+            return false;
+          }
+        }
+      } else {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7579);
+      }
+    }()) {
+      return cljs.core._assoc_BANG_.call(null, tcoll__$1, cljs.core.key.call(null, o), cljs.core.val.call(null, o));
+    } else {
+      var es = cljs.core.seq.call(null, o);
+      var tcoll__$2 = tcoll__$1;
+      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__7581 = cljs.core.next.call(null, es);
+          var G__7582 = cljs.core._assoc_BANG_.call(null, tcoll__$2, cljs.core.key.call(null, e), cljs.core.val.call(null, e));
+          es = G__7581;
+          tcoll__$2 = G__7582;
+          continue;
+        } else {
+          return tcoll__$2;
+        }
+        break;
+      }
+    }
+  } else {
+    throw new Error("conj! after persistent!");
+  }
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  var tcoll__$1 = 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;
+  var tcoll__$1 = this;
+  return cljs.core._lookup.call(null, tcoll__$1, k, null);
+};
+cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, k, not_found) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  if (cljs.core.truth_(self__.editable_QMARK_)) {
+    var idx = cljs.core.array_map_index_of.call(null, tcoll__$1, 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;
+  var tcoll__$1 = 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.__GT_TransientArrayMap = function __GT_TransientArrayMap(editable_QMARK_, len, arr) {
+  return new cljs.core.TransientArrayMap(editable_QMARK_, len, arr);
+};
+cljs.core.array__GT_transient_hash_map = function array__GT_transient_hash_map(len, arr) {
+  var out = cljs.core.transient$.call(null, cljs.core.PersistentHashMap.EMPTY);
+  var i = 0;
+  while (true) {
+    if (i < len) {
+      var G__7583 = cljs.core.assoc_BANG_.call(null, out, arr[i], arr[i + 1]);
+      var G__7584 = i + 2;
+      out = G__7583;
+      i = G__7584;
+      continue;
+    } else {
+      return out;
+    }
+    break;
+  }
+};
+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__3955__auto__, writer__3956__auto__, opts__3957__auto__) {
+  return cljs.core._write.call(null, writer__3956__auto__, "cljs.core/Box");
+};
+cljs.core.__GT_Box = function __GT_Box(val) {
+  return new cljs.core.Box(val);
+};
+cljs.core.key_test = function key_test(key, other) {
+  if (key === other) {
+    return true;
+  } else {
+    if (cljs.core.keyword_identical_QMARK_.call(null, key, other)) {
+      return true;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return cljs.core._EQ_.call(null, key, other);
+      } else {
+        return null;
+      }
+    }
+  }
+};
+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__7587 = cljs.core.aclone.call(null, arr);
+    G__7587[i] = a;
+    return G__7587;
+  };
+  var clone_and_set__5 = function(arr, i, a, j, b) {
+    var G__7588 = cljs.core.aclone.call(null, arr);
+    G__7588[i] = a;
+    G__7588[j] = b;
+    return G__7588;
+  };
+  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__7589 = i + 2;
+        var G__7590 = init__$2;
+        i = G__7589;
+        init__$1 = G__7590;
+        continue;
+      }
+    } else {
+      return init__$1;
+    }
+    break;
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__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 = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
+        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_7591 = 0;
+        var j_7592 = 0;
+        while (true) {
+          if (i_7591 < 32) {
+            if ((self__.bitmap >>> i_7591 & 1) === 0) {
+              var G__7593 = i_7591 + 1;
+              var G__7594 = j_7592;
+              i_7591 = G__7593;
+              j_7592 = G__7594;
+              continue;
+            } else {
+              nodes[i_7591] = !(self__.arr[j_7592] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1, shift + 5, cljs.core.hash.call(null, self__.arr[j_7592]), self__.arr[j_7592], self__.arr[j_7592 + 1], added_leaf_QMARK_) : self__.arr[j_7592 + 1];
+              var G__7595 = i_7591 + 1;
+              var G__7596 = j_7592 + 2;
+              i_7591 = G__7595;
+              j_7592 = G__7596;
+              continue;
+            }
+          } else {
+          }
+          break;
+        }
+        return new cljs.core.ArrayNode(edit__$1, n + 1, nodes);
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [key_or_nil, val_or_node], null);
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
+      var jdx = hash >>> shift & 31;
+      nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, hash, key, val, added_leaf_QMARK_);
+      var i_7597 = 0;
+      var j_7598 = 0;
+      while (true) {
+        if (i_7597 < 32) {
+          if ((self__.bitmap >>> i_7597 & 1) === 0) {
+            var G__7599 = i_7597 + 1;
+            var G__7600 = j_7598;
+            i_7597 = G__7599;
+            j_7598 = G__7600;
+            continue;
+          } else {
+            nodes[i_7597] = !(self__.arr[j_7598] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, cljs.core.hash.call(null, self__.arr[j_7598]), self__.arr[j_7598], self__.arr[j_7598 + 1], added_leaf_QMARK_) : self__.arr[j_7598 + 1];
+            var G__7601 = i_7597 + 1;
+            var G__7602 = j_7598 + 2;
+            i_7597 = G__7601;
+            j_7598 = G__7602;
+            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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          return not_found;
+        } else {
+          return null;
+        }
+      }
+    }
+  }
+};
+cljs.core.__GT_BitmapIndexedNode = function __GT_BitmapIndexedNode(edit, bitmap, arr) {
+  return new cljs.core.BitmapIndexedNode(edit, bitmap, arr);
+};
+cljs.core.BitmapIndexedNode.EMPTY = new cljs.core.BitmapIndexedNode(null, 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 (!(i === idx) && !(arr[i] == null)) {
+        new_arr[j] = arr[i];
+        var G__7603 = i + 1;
+        var G__7604 = j + 2;
+        var G__7605 = bitmap | 1 << i;
+        i = G__7603;
+        j = G__7604;
+        bitmap = G__7605;
+        continue;
+      } else {
+        var G__7606 = i + 1;
+        var G__7607 = j;
+        var G__7608 = bitmap;
+        i = G__7606;
+        j = G__7607;
+        bitmap = G__7608;
+        continue;
+      }
+    } else {
+      return new cljs.core.BitmapIndexedNode(edit, bitmap, new_arr);
+    }
+    break;
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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, cljs.core.aclone.call(null, self__.arr));
+  }
+};
+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__7609 = i + 1;
+          var G__7610 = init__$2;
+          i = G__7609;
+          init__$1 = G__7610;
+          continue;
+        }
+      } else {
+        var G__7611 = i + 1;
+        var G__7612 = init__$1;
+        i = G__7611;
+        init__$1 = G__7612;
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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.__GT_ArrayNode = function __GT_ArrayNode(edit, cnt, arr) {
+  return new cljs.core.ArrayNode(edit, cnt, arr);
+};
+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__7613 = i + 2;
+        i = G__7613;
+        continue;
+      }
+    } else {
+      return-1;
+    }
+    break;
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__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 new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.arr[idx], self__.arr[idx + 1]], null);
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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 = 2 * self__.cnt;
+      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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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.__GT_HashCollisionNode = function __GT_HashCollisionNode(edit, collision_hash, cnt, arr) {
+  return new cljs.core.HashCollisionNode(edit, collision_hash, cnt, arr);
+};
+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;
+}();
+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$ = 32374860;
+};
+cljs.core.NodeSeq.cljs$lang$type = true;
+cljs.core.NodeSeq.cljs$lang$ctorStr = "cljs.core/NodeSeq";
+cljs.core.NodeSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/NodeSeq");
+};
+cljs.core.NodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.NodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.NodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = this;
+  return this$__$1;
+};
+cljs.core.NodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.s == null) {
+    return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.nodes[self__.i], self__.nodes[self__.i + 1]], null);
+  } else {
+    return cljs.core.first.call(null, self__.s);
+  }
+};
+cljs.core.NodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.NodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.NodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_NodeSeq = function __GT_NodeSeq(meta, nodes, i, s, __hash) {
+  return new cljs.core.NodeSeq(meta, nodes, i, s, __hash);
+};
+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__7614 = j + 2;
+                j = G__7614;
+                continue;
+              }
+            } else {
+              var G__7615 = j + 2;
+              j = G__7615;
+              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;
+}();
+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$ = 32374860;
+};
+cljs.core.ArrayNodeSeq.cljs$lang$type = true;
+cljs.core.ArrayNodeSeq.cljs$lang$ctorStr = "cljs.core/ArrayNodeSeq";
+cljs.core.ArrayNodeSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ArrayNodeSeq");
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = this;
+  return this$__$1;
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.first.call(null, self__.s);
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_ArrayNodeSeq = function __GT_ArrayNodeSeq(meta, nodes, i, s, __hash) {
+  return new cljs.core.ArrayNodeSeq(meta, nodes, i, s, __hash);
+};
+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__7616 = j + 1;
+              j = G__7616;
+              continue;
+            }
+          } else {
+            var G__7617 = j + 1;
+            j = G__7617;
+            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;
+}();
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentHashMap");
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.TransientHashMap(function() {
+    var obj7620 = {};
+    return obj7620;
+  }(), 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 coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._lookup.call(null, coll__$1, k, null);
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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;
+  var coll__$1 = this;
+  if (k == null) {
+    if (self__.has_nil_QMARK_ && v === self__.nil_val) {
+      return coll__$1;
+    } 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__$1;
+    } 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;
+  var coll__$1 = this;
+  if (k == null) {
+    return self__.has_nil_QMARK_;
+  } else {
+    if (self__.root == null) {
+      return false;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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__7621 = null;
+  var G__7621__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7621__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(null, k, not_found);
+  };
+  G__7621 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7621__2.call(this, self__, k);
+      case 3:
+        return G__7621__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7621;
+}();
+cljs.core.PersistentHashMap.prototype.apply = function(self__, args7618) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7618)));
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var coll__$1 = 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return init__$1;
+      } else {
+        return null;
+      }
+    }
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (cljs.core.vector_QMARK_.call(null, entry)) {
+    return cljs.core._assoc.call(null, coll__$1, 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__$1, 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;
+  var coll__$1 = 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, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null, self__.nil_val], null), s);
+    } else {
+      return s;
+    }
+  } else {
+    return null;
+  }
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.cnt;
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_map.call(null, coll__$1, other);
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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__$1;
+    }
+  } else {
+    if (self__.root == null) {
+      return coll__$1;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        var new_root = self__.root.inode_without(0, cljs.core.hash.call(null, k), k);
+        if (new_root === self__.root) {
+          return coll__$1;
+        } 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.__GT_PersistentHashMap = function __GT_PersistentHashMap(meta, cnt, root, has_nil_QMARK_, nil_val, __hash) {
+  return new cljs.core.PersistentHashMap(meta, cnt, root, has_nil_QMARK_, nil_val, __hash);
+};
+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__7622 = i + 1;
+      var G__7623 = cljs.core._assoc_BANG_.call(null, out, ks[i], vs[i]);
+      i = G__7622;
+      out = G__7623;
+      continue;
+    } else {
+      return cljs.core.persistent_BANG_.call(null, out);
+    }
+    break;
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientHashMap");
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = function(tcoll, key) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  return tcoll__$1.without_BANG_(key);
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = function(tcoll, key, val) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  return tcoll__$1.assoc_BANG_(key, val);
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, val) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  return tcoll__$1.conj_BANG_(val);
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  return tcoll__$1.persistent_BANG_();
+};
+cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, k) {
+  var self__ = this;
+  var tcoll__$1 = 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;
+  var tcoll__$1 = 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;
+  var coll__$1 = 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__7624 = o;
+      if (G__7624) {
+        var bit__4034__auto__ = G__7624.cljs$lang$protocol_mask$partition0$ & 2048;
+        if (bit__4034__auto__ || G__7624.cljs$core$IMapEntry$) {
+          return true;
+        } else {
+          if (!G__7624.cljs$lang$protocol_mask$partition0$) {
+            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7624);
+          } else {
+            return false;
+          }
+        }
+      } else {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7624);
+      }
+    }()) {
+      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__7625 = cljs.core.next.call(null, es);
+          var G__7626 = tcoll__$1.assoc_BANG_(cljs.core.key.call(null, e), cljs.core.val.call(null, e));
+          es = G__7625;
+          tcoll__$1 = G__7626;
+          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.__GT_TransientHashMap = function __GT_TransientHashMap(edit, root, count, has_nil_QMARK_, nil_val) {
+  return new cljs.core.TransientHashMap(edit, root, count, has_nil_QMARK_, nil_val);
+};
+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__7627 = ascending_QMARK_ ? t.left : t.right;
+      var G__7628 = cljs.core.conj.call(null, stack__$1, t);
+      t = G__7627;
+      stack__$1 = G__7628;
+      continue;
+    } else {
+      return stack__$1;
+    }
+    break;
+  }
+};
+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$ = 32374862;
+};
+cljs.core.PersistentTreeMapSeq.cljs$lang$type = true;
+cljs.core.PersistentTreeMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentTreeMapSeq";
+cljs.core.PersistentTreeMapSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentTreeMapSeq");
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+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$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = this;
+  return this$__$1;
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (self__.cnt < 0) {
+    return cljs.core.count.call(null, cljs.core.next.call(null, coll__$1)) + 1;
+  } else {
+    return self__.cnt;
+  }
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = 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 this$__$1 = 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;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_PersistentTreeMapSeq = function __GT_PersistentTreeMapSeq(meta, stack, ascending_QMARK_, cnt, __hash) {
+  return new cljs.core.PersistentTreeMapSeq(meta, stack, ascending_QMARK_, cnt, __hash);
+};
+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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (right instanceof cljs.core.RedNode && right.left instanceof cljs.core.BlackNode) {
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (left instanceof cljs.core.RedNode && left.right instanceof cljs.core.BlackNode) {
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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;
+      }
+    }
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/BlackNode");
+};
+cljs.core.BlackNode.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$2 = function(node, k) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core._nth.call(null, node__$1, k, null);
+};
+cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$3 = function(node, k, not_found) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core._nth.call(null, node__$1, k, not_found);
+};
+cljs.core.BlackNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(node, k, v) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.assoc.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), k, v);
+};
+cljs.core.BlackNode.prototype.call = function() {
+  var G__7630 = null;
+  var G__7630__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var node = self____$1;
+    return node.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7630__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(null, k, not_found);
+  };
+  G__7630 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7630__2.call(this, self__, k);
+      case 3:
+        return G__7630__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7630;
+}();
+cljs.core.BlackNode.prototype.apply = function(self__, args7629) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7629)));
+};
+cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var node = this;
+  return node.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var node = this;
+  return node.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.BlackNode.prototype.cljs$core$ICollection$_conj$arity$2 = function(node, o) {
+  var self__ = this;
+  var node__$1 = this;
+  return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val, o], null);
+};
+cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_key$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return self__.key;
+};
+cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_val$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = 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;
+  var node__$1 = this;
+  return cljs.core.ci_reduce.call(null, node__$1, f);
+};
+cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$3 = function(node, f, start) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.ci_reduce.call(null, node__$1, f, start);
+};
+cljs.core.BlackNode.prototype.cljs$core$ISeqable$_seq$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, self__.val), self__.key);
+};
+cljs.core.BlackNode.prototype.cljs$core$ICounted$_count$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return 2;
+};
+cljs.core.BlackNode.prototype.cljs$core$IStack$_peek$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return self__.val;
+};
+cljs.core.BlackNode.prototype.cljs$core$IStack$_pop$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);
+};
+cljs.core.BlackNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(node, n, v) {
+  var self__ = this;
+  var node__$1 = this;
+  return(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null)).cljs$core$IVector$_assoc_n$arity$3(null, n, v);
+};
+cljs.core.BlackNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.BlackNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(node, meta) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.with_meta.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), meta);
+};
+cljs.core.BlackNode.prototype.cljs$core$IMeta$_meta$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return null;
+};
+cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$2 = function(node, n) {
+  var self__ = this;
+  var node__$1 = this;
+  if (n === 0) {
+    return self__.key;
+  } else {
+    if (n === 1) {
+      return self__.val;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return null;
+      } else {
+        return null;
+      }
+    }
+  }
+};
+cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$3 = function(node, n, not_found) {
+  var self__ = this;
+  var node__$1 = this;
+  if (n === 0) {
+    return self__.key;
+  } else {
+    if (n === 1) {
+      return self__.val;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return not_found;
+      } else {
+        return null;
+      }
+    }
+  }
+};
+cljs.core.BlackNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.PersistentVector.EMPTY;
+};
+cljs.core.__GT_BlackNode = function __GT_BlackNode(key, val, left, right, __hash) {
+  return new cljs.core.BlackNode(key, val, left, right, __hash);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/RedNode");
+};
+cljs.core.RedNode.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$2 = function(node, k) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core._nth.call(null, node__$1, k, null);
+};
+cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$3 = function(node, k, not_found) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core._nth.call(null, node__$1, k, not_found);
+};
+cljs.core.RedNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(node, k, v) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.assoc.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), k, v);
+};
+cljs.core.RedNode.prototype.call = function() {
+  var G__7632 = null;
+  var G__7632__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var node = self____$1;
+    return node.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7632__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(null, k, not_found);
+  };
+  G__7632 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7632__2.call(this, self__, k);
+      case 3:
+        return G__7632__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7632;
+}();
+cljs.core.RedNode.prototype.apply = function(self__, args7631) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7631)));
+};
+cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var node = this;
+  return node.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var node = this;
+  return node.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.RedNode.prototype.cljs$core$ICollection$_conj$arity$2 = function(node, o) {
+  var self__ = this;
+  var node__$1 = this;
+  return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val, o], null);
+};
+cljs.core.RedNode.prototype.cljs$core$IMapEntry$_key$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return self__.key;
+};
+cljs.core.RedNode.prototype.cljs$core$IMapEntry$_val$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        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;
+  var node__$1 = this;
+  return cljs.core.ci_reduce.call(null, node__$1, f);
+};
+cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$3 = function(node, f, start) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.ci_reduce.call(null, node__$1, f, start);
+};
+cljs.core.RedNode.prototype.cljs$core$ISeqable$_seq$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, self__.val), self__.key);
+};
+cljs.core.RedNode.prototype.cljs$core$ICounted$_count$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return 2;
+};
+cljs.core.RedNode.prototype.cljs$core$IStack$_peek$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return self__.val;
+};
+cljs.core.RedNode.prototype.cljs$core$IStack$_pop$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);
+};
+cljs.core.RedNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(node, n, v) {
+  var self__ = this;
+  var node__$1 = this;
+  return(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null)).cljs$core$IVector$_assoc_n$arity$3(null, n, v);
+};
+cljs.core.RedNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.RedNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(node, meta) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.with_meta.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), meta);
+};
+cljs.core.RedNode.prototype.cljs$core$IMeta$_meta$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return null;
+};
+cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$2 = function(node, n) {
+  var self__ = this;
+  var node__$1 = this;
+  if (n === 0) {
+    return self__.key;
+  } else {
+    if (n === 1) {
+      return self__.val;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return null;
+      } else {
+        return null;
+      }
+    }
+  }
+};
+cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$3 = function(node, n, not_found) {
+  var self__ = this;
+  var node__$1 = this;
+  if (n === 0) {
+    return self__.key;
+  } else {
+    if (n === 1) {
+      return self__.val;
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return not_found;
+      } else {
+        return null;
+      }
+    }
+  }
+};
+cljs.core.RedNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(node) {
+  var self__ = this;
+  var node__$1 = this;
+  return cljs.core.PersistentVector.EMPTY;
+};
+cljs.core.__GT_RedNode = function __GT_RedNode(key, val, left, right, __hash) {
+  return new cljs.core.RedNode(key, val, left, right, __hash);
+};
+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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+            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 (!(del == null) || !(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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          var del = tree_map_remove.call(null, comp, tree.right, k, found);
+          if (!(del == null) || !(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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        return tree.replace(tk, tree.val, tree.left, tree_map_replace.call(null, comp, tree.right, k, v));
+      } else {
+        return null;
+      }
+    }
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentTreeMap");
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._lookup.call(null, coll__$1, k, null);
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  var n = coll__$1.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 coll__$1 = 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__$1;
+    } 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;
+  var coll__$1 = this;
+  return!(coll__$1.entry_at(k) == null);
+};
+cljs.core.PersistentTreeMap.prototype.call = function() {
+  var G__7634 = null;
+  var G__7634__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7634__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(null, k, not_found);
+  };
+  G__7634 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7634__2.call(this, self__, k);
+      case 3:
+        return G__7634__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7634;
+}();
+cljs.core.PersistentTreeMap.prototype.apply = function(self__, args7633) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7633)));
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  if (cljs.core.vector_QMARK_.call(null, entry)) {
+    return cljs.core._assoc.call(null, coll__$1, 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__$1, entry);
+  }
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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__7635 = t.left;
+          t = G__7635;
+          continue;
+        } else {
+          if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+            var G__7636 = t.right;
+            t = G__7636;
+            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;
+  var coll__$1 = 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;
+  var coll__$1 = 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__7637 = cljs.core.conj.call(null, stack, t);
+              var G__7638 = t.left;
+              stack = G__7637;
+              t = G__7638;
+              continue;
+            } else {
+              var G__7639 = stack;
+              var G__7640 = t.right;
+              stack = G__7639;
+              t = G__7640;
+              continue;
+            }
+          } else {
+            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+              if (c > 0) {
+                var G__7641 = cljs.core.conj.call(null, stack, t);
+                var G__7642 = t.right;
+                stack = G__7641;
+                t = G__7642;
+                continue;
+              } else {
+                var G__7643 = stack;
+                var G__7644 = t.left;
+                stack = G__7643;
+                t = G__7644;
+                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;
+  var coll__$1 = this;
+  return cljs.core.key.call(null, entry);
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_comparator$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__.comp;
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.cnt;
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_map.call(null, coll__$1, other);
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 coll__$1 = 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__$1;
+    } 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.__GT_PersistentTreeMap = function __GT_PersistentTreeMap(comp, tree, cnt, meta, __hash) {
+  return new cljs.core.PersistentTreeMap(comp, tree, cnt, meta, __hash);
+};
+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__7645 = cljs.core.nnext.call(null, in$);
+        var G__7646 = cljs.core.assoc_BANG_.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
+        in$ = G__7645;
+        out = G__7646;
+        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__7647) {
+    var keyvals = cljs.core.seq(arglist__7647);
+    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__7648) {
+    var keyvals = cljs.core.seq(arglist__7648);
+    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 = function() {
+      var obj7652 = {};
+      return obj7652;
+    }();
+    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__7653 = cljs.core.nnext.call(null, kvs);
+        kvs = G__7653;
+        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__7654) {
+    var keyvals = cljs.core.seq(arglist__7654);
+    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__7655 = cljs.core.nnext.call(null, in$);
+        var G__7656 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
+        in$ = G__7655;
+        out = G__7656;
+        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__7657) {
+    var keyvals = cljs.core.seq(arglist__7657);
+    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__7658 = cljs.core.nnext.call(null, in$);
+        var G__7659 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
+        in$ = G__7658;
+        out = G__7659;
+        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__7660) {
+    var comparator = cljs.core.first(arglist__7660);
+    var keyvals = cljs.core.rest(arglist__7660);
+    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.KeySeq = function(mseq, _meta) {
+  this.mseq = mseq;
+  this._meta = _meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32374988;
+};
+cljs.core.KeySeq.cljs$lang$type = true;
+cljs.core.KeySeq.cljs$lang$ctorStr = "cljs.core/KeySeq";
+cljs.core.KeySeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/KeySeq");
+};
+cljs.core.KeySeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.hash_coll.call(null, coll__$1);
+};
+cljs.core.KeySeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var nseq = function() {
+    var G__7661 = self__.mseq;
+    if (G__7661) {
+      var bit__4034__auto__ = G__7661.cljs$lang$protocol_mask$partition0$ & 128;
+      if (bit__4034__auto__ || G__7661.cljs$core$INext$) {
+        return true;
+      } else {
+        if (!G__7661.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7661);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7661);
+    }
+  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
+  if (nseq == null) {
+    return null;
+  } else {
+    return new cljs.core.KeySeq(nseq, self__._meta);
+  }
+};
+cljs.core.KeySeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+cljs.core.KeySeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll);
+};
+cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.KeySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.KeySeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var me = cljs.core._first.call(null, self__.mseq);
+  return cljs.core._key.call(null, me);
+};
+cljs.core.KeySeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var nseq = function() {
+    var G__7662 = self__.mseq;
+    if (G__7662) {
+      var bit__4034__auto__ = G__7662.cljs$lang$protocol_mask$partition0$ & 128;
+      if (bit__4034__auto__ || G__7662.cljs$core$INext$) {
+        return true;
+      } else {
+        if (!G__7662.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7662);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7662);
+    }
+  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
+  if (!(nseq == null)) {
+    return new cljs.core.KeySeq(nseq, self__._meta);
+  } else {
+    return cljs.core.List.EMPTY;
+  }
+};
+cljs.core.KeySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.KeySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.KeySeq(self__.mseq, new_meta);
+};
+cljs.core.KeySeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__._meta;
+};
+cljs.core.KeySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__._meta);
+};
+cljs.core.__GT_KeySeq = function __GT_KeySeq(mseq, _meta) {
+  return new cljs.core.KeySeq(mseq, _meta);
+};
+cljs.core.keys = function keys(hash_map) {
+  var temp__4092__auto__ = cljs.core.seq.call(null, hash_map);
+  if (temp__4092__auto__) {
+    var mseq = temp__4092__auto__;
+    return new cljs.core.KeySeq(mseq, null);
+  } else {
+    return null;
+  }
+};
+cljs.core.key = function key(map_entry) {
+  return cljs.core._key.call(null, map_entry);
+};
+cljs.core.ValSeq = function(mseq, _meta) {
+  this.mseq = mseq;
+  this._meta = _meta;
+  this.cljs$lang$protocol_mask$partition1$ = 0;
+  this.cljs$lang$protocol_mask$partition0$ = 32374988;
+};
+cljs.core.ValSeq.cljs$lang$type = true;
+cljs.core.ValSeq.cljs$lang$ctorStr = "cljs.core/ValSeq";
+cljs.core.ValSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ValSeq");
+};
+cljs.core.ValSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.hash_coll.call(null, coll__$1);
+};
+cljs.core.ValSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var nseq = function() {
+    var G__7663 = self__.mseq;
+    if (G__7663) {
+      var bit__4034__auto__ = G__7663.cljs$lang$protocol_mask$partition0$ & 128;
+      if (bit__4034__auto__ || G__7663.cljs$core$INext$) {
+        return true;
+      } else {
+        if (!G__7663.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7663);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7663);
+    }
+  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
+  if (nseq == null) {
+    return null;
+  } else {
+    return new cljs.core.ValSeq(nseq, self__._meta);
+  }
+};
+cljs.core.ValSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.cons.call(null, o, coll__$1);
+};
+cljs.core.ValSeq.prototype.toString = function() {
+  var self__ = this;
+  var coll = this;
+  return cljs.core.pr_str_STAR_.call(null, coll);
+};
+cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, coll__$1);
+};
+cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
+};
+cljs.core.ValSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return coll__$1;
+};
+cljs.core.ValSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var me = cljs.core._first.call(null, self__.mseq);
+  return cljs.core._val.call(null, me);
+};
+cljs.core.ValSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var nseq = function() {
+    var G__7664 = self__.mseq;
+    if (G__7664) {
+      var bit__4034__auto__ = G__7664.cljs$lang$protocol_mask$partition0$ & 128;
+      if (bit__4034__auto__ || G__7664.cljs$core$INext$) {
+        return true;
+      } else {
+        if (!G__7664.cljs$lang$protocol_mask$partition0$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7664);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7664);
+    }
+  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
+  if (!(nseq == null)) {
+    return new cljs.core.ValSeq(nseq, self__._meta);
+  } else {
+    return cljs.core.List.EMPTY;
+  }
+};
+cljs.core.ValSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.equiv_sequential.call(null, coll__$1, other);
+};
+cljs.core.ValSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
+  var self__ = this;
+  var coll__$1 = this;
+  return new cljs.core.ValSeq(self__.mseq, new_meta);
+};
+cljs.core.ValSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return self__._meta;
+};
+cljs.core.ValSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__._meta);
+};
+cljs.core.__GT_ValSeq = function __GT_ValSeq(mseq, _meta) {
+  return new cljs.core.ValSeq(mseq, _meta);
+};
+cljs.core.vals = function vals(hash_map) {
+  var temp__4092__auto__ = cljs.core.seq.call(null, hash_map);
+  if (temp__4092__auto__) {
+    var mseq = temp__4092__auto__;
+    return new cljs.core.ValSeq(mseq, null);
+  } else {
+    return null;
+  }
+};
+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__7665_SHARP_, p2__7666_SHARP_) {
+        return cljs.core.conj.call(null, function() {
+          var or__3408__auto__ = p1__7665_SHARP_;
+          if (cljs.core.truth_(or__3408__auto__)) {
+            return or__3408__auto__;
+          } else {
+            return cljs.core.PersistentArrayMap.EMPTY;
+          }
+        }(), p2__7666_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__7667) {
+    var maps = cljs.core.seq(arglist__7667);
+    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__3408__auto__ = m1;
+            if (cljs.core.truth_(or__3408__auto__)) {
+              return or__3408__auto__;
+            } else {
+              return cljs.core.PersistentArrayMap.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__7668) {
+    var f = cljs.core.first(arglist__7668);
+    var maps = cljs.core.rest(arglist__7668);
+    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.PersistentArrayMap.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, new cljs.core.Keyword("cljs.core", "not-found", "cljs.core/not-found", 4155500789));
+      var G__7669 = cljs.core.not_EQ_.call(null, entry, new cljs.core.Keyword("cljs.core", "not-found", "cljs.core/not-found", 4155500789)) ? cljs.core.assoc.call(null, ret, key, entry) : ret;
+      var G__7670 = cljs.core.next.call(null, keys);
+      ret = G__7669;
+      keys = G__7670;
+      continue;
+    } else {
+      return ret;
+    }
+    break;
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentHashSet");
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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 coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_iset.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, v) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._lookup.call(null, coll__$1, v, null);
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, v, not_found) {
+  var self__ = this;
+  var coll__$1 = this;
+  if (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__7673 = null;
+  var G__7673__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7673__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(null, k, not_found);
+  };
+  G__7673 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7673__2.call(this, self__, k);
+      case 3:
+        return G__7673__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7673;
+}();
+cljs.core.PersistentHashSet.prototype.apply = function(self__, args7672) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7672)));
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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 coll__$1 = this;
+  return cljs.core.set_QMARK_.call(null, other) && (cljs.core.count.call(null, coll__$1) === cljs.core.count.call(null, other) && cljs.core.every_QMARK_.call(null, function(p1__7671_SHARP_) {
+    return cljs.core.contains_QMARK_.call(null, coll__$1, p1__7671_SHARP_);
+  }, other));
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentHashSet.EMPTY, self__.meta);
+};
+cljs.core.__GT_PersistentHashSet = function __GT_PersistentHashSet(meta, hash_map, __hash) {
+  return new cljs.core.PersistentHashSet(meta, hash_map, __hash);
+};
+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 <= cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
+    var arr = no_clone ? items : cljs.core.aclone.call(null, items);
+    var i = 0;
+    var out = cljs.core.transient$.call(null, cljs.core.PersistentArrayMap.EMPTY);
+    while (true) {
+      if (i < len) {
+        var G__7674 = i + 1;
+        var G__7675 = cljs.core._assoc_BANG_.call(null, out, items[i], null);
+        i = G__7674;
+        out = G__7675;
+        continue;
+      } else {
+        return new cljs.core.PersistentHashSet(null, cljs.core._persistent_BANG_.call(null, out), null);
+      }
+      break;
+    }
+  } else {
+    var i = 0;
+    var out = cljs.core.transient$.call(null, cljs.core.PersistentHashSet.EMPTY);
+    while (true) {
+      if (i < len) {
+        var G__7676 = i + 1;
+        var G__7677 = cljs.core._conj_BANG_.call(null, out, items[i]);
+        i = G__7676;
+        out = G__7677;
+        continue;
+      } else {
+        return cljs.core._persistent_BANG_.call(null, out);
+      }
+      break;
+    }
+  }
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientHashSet");
+};
+cljs.core.TransientHashSet.prototype.call = function() {
+  var G__7679 = null;
+  var G__7679__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__7679__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__7679 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7679__2.call(this, self__, k);
+      case 3:
+        return G__7679__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7679;
+}();
+cljs.core.TransientHashSet.prototype.apply = function(self__, args7678) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7678)));
+};
+cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var tcoll = this;
+  if (cljs.core._lookup.call(null, self__.transient_map, k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
+    return null;
+  } else {
+    return k;
+  }
+};
+cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var tcoll = this;
+  if (cljs.core._lookup.call(null, self__.transient_map, k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
+    return not_found;
+  } else {
+    return k;
+  }
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, v) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  return cljs.core._lookup.call(null, tcoll__$1, v, null);
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, v, not_found) {
+  var self__ = this;
+  var tcoll__$1 = 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;
+  var tcoll__$1 = 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;
+  var tcoll__$1 = this;
+  self__.transient_map = cljs.core.dissoc_BANG_.call(null, self__.transient_map, v);
+  return tcoll__$1;
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  self__.transient_map = cljs.core.assoc_BANG_.call(null, self__.transient_map, o, null);
+  return tcoll__$1;
+};
+cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
+  var self__ = this;
+  var tcoll__$1 = this;
+  return new cljs.core.PersistentHashSet(null, cljs.core.persistent_BANG_.call(null, self__.transient_map), null);
+};
+cljs.core.__GT_TransientHashSet = function __GT_TransientHashSet(transient_map) {
+  return new cljs.core.TransientHashSet(transient_map);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentTreeSet");
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_iset.call(null, coll__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, v) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core._lookup.call(null, coll__$1, v, null);
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, v, not_found) {
+  var self__ = this;
+  var coll__$1 = 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__7682 = null;
+  var G__7682__2 = function(self__, k) {
+    var self__ = this;
+    var self____$1 = this;
+    var coll = self____$1;
+    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+  };
+  var G__7682__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(null, k, not_found);
+  };
+  G__7682 = function(self__, k, not_found) {
+    switch(arguments.length) {
+      case 2:
+        return G__7682__2.call(this, self__, k);
+      case 3:
+        return G__7682__3.call(this, self__, k, not_found);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  return G__7682;
+}();
+cljs.core.PersistentTreeSet.prototype.apply = function(self__, args7681) {
+  var self__ = this;
+  var self____$1 = this;
+  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7681)));
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
+  var self__ = this;
+  var coll = this;
+  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  if (cljs.core.count.call(null, self__.tree_map) > 0) {
+    return cljs.core.map.call(null, cljs.core.key, cljs.core.rseq.call(null, self__.tree_map));
+  } else {
+    return null;
+  }
+};
+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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return entry;
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_comparator$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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;
+  var coll__$1 = 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 coll__$1 = this;
+  return cljs.core.set_QMARK_.call(null, other) && (cljs.core.count.call(null, coll__$1) === cljs.core.count.call(null, other) && cljs.core.every_QMARK_.call(null, function(p1__7680_SHARP_) {
+    return cljs.core.contains_QMARK_.call(null, coll__$1, p1__7680_SHARP_);
+  }, other));
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
+  var self__ = this;
+  var coll__$1 = 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;
+  var coll__$1 = this;
+  return self__.meta;
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
+  var self__ = this;
+  var coll__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.PersistentTreeSet.EMPTY, self__.meta);
+};
+cljs.core.__GT_PersistentTreeSet = function __GT_PersistentTreeSet(meta, tree_map, __hash) {
+  return new cljs.core.PersistentTreeSet(meta, tree_map, __hash);
+};
+cljs.core.PersistentTreeSet.EMPTY = new cljs.core.PersistentTreeSet(null, cljs.core.PersistentTreeMap.EMPTY, 0);
+cljs.core.set_from_indexed_seq = function set_from_indexed_seq(iseq) {
+  var arr = iseq.arr;
+  var ret = function() {
+    var a__4226__auto__ = arr;
+    var i = 0;
+    var res = cljs.core._as_transient.call(null, cljs.core.PersistentHashSet.EMPTY);
+    while (true) {
+      if (i < a__4226__auto__.length) {
+        var G__7683 = i + 1;
+        var G__7684 = cljs.core._conj_BANG_.call(null, res, arr[i]);
+        i = G__7683;
+        res = G__7684;
+        continue;
+      } else {
+        return res;
+      }
+      break;
+    }
+  }();
+  return cljs.core._persistent_BANG_.call(null, ret);
+};
+cljs.core.set = function set(coll) {
+  var in$ = cljs.core.seq.call(null, coll);
+  if (in$ == null) {
+    return cljs.core.PersistentHashSet.EMPTY;
+  } else {
+    if (in$ instanceof cljs.core.IndexedSeq && in$.i === 0) {
+      return cljs.core.set_from_indexed_seq.call(null, in$);
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        var in$__$1 = in$;
+        var out = cljs.core._as_transient.call(null, cljs.core.PersistentHashSet.EMPTY);
+        while (true) {
+          if (!(in$__$1 == null)) {
+            var G__7685 = cljs.core._next.call(null, in$__$1);
+            var G__7686 = cljs.core._conj_BANG_.call(null, out, cljs.core._first.call(null, in$__$1));
+            in$__$1 = G__7685;
+            out = G__7686;
+            continue;
+          } else {
+            return cljs.core._persistent_BANG_.call(null, out);
+          }
+          break;
+        }
+      } else {
+        return null;
+      }
+    }
+  }
+};
+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__7687__delegate = function(keys) {
+      return cljs.core.set.call(null, keys);
+    };
+    var G__7687 = function(var_args) {
+      var keys = null;
+      if (arguments.length > 0) {
+        keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+      }
+      return G__7687__delegate.call(this, keys);
+    };
+    G__7687.cljs$lang$maxFixedArity = 0;
+    G__7687.cljs$lang$applyTo = function(arglist__7688) {
+      var keys = cljs.core.seq(arglist__7688);
+      return G__7687__delegate(keys);
+    };
+    G__7687.cljs$core$IFn$_invoke$arity$variadic = G__7687__delegate;
+    return G__7687;
+  }();
+  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.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__7689) {
+    var keys = cljs.core.seq(arglist__7689);
+    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__7690) {
+    var comparator = cljs.core.first(arglist__7690);
+    var keys = cljs.core.rest(arglist__7690);
+    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__7691_SHARP_) {
+      var temp__4090__auto__ = cljs.core.find.call(null, smap, p1__7691_SHARP_);
+      if (cljs.core.truth_(temp__4090__auto__)) {
+        var e = temp__4090__auto__;
+        return cljs.core.second.call(null, e);
+      } else {
+        return p1__7691_SHARP_;
+      }
+    }, coll);
+  }
+};
+cljs.core.distinct = function distinct(coll) {
+  var step = function step(xs, seen) {
+    return new cljs.core.LazySeq(null, function() {
+      return function(p__7698, seen__$1) {
+        while (true) {
+          var vec__7699 = p__7698;
+          var f = cljs.core.nth.call(null, vec__7699, 0, null);
+          var xs__$1 = vec__7699;
+          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__7700 = cljs.core.rest.call(null, s);
+              var G__7701 = seen__$1;
+              p__7698 = G__7700;
+              seen__$1 = G__7701;
+              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, 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__7702 = cljs.core.conj.call(null, ret, cljs.core.first.call(null, s__$1));
+      var G__7703 = cljs.core.next.call(null, s__$1);
+      ret = G__7702;
+      s__$1 = G__7703;
+      continue;
+    } else {
+      return cljs.core.seq.call(null, ret);
+    }
+    break;
+  }
+};
+cljs.core.name = function name(x) {
+  if (function() {
+    var G__7705 = x;
+    if (G__7705) {
+      var bit__4027__auto__ = G__7705.cljs$lang$protocol_mask$partition1$ & 4096;
+      if (bit__4027__auto__ || G__7705.cljs$core$INamed$) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }()) {
+    return cljs.core._name.call(null, x);
+  } else {
+    if (typeof x === "string") {
+      return x;
+    } else {
+      throw new Error([cljs.core.str("Doesn't support name: "), cljs.core.str(x)].join(""));
+    }
+  }
+};
+cljs.core.zipmap = function zipmap(keys, vals) {
+  var map = cljs.core.transient$.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var ks = cljs.core.seq.call(null, keys);
+  var vs = cljs.core.seq.call(null, vals);
+  while (true) {
+    if (ks && vs) {
+      var G__7706 = cljs.core.assoc_BANG_.call(null, map, cljs.core.first.call(null, ks), cljs.core.first.call(null, vs));
+      var G__7707 = cljs.core.next.call(null, ks);
+      var G__7708 = cljs.core.next.call(null, vs);
+      map = G__7706;
+      ks = G__7707;
+      vs = G__7708;
+      continue;
+    } else {
+      return cljs.core.persistent_BANG_.call(null, 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__7711__delegate = function(k, x, y, more) {
+      return cljs.core.reduce.call(null, function(p1__7709_SHARP_, p2__7710_SHARP_) {
+        return max_key.call(null, k, p1__7709_SHARP_, p2__7710_SHARP_);
+      }, max_key.call(null, k, x, y), more);
+    };
+    var G__7711 = 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__7711__delegate.call(this, k, x, y, more);
+    };
+    G__7711.cljs$lang$maxFixedArity = 3;
+    G__7711.cljs$lang$applyTo = function(arglist__7712) {
+      var k = cljs.core.first(arglist__7712);
+      arglist__7712 = cljs.core.next(arglist__7712);
+      var x = cljs.core.first(arglist__7712);
+      arglist__7712 = cljs.core.next(arglist__7712);
+      var y = cljs.core.first(arglist__7712);
+      var more = cljs.core.rest(arglist__7712);
+      return G__7711__delegate(k, x, y, more);
+    };
+    G__7711.cljs$core$IFn$_invoke$arity$variadic = G__7711__delegate;
+    return G__7711;
+  }();
+  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__7715__delegate = function(k, x, y, more) {
+      return cljs.core.reduce.call(null, function(p1__7713_SHARP_, p2__7714_SHARP_) {
+        return min_key.call(null, k, p1__7713_SHARP_, p2__7714_SHARP_);
+      }, min_key.call(null, k, x, y), more);
+    };
+    var G__7715 = 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__7715__delegate.call(this, k, x, y, more);
+    };
+    G__7715.cljs$lang$maxFixedArity = 3;
+    G__7715.cljs$lang$applyTo = function(arglist__7716) {
+      var k = cljs.core.first(arglist__7716);
+      arglist__7716 = cljs.core.next(arglist__7716);
+      var x = cljs.core.first(arglist__7716);
+      arglist__7716 = cljs.core.next(arglist__7716);
+      var y = cljs.core.first(arglist__7716);
+      var more = cljs.core.rest(arglist__7716);
+      return G__7715__delegate(k, x, y, more);
+    };
+    G__7715.cljs$core$IFn$_invoke$arity$variadic = G__7715__delegate;
+    return G__7715;
+  }();
+  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, 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, 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, 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, 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_, cljs.core._GT__EQ_], 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__7719 = temp__4092__auto__;
+        var e = cljs.core.nth.call(null, vec__7719, 0, null);
+        var s = vec__7719;
+        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__7720 = temp__4092__auto__;
+      var e = cljs.core.nth.call(null, vec__7720, 0, null);
+      var s = vec__7720;
+      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_, cljs.core._LT__EQ_], 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__7723 = temp__4092__auto__;
+        var e = cljs.core.nth.call(null, vec__7723, 0, null);
+        var s = vec__7723;
+        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__7724 = temp__4092__auto__;
+      var e = cljs.core.nth.call(null, vec__7724, 0, null);
+      var s = vec__7724;
+      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;
+}();
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Range");
+};
+cljs.core.Range.prototype.cljs$core$IHash$_hash$arity$1 = function(rng) {
+  var self__ = this;
+  var rng__$1 = this;
+  var h__3819__auto__ = self__.__hash;
+  if (!(h__3819__auto__ == null)) {
+    return h__3819__auto__;
+  } else {
+    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, rng__$1);
+    self__.__hash = h__3819__auto____$1;
+    return h__3819__auto____$1;
+  }
+};
+cljs.core.Range.prototype.cljs$core$INext$_next$arity$1 = function(rng) {
+  var self__ = this;
+  var rng__$1 = 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;
+  var rng__$1 = this;
+  return cljs.core.cons.call(null, o, rng__$1);
+};
+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;
+  var rng__$1 = this;
+  return cljs.core.ci_reduce.call(null, rng__$1, f);
+};
+cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$3 = function(rng, f, s) {
+  var self__ = this;
+  var rng__$1 = this;
+  return cljs.core.ci_reduce.call(null, rng__$1, f, s);
+};
+cljs.core.Range.prototype.cljs$core$ISeqable$_seq$arity$1 = function(rng) {
+  var self__ = this;
+  var rng__$1 = this;
+  if (self__.step > 0) {
+    if (self__.start < self__.end) {
+      return rng__$1;
+    } else {
+      return null;
+    }
+  } else {
+    if (self__.start > self__.end) {
+      return rng__$1;
+    } else {
+      return null;
+    }
+  }
+};
+cljs.core.Range.prototype.cljs$core$ICounted$_count$arity$1 = function(rng) {
+  var self__ = this;
+  var rng__$1 = this;
+  if (cljs.core.not.call(null, cljs.core._seq.call(null, rng__$1))) {
+    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;
+  var rng__$1 = this;
+  if (cljs.core._seq.call(null, rng__$1) == null) {
+    return null;
+  } else {
+    return self__.start;
+  }
+};
+cljs.core.Range.prototype.cljs$core$ISeq$_rest$arity$1 = function(rng) {
+  var self__ = this;
+  var rng__$1 = this;
+  if (!(cljs.core._seq.call(null, rng__$1) == 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;
+  var rng__$1 = this;
+  return cljs.core.equiv_sequential.call(null, rng__$1, other);
+};
+cljs.core.Range.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(rng, meta__$1) {
+  var self__ = this;
+  var rng__$1 = 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;
+  var rng__$1 = this;
+  return self__.meta;
+};
+cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$2 = function(rng, n) {
+  var self__ = this;
+  var rng__$1 = this;
+  if (n < cljs.core._count.call(null, rng__$1)) {
+    return self__.start + n * self__.step;
+  } else {
+    if (self__.start > self__.end && self__.step === 0) {
+      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;
+  var rng__$1 = this;
+  if (n < cljs.core._count.call(null, rng__$1)) {
+    return self__.start + n * self__.step;
+  } else {
+    if (self__.start > self__.end && self__.step === 0) {
+      return self__.start;
+    } else {
+      return not_found;
+    }
+  }
+};
+cljs.core.Range.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(rng) {
+  var self__ = this;
+  var rng__$1 = this;
+  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
+};
+cljs.core.__GT_Range = function __GT_Range(meta, start, end, step, __hash) {
+  return new cljs.core.Range(meta, start, end, step, __hash);
+};
+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, 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, null);
+};
+cljs.core.split_with = function split_with(pred, coll) {
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take_while.call(null, pred, coll), cljs.core.drop_while.call(null, pred, coll)], null);
+};
+cljs.core.partition_by = function partition_by(f, coll) {
+  return new cljs.core.LazySeq(null, 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__7725_SHARP_) {
+          return cljs.core._EQ_.call(null, fv, f.call(null, p1__7725_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, 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.PersistentArrayMap.EMPTY), coll));
+};
+cljs.core.reductions = function() {
+  var reductions = null;
+  var reductions__2 = function(f, coll) {
+    return new cljs.core.LazySeq(null, 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._conj.call(null, cljs.core.List.EMPTY, f.call(null));
+      }
+    }, null, null);
+  };
+  var reductions__3 = function(f, init, coll) {
+    return cljs.core.cons.call(null, init, new cljs.core.LazySeq(null, 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, 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__7736 = null;
+      var G__7736__0 = function() {
+        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null)], null);
+      };
+      var G__7736__1 = function(x) {
+        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x)], null);
+      };
+      var G__7736__2 = function(x, y) {
+        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y)], null);
+      };
+      var G__7736__3 = function(x, y, z) {
+        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y, z)], null);
+      };
+      var G__7736__4 = function() {
+        var G__7737__delegate = function(x, y, z, args) {
+          return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.apply.call(null, f, x, y, z, args)], null);
+        };
+        var G__7737 = 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__7737__delegate.call(this, x, y, z, args);
+        };
+        G__7737.cljs$lang$maxFixedArity = 3;
+        G__7737.cljs$lang$applyTo = function(arglist__7738) {
+          var x = cljs.core.first(arglist__7738);
+          arglist__7738 = cljs.core.next(arglist__7738);
+          var y = cljs.core.first(arglist__7738);
+          arglist__7738 = cljs.core.next(arglist__7738);
+          var z = cljs.core.first(arglist__7738);
+          var args = cljs.core.rest(arglist__7738);
+          return G__7737__delegate(x, y, z, args);
+        };
+        G__7737.cljs$core$IFn$_invoke$arity$variadic = G__7737__delegate;
+        return G__7737;
+      }();
+      G__7736 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__7736__0.call(this);
+          case 1:
+            return G__7736__1.call(this, x);
+          case 2:
+            return G__7736__2.call(this, x, y);
+          case 3:
+            return G__7736__3.call(this, x, y, z);
+          default:
+            return G__7736__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7736.cljs$lang$maxFixedArity = 3;
+      G__7736.cljs$lang$applyTo = G__7736__4.cljs$lang$applyTo;
+      return G__7736;
+    }();
+  };
+  var juxt__2 = function(f, g) {
+    return function() {
+      var G__7739 = null;
+      var G__7739__0 = function() {
+        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null), g.call(null)], null);
+      };
+      var G__7739__1 = function(x) {
+        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x), g.call(null, x)], null);
+      };
+      var G__7739__2 = function(x, y) {
+        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y), g.call(null, x, y)], null);
+      };
+      var G__7739__3 = function(x, y, z) {
+        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y, z), g.call(null, x, y, z)], null);
+      };
+      var G__7739__4 = function() {
+        var G__7740__delegate = function(x, y, z, args) {
+          return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.apply.call(null, f, x, y, z, args), cljs.core.apply.call(null, g, x, y, z, args)], null);
+        };
+        var G__7740 = 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__7740__delegate.call(this, x, y, z, args);
+        };
+        G__7740.cljs$lang$maxFixedArity = 3;
+        G__7740.cljs$lang$applyTo = function(arglist__7741) {
+          var x = cljs.core.first(arglist__7741);
+          arglist__7741 = cljs.core.next(arglist__7741);
+          var y = cljs.core.first(arglist__7741);
+          arglist__7741 = cljs.core.next(arglist__7741);
+          var z = cljs.core.first(arglist__7741);
+          var args = cljs.core.rest(arglist__7741);
+          return G__7740__delegate(x, y, z, args);
+        };
+        G__7740.cljs$core$IFn$_invoke$arity$variadic = G__7740__delegate;
+        return G__7740;
+      }();
+      G__7739 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__7739__0.call(this);
+          case 1:
+            return G__7739__1.call(this, x);
+          case 2:
+            return G__7739__2.call(this, x, y);
+          case 3:
+            return G__7739__3.call(this, x, y, z);
+          default:
+            return G__7739__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7739.cljs$lang$maxFixedArity = 3;
+      G__7739.cljs$lang$applyTo = G__7739__4.cljs$lang$applyTo;
+      return G__7739;
+    }();
+  };
+  var juxt__3 = function(f, g, h) {
+    return function() {
+      var G__7742 = null;
+      var G__7742__0 = function() {
+        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null), g.call(null), h.call(null)], null);
+      };
+      var G__7742__1 = function(x) {
+        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x), g.call(null, x), h.call(null, x)], null);
+      };
+      var G__7742__2 = function(x, y) {
+        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y), g.call(null, x, y), h.call(null, x, y)], null);
+      };
+      var G__7742__3 = function(x, y, z) {
+        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y, z), g.call(null, x, y, z), h.call(null, x, y, z)], null);
+      };
+      var G__7742__4 = function() {
+        var G__7743__delegate = function(x, y, z, args) {
+          return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [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)], null);
+        };
+        var G__7743 = 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__7743__delegate.call(this, x, y, z, args);
+        };
+        G__7743.cljs$lang$maxFixedArity = 3;
+        G__7743.cljs$lang$applyTo = function(arglist__7744) {
+          var x = cljs.core.first(arglist__7744);
+          arglist__7744 = cljs.core.next(arglist__7744);
+          var y = cljs.core.first(arglist__7744);
+          arglist__7744 = cljs.core.next(arglist__7744);
+          var z = cljs.core.first(arglist__7744);
+          var args = cljs.core.rest(arglist__7744);
+          return G__7743__delegate(x, y, z, args);
+        };
+        G__7743.cljs$core$IFn$_invoke$arity$variadic = G__7743__delegate;
+        return G__7743;
+      }();
+      G__7742 = function(x, y, z, var_args) {
+        var args = var_args;
+        switch(arguments.length) {
+          case 0:
+            return G__7742__0.call(this);
+          case 1:
+            return G__7742__1.call(this, x);
+          case 2:
+            return G__7742__2.call(this, x, y);
+          case 3:
+            return G__7742__3.call(this, x, y, z);
+          default:
+            return G__7742__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
+        }
+        throw new Error("Invalid arity: " + arguments.length);
+      };
+      G__7742.cljs$lang$maxFixedArity = 3;
+      G__7742.cljs$lang$applyTo = G__7742__4.cljs$lang$applyTo;
+      return G__7742;
+    }();
+  };
+  var juxt__4 = function() {
+    var G__7745__delegate = function(f, g, h, fs) {
+      var fs__$1 = cljs.core.list_STAR_.call(null, f, g, h, fs);
+      return function() {
+        var G__7746 = null;
+        var G__7746__0 = function() {
+          return cljs.core.reduce.call(null, function(p1__7726_SHARP_, p2__7727_SHARP_) {
+            return cljs.core.conj.call(null, p1__7726_SHARP_, p2__7727_SHARP_.call(null));
+          }, cljs.core.PersistentVector.EMPTY, fs__$1);
+        };
+        var G__7746__1 = function(x) {
+          return cljs.core.reduce.call(null, function(p1__7728_SHARP_, p2__7729_SHARP_) {
+            return cljs.core.conj.call(null, p1__7728_SHARP_, p2__7729_SHARP_.call(null, x));
+          }, cljs.core.PersistentVector.EMPTY, fs__$1);
+        };
+        var G__7746__2 = function(x, y) {
+          return cljs.core.reduce.call(null, function(p1__7730_SHARP_, p2__7731_SHARP_) {
+            return cljs.core.conj.call(null, p1__7730_SHARP_, p2__7731_SHARP_.call(null, x, y));
+          }, cljs.core.PersistentVector.EMPTY, fs__$1);
+        };
+        var G__7746__3 = function(x, y, z) {
+          return cljs.core.reduce.call(null, function(p1__7732_SHARP_, p2__7733_SHARP_) {
+            return cljs.core.conj.call(null, p1__7732_SHARP_, p2__7733_SHARP_.call(null, x, y, z));
+          }, cljs.core.PersistentVector.EMPTY, fs__$1);
+        };
+        var G__7746__4 = function() {
+          var G__7747__delegate = function(x, y, z, args) {
+            return cljs.core.reduce.call(null, function(p1__7734_SHARP_, p2__7735_SHARP_) {
+              return cljs.core.conj.call(null, p1__7734_SHARP_, cljs.core.apply.call(null, p2__7735_SHARP_, x, y, z, args));
+            }, cljs.core.PersistentVector.EMPTY, fs__$1);
+          };
+          var G__7747 = 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__7747__delegate.call(this, x, y, z, args);
+          };
+          G__7747.cljs$lang$maxFixedArity = 3;
+          G__7747.cljs$lang$applyTo = function(arglist__7748) {
+            var x = cljs.core.first(arglist__7748);
+            arglist__7748 = cljs.core.next(arglist__7748);
+            var y = cljs.core.first(arglist__7748);
+            arglist__7748 = cljs.core.next(arglist__7748);
+            var z = cljs.core.first(arglist__7748);
+            var args = cljs.core.rest(arglist__7748);
+            return G__7747__delegate(x, y, z, args);
+          };
+          G__7747.cljs$core$IFn$_invoke$arity$variadic = G__7747__delegate;
+          return G__7747;
+        }();
+        G__7746 = function(x, y, z, var_args) {
+          var args = var_args;
+          switch(arguments.length) {
+            case 0:
+              return G__7746__0.call(this);
+            case 1:
+              return G__7746__1.call(this, x);
+            case 2:
+              return G__7746__2.call(this, x, y);
+            case 3:
+              return G__7746__3.call(this, x, y, z);
+            default:
+              return G__7746__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
+          }
+          throw new Error("Invalid arity: " + arguments.length);
+        };
+        G__7746.cljs$lang$maxFixedArity = 3;
+        G__7746.cljs$lang$applyTo = G__7746__4.cljs$lang$applyTo;
+        return G__7746;
+      }();
+    };
+    var G__7745 = 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__7745__delegate.call(this, f, g, h, fs);
+    };
+    G__7745.cljs$lang$maxFixedArity = 3;
+    G__7745.cljs$lang$applyTo = function(arglist__7749) {
+      var f = cljs.core.first(arglist__7749);
+      arglist__7749 = cljs.core.next(arglist__7749);
+      var g = cljs.core.first(arglist__7749);
+      arglist__7749 = cljs.core.next(arglist__7749);
+      var h = cljs.core.first(arglist__7749);
+      var fs = cljs.core.rest(arglist__7749);
+      return G__7745__delegate(f, g, h, fs);
+    };
+    G__7745.cljs$core$IFn$_invoke$arity$variadic = G__7745__delegate;
+    return G__7745;
+  }();
+  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__7750 = cljs.core.next.call(null, coll);
+        coll = G__7750;
+        continue;
+      } else {
+        return null;
+      }
+      break;
+    }
+  };
+  var dorun__2 = function(n, coll) {
+    while (true) {
+      if (cljs.core.seq.call(null, coll) && n > 0) {
+        var G__7751 = n - 1;
+        var G__7752 = cljs.core.next.call(null, coll);
+        n = G__7751;
+        coll = G__7752;
+        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, function() {
+      return cljs.core.cons.call(null, match_data, cljs.core.seq.call(null, post_match) ? re_seq.call(null, re, post_match) : null);
+    }, null, null);
+  } else {
+    return null;
+  }
+};
+cljs.core.re_pattern = function re_pattern(s) {
+  var vec__7754 = cljs.core.re_find.call(null, /^(?:\(\?([idmsux]*)\))?(.*)/, s);
+  var _ = cljs.core.nth.call(null, vec__7754, 0, null);
+  var flags = cljs.core.nth.call(null, vec__7754, 1, null);
+  var pattern = cljs.core.nth.call(null, vec__7754, 2, null);
+  return new RegExp(pattern, flags);
+};
+cljs.core.pr_sequential_writer = function pr_sequential_writer(writer, print_one, begin, sep, end, opts, coll) {
+  var _STAR_print_level_STAR_7756 = cljs.core._STAR_print_level_STAR_;
+  try {
+    cljs.core._STAR_print_level_STAR_ = cljs.core._STAR_print_level_STAR_ == null ? null : cljs.core._STAR_print_level_STAR_ - 1;
+    if (!(cljs.core._STAR_print_level_STAR_ == null) && cljs.core._STAR_print_level_STAR_ < 0) {
+      return cljs.core._write.call(null, writer, "#");
+    } else {
+      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 coll_7757__$1 = cljs.core.next.call(null, coll);
+      var n_7758 = (new cljs.core.Keyword(null, "print-length", "print-length", 3960797560)).cljs$core$IFn$_invoke$arity$1(opts);
+      while (true) {
+        if (coll_7757__$1 && (n_7758 == null || !(n_7758 === 0))) {
+          cljs.core._write.call(null, writer, sep);
+          print_one.call(null, cljs.core.first.call(null, coll_7757__$1), writer, opts);
+          var G__7759 = cljs.core.next.call(null, coll_7757__$1);
+          var G__7760 = n_7758 - 1;
+          coll_7757__$1 = G__7759;
+          n_7758 = G__7760;
+          continue;
+        } else {
+        }
+        break;
+      }
+      if (cljs.core.truth_((new cljs.core.Keyword(null, "print-length", "print-length", 3960797560)).cljs$core$IFn$_invoke$arity$1(opts))) {
+        cljs.core._write.call(null, writer, sep);
+        print_one.call(null, "...", writer, opts);
+      } else {
+      }
+      return cljs.core._write.call(null, writer, end);
+    }
+  } finally {
+    cljs.core._STAR_print_level_STAR_ = _STAR_print_level_STAR_7756;
+  }
+};
+cljs.core.write_all = function() {
+  var write_all__delegate = function(writer, ss) {
+    var seq__7765 = cljs.core.seq.call(null, ss);
+    var chunk__7766 = null;
+    var count__7767 = 0;
+    var i__7768 = 0;
+    while (true) {
+      if (i__7768 < count__7767) {
+        var s = cljs.core._nth.call(null, chunk__7766, i__7768);
+        cljs.core._write.call(null, writer, s);
+        var G__7769 = seq__7765;
+        var G__7770 = chunk__7766;
+        var G__7771 = count__7767;
+        var G__7772 = i__7768 + 1;
+        seq__7765 = G__7769;
+        chunk__7766 = G__7770;
+        count__7767 = G__7771;
+        i__7768 = G__7772;
+        continue;
+      } else {
+        var temp__4092__auto__ = cljs.core.seq.call(null, seq__7765);
+        if (temp__4092__auto__) {
+          var seq__7765__$1 = temp__4092__auto__;
+          if (cljs.core.chunked_seq_QMARK_.call(null, seq__7765__$1)) {
+            var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__7765__$1);
+            var G__7773 = cljs.core.chunk_rest.call(null, seq__7765__$1);
+            var G__7774 = c__4132__auto__;
+            var G__7775 = cljs.core.count.call(null, c__4132__auto__);
+            var G__7776 = 0;
+            seq__7765 = G__7773;
+            chunk__7766 = G__7774;
+            count__7767 = G__7775;
+            i__7768 = G__7776;
+            continue;
+          } else {
+            var s = cljs.core.first.call(null, seq__7765__$1);
+            cljs.core._write.call(null, writer, s);
+            var G__7777 = cljs.core.next.call(null, seq__7765__$1);
+            var G__7778 = null;
+            var G__7779 = 0;
+            var G__7780 = 0;
+            seq__7765 = G__7777;
+            chunk__7766 = G__7778;
+            count__7767 = G__7779;
+            i__7768 = G__7780;
+            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__7781) {
+    var writer = cljs.core.first(arglist__7781);
+    var ss = cljs.core.rest(arglist__7781);
+    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 = function() {
+  var obj7783 = {'"':'\\"', "\\":"\\\\", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t"};
+  return obj7783;
+}();
+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, "#\x3cundefined\x3e");
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        if (cljs.core.truth_(function() {
+          var and__3396__auto__ = cljs.core.get.call(null, opts, new cljs.core.Keyword(null, "meta", "meta", 1017252215));
+          if (cljs.core.truth_(and__3396__auto__)) {
+            var and__3396__auto____$1 = function() {
+              var G__7789 = obj;
+              if (G__7789) {
+                var bit__4034__auto__ = G__7789.cljs$lang$protocol_mask$partition0$ & 131072;
+                if (bit__4034__auto__ || G__7789.cljs$core$IMeta$) {
+                  return true;
+                } else {
+                  if (!G__7789.cljs$lang$protocol_mask$partition0$) {
+                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7789);
+                  } else {
+                    return false;
+                  }
+                }
+              } else {
+                return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7789);
+              }
+            }();
+            if (and__3396__auto____$1) {
+              return cljs.core.meta.call(null, obj);
+            } else {
+              return and__3396__auto____$1;
+            }
+          } else {
+            return and__3396__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__7790 = obj;
+              if (G__7790) {
+                var bit__4027__auto__ = G__7790.cljs$lang$protocol_mask$partition0$ & 2147483648;
+                if (bit__4027__auto__ || G__7790.cljs$core$IPrintWithWriter$) {
+                  return true;
+                } else {
+                  return false;
+                }
+              } else {
+                return false;
+              }
+            }()) {
+              return cljs.core._pr_writer.call(null, obj, writer, opts);
+            } else {
+              if (cljs.core.type.call(null, obj) === Boolean || typeof obj === "number") {
+                return cljs.core._write.call(null, writer, [cljs.core.str(obj)].join(""));
+              } else {
+                if (cljs.core.object_QMARK_.call(null, obj)) {
+                  cljs.core._write.call(null, writer, "#js ");
+                  return cljs.core.print_map.call(null, cljs.core.map.call(null, function(k) {
+                    return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k), obj[k]], null);
+                  }, cljs.core.js_keys.call(null, obj)), pr_writer, writer, opts);
+                } else {
+                  if (obj instanceof Array) {
+                    return cljs.core.pr_sequential_writer.call(null, writer, pr_writer, "#js [", " ", "]", opts, obj);
+                  } else {
+                    if (goog.isString(obj)) {
+                      if (cljs.core.truth_((new cljs.core.Keyword(null, "readably", "readably", 4441712502)).cljs$core$IFn$_invoke$arity$1(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 {
+                      if (cljs.core.fn_QMARK_.call(null, obj)) {
+                        return cljs.core.write_all.call(null, writer, "#\x3c", [cljs.core.str(obj)].join(""), "\x3e");
+                      } 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__7792 = [cljs.core.str("0"), cljs.core.str(ns)].join("");
+                                ns = G__7792;
+                                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.regexp_QMARK_.call(null, obj)) {
+                            return cljs.core.write_all.call(null, writer, '#"', obj.source, '"');
+                          } else {
+                            if (function() {
+                              var G__7791 = obj;
+                              if (G__7791) {
+                                var bit__4034__auto__ = G__7791.cljs$lang$protocol_mask$partition0$ & 2147483648;
+                                if (bit__4034__auto__ || G__7791.cljs$core$IPrintWithWriter$) {
+                                  return true;
+                                } else {
+                                  if (!G__7791.cljs$lang$protocol_mask$partition0$) {
+                                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IPrintWithWriter, G__7791);
+                                  } else {
+                                    return false;
+                                  }
+                                }
+                              } else {
+                                return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IPrintWithWriter, G__7791);
+                              }
+                            }()) {
+                              return cljs.core._pr_writer.call(null, obj, writer, opts);
+                            } else {
+                              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                                return cljs.core.write_all.call(null, writer, "#\x3c", [cljs.core.str(obj)].join(""), "\x3e");
+                              } 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__7797 = cljs.core.seq.call(null, cljs.core.next.call(null, objs));
+  var chunk__7798 = null;
+  var count__7799 = 0;
+  var i__7800 = 0;
+  while (true) {
+    if (i__7800 < count__7799) {
+      var obj = cljs.core._nth.call(null, chunk__7798, i__7800);
+      cljs.core._write.call(null, writer, " ");
+      cljs.core.pr_writer.call(null, obj, writer, opts);
+      var G__7801 = seq__7797;
+      var G__7802 = chunk__7798;
+      var G__7803 = count__7799;
+      var G__7804 = i__7800 + 1;
+      seq__7797 = G__7801;
+      chunk__7798 = G__7802;
+      count__7799 = G__7803;
+      i__7800 = G__7804;
+      continue;
+    } else {
+      var temp__4092__auto__ = cljs.core.seq.call(null, seq__7797);
+      if (temp__4092__auto__) {
+        var seq__7797__$1 = temp__4092__auto__;
+        if (cljs.core.chunked_seq_QMARK_.call(null, seq__7797__$1)) {
+          var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__7797__$1);
+          var G__7805 = cljs.core.chunk_rest.call(null, seq__7797__$1);
+          var G__7806 = c__4132__auto__;
+          var G__7807 = cljs.core.count.call(null, c__4132__auto__);
+          var G__7808 = 0;
+          seq__7797 = G__7805;
+          chunk__7798 = G__7806;
+          count__7799 = G__7807;
+          i__7800 = G__7808;
+          continue;
+        } else {
+          var obj = cljs.core.first.call(null, seq__7797__$1);
+          cljs.core._write.call(null, writer, " ");
+          cljs.core.pr_writer.call(null, obj, writer, opts);
+          var G__7809 = cljs.core.next.call(null, seq__7797__$1);
+          var G__7810 = null;
+          var G__7811 = 0;
+          var G__7812 = 0;
+          seq__7797 = G__7809;
+          chunk__7798 = G__7810;
+          count__7799 = G__7811;
+          i__7800 = G__7812;
+          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, new cljs.core.Keyword(null, "flush-on-newline", "flush-on-newline", 4338025857)))) {
+    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__7813) {
+    var objs = cljs.core.seq(arglist__7813);
+    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__7814) {
+    var objs = cljs.core.seq(arglist__7814);
+    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__7815) {
+    var objs = cljs.core.seq(arglist__7815);
+    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), 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__7816) {
+    var objs = cljs.core.seq(arglist__7816);
+    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), 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__7817) {
+    var objs = cljs.core.seq(arglist__7817);
+    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), false));
+    if (cljs.core.truth_(cljs.core._STAR_print_newline_STAR_)) {
+      return cljs.core.newline.call(null, cljs.core.pr_opts.call(null));
+    } else {
+      return 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__7818) {
+    var objs = cljs.core.seq(arglist__7818);
+    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), 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__7819) {
+    var objs = cljs.core.seq(arglist__7819);
+    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));
+    if (cljs.core.truth_(cljs.core._STAR_print_newline_STAR_)) {
+      return cljs.core.newline.call(null, cljs.core.pr_opts.call(null));
+    } else {
+      return 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__7820) {
+    var objs = cljs.core.seq(arglist__7820);
+    return prn__delegate(objs);
+  };
+  prn.cljs$core$IFn$_invoke$arity$variadic = prn__delegate;
+  return prn;
+}();
+cljs.core.print_map = function print_map(m, print_one, writer, opts) {
+  return cljs.core.pr_sequential_writer.call(null, writer, function(e, w, opts__$1) {
+    print_one.call(null, cljs.core.key.call(null, e), w, opts__$1);
+    cljs.core._write.call(null, w, " ");
+    return print_one.call(null, cljs.core.val.call(null, e), w, opts__$1);
+  }, "{", ", ", "}", opts, cljs.core.seq.call(null, m));
+};
+cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
+};
+cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
+};
+cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
+};
+cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#queue [", " ", "]", opts, cljs.core.seq.call(null, coll__$1));
+};
+cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#{", " ", "}", opts, coll__$1);
+};
+cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
+};
+cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
+};
+cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#{", " ", "}", opts, coll__$1);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
+};
+cljs.core.List.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.List.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  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) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
+};
+cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.Range.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.Range.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
+};
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$ = true;
+cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
+  var coll__$1 = this;
+  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
+};
+cljs.core.PersistentVector.prototype.cljs$core$IComparable$ = true;
+cljs.core.PersistentVector.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
+  var x__$1 = this;
+  return cljs.core.compare_indexed.call(null, x__$1, y);
+};
+cljs.core.Subvec.prototype.cljs$core$IComparable$ = true;
+cljs.core.Subvec.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
+  var x__$1 = this;
+  return cljs.core.compare_indexed.call(null, x__$1, y);
+};
+cljs.core.Keyword.prototype.cljs$core$IComparable$ = true;
+cljs.core.Keyword.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
+  var x__$1 = this;
+  return cljs.core.compare_symbols.call(null, x__$1, y);
+};
+cljs.core.Symbol.prototype.cljs$core$IComparable$ = true;
+cljs.core.Symbol.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
+  var x__$1 = this;
+  return cljs.core.compare_symbols.call(null, x__$1, y);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Atom");
+};
+cljs.core.Atom.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = this;
+  return goog.getUid(this$__$1);
+};
+cljs.core.Atom.prototype.cljs$core$IWatchable$_notify_watches$arity$3 = function(this$, oldval, newval) {
+  var self__ = this;
+  var this$__$1 = this;
+  var seq__7821 = cljs.core.seq.call(null, self__.watches);
+  var chunk__7822 = null;
+  var count__7823 = 0;
+  var i__7824 = 0;
+  while (true) {
+    if (i__7824 < count__7823) {
+      var vec__7825 = cljs.core._nth.call(null, chunk__7822, i__7824);
+      var key = cljs.core.nth.call(null, vec__7825, 0, null);
+      var f = cljs.core.nth.call(null, vec__7825, 1, null);
+      f.call(null, key, this$__$1, oldval, newval);
+      var G__7827 = seq__7821;
+      var G__7828 = chunk__7822;
+      var G__7829 = count__7823;
+      var G__7830 = i__7824 + 1;
+      seq__7821 = G__7827;
+      chunk__7822 = G__7828;
+      count__7823 = G__7829;
+      i__7824 = G__7830;
+      continue;
+    } else {
+      var temp__4092__auto__ = cljs.core.seq.call(null, seq__7821);
+      if (temp__4092__auto__) {
+        var seq__7821__$1 = temp__4092__auto__;
+        if (cljs.core.chunked_seq_QMARK_.call(null, seq__7821__$1)) {
+          var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__7821__$1);
+          var G__7831 = cljs.core.chunk_rest.call(null, seq__7821__$1);
+          var G__7832 = c__4132__auto__;
+          var G__7833 = cljs.core.count.call(null, c__4132__auto__);
+          var G__7834 = 0;
+          seq__7821 = G__7831;
+          chunk__7822 = G__7832;
+          count__7823 = G__7833;
+          i__7824 = G__7834;
+          continue;
+        } else {
+          var vec__7826 = cljs.core.first.call(null, seq__7821__$1);
+          var key = cljs.core.nth.call(null, vec__7826, 0, null);
+          var f = cljs.core.nth.call(null, vec__7826, 1, null);
+          f.call(null, key, this$__$1, oldval, newval);
+          var G__7835 = cljs.core.next.call(null, seq__7821__$1);
+          var G__7836 = null;
+          var G__7837 = 0;
+          var G__7838 = 0;
+          seq__7821 = G__7835;
+          chunk__7822 = G__7836;
+          count__7823 = G__7837;
+          i__7824 = G__7838;
+          continue;
+        }
+      } else {
+        return null;
+      }
+    }
+    break;
+  }
+};
+cljs.core.Atom.prototype.cljs$core$IWatchable$_add_watch$arity$3 = function(this$, key, f) {
+  var self__ = this;
+  var this$__$1 = this;
+  return this$__$1.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;
+  var this$__$1 = this;
+  return this$__$1.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;
+  var a__$1 = this;
+  cljs.core._write.call(null, writer, "#\x3cAtom: ");
+  cljs.core.pr_writer.call(null, self__.state, writer, opts);
+  return cljs.core._write.call(null, writer, "\x3e");
+};
+cljs.core.Atom.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.meta;
+};
+cljs.core.Atom.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return self__.state;
+};
+cljs.core.Atom.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
+  var self__ = this;
+  var o__$1 = this;
+  return o__$1 === other;
+};
+cljs.core.__GT_Atom = function __GT_Atom(state, meta, validator, watches) {
+  return new cljs.core.Atom(state, meta, validator, watches);
+};
+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__7842__delegate = function(x, p__7839) {
+      var map__7841 = p__7839;
+      var map__7841__$1 = cljs.core.seq_QMARK_.call(null, map__7841) ? cljs.core.apply.call(null, cljs.core.hash_map, map__7841) : map__7841;
+      var validator = cljs.core.get.call(null, map__7841__$1, new cljs.core.Keyword(null, "validator", "validator", 4199087812));
+      var meta = cljs.core.get.call(null, map__7841__$1, new cljs.core.Keyword(null, "meta", "meta", 1017252215));
+      return new cljs.core.Atom(x, meta, validator, null);
+    };
+    var G__7842 = function(x, var_args) {
+      var p__7839 = null;
+      if (arguments.length > 1) {
+        p__7839 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
+      }
+      return G__7842__delegate.call(this, x, p__7839);
+    };
+    G__7842.cljs$lang$maxFixedArity = 1;
+    G__7842.cljs$lang$applyTo = function(arglist__7843) {
+      var x = cljs.core.first(arglist__7843);
+      var p__7839 = cljs.core.rest(arglist__7843);
+      return G__7842__delegate(x, p__7839);
+    };
+    G__7842.cljs$core$IFn$_invoke$arity$variadic = G__7842__delegate;
+    return G__7842;
+  }();
+  atom = function(x, var_args) {
+    var p__7839 = 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 validate_7844 = a.validator;
+  if (validate_7844 == null) {
+  } else {
+    if (cljs.core.truth_(validate_7844.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.list(new cljs.core.Symbol(null, "validate", "validate", 1233162959, null), new cljs.core.Symbol(null, "new-value", "new-value", 972165309, null))))].join(""));
+    }
+  }
+  var old_value_7845 = a.state;
+  a.state = new_value;
+  if (a.watches == null) {
+  } else {
+    cljs.core._notify_watches.call(null, a, old_value_7845, 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__7846__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__7846 = 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__7846__delegate.call(this, a, f, x, y, z, more);
+    };
+    G__7846.cljs$lang$maxFixedArity = 5;
+    G__7846.cljs$lang$applyTo = function(arglist__7847) {
+      var a = cljs.core.first(arglist__7847);
+      arglist__7847 = cljs.core.next(arglist__7847);
+      var f = cljs.core.first(arglist__7847);
+      arglist__7847 = cljs.core.next(arglist__7847);
+      var x = cljs.core.first(arglist__7847);
+      arglist__7847 = cljs.core.next(arglist__7847);
+      var y = cljs.core.first(arglist__7847);
+      arglist__7847 = cljs.core.next(arglist__7847);
+      var z = cljs.core.first(arglist__7847);
+      var more = cljs.core.rest(arglist__7847);
+      return G__7846__delegate(a, f, x, y, z, more);
+    };
+    G__7846.cljs$core$IFn$_invoke$arity$variadic = G__7846__delegate;
+    return G__7846;
+  }();
+  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__7848) {
+    var iref = cljs.core.first(arglist__7848);
+    arglist__7848 = cljs.core.next(arglist__7848);
+    var f = cljs.core.first(arglist__7848);
+    var args = cljs.core.rest(arglist__7848);
+    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;
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Delay");
+};
+cljs.core.Delay.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = function(d) {
+  var self__ = this;
+  var d__$1 = this;
+  return(new cljs.core.Keyword(null, "done", "done", 1016993524)).cljs$core$IFn$_invoke$arity$1(cljs.core.deref.call(null, self__.state));
+};
+cljs.core.Delay.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
+  var self__ = this;
+  var ___$1 = this;
+  return(new cljs.core.Keyword(null, "value", "value", 1125876963)).cljs$core$IFn$_invoke$arity$1(cljs.core.swap_BANG_.call(null, self__.state, function(p__7849) {
+    var map__7850 = p__7849;
+    var map__7850__$1 = cljs.core.seq_QMARK_.call(null, map__7850) ? cljs.core.apply.call(null, cljs.core.hash_map, map__7850) : map__7850;
+    var curr_state = map__7850__$1;
+    var done = cljs.core.get.call(null, map__7850__$1, new cljs.core.Keyword(null, "done", "done", 1016993524));
+    if (cljs.core.truth_(done)) {
+      return curr_state;
+    } else {
+      return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "done", "done", 1016993524), true, new cljs.core.Keyword(null, "value", "value", 1125876963), self__.f.call(null)], null);
+    }
+  }));
+};
+cljs.core.__GT_Delay = function __GT_Delay(state, f) {
+  return new cljs.core.Delay(state, f);
+};
+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 = function() {
+  var obj7852 = {};
+  return obj7852;
+}();
+cljs.core._clj__GT_js = function _clj__GT_js(x) {
+  if (function() {
+    var and__3396__auto__ = x;
+    if (and__3396__auto__) {
+      return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x);
+  } else {
+    var x__4011__auto__ = x == null ? null : x;
+    return function() {
+      var or__3408__auto__ = cljs.core._clj__GT_js[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._clj__GT_js["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IEncodeJS.-clj-\x3ejs", x);
+        }
+      }
+    }().call(null, x);
+  }
+};
+cljs.core._key__GT_js = function _key__GT_js(x) {
+  if (function() {
+    var and__3396__auto__ = x;
+    if (and__3396__auto__) {
+      return x.cljs$core$IEncodeJS$_key__GT_js$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x);
+  } else {
+    var x__4011__auto__ = x == null ? null : x;
+    return function() {
+      var or__3408__auto__ = cljs.core._key__GT_js[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._key__GT_js["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IEncodeJS.-key-\x3ejs", x);
+        }
+      }
+    }().call(null, x);
+  }
+};
+cljs.core.key__GT_js = function key__GT_js(k) {
+  if (function() {
+    var G__7854 = k;
+    if (G__7854) {
+      var bit__4034__auto__ = null;
+      if (cljs.core.truth_(function() {
+        var or__3408__auto__ = bit__4034__auto__;
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          return G__7854.cljs$core$IEncodeJS$;
+        }
+      }())) {
+        return true;
+      } else {
+        if (!G__7854.cljs$lang$protocol_mask$partition$) {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7854);
+        } else {
+          return false;
+        }
+      }
+    } else {
+      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7854);
+    }
+  }()) {
+    return cljs.core._clj__GT_js.call(null, k);
+  } else {
+    if (typeof k === "string" || (typeof k === "number" || (k instanceof cljs.core.Keyword || 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__7868 = x;
+      if (G__7868) {
+        var bit__4034__auto__ = null;
+        if (cljs.core.truth_(function() {
+          var or__3408__auto__ = bit__4034__auto__;
+          if (cljs.core.truth_(or__3408__auto__)) {
+            return or__3408__auto__;
+          } else {
+            return G__7868.cljs$core$IEncodeJS$;
+          }
+        }())) {
+          return true;
+        } else {
+          if (!G__7868.cljs$lang$protocol_mask$partition$) {
+            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7868);
+          } else {
+            return false;
+          }
+        }
+      } else {
+        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7868);
+      }
+    }()) {
+      return cljs.core._clj__GT_js.call(null, x);
+    } else {
+      if (x instanceof cljs.core.Keyword) {
+        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 = function() {
+              var obj7870 = {};
+              return obj7870;
+            }();
+            var seq__7871_7881 = cljs.core.seq.call(null, x);
+            var chunk__7872_7882 = null;
+            var count__7873_7883 = 0;
+            var i__7874_7884 = 0;
+            while (true) {
+              if (i__7874_7884 < count__7873_7883) {
+                var vec__7875_7885 = cljs.core._nth.call(null, chunk__7872_7882, i__7874_7884);
+                var k_7886 = cljs.core.nth.call(null, vec__7875_7885, 0, null);
+                var v_7887 = cljs.core.nth.call(null, vec__7875_7885, 1, null);
+                m[cljs.core.key__GT_js.call(null, k_7886)] = clj__GT_js.call(null, v_7887);
+                var G__7888 = seq__7871_7881;
+                var G__7889 = chunk__7872_7882;
+                var G__7890 = count__7873_7883;
+                var G__7891 = i__7874_7884 + 1;
+                seq__7871_7881 = G__7888;
+                chunk__7872_7882 = G__7889;
+                count__7873_7883 = G__7890;
+                i__7874_7884 = G__7891;
+                continue;
+              } else {
+                var temp__4092__auto___7892 = cljs.core.seq.call(null, seq__7871_7881);
+                if (temp__4092__auto___7892) {
+                  var seq__7871_7893__$1 = temp__4092__auto___7892;
+                  if (cljs.core.chunked_seq_QMARK_.call(null, seq__7871_7893__$1)) {
+                    var c__4132__auto___7894 = cljs.core.chunk_first.call(null, seq__7871_7893__$1);
+                    var G__7895 = cljs.core.chunk_rest.call(null, seq__7871_7893__$1);
+                    var G__7896 = c__4132__auto___7894;
+                    var G__7897 = cljs.core.count.call(null, c__4132__auto___7894);
+                    var G__7898 = 0;
+                    seq__7871_7881 = G__7895;
+                    chunk__7872_7882 = G__7896;
+                    count__7873_7883 = G__7897;
+                    i__7874_7884 = G__7898;
+                    continue;
+                  } else {
+                    var vec__7876_7899 = cljs.core.first.call(null, seq__7871_7893__$1);
+                    var k_7900 = cljs.core.nth.call(null, vec__7876_7899, 0, null);
+                    var v_7901 = cljs.core.nth.call(null, vec__7876_7899, 1, null);
+                    m[cljs.core.key__GT_js.call(null, k_7900)] = clj__GT_js.call(null, v_7901);
+                    var G__7902 = cljs.core.next.call(null, seq__7871_7893__$1);
+                    var G__7903 = null;
+                    var G__7904 = 0;
+                    var G__7905 = 0;
+                    seq__7871_7881 = G__7902;
+                    chunk__7872_7882 = G__7903;
+                    count__7873_7883 = G__7904;
+                    i__7874_7884 = G__7905;
+                    continue;
+                  }
+                } else {
+                }
+              }
+              break;
+            }
+            return m;
+          } else {
+            if (cljs.core.coll_QMARK_.call(null, x)) {
+              var arr = [];
+              var seq__7877_7906 = cljs.core.seq.call(null, cljs.core.map.call(null, clj__GT_js, x));
+              var chunk__7878_7907 = null;
+              var count__7879_7908 = 0;
+              var i__7880_7909 = 0;
+              while (true) {
+                if (i__7880_7909 < count__7879_7908) {
+                  var x_7910__$1 = cljs.core._nth.call(null, chunk__7878_7907, i__7880_7909);
+                  arr.push(x_7910__$1);
+                  var G__7911 = seq__7877_7906;
+                  var G__7912 = chunk__7878_7907;
+                  var G__7913 = count__7879_7908;
+                  var G__7914 = i__7880_7909 + 1;
+                  seq__7877_7906 = G__7911;
+                  chunk__7878_7907 = G__7912;
+                  count__7879_7908 = G__7913;
+                  i__7880_7909 = G__7914;
+                  continue;
+                } else {
+                  var temp__4092__auto___7915 = cljs.core.seq.call(null, seq__7877_7906);
+                  if (temp__4092__auto___7915) {
+                    var seq__7877_7916__$1 = temp__4092__auto___7915;
+                    if (cljs.core.chunked_seq_QMARK_.call(null, seq__7877_7916__$1)) {
+                      var c__4132__auto___7917 = cljs.core.chunk_first.call(null, seq__7877_7916__$1);
+                      var G__7918 = cljs.core.chunk_rest.call(null, seq__7877_7916__$1);
+                      var G__7919 = c__4132__auto___7917;
+                      var G__7920 = cljs.core.count.call(null, c__4132__auto___7917);
+                      var G__7921 = 0;
+                      seq__7877_7906 = G__7918;
+                      chunk__7878_7907 = G__7919;
+                      count__7879_7908 = G__7920;
+                      i__7880_7909 = G__7921;
+                      continue;
+                    } else {
+                      var x_7922__$1 = cljs.core.first.call(null, seq__7877_7916__$1);
+                      arr.push(x_7922__$1);
+                      var G__7923 = cljs.core.next.call(null, seq__7877_7916__$1);
+                      var G__7924 = null;
+                      var G__7925 = 0;
+                      var G__7926 = 0;
+                      seq__7877_7906 = G__7923;
+                      chunk__7878_7907 = G__7924;
+                      count__7879_7908 = G__7925;
+                      i__7880_7909 = G__7926;
+                      continue;
+                    }
+                  } else {
+                  }
+                }
+                break;
+              }
+              return arr;
+            } else {
+              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                return x;
+              } else {
+                return null;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+cljs.core.IEncodeClojure = function() {
+  var obj7928 = {};
+  return obj7928;
+}();
+cljs.core._js__GT_clj = function _js__GT_clj(x, options) {
+  if (function() {
+    var and__3396__auto__ = x;
+    if (and__3396__auto__) {
+      return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x, options);
+  } else {
+    var x__4011__auto__ = x == null ? null : x;
+    return function() {
+      var or__3408__auto__ = cljs.core._js__GT_clj[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._js__GT_clj["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__auto____$1;
+        } else {
+          throw cljs.core.missing_protocol.call(null, "IEncodeClojure.-js-\x3eclj", 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, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "keywordize-keys", "keywordize-keys", 4191781672), false], null));
+  };
+  var js__GT_clj__2 = function() {
+    var G__7949__delegate = function(x, opts) {
+      if (function() {
+        var G__7939 = x;
+        if (G__7939) {
+          var bit__4034__auto__ = null;
+          if (cljs.core.truth_(function() {
+            var or__3408__auto__ = bit__4034__auto__;
+            if (cljs.core.truth_(or__3408__auto__)) {
+              return or__3408__auto__;
+            } else {
+              return G__7939.cljs$core$IEncodeClojure$;
+            }
+          }())) {
+            return true;
+          } else {
+            if (!G__7939.cljs$lang$protocol_mask$partition$) {
+              return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeClojure, G__7939);
+            } else {
+              return false;
+            }
+          }
+        } else {
+          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeClojure, G__7939);
+        }
+      }()) {
+        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__7940 = opts;
+          var map__7940__$1 = cljs.core.seq_QMARK_.call(null, map__7940) ? cljs.core.apply.call(null, cljs.core.hash_map, map__7940) : map__7940;
+          var keywordize_keys = cljs.core.get.call(null, map__7940__$1, new cljs.core.Keyword(null, "keywordize-keys", "keywordize-keys", 4191781672));
+          var keyfn = cljs.core.truth_(keywordize_keys) ? cljs.core.keyword : cljs.core.str;
+          var f = function(map__7940, map__7940__$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.PersistentArrayMap.EMPTY, function() {
+                        var iter__4101__auto__ = function(map__7940, map__7940__$1, keywordize_keys, keyfn) {
+                          return function iter__7945(s__7946) {
+                            return new cljs.core.LazySeq(null, function(map__7940, map__7940__$1, keywordize_keys, keyfn) {
+                              return function() {
+                                var s__7946__$1 = s__7946;
+                                while (true) {
+                                  var temp__4092__auto__ = cljs.core.seq.call(null, s__7946__$1);
+                                  if (temp__4092__auto__) {
+                                    var s__7946__$2 = temp__4092__auto__;
+                                    if (cljs.core.chunked_seq_QMARK_.call(null, s__7946__$2)) {
+                                      var c__4099__auto__ = cljs.core.chunk_first.call(null, s__7946__$2);
+                                      var size__4100__auto__ = cljs.core.count.call(null, c__4099__auto__);
+                                      var b__7948 = cljs.core.chunk_buffer.call(null, size__4100__auto__);
+                                      if (function() {
+                                        var i__7947 = 0;
+                                        while (true) {
+                                          if (i__7947 < size__4100__auto__) {
+                                            var k = cljs.core._nth.call(null, c__4099__auto__, i__7947);
+                                            cljs.core.chunk_append.call(null, b__7948, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [keyfn.call(null, k), thisfn.call(null, x__$1[k])], null));
+                                            var G__7950 = i__7947 + 1;
+                                            i__7947 = G__7950;
+                                            continue;
+                                          } else {
+                                            return true;
+                                          }
+                                          break;
+                                        }
+                                      }()) {
+                                        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__7948), iter__7945.call(null, cljs.core.chunk_rest.call(null, s__7946__$2)));
+                                      } else {
+                                        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__7948), null);
+                                      }
+                                    } else {
+                                      var k = cljs.core.first.call(null, s__7946__$2);
+                                      return cljs.core.cons.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [keyfn.call(null, k), thisfn.call(null, x__$1[k])], null), iter__7945.call(null, cljs.core.rest.call(null, s__7946__$2)));
+                                    }
+                                  } else {
+                                    return null;
+                                  }
+                                  break;
+                                }
+                              };
+                            }(map__7940, map__7940__$1, keywordize_keys, keyfn), null, null);
+                          };
+                        }(map__7940, map__7940__$1, keywordize_keys, keyfn);
+                        return iter__4101__auto__.call(null, cljs.core.js_keys.call(null, x__$1));
+                      }());
+                    } else {
+                      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+                        return x__$1;
+                      } else {
+                        return null;
+                      }
+                    }
+                  }
+                }
+              }
+            };
+          }(map__7940, map__7940__$1, keywordize_keys, keyfn);
+          return f.call(null, x);
+        } else {
+          return null;
+        }
+      }
+    };
+    var G__7949 = 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__7949__delegate.call(this, x, opts);
+    };
+    G__7949.cljs$lang$maxFixedArity = 1;
+    G__7949.cljs$lang$applyTo = function(arglist__7951) {
+      var x = cljs.core.first(arglist__7951);
+      var opts = cljs.core.rest(arglist__7951);
+      return G__7949__delegate(x, opts);
+    };
+    G__7949.cljs$core$IFn$_invoke$arity$variadic = G__7949__delegate;
+    return G__7949;
+  }();
+  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.PersistentArrayMap.EMPTY);
+  return function() {
+    var G__7952__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__7952 = function(var_args) {
+      var args = null;
+      if (arguments.length > 0) {
+        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+      }
+      return G__7952__delegate.call(this, args);
+    };
+    G__7952.cljs$lang$maxFixedArity = 0;
+    G__7952.cljs$lang$applyTo = function(arglist__7953) {
+      var args = cljs.core.seq(arglist__7953);
+      return G__7952__delegate(args);
+    };
+    G__7952.cljs$core$IFn$_invoke$arity$variadic = G__7952__delegate;
+    return G__7952;
+  }();
+};
+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__7954 = ret;
+        f = G__7954;
+        continue;
+      } else {
+        return ret;
+      }
+      break;
+    }
+  };
+  var trampoline__2 = function() {
+    var G__7955__delegate = function(f, args) {
+      return trampoline.call(null, function() {
+        return cljs.core.apply.call(null, f, args);
+      });
+    };
+    var G__7955 = 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__7955__delegate.call(this, f, args);
+    };
+    G__7955.cljs$lang$maxFixedArity = 1;
+    G__7955.cljs$lang$applyTo = function(arglist__7956) {
+      var f = cljs.core.first(arglist__7956);
+      var args = cljs.core.rest(arglist__7956);
+      return G__7955__delegate(f, args);
+    };
+    G__7955.cljs$core$IFn$_invoke$arity$variadic = G__7955__delegate;
+    return G__7955;
+  }();
+  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.PersistentArrayMap.EMPTY, coll);
+};
+cljs.core.make_hierarchy = function make_hierarchy() {
+  return new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "parents", "parents", 4515496059), cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "descendants", "descendants", 768214664), cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442), cljs.core.PersistentArrayMap.EMPTY], null);
+};
+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__7957) {
+    var f = cljs.core.first(arglist__7957);
+    var args = cljs.core.rest(arglist__7957);
+    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__3408__auto__ = cljs.core._EQ_.call(null, child, parent);
+    if (or__3408__auto__) {
+      return or__3408__auto__;
+    } else {
+      var or__3408__auto____$1 = cljs.core.contains_QMARK_.call(null, (new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(h).call(null, child), parent);
+      if (or__3408__auto____$1) {
+        return or__3408__auto____$1;
+      } else {
+        var and__3396__auto__ = cljs.core.vector_QMARK_.call(null, parent);
+        if (and__3396__auto__) {
+          var and__3396__auto____$1 = cljs.core.vector_QMARK_.call(null, child);
+          if (and__3396__auto____$1) {
+            var and__3396__auto____$2 = cljs.core.count.call(null, parent) === cljs.core.count.call(null, child);
+            if (and__3396__auto____$2) {
+              var ret = true;
+              var i = 0;
+              while (true) {
+                if (!ret || i === cljs.core.count.call(null, parent)) {
+                  return ret;
+                } else {
+                  var G__7958 = isa_QMARK_.call(null, h, child.call(null, i), parent.call(null, i));
+                  var G__7959 = i + 1;
+                  ret = G__7958;
+                  i = G__7959;
+                  continue;
+                }
+                break;
+              }
+            } else {
+              return and__3396__auto____$2;
+            }
+          } else {
+            return and__3396__auto____$1;
+          }
+        } else {
+          return and__3396__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(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(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(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(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(null, "descendants", "descendants", 768214664)).cljs$core$IFn$_invoke$arity$1(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.list(new cljs.core.Symbol(null, "namespace", "namespace", -388313324, null), new cljs.core.Symbol(null, "parent", "parent", 1659011683, null))))].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.list(new cljs.core.Symbol(null, "not\x3d", "not\x3d", -1637144189, null), new cljs.core.Symbol(null, "tag", "tag", -1640416941, null), new cljs.core.Symbol(null, "parent", "parent", 1659011683, null))))].join(""));
+    }
+    var tp = (new cljs.core.Keyword(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(h);
+    var td = (new cljs.core.Keyword(null, "descendants", "descendants", 768214664)).cljs$core$IFn$_invoke$arity$1(h);
+    var ta = (new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(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__3408__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 new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "parents", "parents", 4515496059), cljs.core.assoc.call(null, (new cljs.core.Keyword(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(h), tag, cljs.core.conj.call(null, cljs.core.get.call(null, tp, tag, cljs.core.PersistentHashSet.EMPTY), parent)), new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442), tf.call(null, (new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(h), 
+      tag, td, parent, ta), new cljs.core.Keyword(null, "descendants", "descendants", 768214664), tf.call(null, (new cljs.core.Keyword(null, "descendants", "descendants", 768214664)).cljs$core$IFn$_invoke$arity$1(h), parent, ta, tag, td)], null);
+    }();
+    if (cljs.core.truth_(or__3408__auto__)) {
+      return or__3408__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(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(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__7960_SHARP_) {
+        return cljs.core.cons.call(null, cljs.core.first.call(null, p1__7960_SHARP_), cljs.core.interpose.call(null, cljs.core.first.call(null, p1__7960_SHARP_), cljs.core.second.call(null, p1__7960_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__7961_SHARP_, p2__7962_SHARP_) {
+        return cljs.core.apply.call(null, cljs.core.derive, p1__7961_SHARP_, p2__7962_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__3408__auto__ = cljs.core.truth_(function() {
+    var and__3396__auto__ = xprefs;
+    if (cljs.core.truth_(and__3396__auto__)) {
+      return xprefs.call(null, y);
+    } else {
+      return and__3396__auto__;
+    }
+  }()) ? true : null;
+  if (cljs.core.truth_(or__3408__auto__)) {
+    return or__3408__auto__;
+  } else {
+    var or__3408__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__7963 = cljs.core.rest.call(null, ps);
+          ps = G__7963;
+          continue;
+        } else {
+          return null;
+        }
+        break;
+      }
+    }();
+    if (cljs.core.truth_(or__3408__auto____$1)) {
+      return or__3408__auto____$1;
+    } else {
+      var or__3408__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__7964 = cljs.core.rest.call(null, ps);
+            ps = G__7964;
+            continue;
+          } else {
+            return null;
+          }
+          break;
+        }
+      }();
+      if (cljs.core.truth_(or__3408__auto____$2)) {
+        return or__3408__auto____$2;
+      } else {
+        return false;
+      }
+    }
+  }
+};
+cljs.core.dominates = function dominates(x, y, prefer_table) {
+  var or__3408__auto__ = cljs.core.prefers_STAR_.call(null, x, y, prefer_table);
+  if (cljs.core.truth_(or__3408__auto__)) {
+    return or__3408__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__7967) {
+    var vec__7968 = p__7967;
+    var k = cljs.core.nth.call(null, vec__7968, 0, null);
+    var _ = cljs.core.nth.call(null, vec__7968, 1, null);
+    var e = vec__7968;
+    if (cljs.core.isa_QMARK_.call(null, cljs.core.deref.call(null, hierarchy), dispatch_val, k)) {
+      var be2 = cljs.core.truth_(function() {
+        var or__3408__auto__ = be == null;
+        if (or__3408__auto__) {
+          return or__3408__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(" -\x3e "), 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 = function() {
+  var obj7970 = {};
+  return obj7970;
+}();
+cljs.core._reset = function _reset(mf) {
+  if (function() {
+    var and__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_reset$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_reset$arity$1(mf);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._reset[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._reset["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_add_method$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_add_method$arity$3(mf, dispatch_val, method);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._add_method[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._add_method["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_remove_method$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf, dispatch_val);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._remove_method[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._remove_method["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_prefer_method$arity$3;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf, dispatch_val, dispatch_val_y);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._prefer_method[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._prefer_method["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_get_method$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_get_method$arity$2(mf, dispatch_val);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._get_method[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._get_method["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_methods$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_methods$arity$1(mf);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._methods[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._methods["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_prefers$arity$1;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_prefers$arity$1(mf);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._prefers[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._prefers["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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__3396__auto__ = mf;
+    if (and__3396__auto__) {
+      return mf.cljs$core$IMultiFn$_dispatch$arity$2;
+    } else {
+      return and__3396__auto__;
+    }
+  }()) {
+    return mf.cljs$core$IMultiFn$_dispatch$arity$2(mf, args);
+  } else {
+    var x__4011__auto__ = mf == null ? null : mf;
+    return function() {
+      var or__3408__auto__ = cljs.core._dispatch[goog.typeOf(x__4011__auto__)];
+      if (or__3408__auto__) {
+        return or__3408__auto__;
+      } else {
+        var or__3408__auto____$1 = cljs.core._dispatch["_"];
+        if (or__3408__auto____$1) {
+          return or__3408__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, name, 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(name), cljs.core.str("' for dispatch value: "), cljs.core.str(dispatch_val)].join(""));
+  }
+  return cljs.core.apply.call(null, target_fn, args);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/MultiFn");
+};
+cljs.core.MultiFn.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = this;
+  return goog.getUid(this$__$1);
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_reset$arity$1 = function(mf) {
+  var self__ = this;
+  var mf__$1 = this;
+  cljs.core.swap_BANG_.call(null, self__.method_table, function(mf__$2) {
+    return cljs.core.PersistentArrayMap.EMPTY;
+  });
+  cljs.core.swap_BANG_.call(null, self__.method_cache, function(mf__$2) {
+    return cljs.core.PersistentArrayMap.EMPTY;
+  });
+  cljs.core.swap_BANG_.call(null, self__.prefer_table, function(mf__$2) {
+    return cljs.core.PersistentArrayMap.EMPTY;
+  });
+  cljs.core.swap_BANG_.call(null, self__.cached_hierarchy, function(mf__$2) {
+    return null;
+  });
+  return mf__$1;
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_add_method$arity$3 = function(mf, dispatch_val, method) {
+  var self__ = this;
+  var mf__$1 = 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__$1;
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_remove_method$arity$2 = function(mf, dispatch_val) {
+  var self__ = this;
+  var mf__$1 = 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__$1;
+};
+cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_get_method$arity$2 = function(mf, dispatch_val) {
+  var self__ = this;
+  var mf__$1 = 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;
+  var mf__$1 = 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;
+  var mf__$1 = 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;
+  var mf__$1 = 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;
+  var mf__$1 = this;
+  return cljs.core.do_dispatch.call(null, mf__$1, self__.name, self__.dispatch_fn, args);
+};
+cljs.core.__GT_MultiFn = function __GT_MultiFn(name, dispatch_fn, default_dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy) {
+  return new cljs.core.MultiFn(name, dispatch_fn, default_dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy);
+};
+cljs.core.MultiFn.prototype.call = function() {
+  var G__7971__delegate = function(_, args) {
+    var self = this;
+    return cljs.core._dispatch.call(null, self, args);
+  };
+  var G__7971 = function(_, var_args) {
+    var args = null;
+    if (arguments.length > 1) {
+      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
+    }
+    return G__7971__delegate.call(this, _, args);
+  };
+  G__7971.cljs$lang$maxFixedArity = 1;
+  G__7971.cljs$lang$applyTo = function(arglist__7972) {
+    var _ = cljs.core.first(arglist__7972);
+    var args = cljs.core.rest(arglist__7972);
+    return G__7971__delegate(_, args);
+  };
+  G__7971.cljs$core$IFn$_invoke$arity$variadic = G__7971__delegate;
+  return G__7971;
+}();
+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);
+};
+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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
+  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/UUID");
+};
+cljs.core.UUID.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
+  var self__ = this;
+  var this$__$1 = this;
+  return goog.string.hashCode(cljs.core.pr_str.call(null, this$__$1));
+};
+cljs.core.UUID.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(_, writer, ___$1) {
+  var self__ = this;
+  var ___$2 = 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 ___$1 = this;
+  return other instanceof cljs.core.UUID && self__.uuid === other.uuid;
+};
+cljs.core.__GT_UUID = function __GT_UUID(uuid) {
+  return new cljs.core.UUID(uuid);
+};
+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__3955__auto__, writer__3956__auto__, opts__3957__auto__) {
+  return cljs.core._write.call(null, writer__3956__auto__, "cljs.core/ExceptionInfo");
+};
+cljs.core.__GT_ExceptionInfo = function __GT_ExceptionInfo(message, data, cause) {
+  return new cljs.core.ExceptionInfo(message, data, cause);
+};
+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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          return 0;
+        } else {
+          return null;
+        }
+      }
+    }
+  };
+};
+cljs.core.special_symbol_QMARK_ = function special_symbol_QMARK_(x) {
+  return cljs.core.contains_QMARK_.call(null, new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 19, [new cljs.core.Symbol(null, "deftype*", "deftype*", -978581244, null), null, new cljs.core.Symbol(null, "new", "new", -1640422567, null), null, new cljs.core.Symbol(null, "quote", "quote", -1532577739, null), null, new cljs.core.Symbol(null, "\x26", "\x26", -1640531489, null), null, new cljs.core.Symbol(null, "set!", "set!", -1637004872, null), null, new cljs.core.Symbol(null, 
+  "recur", "recur", -1532142362, null), null, new cljs.core.Symbol(null, ".", ".", -1640531481, null), null, new cljs.core.Symbol(null, "ns", "ns", -1640528002, null), null, new cljs.core.Symbol(null, "do", "do", -1640528316, null), null, new cljs.core.Symbol(null, "fn*", "fn*", -1640430053, null), null, new cljs.core.Symbol(null, "throw", "throw", -1530191713, null), null, new cljs.core.Symbol(null, "letfn*", "letfn*", 1548249632, null), null, new cljs.core.Symbol(null, "js*", "js*", -1640426054, 
+  null), null, new cljs.core.Symbol(null, "defrecord*", "defrecord*", 774272013, null), null, new cljs.core.Symbol(null, "let*", "let*", -1637213400, null), null, new cljs.core.Symbol(null, "loop*", "loop*", -1537374273, null), null, new cljs.core.Symbol(null, "try", "try", -1640416396, null), null, new cljs.core.Symbol(null, "if", "if", -1640528170, null), null, new cljs.core.Symbol(null, "def", "def", -1640432194, null), null], null), null), x);
+};
+goog.provide("nonaga.setup");
+goog.require("cljs.core");
+nonaga.setup.set_pre_BANG_ = function set_pre_BANG_(output) {
+  var new_text = document.createTextNode(output);
+  var output__$1 = document.getElementById("test-output");
+  return output__$1.appendChild(new_text);
+};
+cljs.core.set_print_fn_BANG_.call(null, function(p1__5232_SHARP_) {
+  return nonaga.setup.set_pre_BANG_.call(null, p1__5232_SHARP_);
+});
+goog.provide("nonaga.rules.coord");
+goog.require("cljs.core");
+nonaga.rules.coord.nw = function nw(p__19832) {
+  var vec__19834 = p__19832;
+  var x = cljs.core.nth.call(null, vec__19834, 0, null);
+  var y = cljs.core.nth.call(null, vec__19834, 1, null);
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.odd_QMARK_.call(null, y) ? x : x - 1, y + 1], null);
+};
+nonaga.rules.coord.ne = function ne(p__19835) {
+  var vec__19837 = p__19835;
+  var x = cljs.core.nth.call(null, vec__19837, 0, null);
+  var y = cljs.core.nth.call(null, vec__19837, 1, null);
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.even_QMARK_.call(null, y) ? x : x + 1, y + 1], null);
+};
+nonaga.rules.coord.w = function w(p__19838) {
+  var vec__19840 = p__19838;
+  var x = cljs.core.nth.call(null, vec__19840, 0, null);
+  var y = cljs.core.nth.call(null, vec__19840, 1, null);
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [x - 1, y], null);
+};
+nonaga.rules.coord.e = function e(p__19841) {
+  var vec__19843 = p__19841;
+  var x = cljs.core.nth.call(null, vec__19843, 0, null);
+  var y = cljs.core.nth.call(null, vec__19843, 1, null);
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [x + 1, y], null);
+};
+nonaga.rules.coord.sw = function sw(p__19844) {
+  var vec__19846 = p__19844;
+  var x = cljs.core.nth.call(null, vec__19846, 0, null);
+  var y = cljs.core.nth.call(null, vec__19846, 1, null);
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.odd_QMARK_.call(null, y) ? x : x - 1, y - 1], null);
+};
+nonaga.rules.coord.se = function se(p__19847) {
+  var vec__19849 = p__19847;
+  var x = cljs.core.nth.call(null, vec__19849, 0, null);
+  var y = cljs.core.nth.call(null, vec__19849, 1, null);
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.even_QMARK_.call(null, y) ? x : x + 1, y - 1], null);
+};
+nonaga.rules.coord.directions = new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.nw, nonaga.rules.coord.ne, nonaga.rules.coord.e, nonaga.rules.coord.se, nonaga.rules.coord.sw, nonaga.rules.coord.w], null);
+nonaga.rules.coord.side_by_side_directions = new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.nw, nonaga.rules.coord.ne], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.ne, nonaga.rules.coord.e], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.e, 
+nonaga.rules.coord.se], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.se, nonaga.rules.coord.sw], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.sw, nonaga.rules.coord.w], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.w, nonaga.rules.coord.nw], null)], null);
+nonaga.rules.coord.neighbouring_directions = new cljs.core.PersistentArrayMap.fromArray([nonaga.rules.coord.nw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.ne, nonaga.rules.coord.w], null), nonaga.rules.coord.ne, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.nw, nonaga.rules.coord.e], null), nonaga.rules.coord.w, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[nonaga.rules.coord.nw, nonaga.rules.coord.sw], null), nonaga.rules.coord.e, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.ne, nonaga.rules.coord.se], null), nonaga.rules.coord.sw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.se, nonaga.rules.coord.w], null), nonaga.rules.coord.se, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.sw, 
+nonaga.rules.coord.e], null)], true, false);
+nonaga.rules.coord.neighbours = function neighbours(cell) {
+  return cljs.core.into.call(null, cljs.core.PersistentHashSet.EMPTY, cljs.core.apply.call(null, cljs.core.juxt, nonaga.rules.coord.directions).call(null, cell));
+};
+nonaga.rules.coord.distance = function distance(p__19850, p__19851) {
+  var vec__19854 = p__19850;
+  var x1 = cljs.core.nth.call(null, vec__19854, 0, null);
+  var y1 = cljs.core.nth.call(null, vec__19854, 1, null);
+  var vec__19855 = p__19851;
+  var x2 = cljs.core.nth.call(null, vec__19855, 0, null);
+  var y2 = cljs.core.nth.call(null, vec__19855, 1, null);
+  var xdiff = Math.abs.call(null, x1 - x2);
+  var ydiff = Math.abs.call(null, y1 - y2);
+  var halfy = ydiff / 2 | 0;
+  if (xdiff > halfy) {
+    return xdiff + halfy;
+  } else {
+    return ydiff;
+  }
+};
+nonaga.rules.coord.tag_with_distance = function tag_with_distance(destination, source) {
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.distance.call(null, source, destination), source], null);
+};
+goog.provide("nonaga.rules.ball");
+goog.require("cljs.core");
+goog.require("nonaga.rules.coord");
+goog.require("nonaga.rules.coord");
+nonaga.rules.ball.invalid_space_QMARK_ = function invalid_space_QMARK_(p__6589, coord) {
+  var map__6591 = p__6589;
+  var map__6591__$1 = cljs.core.seq_QMARK_.call(null, map__6591) ? cljs.core.apply.call(null, cljs.core.hash_map, map__6591) : map__6591;
+  var blue = cljs.core.get.call(null, map__6591__$1, new cljs.core.Keyword(null, "blue", "blue", 1016931276));
+  var red = cljs.core.get.call(null, map__6591__$1, new cljs.core.Keyword(null, "red", "red", 1014017027));
+  var rings = cljs.core.get.call(null, map__6591__$1, new cljs.core.Keyword(null, "rings", "rings", 1122422709));
+  return cljs.core.not.call(null, function() {
+    var and__3396__auto__ = rings.call(null, coord);
+    if (cljs.core.truth_(and__3396__auto__)) {
+      return cljs.core.not.call(null, function() {
+        var or__3408__auto__ = red.call(null, coord);
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          return blue.call(null, coord);
+        }
+      }());
+    } else {
+      return and__3396__auto__;
+    }
+  }());
+};
+nonaga.rules.ball.move = function move(board, coord, direction) {
+  return cljs.core.first.call(null, function() {
+    var iter__4101__auto__ = function iter__6596(s__6597) {
+      return new cljs.core.LazySeq(null, function() {
+        var s__6597__$1 = s__6597;
+        while (true) {
+          var temp__4092__auto__ = cljs.core.seq.call(null, s__6597__$1);
+          if (temp__4092__auto__) {
+            var s__6597__$2 = temp__4092__auto__;
+            if (cljs.core.chunked_seq_QMARK_.call(null, s__6597__$2)) {
+              var c__4099__auto__ = cljs.core.chunk_first.call(null, s__6597__$2);
+              var size__4100__auto__ = cljs.core.count.call(null, c__4099__auto__);
+              var b__6599 = cljs.core.chunk_buffer.call(null, size__4100__auto__);
+              if (function() {
+                var i__6598 = 0;
+                while (true) {
+                  if (i__6598 < size__4100__auto__) {
+                    var step = cljs.core._nth.call(null, c__4099__auto__, i__6598);
+                    if (nonaga.rules.ball.invalid_space_QMARK_.call(null, board, direction.call(null, step))) {
+                      cljs.core.chunk_append.call(null, b__6599, step);
+                      var G__6600 = i__6598 + 1;
+                      i__6598 = G__6600;
+                      continue;
+                    } else {
+                      var G__6601 = i__6598 + 1;
+                      i__6598 = G__6601;
+                      continue;
+                    }
+                  } else {
+                    return true;
+                  }
+                  break;
+                }
+              }()) {
+                return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__6599), iter__6596.call(null, cljs.core.chunk_rest.call(null, s__6597__$2)));
+              } else {
+                return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__6599), null);
+              }
+            } else {
+              var step = cljs.core.first.call(null, s__6597__$2);
+              if (nonaga.rules.ball.invalid_space_QMARK_.call(null, board, direction.call(null, step))) {
+                return cljs.core.cons.call(null, step, iter__6596.call(null, cljs.core.rest.call(null, s__6597__$2)));
+              } else {
+                var G__6602 = cljs.core.rest.call(null, s__6597__$2);
+                s__6597__$1 = G__6602;
+                continue;
+              }
+            }
+          } else {
+            return null;
+          }
+          break;
+        }
+      }, null, null);
+    };
+    return iter__4101__auto__.call(null, cljs.core.iterate.call(null, direction, coord));
+  }());
+};
+nonaga.rules.ball.valid_destinations = function valid_destinations(board, coord) {
+  return cljs.core.disj.call(null, cljs.core.into.call(null, cljs.core.PersistentHashSet.EMPTY, cljs.core.map.call(null, cljs.core.partial.call(null, nonaga.rules.ball.move, board, coord), nonaga.rules.coord.directions)), coord);
+};
+goog.provide("nonaga.core");
+goog.require("cljs.core");
+nonaga.core.initial_game = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, 
+cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), 
+cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
+nonaga.core.enclosing_ring = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 
+5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), 
+new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
+nonaga.core.move_ball = function move_ball(game, color, from, to) {
+  return cljs.core.update_in.call(null, game, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [color], null), function(p1__20842_SHARP_) {
+    return cljs.core.conj.call(null, cljs.core.disj.call(null, p1__20842_SHARP_, from), to);
+  });
+};
+nonaga.core.move_ring = function move_ring(game, from, to) {
+  return cljs.core.update_in.call(null, game, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "rings", "rings", 1122422709)], null), function(p1__20843_SHARP_) {
+    return cljs.core.conj.call(null, cljs.core.disj.call(null, p1__20843_SHARP_, from), to);
+  });
+};
+goog.provide("clojure.string");
+goog.require("cljs.core");
+goog.require("goog.string.StringBuffer");
+goog.require("goog.string.StringBuffer");
+goog.require("goog.string");
+goog.require("goog.string");
+clojure.string.seq_reverse = function seq_reverse(coll) {
+  return cljs.core.reduce.call(null, cljs.core.conj, cljs.core.List.EMPTY, coll);
+};
+clojure.string.reverse = function reverse(s) {
+  return s.split("").reverse().join("");
+};
+clojure.string.replace = function replace(s, match, replacement) {
+  if (typeof match === "string") {
+    return s.replace(new RegExp(goog.string.regExpEscape(match), "g"), replacement);
+  } else {
+    if (cljs.core.truth_(match.hasOwnProperty("source"))) {
+      return s.replace(new RegExp(match.source, "g"), replacement);
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw[cljs.core.str("Invalid match arg: "), cljs.core.str(match)].join("");
+      } else {
+        return null;
+      }
+    }
+  }
+};
+clojure.string.replace_first = function replace_first(s, match, replacement) {
+  return s.replace(match, replacement);
+};
+clojure.string.join = function() {
+  var join = null;
+  var join__1 = function(coll) {
+    return cljs.core.apply.call(null, cljs.core.str, coll);
+  };
+  var join__2 = function(separator, coll) {
+    return cljs.core.apply.call(null, cljs.core.str, cljs.core.interpose.call(null, separator, coll));
+  };
+  join = function(separator, coll) {
+    switch(arguments.length) {
+      case 1:
+        return join__1.call(this, separator);
+      case 2:
+        return join__2.call(this, separator, coll);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  join.cljs$core$IFn$_invoke$arity$1 = join__1;
+  join.cljs$core$IFn$_invoke$arity$2 = join__2;
+  return join;
+}();
+clojure.string.upper_case = function upper_case(s) {
+  return s.toUpperCase();
+};
+clojure.string.lower_case = function lower_case(s) {
+  return s.toLowerCase();
+};
+clojure.string.capitalize = function capitalize(s) {
+  if (cljs.core.count.call(null, s) < 2) {
+    return clojure.string.upper_case.call(null, s);
+  } else {
+    return[cljs.core.str(clojure.string.upper_case.call(null, cljs.core.subs.call(null, s, 0, 1))), cljs.core.str(clojure.string.lower_case.call(null, cljs.core.subs.call(null, s, 1)))].join("");
+  }
+};
+clojure.string.pop_last_while_empty = function pop_last_while_empty(v) {
+  var v__$1 = v;
+  while (true) {
+    if (cljs.core._EQ_.call(null, "", cljs.core.peek.call(null, v__$1))) {
+      var G__8049 = cljs.core.pop.call(null, v__$1);
+      v__$1 = G__8049;
+      continue;
+    } else {
+      return v__$1;
+    }
+    break;
+  }
+};
+clojure.string.discard_trailing_if_needed = function discard_trailing_if_needed(limit, v) {
+  if (cljs.core._EQ_.call(null, 0, limit)) {
+    return clojure.string.pop_last_while_empty.call(null, v);
+  } else {
+    return v;
+  }
+};
+clojure.string.split_with_empty_regex = function split_with_empty_regex(s, limit) {
+  if (limit <= 0 || limit >= 2 + cljs.core.count.call(null, s)) {
+    return cljs.core.conj.call(null, cljs.core.vec.call(null, cljs.core.cons.call(null, "", cljs.core.map.call(null, cljs.core.str, cljs.core.seq.call(null, s)))), "");
+  } else {
+    var pred__8053 = cljs.core._EQ_;
+    var expr__8054 = limit;
+    if (cljs.core.truth_(pred__8053.call(null, 1, expr__8054))) {
+      return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [s], null);
+    } else {
+      if (cljs.core.truth_(pred__8053.call(null, 2, expr__8054))) {
+        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, ["", s], null);
+      } else {
+        var c = limit - 2;
+        return cljs.core.conj.call(null, cljs.core.vec.call(null, cljs.core.cons.call(null, "", cljs.core.subvec.call(null, cljs.core.vec.call(null, cljs.core.map.call(null, cljs.core.str, cljs.core.seq.call(null, s))), 0, c))), cljs.core.subs.call(null, s, c));
+      }
+    }
+  }
+};
+clojure.string.split = function() {
+  var split = null;
+  var split__2 = function(s, re) {
+    return split.call(null, s, re, 0);
+  };
+  var split__3 = function(s, re, limit) {
+    return clojure.string.discard_trailing_if_needed.call(null, limit, cljs.core._EQ_.call(null, [cljs.core.str(re)].join(""), "/(?:)/") ? clojure.string.split_with_empty_regex.call(null, s, limit) : limit < 1 ? cljs.core.vec.call(null, [cljs.core.str(s)].join("").split(re)) : function() {
+      var s__$1 = s;
+      var limit__$1 = limit;
+      var parts = cljs.core.PersistentVector.EMPTY;
+      while (true) {
+        if (cljs.core._EQ_.call(null, limit__$1, 1)) {
+          return cljs.core.conj.call(null, parts, s__$1);
+        } else {
+          var temp__4090__auto__ = cljs.core.re_find.call(null, re, s__$1);
+          if (cljs.core.truth_(temp__4090__auto__)) {
+            var m = temp__4090__auto__;
+            var index = s__$1.indexOf(m);
+            var G__8056 = s__$1.substring(index + cljs.core.count.call(null, m));
+            var G__8057 = limit__$1 - 1;
+            var G__8058 = cljs.core.conj.call(null, parts, s__$1.substring(0, index));
+            s__$1 = G__8056;
+            limit__$1 = G__8057;
+            parts = G__8058;
+            continue;
+          } else {
+            return cljs.core.conj.call(null, parts, s__$1);
+          }
+        }
+        break;
+      }
+    }());
+  };
+  split = function(s, re, limit) {
+    switch(arguments.length) {
+      case 2:
+        return split__2.call(this, s, re);
+      case 3:
+        return split__3.call(this, s, re, limit);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  split.cljs$core$IFn$_invoke$arity$2 = split__2;
+  split.cljs$core$IFn$_invoke$arity$3 = split__3;
+  return split;
+}();
+clojure.string.split_lines = function split_lines(s) {
+  return clojure.string.split.call(null, s, /\n|\r\n/);
+};
+clojure.string.trim = function trim(s) {
+  return goog.string.trim(s);
+};
+clojure.string.triml = function triml(s) {
+  return goog.string.trimLeft(s);
+};
+clojure.string.trimr = function trimr(s) {
+  return goog.string.trimRight(s);
+};
+clojure.string.trim_newline = function trim_newline(s) {
+  var index = s.length;
+  while (true) {
+    if (index === 0) {
+      return "";
+    } else {
+      var ch = cljs.core.get.call(null, s, index - 1);
+      if (cljs.core._EQ_.call(null, ch, "\n") || cljs.core._EQ_.call(null, ch, "\r")) {
+        var G__8059 = index - 1;
+        index = G__8059;
+        continue;
+      } else {
+        return s.substring(0, index);
+      }
+    }
+    break;
+  }
+};
+clojure.string.blank_QMARK_ = function blank_QMARK_(s) {
+  return goog.string.isEmptySafe(s);
+};
+clojure.string.escape = function escape__$1(s, cmap) {
+  var buffer = new goog.string.StringBuffer;
+  var length = s.length;
+  var index = 0;
+  while (true) {
+    if (cljs.core._EQ_.call(null, length, index)) {
+      return buffer.toString();
+    } else {
+      var ch = s.charAt(index);
+      var temp__4090__auto___8060 = cljs.core.get.call(null, cmap, ch);
+      if (cljs.core.truth_(temp__4090__auto___8060)) {
+        var replacement_8061 = temp__4090__auto___8060;
+        buffer.append([cljs.core.str(replacement_8061)].join(""));
+      } else {
+        buffer.append(ch);
+      }
+      var G__8062 = index + 1;
+      index = G__8062;
+      continue;
+    }
+    break;
+  }
+};
+goog.provide("cemerick.cljs.test");
+goog.require("cljs.core");
+goog.require("clojure.string");
+goog.require("clojure.string");
+cemerick.cljs.test._STAR_report_counters_STAR_ = null;
+cemerick.cljs.test._STAR_initial_report_counters_STAR_ = new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "test", "test", 1017460740), 0, new cljs.core.Keyword(null, "pass", "pass", 1017337731), 0, new cljs.core.Keyword(null, "fail", "fail", 1017039504), 0, new cljs.core.Keyword(null, "error", "error", 1110689146), 0], null);
+cemerick.cljs.test._STAR_testing_vars_STAR_ = cljs.core.List.EMPTY;
+cemerick.cljs.test._STAR_testing_contexts_STAR_ = cljs.core.List.EMPTY;
+cemerick.cljs.test._STAR_test_print_fn_STAR_ = null;
+cemerick.cljs.test.registered_tests = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+cemerick.cljs.test.registered_test_hooks = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+cemerick.cljs.test.registered_fixtures = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+cemerick.cljs.test.register_test_BANG_ = function register_test_BANG_(ns, name) {
+  return cljs.core.swap_BANG_.call(null, cemerick.cljs.test.registered_tests, cljs.core.update_in, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns], null), cljs.core.fnil.call(null, cljs.core.conj, cljs.core.PersistentHashSet.EMPTY), name);
+};
+cemerick.cljs.test.register_test_ns_hook_BANG_ = function register_test_ns_hook_BANG_(ns, name) {
+  return cljs.core.swap_BANG_.call(null, cemerick.cljs.test.registered_test_hooks, cljs.core.assoc, ns, name);
+};
+cemerick.cljs.test.testing_vars_str = function testing_vars_str(m) {
+  var map__8004 = m;
+  var map__8004__$1 = cljs.core.seq_QMARK_.call(null, map__8004) ? cljs.core.apply.call(null, cljs.core.hash_map, map__8004) : map__8004;
+  var line = cljs.core.get.call(null, map__8004__$1, new cljs.core.Keyword(null, "line", "line", 1017226086));
+  var file = cljs.core.get.call(null, map__8004__$1, new cljs.core.Keyword(null, "file", "file", 1017047278));
+  return[cljs.core.str(cljs.core.pr_str.call(null, cljs.core.reverse.call(null, cemerick.cljs.test._STAR_testing_vars_STAR_))), cljs.core.str(" ("), cljs.core.str(file), cljs.core.str(":"), cljs.core.str(line), cljs.core.str(")")].join("");
+};
+cemerick.cljs.test.testing_contexts_str = function testing_contexts_str() {
+  return cljs.core.apply.call(null, cljs.core.str, cljs.core.interpose.call(null, " ", cljs.core.reverse.call(null, cemerick.cljs.test._STAR_testing_contexts_STAR_)));
+};
+cemerick.cljs.test.inc_report_counter = function inc_report_counter(name) {
+  if (cljs.core.truth_(cemerick.cljs.test._STAR_report_counters_STAR_)) {
+    return cljs.core.swap_BANG_.call(null, cemerick.cljs.test._STAR_report_counters_STAR_, cljs.core.update_in, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [name], null), cljs.core.fnil.call(null, cljs.core.inc, 0));
+  } else {
+    return null;
+  }
+};
+cemerick.cljs.test.report = function() {
+  var method_table__4242__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var prefer_table__4243__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var method_cache__4244__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var cached_hierarchy__4245__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var hierarchy__4246__auto__ = cljs.core.get.call(null, cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "hierarchy", "hierarchy", 3129050535), cljs.core.get_global_hierarchy.call(null));
+  return new cljs.core.MultiFn("report", new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "default", "default", 2558708147), hierarchy__4246__auto__, method_table__4242__auto__, prefer_table__4243__auto__, method_cache__4244__auto__, cached_hierarchy__4245__auto__);
+}();
+cemerick.cljs.test.file_and_line = function file_and_line(error) {
+  return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "file", "file", 1017047278), error.fileName, new cljs.core.Keyword(null, "line", "line", 1017226086), error.lineNumber], null);
+};
+cemerick.cljs.test.do_report = function do_report(m) {
+  return cemerick.cljs.test.report.call(null, function() {
+    var G__8006 = (new cljs.core.Keyword(null, "type", "type", 1017479852)).cljs$core$IFn$_invoke$arity$1(m);
+    if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "error", "error", 1110689146), G__8006)) {
+      return cljs.core.merge.call(null, cemerick.cljs.test.file_and_line.call(null, (new cljs.core.Keyword(null, "actual", "actual", 3885931776)).cljs$core$IFn$_invoke$arity$1(m)), m);
+    } else {
+      if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "fail", "fail", 1017039504), G__8006)) {
+        return cljs.core.merge.call(null, cemerick.cljs.test.file_and_line.call(null, Error()), m);
+      } else {
+        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+          return m;
+        } else {
+          return null;
+        }
+      }
+    }
+  }());
+};
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "default", "default", 2558708147), function(m) {
+  var _STAR_print_fn_STAR_8007 = cljs.core._STAR_print_fn_STAR_;
+  try {
+    cljs.core._STAR_print_fn_STAR_ = function() {
+      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return cljs.core._STAR_print_fn_STAR_;
+      }
+    }();
+    return cljs.core.prn.call(null, m);
+  } finally {
+    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8007;
+  }
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "pass", "pass", 1017337731), function(m) {
+  var _STAR_print_fn_STAR_8008 = cljs.core._STAR_print_fn_STAR_;
+  try {
+    cljs.core._STAR_print_fn_STAR_ = function() {
+      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return cljs.core._STAR_print_fn_STAR_;
+      }
+    }();
+    return cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "pass", "pass", 1017337731));
+  } finally {
+    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8008;
+  }
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "fail", "fail", 1017039504), function(m) {
+  var _STAR_print_fn_STAR_8009 = cljs.core._STAR_print_fn_STAR_;
+  try {
+    cljs.core._STAR_print_fn_STAR_ = function() {
+      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return cljs.core._STAR_print_fn_STAR_;
+      }
+    }();
+    cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "fail", "fail", 1017039504));
+    cljs.core.println.call(null, "\nFAIL in", cemerick.cljs.test.testing_vars_str.call(null, m));
+    if (cljs.core.seq.call(null, cemerick.cljs.test._STAR_testing_contexts_STAR_)) {
+      cljs.core.println.call(null, cemerick.cljs.test.testing_contexts_str.call(null));
+    } else {
+    }
+    var temp__4092__auto___8010 = (new cljs.core.Keyword(null, "message", "message", 1968829305)).cljs$core$IFn$_invoke$arity$1(m);
+    if (cljs.core.truth_(temp__4092__auto___8010)) {
+      var message_8011 = temp__4092__auto___8010;
+      cljs.core.println.call(null, message_8011);
+    } else {
+    }
+    cljs.core.println.call(null, "expected:", cljs.core.pr_str.call(null, (new cljs.core.Keyword(null, "expected", "expected", 3373152810)).cljs$core$IFn$_invoke$arity$1(m)));
+    return cljs.core.println.call(null, "  actual:", cljs.core.pr_str.call(null, (new cljs.core.Keyword(null, "actual", "actual", 3885931776)).cljs$core$IFn$_invoke$arity$1(m)));
+  } finally {
+    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8009;
+  }
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "error", "error", 1110689146), function(m) {
+  var _STAR_print_fn_STAR_8012 = cljs.core._STAR_print_fn_STAR_;
+  try {
+    cljs.core._STAR_print_fn_STAR_ = function() {
+      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return cljs.core._STAR_print_fn_STAR_;
+      }
+    }();
+    cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "error", "error", 1110689146));
+    cljs.core.println.call(null, "\nERROR in", cemerick.cljs.test.testing_vars_str.call(null, m));
+    if (cljs.core.seq.call(null, cemerick.cljs.test._STAR_testing_contexts_STAR_)) {
+      cljs.core.println.call(null, cemerick.cljs.test.testing_contexts_str.call(null));
+    } else {
+    }
+    var temp__4092__auto___8013 = (new cljs.core.Keyword(null, "message", "message", 1968829305)).cljs$core$IFn$_invoke$arity$1(m);
+    if (cljs.core.truth_(temp__4092__auto___8013)) {
+      var message_8014 = temp__4092__auto___8013;
+      cljs.core.println.call(null, message_8014);
+    } else {
+    }
+    cljs.core.println.call(null, "expected:", cljs.core.pr_str.call(null, (new cljs.core.Keyword(null, "expected", "expected", 3373152810)).cljs$core$IFn$_invoke$arity$1(m)));
+    cljs.core.print.call(null, "  actual: ");
+    var actual = (new cljs.core.Keyword(null, "actual", "actual", 3885931776)).cljs$core$IFn$_invoke$arity$1(m);
+    if (actual instanceof Error) {
+      return cljs.core.println.call(null, actual.stack);
+    } else {
+      return cljs.core.prn.call(null, actual);
+    }
+  } finally {
+    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8012;
+  }
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "summary", "summary", 3451231E3), function(m) {
+  var _STAR_print_fn_STAR_8015 = cljs.core._STAR_print_fn_STAR_;
+  try {
+    cljs.core._STAR_print_fn_STAR_ = function() {
+      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return cljs.core._STAR_print_fn_STAR_;
+      }
+    }();
+    cljs.core.println.call(null, "\nRan", (new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(m), "tests containing", (new cljs.core.Keyword(null, "pass", "pass", 1017337731)).cljs$core$IFn$_invoke$arity$1(m) + (new cljs.core.Keyword(null, "fail", "fail", 1017039504)).cljs$core$IFn$_invoke$arity$1(m) + (new cljs.core.Keyword(null, "error", "error", 1110689146)).cljs$core$IFn$_invoke$arity$1(m), "assertions.");
+    return cljs.core.println.call(null, (new cljs.core.Keyword(null, "fail", "fail", 1017039504)).cljs$core$IFn$_invoke$arity$1(m), "failures,", (new cljs.core.Keyword(null, "error", "error", 1110689146)).cljs$core$IFn$_invoke$arity$1(m), "errors.");
+  } finally {
+    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8015;
+  }
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "begin-test-ns", "begin-test-ns", 1359210286), function(m) {
+  var _STAR_print_fn_STAR_8016 = cljs.core._STAR_print_fn_STAR_;
+  try {
+    cljs.core._STAR_print_fn_STAR_ = function() {
+      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return cljs.core._STAR_print_fn_STAR_;
+      }
+    }();
+    return cljs.core.println.call(null, "\nTesting", (new cljs.core.Keyword(null, "ns", "ns", 1013907767)).cljs$core$IFn$_invoke$arity$1(m));
+  } finally {
+    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8016;
+  }
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "end-test-ns", "end-test-ns", 3401491808), function(m) {
+  return null;
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "begin-test-var", "begin-test-var", 3128464258), function(m) {
+  return null;
+});
+cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "end-test-var", "end-test-var", 2014682E3), function(m) {
+  return null;
+});
+cemerick.cljs.test.register_fixtures_BANG_ = function() {
+  var register_fixtures_BANG___delegate = function(ns_sym, fixture_type, fixture_fns) {
+    return cljs.core.swap_BANG_.call(null, cemerick.cljs.test.registered_fixtures, cljs.core.update_in, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns_sym, fixture_type], null), cljs.core.constantly.call(null, fixture_fns));
+  };
+  var register_fixtures_BANG_ = function(ns_sym, fixture_type, var_args) {
+    var fixture_fns = null;
+    if (arguments.length > 2) {
+      fixture_fns = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
+    }
+    return register_fixtures_BANG___delegate.call(this, ns_sym, fixture_type, fixture_fns);
+  };
+  register_fixtures_BANG_.cljs$lang$maxFixedArity = 2;
+  register_fixtures_BANG_.cljs$lang$applyTo = function(arglist__8017) {
+    var ns_sym = cljs.core.first(arglist__8017);
+    arglist__8017 = cljs.core.next(arglist__8017);
+    var fixture_type = cljs.core.first(arglist__8017);
+    var fixture_fns = cljs.core.rest(arglist__8017);
+    return register_fixtures_BANG___delegate(ns_sym, fixture_type, fixture_fns);
+  };
+  register_fixtures_BANG_.cljs$core$IFn$_invoke$arity$variadic = register_fixtures_BANG___delegate;
+  return register_fixtures_BANG_;
+}();
+cemerick.cljs.test.default_fixture = function default_fixture(f) {
+  return f.call(null);
+};
+cemerick.cljs.test.compose_fixtures = function compose_fixtures(f1, f2) {
+  return function(g) {
+    return f1.call(null, function() {
+      return f2.call(null, g);
+    });
+  };
+};
+cemerick.cljs.test.join_fixtures = function join_fixtures(fixtures) {
+  return cljs.core.reduce.call(null, cemerick.cljs.test.compose_fixtures, cemerick.cljs.test.default_fixture, fixtures);
+};
+cemerick.cljs.test.test_function = function test_function(v) {
+  if (cljs.core.fn_QMARK_.call(null, v)) {
+  } else {
+    throw new Error([cljs.core.str("Assert failed: "), cljs.core.str("test-var must be passed the function to be tested (not a symbol naming it)"), cljs.core.str("\n"), cljs.core.str(cljs.core.pr_str.call(null, cljs.core.list(new cljs.core.Symbol(null, "fn?", "fn?", -1640430032, null), new cljs.core.Symbol(null, "v", "v", -1640531409, null))))].join(""));
+  }
+  var temp__4092__auto__ = (new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v));
+  if (cljs.core.truth_(temp__4092__auto__)) {
+    var t = temp__4092__auto__;
+    var _STAR_testing_vars_STAR_8020 = cemerick.cljs.test._STAR_testing_vars_STAR_;
+    try {
+      cemerick.cljs.test._STAR_testing_vars_STAR_ = cljs.core.conj.call(null, cemerick.cljs.test._STAR_testing_vars_STAR_, function() {
+        var or__3408__auto__ = (new cljs.core.Keyword(null, "name", "name", 1017277949)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v));
+        if (cljs.core.truth_(or__3408__auto__)) {
+          return or__3408__auto__;
+        } else {
+          return v;
+        }
+      }());
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "begin-test-var", "begin-test-var", 3128464258), new cljs.core.Keyword(null, "var", "var", 1014020761), v], null));
+      cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "test", "test", 1017460740));
+      try {
+        t.call(null);
+      } catch (e8021) {
+        if (e8021 instanceof Error) {
+          var e_8022 = e8021;
+          cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), "Uncaught exception, not in assertion.", new cljs.core.Keyword(null, "expected", "expected", 3373152810), null, new cljs.core.Keyword(null, "actual", "actual", 3885931776), e_8022], null));
+        } else {
+          if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+            throw e8021;
+          } else {
+          }
+        }
+      }
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "end-test-var", "end-test-var", 2014682E3), new cljs.core.Keyword(null, "var", "var", 1014020761), v], null));
+    } finally {
+      cemerick.cljs.test._STAR_testing_vars_STAR_ = _STAR_testing_vars_STAR_8020;
+    }
+  } else {
+    return null;
+  }
+};
+cemerick.cljs.test.test_all_vars = function test_all_vars(ns_sym) {
+  var once_fixture_fn = cemerick.cljs.test.join_fixtures.call(null, (new cljs.core.Keyword(null, "once", "once", 1017319923)).cljs$core$IFn$_invoke$arity$1(ns_sym.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_fixtures))));
+  var each_fixture_fn = cemerick.cljs.test.join_fixtures.call(null, (new cljs.core.Keyword(null, "each", "each", 1017009523)).cljs$core$IFn$_invoke$arity$1(ns_sym.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_fixtures))));
+  return once_fixture_fn.call(null, function() {
+    var seq__8027 = cljs.core.seq.call(null, cljs.core.get.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_tests), ns_sym));
+    var chunk__8028 = null;
+    var count__8029 = 0;
+    var i__8030 = 0;
+    while (true) {
+      if (i__8030 < count__8029) {
+        var v = cljs.core._nth.call(null, chunk__8028, i__8030);
+        if (cljs.core.truth_((new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v)))) {
+          each_fixture_fn.call(null, function(seq__8027, chunk__8028, count__8029, i__8030, v) {
+            return function() {
+              return cemerick.cljs.test.test_function.call(null, v);
+            };
+          }(seq__8027, chunk__8028, count__8029, i__8030, v));
+        } else {
+        }
+        var G__8031 = seq__8027;
+        var G__8032 = chunk__8028;
+        var G__8033 = count__8029;
+        var G__8034 = i__8030 + 1;
+        seq__8027 = G__8031;
+        chunk__8028 = G__8032;
+        count__8029 = G__8033;
+        i__8030 = G__8034;
+        continue;
+      } else {
+        var temp__4092__auto__ = cljs.core.seq.call(null, seq__8027);
+        if (temp__4092__auto__) {
+          var seq__8027__$1 = temp__4092__auto__;
+          if (cljs.core.chunked_seq_QMARK_.call(null, seq__8027__$1)) {
+            var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__8027__$1);
+            var G__8035 = cljs.core.chunk_rest.call(null, seq__8027__$1);
+            var G__8036 = c__4132__auto__;
+            var G__8037 = cljs.core.count.call(null, c__4132__auto__);
+            var G__8038 = 0;
+            seq__8027 = G__8035;
+            chunk__8028 = G__8036;
+            count__8029 = G__8037;
+            i__8030 = G__8038;
+            continue;
+          } else {
+            var v = cljs.core.first.call(null, seq__8027__$1);
+            if (cljs.core.truth_((new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v)))) {
+              each_fixture_fn.call(null, function(seq__8027, chunk__8028, count__8029, i__8030, v, seq__8027__$1, temp__4092__auto__) {
+                return function() {
+                  return cemerick.cljs.test.test_function.call(null, v);
+                };
+              }(seq__8027, chunk__8028, count__8029, i__8030, v, seq__8027__$1, temp__4092__auto__));
+            } else {
+            }
+            var G__8039 = cljs.core.next.call(null, seq__8027__$1);
+            var G__8040 = null;
+            var G__8041 = 0;
+            var G__8042 = 0;
+            seq__8027 = G__8039;
+            chunk__8028 = G__8040;
+            count__8029 = G__8041;
+            i__8030 = G__8042;
+            continue;
+          }
+        } else {
+          return null;
+        }
+      }
+      break;
+    }
+  });
+};
+cemerick.cljs.test.test_ns = function test_ns(ns_sym) {
+  var _STAR_report_counters_STAR_8044 = cemerick.cljs.test._STAR_report_counters_STAR_;
+  try {
+    cemerick.cljs.test._STAR_report_counters_STAR_ = cljs.core.atom.call(null, cemerick.cljs.test._STAR_initial_report_counters_STAR_);
+    cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "begin-test-ns", "begin-test-ns", 1359210286), new cljs.core.Keyword(null, "ns", "ns", 1013907767), ns_sym], null));
+    var temp__4090__auto___8045 = cljs.core.get.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_test_hooks), ns_sym);
+    if (cljs.core.truth_(temp__4090__auto___8045)) {
+      var test_hook_8046 = temp__4090__auto___8045;
+      test_hook_8046.call(null);
+    } else {
+      cemerick.cljs.test.test_all_vars.call(null, ns_sym);
+    }
+    cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "end-test-ns", "end-test-ns", 3401491808), new cljs.core.Keyword(null, "ns", "ns", 1013907767), ns_sym], null));
+    return cljs.core.deref.call(null, cemerick.cljs.test._STAR_report_counters_STAR_);
+  } finally {
+    cemerick.cljs.test._STAR_report_counters_STAR_ = _STAR_report_counters_STAR_8044;
+  }
+};
+cemerick.cljs.test.run_tests_STAR_ = function() {
+  var run_tests_STAR___delegate = function(namespaces) {
+    var summary = cljs.core.assoc.call(null, cljs.core.apply.call(null, cljs.core.merge_with, cljs.core._PLUS_, cljs.core.map.call(null, cemerick.cljs.test.test_ns, namespaces)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "summary", "summary", 3451231E3));
+    cemerick.cljs.test.do_report.call(null, summary);
+    return summary;
+  };
+  var run_tests_STAR_ = function(var_args) {
+    var namespaces = null;
+    if (arguments.length > 0) {
+      namespaces = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+    }
+    return run_tests_STAR___delegate.call(this, namespaces);
+  };
+  run_tests_STAR_.cljs$lang$maxFixedArity = 0;
+  run_tests_STAR_.cljs$lang$applyTo = function(arglist__8047) {
+    var namespaces = cljs.core.seq(arglist__8047);
+    return run_tests_STAR___delegate(namespaces);
+  };
+  run_tests_STAR_.cljs$core$IFn$_invoke$arity$variadic = run_tests_STAR___delegate;
+  return run_tests_STAR_;
+}();
+goog.exportSymbol("cemerick.cljs.test.run_tests_STAR_", cemerick.cljs.test.run_tests_STAR_);
+cemerick.cljs.test.run_all_tests = function() {
+  var run_all_tests = null;
+  var run_all_tests__0 = function() {
+    return cljs.core.apply.call(null, cemerick.cljs.test.run_tests_STAR_, cljs.core.keys.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_tests)));
+  };
+  var run_all_tests__1 = function(re) {
+    return cljs.core.apply.call(null, cemerick.cljs.test.run_tests_STAR_, cljs.core.filter.call(null, function(p1__8048_SHARP_) {
+      return cljs.core.re_matches.call(null, re, cljs.core.name.call(null, p1__8048_SHARP_));
+    }, cljs.core.keys.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_tests))));
+  };
+  run_all_tests = function(re) {
+    switch(arguments.length) {
+      case 0:
+        return run_all_tests__0.call(this);
+      case 1:
+        return run_all_tests__1.call(this, re);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  run_all_tests.cljs$core$IFn$_invoke$arity$0 = run_all_tests__0;
+  run_all_tests.cljs$core$IFn$_invoke$arity$1 = run_all_tests__1;
+  return run_all_tests;
+}();
+goog.exportSymbol("cemerick.cljs.test.run_all_tests", cemerick.cljs.test.run_all_tests);
+cemerick.cljs.test.successful_QMARK_ = function successful_QMARK_(summary) {
+  return(new cljs.core.Keyword(null, "fail", "fail", 1017039504)).cljs$core$IFn$_invoke$arity$2(summary, 0) === 0 && (new cljs.core.Keyword(null, "error", "error", 1110689146)).cljs$core$IFn$_invoke$arity$2(summary, 0) === 0;
+};
+goog.exportSymbol("cemerick.cljs.test.successful_QMARK_", cemerick.cljs.test.successful_QMARK_);
+cemerick.cljs.test.set_print_fn_BANG_ = function set_print_fn_BANG_(f) {
+  return cljs.core._STAR_print_fn_STAR_ = f;
+};
+goog.exportSymbol("cemerick.cljs.test.set_print_fn_BANG_", cemerick.cljs.test.set_print_fn_BANG_);
+goog.provide("nonaga.ball_test");
+goog.require("cljs.core");
+goog.require("nonaga.core");
+goog.require("nonaga.rules.ball");
+goog.require("nonaga.rules.coord");
+goog.require("cemerick.cljs.test");
+goog.require("cemerick.cljs.test");
+goog.require("nonaga.rules.coord");
+goog.require("nonaga.rules.ball");
+goog.require("nonaga.core");
+nonaga.ball_test.invalid_space = function invalid_space() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.ball_test.invalid_space);
+};
+nonaga.ball_test.invalid_space = cljs.core.vary_meta.call(null, nonaga.ball_test.invalid_space, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "invalid-space", "invalid-space", 386194281, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function invalid_space_test() {
+  try {
+    var values__6663__auto___6810 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.invalid_space_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null))), true);
+    var result__6664__auto___6811 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6810);
+    if (cljs.core.truth_(result__6664__auto___6811)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6810), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6810)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], 
+      null)))], null));
+    }
+  } catch (e6807) {
+    if (e6807 instanceof Error) {
+      var t__6700__auto___6812 = e6807;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6812, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, 
+      cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6807;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__6663__auto___6813 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.invalid_space_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))), true);
+    var result__6664__auto___6814 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6813);
+    if (cljs.core.truth_(result__6664__auto___6814)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6813), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6813)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], 
+      null)))], null));
+    }
+  } catch (e6808) {
+    if (e6808 instanceof Error) {
+      var t__6700__auto___6815 = e6808;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6815, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, 
+      cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6808;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.invalid_space_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))), false);
+    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
+    if (cljs.core.truth_(result__6664__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], 
+      null)))], null));
+    }
+    return result__6664__auto__;
+  } catch (e6809) {
+    if (e6809 instanceof Error) {
+      var t__6700__auto__ = e6809;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6809;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.ball-test", "nonaga.ball-test", -2131830151, null), nonaga.ball_test.invalid_space);
+nonaga.ball_test.movement = function movement() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.ball_test.movement);
+};
+nonaga.ball_test.movement = cljs.core.vary_meta.call(null, nonaga.ball_test.movement, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "movement", "movement", -1744209304, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function movement_test() {
+  try {
+    var values__6663__auto___6824 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.move.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), nonaga.rules.coord.nw)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null));
+    var result__6664__auto___6825 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6824);
+    if (cljs.core.truth_(result__6664__auto___6825)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6824), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6824)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null)))], null));
+    }
+  } catch (e6820) {
+    if (e6820 instanceof Error) {
+      var t__6700__auto___6826 = e6820;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6826, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6820;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__6663__auto___6827 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.move.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), nonaga.rules.coord.e)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null));
+    var result__6664__auto___6828 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6827);
+    if (cljs.core.truth_(result__6664__auto___6828)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6827), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6827)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
+    }
+  } catch (e6821) {
+    if (e6821 instanceof Error) {
+      var t__6700__auto___6829 = e6821;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6829, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6821;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__6663__auto___6830 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.move.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), nonaga.rules.coord.e)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null));
+    var result__6664__auto___6831 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6830);
+    if (cljs.core.truth_(result__6664__auto___6831)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6830), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6830)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
+    }
+  } catch (e6822) {
+    if (e6822 instanceof Error) {
+      var t__6700__auto___6832 = e6822;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6832, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6822;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.valid_destinations.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 
+    4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true));
+    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
+    if (cljs.core.truth_(result__6664__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), new cljs.core.Symbol(null, 
+      "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    }
+    return result__6664__auto__;
+  } catch (e6823) {
+    if (e6823 instanceof Error) {
+      var t__6700__auto__ = e6823;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), new cljs.core.Symbol(null, "initial-game", "initial-game", 
+      -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6823;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.ball-test", "nonaga.ball-test", -2131830151, null), nonaga.ball_test.movement);
+goog.provide("nonaga.core_test");
+goog.require("cljs.core");
+goog.require("cemerick.cljs.test");
+goog.require("cemerick.cljs.test");
+goog.require("nonaga.core");
+goog.require("nonaga.core");
+nonaga.core_test.after_red_move = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), 
+cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
+nonaga.core_test.ball_move = function ball_move() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.core_test.ball_move);
+};
+nonaga.core_test.ball_move = cljs.core.vary_meta.call(null, nonaga.core_test.ball_move, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "ball-move", "ball-move", -925517672, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function ball_move_test() {
+  try {
+    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.core.move_ball.call(null, nonaga.core.initial_game, new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))), nonaga.core_test.after_red_move);
+    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
+    if (cljs.core.truth_(result__6664__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-red-move", "after-red-move", 492316183, null), cljs.core.list(new cljs.core.Symbol("c", "move-ball", "c/move-ball", -618776209, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [3, 0], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-red-move", "after-red-move", 492316183, null), cljs.core.list(new cljs.core.Symbol("c", "move-ball", "c/move-ball", -618776209, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.Keyword(null, 
+      "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)))], null));
+    }
+    return result__6664__auto__;
+  } catch (e6801) {
+    if (e6801 instanceof Error) {
+      var t__6700__auto__ = e6801;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      new cljs.core.Symbol(null, "after-red-move", "after-red-move", 492316183, null), cljs.core.list(new cljs.core.Symbol("c", "move-ball", "c/move-ball", -618776209, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)))], 
+      null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6801;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.core-test", "nonaga.core-test", -185125671, null), nonaga.core_test.ball_move);
+nonaga.core_test.after_ring_move = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), 
+cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
+nonaga.core_test.ring_move = function ring_move() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.core_test.ring_move);
+};
+nonaga.core_test.ring_move = cljs.core.vary_meta.call(null, nonaga.core_test.ring_move, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "ring-move", "ring-move", -1385542905, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function ring_move_test() {
+  try {
+    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.core.move_ring.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null))), nonaga.core_test.after_ring_move);
+    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
+    if (cljs.core.truth_(result__6664__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-ring-move", "after-ring-move", 320966742, null), cljs.core.list(new cljs.core.Symbol("c", "move-ring", "c/move-ring", -618291874, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-ring-move", "after-ring-move", 320966742, null), cljs.core.list(new cljs.core.Symbol("c", "move-ring", "c/move-ring", -618291874, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null)))], null));
+    }
+    return result__6664__auto__;
+  } catch (e6803) {
+    if (e6803 instanceof Error) {
+      var t__6700__auto__ = e6803;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      new cljs.core.Symbol(null, "after-ring-move", "after-ring-move", 320966742, null), cljs.core.list(new cljs.core.Symbol("c", "move-ring", "c/move-ring", -618291874, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6803;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.core-test", "nonaga.core-test", -185125671, null), nonaga.core_test.ring_move);
+goog.provide("nonaga.rules.coord_test");
+goog.require("cljs.core");
+goog.require("nonaga.rules.coord");
+goog.require("cemerick.cljs.test");
+goog.require("cemerick.cljs.test");
+goog.require("nonaga.rules.coord");
+nonaga.rules.coord_test.directional_functions = function directional_functions() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.coord_test.directional_functions);
+};
+nonaga.rules.coord_test.directional_functions = cljs.core.vary_meta.call(null, nonaga.rules.coord_test.directional_functions, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "directional-functions", "directional-functions", 5781297, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function directional_functions_test() {
+  try {
+    var values__5008__auto___6195 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.nw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)], null));
+    var result__5009__auto___6196 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6195);
+    if (cljs.core.truth_(result__5009__auto___6196)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6195), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 
+      3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6195)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
+      "nw", "nw", -1640527998, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))))], null));
+    }
+  } catch (e6189) {
+    if (e6189 instanceof Error) {
+      var t__5045__auto___6197 = e6189;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6197, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [1, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6189;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6198 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.ne, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)], null));
+    var result__5009__auto___6199 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6198);
+    if (cljs.core.truth_(result__5009__auto___6199)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6198), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 
+      3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6198)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
+      "ne", "ne", -1640528016, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null))))], null));
+    }
+  } catch (e6190) {
+    if (e6190 instanceof Error) {
+      var t__5045__auto___6200 = e6190;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6200, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [3, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6190;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6201 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.e, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], null));
+    var result__5009__auto___6202 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6201);
+    if (cljs.core.truth_(result__5009__auto___6202)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6201), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 
+      2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "e", "e", -1640531426, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6201)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
+      "e", "e", -1640531426, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null))))], null));
+    }
+  } catch (e6191) {
+    if (e6191 instanceof Error) {
+      var t__5045__auto___6203 = e6191;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6203, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "e", "e", -1640531426, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6191;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6204 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.se, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], null));
+    var result__5009__auto___6205 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6204);
+    if (cljs.core.truth_(result__5009__auto___6205)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6204), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 
+      1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "se", "se", -1640527861, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6204)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
+      "se", "se", -1640527861, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))))], null));
+    }
+  } catch (e6192) {
+    if (e6192 instanceof Error) {
+      var t__5045__auto___6206 = e6192;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6206, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [3, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "se", "se", -1640527861, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6192;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6207 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.sw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)], null));
+    var result__5009__auto___6208 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6207);
+    if (cljs.core.truth_(result__5009__auto___6208)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6207), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 
+      1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "sw", "sw", -1640527843, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6207)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
+      "sw", "sw", -1640527843, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null))))], null));
+    }
+  } catch (e6193) {
+    if (e6193 instanceof Error) {
+      var t__5045__auto___6209 = e6193;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6209, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
+      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [1, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "sw", "sw", -1640527843, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6193;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.w, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null));
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 
+      2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "w", "w", -1640531408, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
+      "w", "w", -1640531408, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))))], null));
+    }
+    return result__5009__auto__;
+  } catch (e6194) {
+    if (e6194 instanceof Error) {
+      var t__5045__auto__ = e6194;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "w", "w", -1640531408, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6194;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.coord-test", "nonaga.rules.coord-test", -522322342, null), nonaga.rules.coord_test.directional_functions);
+nonaga.rules.coord_test.neighbouring_cells = function neighbouring_cells() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.coord_test.neighbouring_cells);
+};
+nonaga.rules.coord_test.neighbouring_cells = cljs.core.vary_meta.call(null, nonaga.rules.coord_test.neighbouring_cells, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "neighbouring-cells", "neighbouring-cells", -580156446, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function neighbouring_cells_test() {
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.neighbours.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null))), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true));
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "neighbours", "neighbours", -1345037905, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "neighbours", "neighbours", -1345037905, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [2, 2], null)))], null));
+    }
+    return result__5009__auto__;
+  } catch (e6211) {
+    if (e6211 instanceof Error) {
+      var t__5045__auto__ = e6211;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "neighbours", "neighbours", -1345037905, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6211;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.coord-test", "nonaga.rules.coord-test", -522322342, null), nonaga.rules.coord_test.neighbouring_cells);
+nonaga.rules.coord_test.distances = function distances() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.coord_test.distances);
+};
+nonaga.rules.coord_test.distances = cljs.core.vary_meta.call(null, nonaga.rules.coord_test.distances, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "distances", "distances", -1288213289, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function distances_test() {
+  try {
+    var values__5008__auto___6228 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 0], null))), 12);
+    var result__5009__auto___6229 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6228);
+    if (cljs.core.truth_(result__5009__auto___6229)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6228), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 12, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 0], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6228)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 12, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 
+      0], null)))], null));
+    }
+  } catch (e6220) {
+    if (e6220 instanceof Error) {
+      var t__5045__auto___6230 = e6220;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6230, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 12, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 0], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6220;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6231 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 7], null))), 17);
+    var result__5009__auto___6232 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6231);
+    if (cljs.core.truth_(result__5009__auto___6232)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6231), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 7], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6231)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 
+      7], null)))], null));
+    }
+  } catch (e6221) {
+    if (e6221 instanceof Error) {
+      var t__5045__auto___6233 = e6221;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6233, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 7], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6221;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6234 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 11], null))), 17);
+    var result__5009__auto___6235 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6234);
+    if (cljs.core.truth_(result__5009__auto___6235)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6234), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 11], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6234)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 
+      11], null)))], null));
+    }
+  } catch (e6222) {
+    if (e6222 instanceof Error) {
+      var t__5045__auto___6236 = e6222;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6236, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 11], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6222;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6237 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 5], null))), 5);
+    var result__5009__auto___6238 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6237);
+    if (cljs.core.truth_(result__5009__auto___6238)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6237), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 5, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 5], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6237)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 5, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 
+      5], null)))], null));
+    }
+  } catch (e6223) {
+    if (e6223 instanceof Error) {
+      var t__5045__auto___6239 = e6223;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6239, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 5, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 5], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6223;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6240 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 10], null))), 10);
+    var result__5009__auto___6241 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6240);
+    if (cljs.core.truth_(result__5009__auto___6241)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6240), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 10, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 10], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6240)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 10, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 
+      10], null)))], null));
+    }
+  } catch (e6224) {
+    if (e6224 instanceof Error) {
+      var t__5045__auto___6242 = e6224;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6242, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 10, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 10], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6224;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6243 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 8], null))), 8);
+    var result__5009__auto___6244 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6243);
+    if (cljs.core.truth_(result__5009__auto___6244)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6243), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 8, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 8], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6243)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 8, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
+      8], null)))], null));
+    }
+  } catch (e6225) {
+    if (e6225 instanceof Error) {
+      var t__5045__auto___6245 = e6225;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6245, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 8, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 8], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6225;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___6246 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 8], null))), 9);
+    var result__5009__auto___6247 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6246);
+    if (cljs.core.truth_(result__5009__auto___6247)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6246), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 9, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 8], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6246)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 9, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 
+      8], null)))], null));
+    }
+  } catch (e6226) {
+    if (e6226 instanceof Error) {
+      var t__5045__auto___6248 = e6226;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6248, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 9, 
+      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 8], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6226;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, -9], null))), 20);
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 20, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, -9], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 20, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, 
+      -9], null)))], null));
+    }
+    return result__5009__auto__;
+  } catch (e6227) {
+    if (e6227 instanceof Error) {
+      var t__5045__auto__ = e6227;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      20, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, -9], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e6227;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.coord-test", "nonaga.rules.coord-test", -522322342, null), nonaga.rules.coord_test.distances);
+goog.provide("clojure.set");
+goog.require("cljs.core");
+clojure.set.bubble_max_key = function bubble_max_key(k, coll) {
+  var max = cljs.core.apply.call(null, cljs.core.max_key, k, coll);
+  return cljs.core.cons.call(null, max, cljs.core.remove.call(null, function(p1__7973_SHARP_) {
+    return max === p1__7973_SHARP_;
+  }, coll));
+};
+clojure.set.union = function() {
+  var union = null;
+  var union__0 = function() {
+    return cljs.core.PersistentHashSet.EMPTY;
+  };
+  var union__1 = function(s1) {
+    return s1;
+  };
+  var union__2 = function(s1, s2) {
+    if (cljs.core.count.call(null, s1) < cljs.core.count.call(null, s2)) {
+      return cljs.core.reduce.call(null, cljs.core.conj, s2, s1);
+    } else {
+      return cljs.core.reduce.call(null, cljs.core.conj, s1, s2);
+    }
+  };
+  var union__3 = function() {
+    var G__7974__delegate = function(s1, s2, sets) {
+      var bubbled_sets = clojure.set.bubble_max_key.call(null, cljs.core.count, cljs.core.conj.call(null, sets, s2, s1));
+      return cljs.core.reduce.call(null, cljs.core.into, cljs.core.first.call(null, bubbled_sets), cljs.core.rest.call(null, bubbled_sets));
+    };
+    var G__7974 = function(s1, s2, var_args) {
+      var sets = null;
+      if (arguments.length > 2) {
+        sets = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
+      }
+      return G__7974__delegate.call(this, s1, s2, sets);
+    };
+    G__7974.cljs$lang$maxFixedArity = 2;
+    G__7974.cljs$lang$applyTo = function(arglist__7975) {
+      var s1 = cljs.core.first(arglist__7975);
+      arglist__7975 = cljs.core.next(arglist__7975);
+      var s2 = cljs.core.first(arglist__7975);
+      var sets = cljs.core.rest(arglist__7975);
+      return G__7974__delegate(s1, s2, sets);
+    };
+    G__7974.cljs$core$IFn$_invoke$arity$variadic = G__7974__delegate;
+    return G__7974;
+  }();
+  union = function(s1, s2, var_args) {
+    var sets = var_args;
+    switch(arguments.length) {
+      case 0:
+        return union__0.call(this);
+      case 1:
+        return union__1.call(this, s1);
+      case 2:
+        return union__2.call(this, s1, s2);
+      default:
+        return union__3.cljs$core$IFn$_invoke$arity$variadic(s1, s2, cljs.core.array_seq(arguments, 2));
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  union.cljs$lang$maxFixedArity = 2;
+  union.cljs$lang$applyTo = union__3.cljs$lang$applyTo;
+  union.cljs$core$IFn$_invoke$arity$0 = union__0;
+  union.cljs$core$IFn$_invoke$arity$1 = union__1;
+  union.cljs$core$IFn$_invoke$arity$2 = union__2;
+  union.cljs$core$IFn$_invoke$arity$variadic = union__3.cljs$core$IFn$_invoke$arity$variadic;
+  return union;
+}();
+clojure.set.intersection = function() {
+  var intersection = null;
+  var intersection__1 = function(s1) {
+    return s1;
+  };
+  var intersection__2 = function(s1, s2) {
+    while (true) {
+      if (cljs.core.count.call(null, s2) < cljs.core.count.call(null, s1)) {
+        var G__7977 = s2;
+        var G__7978 = s1;
+        s1 = G__7977;
+        s2 = G__7978;
+        continue;
+      } else {
+        return cljs.core.reduce.call(null, function(s1, s2) {
+          return function(result, item) {
+            if (cljs.core.contains_QMARK_.call(null, s2, item)) {
+              return result;
+            } else {
+              return cljs.core.disj.call(null, result, item);
+            }
+          };
+        }(s1, s2), s1, s1);
+      }
+      break;
+    }
+  };
+  var intersection__3 = function() {
+    var G__7979__delegate = function(s1, s2, sets) {
+      var bubbled_sets = clojure.set.bubble_max_key.call(null, function(p1__7976_SHARP_) {
+        return-cljs.core.count.call(null, p1__7976_SHARP_);
+      }, cljs.core.conj.call(null, sets, s2, s1));
+      return cljs.core.reduce.call(null, intersection, cljs.core.first.call(null, bubbled_sets), cljs.core.rest.call(null, bubbled_sets));
+    };
+    var G__7979 = function(s1, s2, var_args) {
+      var sets = null;
+      if (arguments.length > 2) {
+        sets = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
+      }
+      return G__7979__delegate.call(this, s1, s2, sets);
+    };
+    G__7979.cljs$lang$maxFixedArity = 2;
+    G__7979.cljs$lang$applyTo = function(arglist__7980) {
+      var s1 = cljs.core.first(arglist__7980);
+      arglist__7980 = cljs.core.next(arglist__7980);
+      var s2 = cljs.core.first(arglist__7980);
+      var sets = cljs.core.rest(arglist__7980);
+      return G__7979__delegate(s1, s2, sets);
+    };
+    G__7979.cljs$core$IFn$_invoke$arity$variadic = G__7979__delegate;
+    return G__7979;
+  }();
+  intersection = function(s1, s2, var_args) {
+    var sets = var_args;
+    switch(arguments.length) {
+      case 1:
+        return intersection__1.call(this, s1);
+      case 2:
+        return intersection__2.call(this, s1, s2);
+      default:
+        return intersection__3.cljs$core$IFn$_invoke$arity$variadic(s1, s2, cljs.core.array_seq(arguments, 2));
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  intersection.cljs$lang$maxFixedArity = 2;
+  intersection.cljs$lang$applyTo = intersection__3.cljs$lang$applyTo;
+  intersection.cljs$core$IFn$_invoke$arity$1 = intersection__1;
+  intersection.cljs$core$IFn$_invoke$arity$2 = intersection__2;
+  intersection.cljs$core$IFn$_invoke$arity$variadic = intersection__3.cljs$core$IFn$_invoke$arity$variadic;
+  return intersection;
+}();
+clojure.set.difference = function() {
+  var difference = null;
+  var difference__1 = function(s1) {
+    return s1;
+  };
+  var difference__2 = function(s1, s2) {
+    if (cljs.core.count.call(null, s1) < cljs.core.count.call(null, s2)) {
+      return cljs.core.reduce.call(null, function(result, item) {
+        if (cljs.core.contains_QMARK_.call(null, s2, item)) {
+          return cljs.core.disj.call(null, result, item);
+        } else {
+          return result;
+        }
+      }, s1, s1);
+    } else {
+      return cljs.core.reduce.call(null, cljs.core.disj, s1, s2);
+    }
+  };
+  var difference__3 = function() {
+    var G__7981__delegate = function(s1, s2, sets) {
+      return cljs.core.reduce.call(null, difference, s1, cljs.core.conj.call(null, sets, s2));
+    };
+    var G__7981 = function(s1, s2, var_args) {
+      var sets = null;
+      if (arguments.length > 2) {
+        sets = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
+      }
+      return G__7981__delegate.call(this, s1, s2, sets);
+    };
+    G__7981.cljs$lang$maxFixedArity = 2;
+    G__7981.cljs$lang$applyTo = function(arglist__7982) {
+      var s1 = cljs.core.first(arglist__7982);
+      arglist__7982 = cljs.core.next(arglist__7982);
+      var s2 = cljs.core.first(arglist__7982);
+      var sets = cljs.core.rest(arglist__7982);
+      return G__7981__delegate(s1, s2, sets);
+    };
+    G__7981.cljs$core$IFn$_invoke$arity$variadic = G__7981__delegate;
+    return G__7981;
+  }();
+  difference = function(s1, s2, var_args) {
+    var sets = var_args;
+    switch(arguments.length) {
+      case 1:
+        return difference__1.call(this, s1);
+      case 2:
+        return difference__2.call(this, s1, s2);
+      default:
+        return difference__3.cljs$core$IFn$_invoke$arity$variadic(s1, s2, cljs.core.array_seq(arguments, 2));
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  difference.cljs$lang$maxFixedArity = 2;
+  difference.cljs$lang$applyTo = difference__3.cljs$lang$applyTo;
+  difference.cljs$core$IFn$_invoke$arity$1 = difference__1;
+  difference.cljs$core$IFn$_invoke$arity$2 = difference__2;
+  difference.cljs$core$IFn$_invoke$arity$variadic = difference__3.cljs$core$IFn$_invoke$arity$variadic;
+  return difference;
+}();
+clojure.set.select = function select(pred, xset) {
+  return cljs.core.reduce.call(null, function(s, k) {
+    if (cljs.core.truth_(pred.call(null, k))) {
+      return s;
+    } else {
+      return cljs.core.disj.call(null, s, k);
+    }
+  }, xset, xset);
+};
+clojure.set.project = function project(xrel, ks) {
+  return cljs.core.set.call(null, cljs.core.map.call(null, function(p1__7983_SHARP_) {
+    return cljs.core.select_keys.call(null, p1__7983_SHARP_, ks);
+  }, xrel));
+};
+clojure.set.rename_keys = function rename_keys(map, kmap) {
+  return cljs.core.reduce.call(null, function(m, p__7986) {
+    var vec__7987 = p__7986;
+    var old = cljs.core.nth.call(null, vec__7987, 0, null);
+    var new$ = cljs.core.nth.call(null, vec__7987, 1, null);
+    if (cljs.core.not_EQ_.call(null, old, new$) && cljs.core.contains_QMARK_.call(null, m, old)) {
+      return cljs.core.dissoc.call(null, cljs.core.assoc.call(null, m, new$, cljs.core.get.call(null, m, old)), old);
+    } else {
+      return m;
+    }
+  }, map, kmap);
+};
+clojure.set.rename = function rename(xrel, kmap) {
+  return cljs.core.set.call(null, cljs.core.map.call(null, function(p1__7988_SHARP_) {
+    return clojure.set.rename_keys.call(null, p1__7988_SHARP_, kmap);
+  }, xrel));
+};
+clojure.set.index = function index(xrel, ks) {
+  return cljs.core.reduce.call(null, function(m, x) {
+    var ik = cljs.core.select_keys.call(null, x, ks);
+    return cljs.core.assoc.call(null, m, ik, cljs.core.conj.call(null, cljs.core.get.call(null, m, ik, cljs.core.PersistentHashSet.EMPTY), x));
+  }, cljs.core.PersistentArrayMap.EMPTY, xrel);
+};
+clojure.set.map_invert = function map_invert(m) {
+  return cljs.core.reduce.call(null, function(m__$1, p__7991) {
+    var vec__7992 = p__7991;
+    var k = cljs.core.nth.call(null, vec__7992, 0, null);
+    var v = cljs.core.nth.call(null, vec__7992, 1, null);
+    return cljs.core.assoc.call(null, m__$1, v, k);
+  }, cljs.core.PersistentArrayMap.EMPTY, m);
+};
+clojure.set.join = function() {
+  var join = null;
+  var join__2 = function(xrel, yrel) {
+    if (cljs.core.seq.call(null, xrel) && cljs.core.seq.call(null, yrel)) {
+      var ks = clojure.set.intersection.call(null, cljs.core.set.call(null, cljs.core.keys.call(null, cljs.core.first.call(null, xrel))), cljs.core.set.call(null, cljs.core.keys.call(null, cljs.core.first.call(null, yrel))));
+      var vec__7999 = cljs.core.count.call(null, xrel) <= cljs.core.count.call(null, yrel) ? new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel, yrel], null) : new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel, xrel], null);
+      var r = cljs.core.nth.call(null, vec__7999, 0, null);
+      var s = cljs.core.nth.call(null, vec__7999, 1, null);
+      var idx = clojure.set.index.call(null, r, ks);
+      return cljs.core.reduce.call(null, function(ret, x) {
+        var found = idx.call(null, cljs.core.select_keys.call(null, x, ks));
+        if (cljs.core.truth_(found)) {
+          return cljs.core.reduce.call(null, function(p1__7993_SHARP_, p2__7994_SHARP_) {
+            return cljs.core.conj.call(null, p1__7993_SHARP_, cljs.core.merge.call(null, p2__7994_SHARP_, x));
+          }, ret, found);
+        } else {
+          return ret;
+        }
+      }, cljs.core.PersistentHashSet.EMPTY, s);
+    } else {
+      return cljs.core.PersistentHashSet.EMPTY;
+    }
+  };
+  var join__3 = function(xrel, yrel, km) {
+    var vec__8000 = cljs.core.count.call(null, xrel) <= cljs.core.count.call(null, yrel) ? new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel, yrel, clojure.set.map_invert.call(null, km)], null) : new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel, xrel, km], null);
+    var r = cljs.core.nth.call(null, vec__8000, 0, null);
+    var s = cljs.core.nth.call(null, vec__8000, 1, null);
+    var k = cljs.core.nth.call(null, vec__8000, 2, null);
+    var idx = clojure.set.index.call(null, r, cljs.core.vals.call(null, k));
+    return cljs.core.reduce.call(null, function(ret, x) {
+      var found = idx.call(null, clojure.set.rename_keys.call(null, cljs.core.select_keys.call(null, x, cljs.core.keys.call(null, k)), k));
+      if (cljs.core.truth_(found)) {
+        return cljs.core.reduce.call(null, function(p1__7995_SHARP_, p2__7996_SHARP_) {
+          return cljs.core.conj.call(null, p1__7995_SHARP_, cljs.core.merge.call(null, p2__7996_SHARP_, x));
+        }, ret, found);
+      } else {
+        return ret;
+      }
+    }, cljs.core.PersistentHashSet.EMPTY, s);
+  };
+  join = function(xrel, yrel, km) {
+    switch(arguments.length) {
+      case 2:
+        return join__2.call(this, xrel, yrel);
+      case 3:
+        return join__3.call(this, xrel, yrel, km);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  join.cljs$core$IFn$_invoke$arity$2 = join__2;
+  join.cljs$core$IFn$_invoke$arity$3 = join__3;
+  return join;
+}();
+clojure.set.subset_QMARK_ = function subset_QMARK_(set1, set2) {
+  return cljs.core.count.call(null, set1) <= cljs.core.count.call(null, set2) && cljs.core.every_QMARK_.call(null, function(p1__8001_SHARP_) {
+    return cljs.core.contains_QMARK_.call(null, set2, p1__8001_SHARP_);
+  }, set1);
+};
+clojure.set.superset_QMARK_ = function superset_QMARK_(set1, set2) {
+  return cljs.core.count.call(null, set1) >= cljs.core.count.call(null, set2) && cljs.core.every_QMARK_.call(null, function(p1__8002_SHARP_) {
+    return cljs.core.contains_QMARK_.call(null, set1, p1__8002_SHARP_);
+  }, set2);
+};
+goog.provide("nonaga.rules.rings");
+goog.require("cljs.core");
+goog.require("clojure.set");
+goog.require("nonaga.rules.coord");
+goog.require("nonaga.rules.coord");
+goog.require("clojure.set");
+nonaga.rules.rings.valid_slide_QMARK_ = function valid_slide_QMARK_(rings, coord, direction) {
+  var sliding_into_ring_QMARK_ = rings.call(null, direction.call(null, coord));
+  var gap_too_small_QMARK_ = cljs.core.apply.call(null, function(sliding_into_ring_QMARK_) {
+    return function(p1__21360_SHARP_, p2__21361_SHARP_) {
+      var and__3396__auto__ = p1__21360_SHARP_;
+      if (cljs.core.truth_(and__3396__auto__)) {
+        return p2__21361_SHARP_;
+      } else {
+        return and__3396__auto__;
+      }
+    };
+  }(sliding_into_ring_QMARK_), cljs.core.map.call(null, rings, cljs.core.map.call(null, function(sliding_into_ring_QMARK_) {
+    return function(p1__21362_SHARP_) {
+      return p1__21362_SHARP_.call(null, coord);
+    };
+  }(sliding_into_ring_QMARK_), nonaga.rules.coord.neighbouring_directions.call(null, direction))));
+  return cljs.core.not.call(null, function() {
+    var or__3408__auto__ = sliding_into_ring_QMARK_;
+    if (cljs.core.truth_(or__3408__auto__)) {
+      return or__3408__auto__;
+    } else {
+      return gap_too_small_QMARK_;
+    }
+  }());
+};
+nonaga.rules.rings.valid_slides = function valid_slides(rings, coord) {
+  return cljs.core.filter.call(null, cljs.core.partial.call(null, nonaga.rules.rings.valid_slide_QMARK_, rings, coord), cljs.core.keys.call(null, nonaga.rules.coord.neighbouring_directions));
+};
+nonaga.rules.rings.neighbour_distances = function neighbour_distances(rings, source, destination) {
+  return cljs.core.map.call(null, cljs.core.partial.call(null, nonaga.rules.coord.tag_with_distance, destination), cljs.core.map.call(null, function(p1__21363_SHARP_) {
+    return p1__21363_SHARP_.call(null, source);
+  }, nonaga.rules.rings.valid_slides.call(null, rings, source)));
+};
+nonaga.rules.rings.can_move_to_QMARK_ = function() {
+  var can_move_to_QMARK_ = null;
+  var can_move_to_QMARK___3 = function(rings, source, destination) {
+    if (cljs.core.truth_(rings.call(null, destination))) {
+      return false;
+    } else {
+      return can_move_to_QMARK_.call(null, rings, cljs.core.sorted_set.call(null, nonaga.rules.coord.tag_with_distance.call(null, destination, source)), cljs.core.sorted_set.call(null), destination, 0);
+    }
+  };
+  var can_move_to_QMARK___5 = function(rings, unexploded, exploded, destination, count) {
+    while (true) {
+      var next_choice = cljs.core.first.call(null, unexploded);
+      var vec__21365 = next_choice;
+      var _ = cljs.core.nth.call(null, vec__21365, 0, null);
+      var source = cljs.core.nth.call(null, vec__21365, 1, null);
+      var explosion = nonaga.rules.rings.neighbour_distances.call(null, rings, source, destination);
+      var new_exploded = cljs.core.conj.call(null, exploded, next_choice);
+      var new_unexploded = clojure.set.difference.call(null, cljs.core.into.call(null, unexploded, explosion), new_exploded);
+      if (cljs.core.truth_(new_unexploded.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, destination], null)))) {
+        return true;
+      } else {
+        if (cljs.core.empty_QMARK_.call(null, new_unexploded)) {
+          return false;
+        } else {
+          if (count > 100) {
+            return false;
+          } else {
+            var G__21366 = rings;
+            var G__21367 = new_unexploded;
+            var G__21368 = new_exploded;
+            var G__21369 = destination;
+            var G__21370 = count + 1;
+            rings = G__21366;
+            unexploded = G__21367;
+            exploded = G__21368;
+            destination = G__21369;
+            count = G__21370;
+            continue;
+          }
+        }
+      }
+      break;
+    }
+  };
+  can_move_to_QMARK_ = function(rings, unexploded, exploded, destination, count) {
+    switch(arguments.length) {
+      case 3:
+        return can_move_to_QMARK___3.call(this, rings, unexploded, exploded);
+      case 5:
+        return can_move_to_QMARK___5.call(this, rings, unexploded, exploded, destination, count);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  can_move_to_QMARK_.cljs$core$IFn$_invoke$arity$3 = can_move_to_QMARK___3;
+  can_move_to_QMARK_.cljs$core$IFn$_invoke$arity$5 = can_move_to_QMARK___5;
+  return can_move_to_QMARK_;
+}();
+nonaga.rules.rings.valid_destinations = function valid_destinations(rings, source) {
+  var other_rings = cljs.core.disj.call(null, rings, source);
+  var candidates = cljs.core.into.call(null, cljs.core.PersistentHashSet.EMPTY, cljs.core.map.call(null, cljs.core.first, cljs.core.filter.call(null, function(other_rings) {
+    return function(p__21373) {
+      var vec__21374 = p__21373;
+      var cell = cljs.core.nth.call(null, vec__21374, 0, null);
+      var neighbours = cljs.core.nth.call(null, vec__21374, 1, null);
+      return 1 < neighbours && neighbours < 6;
+    };
+  }(other_rings), cljs.core.frequencies.call(null, cljs.core.mapcat.call(null, nonaga.rules.coord.neighbours, other_rings)))));
+  var availables = clojure.set.difference.call(null, candidates, rings);
+  var slidables = cljs.core.filter.call(null, cljs.core.partial.call(null, nonaga.rules.rings.can_move_to_QMARK_, rings, source), availables);
+  return cljs.core.set.call(null, slidables);
+};
+nonaga.rules.rings.has_double_gap_QMARK_ = function has_double_gap_QMARK_(rings, coord) {
+  return!cljs.core.empty_QMARK_.call(null, cljs.core.filter.call(null, cljs.core.empty_QMARK_, cljs.core.map.call(null, cljs.core.partial.call(null, clojure.set.intersection, rings), cljs.core.map.call(null, cljs.core.set, cljs.core.apply.call(null, cljs.core.juxt, cljs.core.map.call(null, cljs.core.partial.call(null, cljs.core.apply, cljs.core.juxt), nonaga.rules.coord.side_by_side_directions)).call(null, coord)))));
+};
+nonaga.rules.rings.can_be_moved_QMARK_ = function can_be_moved_QMARK_(p__21375, coord) {
+  var map__21377 = p__21375;
+  var map__21377__$1 = cljs.core.seq_QMARK_.call(null, map__21377) ? cljs.core.apply.call(null, cljs.core.hash_map, map__21377) : map__21377;
+  var blue = cljs.core.get.call(null, map__21377__$1, new cljs.core.Keyword(null, "blue", "blue", 1016931276));
+  var red = cljs.core.get.call(null, map__21377__$1, new cljs.core.Keyword(null, "red", "red", 1014017027));
+  var rings = cljs.core.get.call(null, map__21377__$1, new cljs.core.Keyword(null, "rings", "rings", 1122422709));
+  var num_neighbours = cljs.core.count.call(null, clojure.set.intersection.call(null, nonaga.rules.coord.neighbours.call(null, coord), rings));
+  var and__3396__auto__ = rings.call(null, coord);
+  if (cljs.core.truth_(and__3396__auto__)) {
+    return cljs.core.not.call(null, function() {
+      var or__3408__auto__ = red.call(null, coord);
+      if (cljs.core.truth_(or__3408__auto__)) {
+        return or__3408__auto__;
+      } else {
+        return blue.call(null, coord);
+      }
+    }()) && (num_neighbours < 5 && nonaga.rules.rings.has_double_gap_QMARK_.call(null, rings, coord));
+  } else {
+    return and__3396__auto__;
+  }
+};
+goog.provide("nonaga.react");
+goog.require("cljs.core");
+nonaga.react.div = function() {
+  var div__delegate = function(props, children) {
+    return React.DOM.div(cljs.core.clj__GT_js.call(null, props), cljs.core.clj__GT_js.call(null, children));
+  };
+  var div = function(props, var_args) {
+    var children = null;
+    if (arguments.length > 1) {
+      children = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
+    }
+    return div__delegate.call(this, props, children);
+  };
+  div.cljs$lang$maxFixedArity = 1;
+  div.cljs$lang$applyTo = function(arglist__8511) {
+    var props = cljs.core.first(arglist__8511);
+    var children = cljs.core.rest(arglist__8511);
+    return div__delegate(props, children);
+  };
+  div.cljs$core$IFn$_invoke$arity$variadic = div__delegate;
+  return div;
+}();
+nonaga.react.p = function() {
+  var p__delegate = function(props, children) {
+    return React.DOM.p(cljs.core.clj__GT_js.call(null, props), cljs.core.clj__GT_js.call(null, children));
+  };
+  var p = function(props, var_args) {
+    var children = null;
+    if (arguments.length > 1) {
+      children = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
+    }
+    return p__delegate.call(this, props, children);
+  };
+  p.cljs$lang$maxFixedArity = 1;
+  p.cljs$lang$applyTo = function(arglist__8512) {
+    var props = cljs.core.first(arglist__8512);
+    var children = cljs.core.rest(arglist__8512);
+    return p__delegate(props, children);
+  };
+  p.cljs$core$IFn$_invoke$arity$variadic = p__delegate;
+  return p;
+}();
+nonaga.react.svg = function() {
+  var svg__delegate = function(props, children) {
+    return React.DOM.svg(cljs.core.clj__GT_js.call(null, props), cljs.core.clj__GT_js.call(null, children));
+  };
+  var svg = function(props, var_args) {
+    var children = null;
+    if (arguments.length > 1) {
+      children = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
+    }
+    return svg__delegate.call(this, props, children);
+  };
+  svg.cljs$lang$maxFixedArity = 1;
+  svg.cljs$lang$applyTo = function(arglist__8513) {
+    var props = cljs.core.first(arglist__8513);
+    var children = cljs.core.rest(arglist__8513);
+    return svg__delegate(props, children);
+  };
+  svg.cljs$core$IFn$_invoke$arity$variadic = svg__delegate;
+  return svg;
+}();
+nonaga.react.circle = function circle(props) {
+  return React.DOM.circle(cljs.core.clj__GT_js.call(null, props));
+};
+nonaga.react.create_class = function() {
+  var create_class__delegate = function(p__8514) {
+    var map__8516 = p__8514;
+    var map__8516__$1 = cljs.core.seq_QMARK_.call(null, map__8516) ? cljs.core.apply.call(null, cljs.core.hash_map, map__8516) : map__8516;
+    var config = map__8516__$1;
+    return React.createClass(cljs.core.clj__GT_js.call(null, config));
+  };
+  var create_class = function(var_args) {
+    var p__8514 = null;
+    if (arguments.length > 0) {
+      p__8514 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
+    }
+    return create_class__delegate.call(this, p__8514);
+  };
+  create_class.cljs$lang$maxFixedArity = 0;
+  create_class.cljs$lang$applyTo = function(arglist__8517) {
+    var p__8514 = cljs.core.seq(arglist__8517);
+    return create_class__delegate(p__8514);
+  };
+  create_class.cljs$core$IFn$_invoke$arity$variadic = create_class__delegate;
+  return create_class;
+}();
+nonaga.react.render_component = function render_component(component, node) {
+  return React.renderComponent(component, node);
+};
+goog.provide("nonaga.draw");
+goog.require("cljs.core");
+goog.require("nonaga.react");
+goog.require("nonaga.rules.rings");
+goog.require("nonaga.rules.rings");
+goog.require("nonaga.rules.ball");
+goog.require("nonaga.rules.ball");
+goog.require("nonaga.core");
+goog.require("nonaga.core");
+goog.require("nonaga.react");
+nonaga.draw.hex__GT_svg = function hex__GT_svg(p__22287) {
+  var vec__22289 = p__22287;
+  var hex_x = cljs.core.nth.call(null, vec__22289, 0, null);
+  var hex_y = cljs.core.nth.call(null, vec__22289, 1, null);
+  var width = 40;
+  var half = width / 2;
+  var svg_x = 160 + width * hex_x + (cljs.core.odd_QMARK_.call(null, hex_y) ? half : 0);
+  var svg_y = 160 + width * hex_y;
+  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [svg_x, svg_y], null);
+};
+nonaga.draw.ring = function() {
+  var ring = null;
+  var ring__2 = function(color, coord) {
+    return ring.call(null, color, null, coord);
+  };
+  var ring__3 = function(color, click, p__22290) {
+    var vec__22292 = p__22290;
+    var x = cljs.core.nth.call(null, vec__22292, 0, null);
+    var y = cljs.core.nth.call(null, vec__22292, 1, null);
+    var coord = vec__22292;
+    return nonaga.react.circle.call(null, cljs.core.PersistentHashMap.fromArrays(["fill", "onClick", "strokeWidth", "style", "r", "cx", "cy", "stroke", "key"], ["transparent", click, "7px", new cljs.core.PersistentArrayMap(null, 1, ["cursor", cljs.core.truth_(click) ? "pointer" : null], null), 14, x, y, color, [cljs.core.str("ring:"), cljs.core.str(x), cljs.core.str(","), cljs.core.str(y)].join("")]));
+  };
+  ring = function(color, click, p__22290) {
+    switch(arguments.length) {
+      case 2:
+        return ring__2.call(this, color, click);
+      case 3:
+        return ring__3.call(this, color, click, p__22290);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  ring.cljs$core$IFn$_invoke$arity$2 = ring__2;
+  ring.cljs$core$IFn$_invoke$arity$3 = ring__3;
+  return ring;
+}();
+nonaga.draw.marble = function() {
+  var marble = null;
+  var marble__2 = function(color, coord) {
+    return marble.call(null, color, null, coord);
+  };
+  var marble__3 = function(color, click, p__22293) {
+    var vec__22295 = p__22293;
+    var x = cljs.core.nth.call(null, vec__22295, 0, null);
+    var y = cljs.core.nth.call(null, vec__22295, 1, null);
+    var coord = vec__22295;
+    return nonaga.react.circle.call(null, new cljs.core.PersistentArrayMap(null, 7, ["cx", x, "cy", y, "r", 8, "fill", cljs.core.name.call(null, color), "onClick", click, "style", new cljs.core.PersistentArrayMap(null, 1, ["cursor", cljs.core.truth_(click) ? "pointer" : null], null), "key", [cljs.core.str("marble"), cljs.core.str(x), cljs.core.str(","), cljs.core.str(y)].join("")], null));
+  };
+  marble = function(color, click, p__22293) {
+    switch(arguments.length) {
+      case 2:
+        return marble__2.call(this, color, click);
+      case 3:
+        return marble__3.call(this, color, click, p__22293);
+    }
+    throw new Error("Invalid arity: " + arguments.length);
+  };
+  marble.cljs$core$IFn$_invoke$arity$2 = marble__2;
+  marble.cljs$core$IFn$_invoke$arity$3 = marble__3;
+  return marble;
+}();
+nonaga.draw.opposite = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.Keyword(null, "blue", "blue", 1016931276), new cljs.core.Keyword(null, "blue", "blue", 1016931276), new cljs.core.Keyword(null, "red", "red", 1014017027)], null);
+nonaga.draw.light_colors = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.Keyword(null, "pink", "pink", 1017345256), new cljs.core.Keyword(null, "blue", "blue", 1016931276), new cljs.core.Keyword(null, "lightblue", "lightblue", 1699995106)], null);
+nonaga.draw.update_state = function update_state(component, update_fn) {
+  return function() {
+    var old_state = component.state.wrapper;
+    return component.setState({"wrapper":update_fn.call(null, old_state)});
+  };
+};
+nonaga.draw.move_marble = function move_marble(component, color, from, to) {
+  return nonaga.draw.update_state.call(null, component, function(p1__22296_SHARP_) {
+    return cljs.core.assoc.call(null, nonaga.core.move_ball.call(null, p1__22296_SHARP_, color, from, to), new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "marble-moved", "marble-moved", 2104727445), color], null));
+  });
+};
+nonaga.draw.draw_valid_marble_moves = function draw_valid_marble_moves(component, state) {
+  var vec__22299 = (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state);
+  var type = cljs.core.nth.call(null, vec__22299, 0, null);
+  var event_data = cljs.core.nthnext.call(null, vec__22299, 1);
+  if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885), type)) {
+    var vec__22300 = event_data;
+    var color = cljs.core.nth.call(null, vec__22300, 0, null);
+    var selected = cljs.core.nth.call(null, vec__22300, 1, null);
+    return cljs.core.map.call(null, function(hex) {
+      return nonaga.draw.marble.call(null, nonaga.draw.light_colors.call(null, color), nonaga.draw.move_marble.call(null, component, color, selected, hex), nonaga.draw.hex__GT_svg.call(null, hex));
+    }, nonaga.rules.ball.valid_destinations.call(null, state, selected));
+  } else {
+    return null;
+  }
+};
+nonaga.draw.start_marble_move = function start_marble_move(component, color, coord) {
+  return nonaga.draw.update_state.call(null, component, function(p1__22301_SHARP_) {
+    return cljs.core.assoc.call(null, p1__22301_SHARP_, new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885), color, coord], null));
+  });
+};
+nonaga.draw.draw_marbles = function draw_marbles(component, state, color) {
+  var etype = cljs.core.get_in.call(null, state, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "event", "event", 1110795788), 0], null));
+  var cp = cljs.core.get_in.call(null, state, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "event", "event", 1110795788), 1], null));
+  var coords = color.call(null, state);
+  var click = cljs.core.partial.call(null, nonaga.draw.start_marble_move, component);
+  return cljs.core.map.call(null, function(hex, svg) {
+    return nonaga.draw.marble.call(null, color, (cljs.core._EQ_.call(null, etype, new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291)) || cljs.core._EQ_.call(null, etype, new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885))) && cljs.core._EQ_.call(null, cp, color) ? click.call(null, color, hex) : null, svg);
+  }, coords, cljs.core.map.call(null, nonaga.draw.hex__GT_svg, coords));
+};
+nonaga.draw.ring_selected = function ring_selected(component, color, coord) {
+  return nonaga.draw.update_state.call(null, component, function(p1__22302_SHARP_) {
+    return cljs.core.assoc.call(null, p1__22302_SHARP_, new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), color, coord], null));
+  });
+};
+nonaga.draw.draw_rings = function draw_rings(component, state) {
+  var vec__22305 = (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state);
+  var type = cljs.core.nth.call(null, vec__22305, 0, null);
+  var event_data = cljs.core.nthnext.call(null, vec__22305, 1);
+  var coords = (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(state);
+  return cljs.core.map.call(null, function(hex, svg) {
+    if (cljs.core.truth_(function() {
+      var and__3396__auto__ = cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "marble-moved", "marble-moved", 2104727445), type) || cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), type);
+      if (and__3396__auto__) {
+        return nonaga.rules.rings.can_be_moved_QMARK_.call(null, state, hex);
+      } else {
+        return and__3396__auto__;
+      }
+    }())) {
+      var vec__22306 = event_data;
+      var color = cljs.core.nth.call(null, vec__22306, 0, null);
+      return nonaga.draw.ring.call(null, "#444", nonaga.draw.ring_selected.call(null, component, color, hex), svg);
+    } else {
+      return nonaga.draw.ring.call(null, "#999", svg);
+    }
+  }, coords, cljs.core.map.call(null, nonaga.draw.hex__GT_svg, coords));
+};
+nonaga.draw.move_ring = function move_ring(component, color, from, to) {
+  return nonaga.draw.update_state.call(null, component, function(p1__22307_SHARP_) {
+    return cljs.core.assoc.call(null, cljs.core.assoc.call(null, nonaga.core.move_ring.call(null, p1__22307_SHARP_, from, to), new cljs.core.Keyword(null, "last-ring", "last-ring", 2980977273), to), new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291), nonaga.draw.opposite.call(null, color)], null));
+  });
+};
+nonaga.draw.draw_potential_rings = function draw_potential_rings(component, state) {
+  var vec__22310 = (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state);
+  var type = cljs.core.nth.call(null, vec__22310, 0, null);
+  var event_data = cljs.core.nthnext.call(null, vec__22310, 1);
+  var coords = (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(state);
+  if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), type)) {
+    var vec__22311 = event_data;
+    var color = cljs.core.nth.call(null, vec__22311, 0, null);
+    var source = cljs.core.nth.call(null, vec__22311, 1, null);
+    var destinations = nonaga.rules.rings.valid_destinations.call(null, coords, source);
+    return cljs.core.map.call(null, function(hex, svg) {
+      return nonaga.draw.ring.call(null, "#DDD", nonaga.draw.move_ring.call(null, component, color, source, hex), svg);
+    }, destinations, cljs.core.map.call(null, nonaga.draw.hex__GT_svg, destinations));
+  } else {
+    return null;
+  }
+};
+nonaga.draw.color_name = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "red", "red", 1014017027), "Red", new cljs.core.Keyword(null, "blue", "blue", 1016931276), "Blue"], null);
+nonaga.draw.instructions = function() {
+  var method_table__4242__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var prefer_table__4243__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var method_cache__4244__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var cached_hierarchy__4245__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
+  var hierarchy__4246__auto__ = cljs.core.get.call(null, cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "hierarchy", "hierarchy", 3129050535), cljs.core.get_global_hierarchy.call(null));
+  return new cljs.core.MultiFn("instructions", cljs.core.first, new cljs.core.Keyword(null, "default", "default", 2558708147), hierarchy__4246__auto__, method_table__4242__auto__, prefer_table__4243__auto__, method_cache__4244__auto__, cached_hierarchy__4245__auto__);
+}();
+cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291), function(p__22312) {
+  var vec__22313 = p__22312;
+  var type = cljs.core.nth.call(null, vec__22313, 0, null);
+  var color = cljs.core.nth.call(null, vec__22313, 1, null);
+  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects a marble to move.")].join("");
+});
+cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885), function(p__22314) {
+  var vec__22315 = p__22314;
+  var type = cljs.core.nth.call(null, vec__22315, 0, null);
+  var color = cljs.core.nth.call(null, vec__22315, 1, null);
+  var source = cljs.core.nth.call(null, vec__22315, 2, null);
+  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects where to move the marble.")].join("");
+});
+cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "marble-moved", "marble-moved", 2104727445), function(p__22316) {
+  var vec__22317 = p__22316;
+  var type = cljs.core.nth.call(null, vec__22317, 0, null);
+  var color = cljs.core.nth.call(null, vec__22317, 1, null);
+  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects a ring to move.")].join("");
+});
+cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), function(p__22318) {
+  var vec__22319 = p__22318;
+  var type = cljs.core.nth.call(null, vec__22319, 0, null);
+  var color = cljs.core.nth.call(null, vec__22319, 1, null);
+  var source = cljs.core.nth.call(null, vec__22319, 2, null);
+  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects where to move the ring.")].join("");
+});
+nonaga.draw.board = nonaga.react.create_class.call(null, "getInitialState", function() {
+  var this$ = this;
+  var initial_state = cljs.core.assoc.call(null, nonaga.core.initial_game, new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291), new cljs.core.Keyword(null, "red", "red", 1014017027)], null));
+  return{"wrapper":initial_state};
+}, "render", function() {
+  var this$ = this;
+  var state = this$.state.wrapper;
+  return nonaga.react.div.call(null, cljs.core.PersistentArrayMap.EMPTY, nonaga.react.p.call(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "id", "id", 1013907597), "instructions"], null), nonaga.draw.instructions.call(null, (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state))), nonaga.react.svg.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "width", "width", 1127031096), 480, new cljs.core.Keyword(null, 
+  "height", "height", 4087841945), 480], null), nonaga.draw.draw_rings.call(null, this$, state), nonaga.draw.draw_potential_rings.call(null, this$, state), function() {
+    var temp__4090__auto__ = (new cljs.core.Keyword(null, "last-ring", "last-ring", 2980977273)).cljs$core$IFn$_invoke$arity$1(state);
+    if (cljs.core.truth_(temp__4090__auto__)) {
+      var last_ring = temp__4090__auto__;
+      return nonaga.draw.ring.call(null, "#000", nonaga.draw.hex__GT_svg.call(null, last_ring));
+    } else {
+      return null;
+    }
+  }(), nonaga.draw.draw_marbles.call(null, this$, state, new cljs.core.Keyword(null, "red", "red", 1014017027)), nonaga.draw.draw_marbles.call(null, this$, state, new cljs.core.Keyword(null, "blue", "blue", 1016931276)), nonaga.draw.draw_valid_marble_moves.call(null, this$, state)));
+});
+nonaga.draw.start = function start() {
+  return nonaga.react.render_component.call(null, nonaga.draw.board.call(null), document.getElementById("content"));
+};
+goog.provide("nonaga.rules.ring_test");
+goog.require("cljs.core");
+goog.require("nonaga.core");
+goog.require("clojure.set");
+goog.require("nonaga.rules.rings");
+goog.require("nonaga.rules.coord");
+goog.require("cemerick.cljs.test");
+goog.require("cemerick.cljs.test");
+goog.require("clojure.set");
+goog.require("nonaga.rules.coord");
+goog.require("nonaga.rules.rings");
+goog.require("nonaga.core");
+nonaga.rules.ring_test.board_with_gap = cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true);
+nonaga.rules.ring_test.which_slides_are_valid = function which_slides_are_valid() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.which_slides_are_valid);
+};
+nonaga.rules.ring_test.which_slides_are_valid = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.which_slides_are_valid, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "which-slides-are-valid", "which-slides-are-valid", 1667419009, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function which_slides_are_valid_test() {
+  try {
+    var values__5008__auto___22185 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_slide_QMARK_.call(null, (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(nonaga.core.initial_game), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), nonaga.rules.coord.ne)), false);
+    var result__5009__auto___22186 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22185);
+    if (cljs.core.truth_(result__5009__auto___22186)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22185), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22185)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
+    }
+  } catch (e22181) {
+    if (e22181 instanceof Error) {
+      var t__5045__auto___22187 = e22181;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22187, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22181;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22188 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_slide_QMARK_.call(null, (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(nonaga.core.initial_game), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), nonaga.rules.coord.se)), true);
+    var result__5009__auto___22189 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22188);
+    if (cljs.core.truth_(result__5009__auto___22189)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22188), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "se", "se", -1640527861, null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22188)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "se", "se", -1640527861, null)))], null));
+    }
+  } catch (e22182) {
+    if (e22182 instanceof Error) {
+      var t__5045__auto___22190 = e22182;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22190, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      true, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "se", "se", -1640527861, null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22182;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22191 = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_slide_QMARK_.call(null, nonaga.rules.ring_test.board_with_gap, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), nonaga.rules.coord.ne));
+    var result__5009__auto___22192 = cljs.core.apply.call(null, cljs.core.not, values__5008__auto___22191);
+    if (cljs.core.truth_(result__5009__auto___22192)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto___22191), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto___22191)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), new cljs.core.Symbol(null, 
+      "ne", "ne", -1640528016, null)))], null));
+    }
+  } catch (e22183) {
+    if (e22183 instanceof Error) {
+      var t__5045__auto___22193 = e22183;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22193, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
+      "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22183;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.ne), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)), nonaga.rules.ring_test.board_with_gap);
+    var result__5009__auto__ = cljs.core.apply.call(null, nonaga.rules.rings.valid_slide_QMARK_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, nonaga.rules.rings.valid_slide_QMARK_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", 
+      "fail", 1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null))], null));
+    }
+    return result__5009__auto__;
+  } catch (e22184) {
+    if (e22184 instanceof Error) {
+      var t__5045__auto__ = e22184;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, 
+      null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22184;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.which_slides_are_valid);
+nonaga.rules.ring_test.enumerate_valid_directions_to_slide = function enumerate_valid_directions_to_slide() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.enumerate_valid_directions_to_slide);
+};
+nonaga.rules.ring_test.enumerate_valid_directions_to_slide = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.enumerate_valid_directions_to_slide, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "enumerate-valid-directions-to-slide", "enumerate-valid-directions-to-slide", -9756425, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function enumerate_valid_directions_to_slide_test() {
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.count.call(null, nonaga.rules.rings.valid_slides.call(null, nonaga.rules.ring_test.board_with_gap, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null)))), 3);
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), 3, cljs.core.list(new cljs.core.Symbol(null, "count", "count", -1545680184, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slides", "valid-slides", 513612172, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null))))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 3, cljs.core.list(new cljs.core.Symbol(null, "count", "count", -1545680184, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slides", "valid-slides", 513612172, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null))))], null));
+    }
+    return result__5009__auto__;
+  } catch (e22195) {
+    if (e22195 instanceof Error) {
+      var t__5045__auto__ = e22195;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      3, cljs.core.list(new cljs.core.Symbol(null, "count", "count", -1545680184, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slides", "valid-slides", 513612172, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null))))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22195;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.enumerate_valid_directions_to_slide);
+nonaga.rules.ring_test.path_finding = function path_finding() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.path_finding);
+};
+nonaga.rules.ring_test.path_finding = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.path_finding, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "path-finding", "path-finding", 1667655578, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function path_finding_test() {
+  try {
+    var values__5008__auto___22212 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), 
+    true);
+    var result__5009__auto___22213 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22212);
+    if (cljs.core.truth_(result__5009__auto___22213)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22212), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22212)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+  } catch (e22204) {
+    if (e22204 instanceof Error) {
+      var t__5045__auto___22214 = e22204;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22214, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22204;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22215 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), false);
+    var result__5009__auto___22216 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22215);
+    if (cljs.core.truth_(result__5009__auto___22216)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22215), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22215)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+  } catch (e22205) {
+    if (e22205 instanceof Error) {
+      var t__5045__auto___22217 = e22205;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22217, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22205;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22218 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), true);
+    var result__5009__auto___22219 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22218);
+    if (cljs.core.truth_(result__5009__auto___22219)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22218), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22218)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+  } catch (e22206) {
+    if (e22206 instanceof Error) {
+      var t__5045__auto___22220 = e22206;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22220, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22206;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22221 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+    [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), true);
+    var result__5009__auto___22222 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22221);
+    if (cljs.core.truth_(result__5009__auto___22222)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22221), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22221)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
+      2], null)))], null));
+    }
+  } catch (e22207) {
+    if (e22207 instanceof Error) {
+      var t__5045__auto___22223 = e22207;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22223, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), 
+      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22207;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22224 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+    [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 
+    2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), false);
+    var result__5009__auto___22225 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22224);
+    if (cljs.core.truth_(result__5009__auto___22225)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22224), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22224)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+  } catch (e22208) {
+    if (e22208 instanceof Error) {
+      var t__5045__auto___22226 = e22208;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22226, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), 
+      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22208;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22227 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+    [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
+    2], null))), false);
+    var result__5009__auto___22228 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22227);
+    if (cljs.core.truth_(result__5009__auto___22228)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22227), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22227)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], 
+      null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+  } catch (e22209) {
+    if (e22209 instanceof Error) {
+      var t__5045__auto___22229 = e22209;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22229, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], 
+      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], 
+      null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22209;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22230 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+    [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
+    2], null))), false);
+    var result__5009__auto___22231 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22230);
+    if (cljs.core.truth_(result__5009__auto___22231)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22230), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
+      2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22230)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], 
+      true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+  } catch (e22210) {
+    if (e22210 instanceof Error) {
+      var t__5045__auto___22232 = e22210;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22232, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), 
+      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], 
+      null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22210;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+    [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), false);
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 
+      2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    }
+    return result__5009__auto__;
+  } catch (e22211) {
+    if (e22211 instanceof Error) {
+      var t__5045__auto__ = e22211;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), 
+      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22211;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.path_finding);
+nonaga.rules.ring_test.knows_where_you_can_go = function knows_where_you_can_go() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.knows_where_you_can_go);
+};
+nonaga.rules.ring_test.knows_where_you_can_go = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.knows_where_you_can_go, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "knows-where-you-can-go", "knows-where-you-can-go", -538163273, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function knows_where_you_can_go_test() {
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_destinations.call(null, (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(nonaga.core.initial_game), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], 
+    null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 
+    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, -1], null)], true));
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [2, -1], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, -1], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 
+      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    }
+    return result__5009__auto__;
+  } catch (e22234) {
+    if (e22234 instanceof Error) {
+      var t__5045__auto__ = e22234;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
+      cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+      [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, -1], 
+      null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22234;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.knows_where_you_can_go);
+nonaga.rules.ring_test.knows_what_can_moved = function knows_what_can_moved() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.knows_what_can_moved);
+};
+nonaga.rules.ring_test.knows_what_can_moved = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.knows_what_can_moved, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "knows-what-can-moved", "knows-what-can-moved", -1622980213, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function knows_what_can_moved_test() {
+  try {
+    var values__5008__auto___22239 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null)), nonaga.core.initial_game);
+    var result__5009__auto___22240 = cljs.core.apply.call(null, nonaga.rules.rings.can_be_moved_QMARK_, values__5008__auto___22239);
+    if (cljs.core.truth_(result__5009__auto___22240)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, nonaga.rules.rings.can_be_moved_QMARK_, values__5008__auto___22239), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), values__5008__auto___22239)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, 
+      "fail", "fail", 1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))], null));
+    }
+  } catch (e22237) {
+    if (e22237 instanceof Error) {
+      var t__5045__auto___22241 = e22237;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22241, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, 
+      null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22237;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_be_moved_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)));
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core.not, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 1017039504), 
+      new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    }
+    return result__5009__auto__;
+  } catch (e22238) {
+    if (e22238 instanceof Error) {
+      var t__5045__auto__ = e22238;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
+      "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22238;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.knows_what_can_moved);
+nonaga.rules.ring_test.one_each_way = new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
+[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 
+2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true)], null);
+nonaga.rules.ring_test.has_double_gap_QMARK__test = function has_double_gap_QMARK__test() {
+  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.has_double_gap_QMARK__test);
+};
+nonaga.rules.ring_test.has_double_gap_QMARK__test = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.has_double_gap_QMARK__test, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "has-double-gap?-test", "has-double-gap?-test", 1097403718, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function has_double_gap_QMARK__test_test() {
+  try {
+    var values__5008__auto___22248 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)), nonaga.core.initial_game);
+    var result__5009__auto___22249 = cljs.core.apply.call(null, nonaga.rules.rings.has_double_gap_QMARK_, values__5008__auto___22248);
+    if (cljs.core.truth_(result__5009__auto___22249)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, nonaga.rules.rings.has_double_gap_QMARK_, values__5008__auto___22248), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), values__5008__auto___22248)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, 
+      "fail", "fail", 1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))], null));
+    }
+  } catch (e22245) {
+    if (e22245 instanceof Error) {
+      var t__5045__auto___22250 = e22245;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22250, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", 
+      -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22245;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto___22251 = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.has_double_gap_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)));
+    var result__5009__auto___22252 = cljs.core.apply.call(null, cljs.core.not, values__5008__auto___22251);
+    if (cljs.core.truth_(result__5009__auto___22252)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto___22251), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto___22251)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
+      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], 
+      null));
+    }
+  } catch (e22246) {
+    if (e22246 instanceof Error) {
+      var t__5045__auto___22253 = e22246;
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22253, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
+      "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22246;
+      } else {
+      }
+    }
+  }
+  try {
+    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.has_double_gap_QMARK_.call(null, nonaga.rules.ring_test.one_each_way, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)));
+    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core.not, values__5008__auto__);
+    if (cljs.core.truth_(result__5009__auto__)) {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
+      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "one-each-way", "one-each-way", 358013539, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)))], null));
+    } else {
+      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 1017039504), 
+      new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "one-each-way", "one-each-way", 358013539, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)))], null));
+    }
+    return result__5009__auto__;
+  } catch (e22247) {
+    if (e22247 instanceof Error) {
+      var t__5045__auto__ = e22247;
+      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
+      "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "one-each-way", "one-each-way", 358013539, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)))], null));
+    } else {
+      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
+        throw e22247;
+      } else {
+        return null;
+      }
+    }
+  }
+});
+cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.has_double_gap_QMARK__test);
diff --git a/resources/test.html b/resources/test.html
new file mode 100644
index 0000000..0cfa57a
--- /dev/null
+++ b/resources/test.html
@@ -0,0 +1,17 @@
+<html>
+  <head>
+    <style>
+      #content { float: left; }
+    </style>
+  </head>
+  <body>
+    <div id="content"></div>
+    <pre id="test-output"></pre>
+    <script src="js/react-0.8.0.js"></script>
+    <script src="js/test.js"></script>
+    <script>
+      nonaga.draw.start();
+      cemerick.cljs.test.run_all_tests();
+    </script>
+  </body>
+</html>
diff --git a/test/nonaga/setup.cljs b/test/nonaga/setup.cljs
new file mode 100644
index 0000000..04a550e
--- /dev/null
+++ b/test/nonaga/setup.cljs
@@ -0,0 +1,9 @@
+(ns nonaga.setup)
+
+(defn set-pre! [output]
+  (let [new-text (js/document.createTextNode output)
+        output (js/document.getElementById "test-output")]
+    (.appendChild output new-text)))
+
+(set-print-fn! #(set-pre! %))
+

From 4b8b57dd2f1ab90090bfb58bcf94e31395498789 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Mon, 20 Jan 2014 17:35:01 +1100
Subject: [PATCH 05/39] removed generated test.js

---
 .gitignore           |     1 +
 resources/js/test.js | 25504 -----------------------------------------
 2 files changed, 1 insertion(+), 25504 deletions(-)
 delete mode 100644 resources/js/test.js

diff --git a/.gitignore b/.gitignore
index a4a8d78..a69a86d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@ pom.xml.asc
 /.lein-*
 /.nrepl-port
 /resources/js/main.js
+/resources/js/test.js
diff --git a/resources/js/test.js b/resources/js/test.js
deleted file mode 100644
index cf8008f..0000000
--- a/resources/js/test.js
+++ /dev/null
@@ -1,25504 +0,0 @@
-var CLOSURE_NO_DEPS = true;
-var COMPILED = false;
-var goog = goog || {};
-goog.global = this;
-goog.DEBUG = true;
-goog.LOCALE = "en";
-goog.TRUSTED_SITE = true;
-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;
-      if (doc.readyState == "complete") {
-        var isDeps = /\bdeps.js$/.test(src);
-        if (isDeps) {
-          return false;
-        } else {
-          throw Error('Cannot write "' + src + '" after document load');
-        }
-      }
-      doc.write('\x3cscript type\x3d"text/javascript" src\x3d"' + src + '"\x3e\x3c/' + "script\x3e");
-      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.random() * 1E9 >>> 0);
-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 = goog.TRUSTED_SITE && 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_ \x3d 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.getMsgWithFallback = function(a, b) {
-  return a;
-};
-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 ? "\x3cbr /\x3e" : "\x3cbr\x3e");
-};
-goog.string.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
-  if (opt_isLikelyToContainHtmlChars) {
-    return str.replace(goog.string.amperRe_, "\x26amp;").replace(goog.string.ltRe_, "\x26lt;").replace(goog.string.gtRe_, "\x26gt;").replace(goog.string.quotRe_, "\x26quot;");
-  } else {
-    if (!goog.string.allRe_.test(str)) {
-      return str;
-    }
-    if (str.indexOf("\x26") != -1) {
-      str = str.replace(goog.string.amperRe_, "\x26amp;");
-    }
-    if (str.indexOf("\x3c") != -1) {
-      str = str.replace(goog.string.ltRe_, "\x26lt;");
-    }
-    if (str.indexOf("\x3e") != -1) {
-      str = str.replace(goog.string.gtRe_, "\x26gt;");
-    }
-    if (str.indexOf('"') != -1) {
-      str = str.replace(goog.string.quotRe_, "\x26quot;");
-    }
-    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, "\x26")) {
-    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 = {"\x26amp;":"\x26", "\x26lt;":"\x3c", "\x26gt;":"\x3e", "\x26quot;":'"'};
-  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 "\x26";
-      case "lt":
-        return "\x3c";
-      case "gt":
-        return "\x3e";
-      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, " \x26#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 = goog.TRUSTED_SITE;
-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.count = function(arr, f, opt_obj) {
-  var count = 0;
-  goog.array.forEach(arr, function(element, index, arr) {
-    if (f.call(opt_obj, element, index, arr)) {
-      ++count;
-    }
-  }, opt_obj);
-  return count;
-};
-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)) && Object.prototype.hasOwnProperty.call(arr2, "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.toObject = function(arr, keyFunc, opt_obj) {
-  var ret = {};
-  goog.array.forEach(arr, function(element, index) {
-    ret[keyFunc.call(opt_obj, element, index, arr)] = element;
-  });
-  return ret;
-};
-goog.array.range = function(startOrEnd, opt_end, opt_step) {
-  var array = [];
-  var start = 0;
-  var end = startOrEnd;
-  var step = opt_step || 1;
-  if (opt_end !== undefined) {
-    start = startOrEnd;
-    end = opt_end;
-  }
-  if (step * (end - start) < 0) {
-    return[];
-  }
-  if (step > 0) {
-    for (var i = start;i < end;i += step) {
-      array.push(i);
-    }
-  } else {
-    for (var i = start;i > end;i += step) {
-      array.push(i);
-    }
-  }
-  return array;
-};
-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.object.createImmutableView = function(obj) {
-  var result = obj;
-  if (Object.isFrozen && !Object.isFrozen(obj)) {
-    result = Object.create(obj);
-    Object.freeze(result);
-  }
-  return result;
-};
-goog.object.isImmutableView = function(obj) {
-  return!!Object.isFrozen && Object.isFrozen(obj);
-};
-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.array");
-goog.require("goog.object");
-goog.require("goog.object");
-goog.require("goog.string.StringBuffer");
-goog.require("goog.string.StringBuffer");
-goog.require("goog.string");
-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;
-};
-cljs.core._STAR_flush_on_newline_STAR_ = true;
-cljs.core._STAR_print_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._STAR_print_length_STAR_ = null;
-cljs.core._STAR_print_level_STAR_ = null;
-cljs.core.pr_opts = function pr_opts() {
-  return new cljs.core.PersistentArrayMap(null, 5, [new cljs.core.Keyword(null, "flush-on-newline", "flush-on-newline", 4338025857), cljs.core._STAR_flush_on_newline_STAR_, new cljs.core.Keyword(null, "readably", "readably", 4441712502), cljs.core._STAR_print_readably_STAR_, new cljs.core.Keyword(null, "meta", "meta", 1017252215), cljs.core._STAR_print_meta_STAR_, new cljs.core.Keyword(null, "dup", "dup", 1014004081), cljs.core._STAR_print_dup_STAR_, new cljs.core.Keyword(null, "print-length", "print-length", 
-  3960797560), cljs.core._STAR_print_length_STAR_], null);
-};
-cljs.core.enable_console_print_BANG_ = function enable_console_print_BANG_() {
-  cljs.core._STAR_print_newline_STAR_ = false;
-  return cljs.core._STAR_print_fn_STAR_ = function() {
-    var G__6957__delegate = function(args) {
-      return console.log.apply(console, cljs.core.into_array.call(null, args));
-    };
-    var G__6957 = function(var_args) {
-      var args = null;
-      if (arguments.length > 0) {
-        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-      }
-      return G__6957__delegate.call(this, args);
-    };
-    G__6957.cljs$lang$maxFixedArity = 0;
-    G__6957.cljs$lang$applyTo = function(arglist__6958) {
-      var args = cljs.core.seq(arglist__6958);
-      return G__6957__delegate(args);
-    };
-    G__6957.cljs$core$IFn$_invoke$arity$variadic = G__6957__delegate;
-    return G__6957;
-  }();
-};
-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.object_QMARK_ = function object_QMARK_(x) {
-  if (!(x == null)) {
-    return x.constructor === Object;
-  } else {
-    return false;
-  }
-};
-cljs.core.string_QMARK_ = function string_QMARK_(x) {
-  return goog.isString(x);
-};
-cljs.core.native_satisfies_QMARK_ = function native_satisfies_QMARK_(p, x) {
-  var x__$1 = x == null ? null : x;
-  if (p[goog.typeOf(x__$1)]) {
-    return true;
-  } else {
-    if (p["_"]) {
-      return true;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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__3396__auto__ = ty;
-    if (cljs.core.truth_(and__3396__auto__)) {
-      return ty.cljs$lang$type;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) ? ty.cljs$lang$ctorStr : goog.typeOf(obj);
-  return new Error(["No protocol method ", proto, " defined for type ", ty__$1, ": ", obj].join(""));
-};
-cljs.core.type__GT_str = function type__GT_str(ty) {
-  var temp__4090__auto__ = ty.cljs$lang$ctorStr;
-  if (cljs.core.truth_(temp__4090__auto__)) {
-    var s = temp__4090__auto__;
-    return s;
-  } else {
-    return[cljs.core.str(ty)].join("");
-  }
-};
-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.aclone = function aclone(arr) {
-  var len = arr.length;
-  var new_arr = new Array(len);
-  var n__4232__auto___6959 = len;
-  var i_6960 = 0;
-  while (true) {
-    if (i_6960 < n__4232__auto___6959) {
-      new_arr[i_6960] = arr[i_6960];
-      var G__6961 = i_6960 + 1;
-      i_6960 = G__6961;
-      continue;
-    } else {
-    }
-    break;
-  }
-  return new_arr;
-};
-cljs.core.array = function array(var_args) {
-  return Array.prototype.slice.call(arguments);
-};
-cljs.core.aget = function() {
-  var aget = null;
-  var aget__2 = function(array, i) {
-    return array[i];
-  };
-  var aget__3 = function() {
-    var G__6962__delegate = function(array, i, idxs) {
-      return cljs.core.apply.call(null, aget, aget.call(null, array, i), idxs);
-    };
-    var G__6962 = 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__6962__delegate.call(this, array, i, idxs);
-    };
-    G__6962.cljs$lang$maxFixedArity = 2;
-    G__6962.cljs$lang$applyTo = function(arglist__6963) {
-      var array = cljs.core.first(arglist__6963);
-      arglist__6963 = cljs.core.next(arglist__6963);
-      var i = cljs.core.first(arglist__6963);
-      var idxs = cljs.core.rest(arglist__6963);
-      return G__6962__delegate(array, i, idxs);
-    };
-    G__6962.cljs$core$IFn$_invoke$arity$variadic = G__6962__delegate;
-    return G__6962;
-  }();
-  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() {
-  var aset = null;
-  var aset__3 = function(array, i, val) {
-    return array[i] = val;
-  };
-  var aset__4 = function() {
-    var G__6964__delegate = function(array, idx, idx2, idxv) {
-      return cljs.core.apply.call(null, aset, array[idx], idx2, idxv);
-    };
-    var G__6964 = function(array, idx, idx2, var_args) {
-      var idxv = null;
-      if (arguments.length > 3) {
-        idxv = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0);
-      }
-      return G__6964__delegate.call(this, array, idx, idx2, idxv);
-    };
-    G__6964.cljs$lang$maxFixedArity = 3;
-    G__6964.cljs$lang$applyTo = function(arglist__6965) {
-      var array = cljs.core.first(arglist__6965);
-      arglist__6965 = cljs.core.next(arglist__6965);
-      var idx = cljs.core.first(arglist__6965);
-      arglist__6965 = cljs.core.next(arglist__6965);
-      var idx2 = cljs.core.first(arglist__6965);
-      var idxv = cljs.core.rest(arglist__6965);
-      return G__6964__delegate(array, idx, idx2, idxv);
-    };
-    G__6964.cljs$core$IFn$_invoke$arity$variadic = G__6964__delegate;
-    return G__6964;
-  }();
-  aset = function(array, idx, idx2, var_args) {
-    var idxv = var_args;
-    switch(arguments.length) {
-      case 3:
-        return aset__3.call(this, array, idx, idx2);
-      default:
-        return aset__4.cljs$core$IFn$_invoke$arity$variadic(array, idx, idx2, cljs.core.array_seq(arguments, 3));
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  aset.cljs$lang$maxFixedArity = 3;
-  aset.cljs$lang$applyTo = aset__4.cljs$lang$applyTo;
-  aset.cljs$core$IFn$_invoke$arity$3 = aset__3;
-  aset.cljs$core$IFn$_invoke$arity$variadic = aset__4.cljs$core$IFn$_invoke$arity$variadic;
-  return aset;
-}();
-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 = function() {
-  var obj6967 = {};
-  return obj6967;
-}();
-cljs.core.IFn = function() {
-  var obj6969 = {};
-  return obj6969;
-}();
-cljs.core._invoke = function() {
-  var _invoke = null;
-  var _invoke__1 = function(this$) {
-    if (function() {
-      var and__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$1;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$1(this$);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$2;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$2(this$, a);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$3;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$3(this$, a, b);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$4;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$4(this$, a, b, c);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$5;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$6;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$6(this$, a, b, c, d, e);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$7;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$7(this$, a, b, c, d, e, f);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$8;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$8(this$, a, b, c, d, e, f, g);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$9;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$9(this$, a, b, c, d, e, f, g, h);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$10;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$10(this$, a, b, c, d, e, f, g, h, i);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$11;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$11(this$, a, b, c, d, e, f, g, h, i, j);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$12;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return this$.cljs$core$IFn$_invoke$arity$12(this$, a, b, c, d, e, f, g, h, i, j, k);
-    } else {
-      var x__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$13;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$14;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$15;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$16;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$17;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$18;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$19;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$20;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = this$;
-      if (and__3396__auto__) {
-        return this$.cljs$core$IFn$_invoke$arity$21;
-      } else {
-        return and__3396__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__4011__auto__ = this$ == null ? null : this$;
-      return function() {
-        var or__3408__auto__ = cljs.core._invoke[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._invoke["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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 = function() {
-  var obj6971 = {};
-  return obj6971;
-}();
-cljs.core._count = function _count(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ICounted$_count$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ICounted$_count$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._count[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._count["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ICounted.-count", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.IEmptyableCollection = function() {
-  var obj6973 = {};
-  return obj6973;
-}();
-cljs.core._empty = function _empty(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IEmptyableCollection$_empty$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._empty[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._empty["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IEmptyableCollection.-empty", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.ICollection = function() {
-  var obj6975 = {};
-  return obj6975;
-}();
-cljs.core._conj = function _conj(coll, o) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ICollection$_conj$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ICollection$_conj$arity$2(coll, o);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._conj[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._conj["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ICollection.-conj", coll);
-        }
-      }
-    }().call(null, coll, o);
-  }
-};
-cljs.core.IIndexed = function() {
-  var obj6977 = {};
-  return obj6977;
-}();
-cljs.core._nth = function() {
-  var _nth = null;
-  var _nth__2 = function(coll, n) {
-    if (function() {
-      var and__3396__auto__ = coll;
-      if (and__3396__auto__) {
-        return coll.cljs$core$IIndexed$_nth$arity$2;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return coll.cljs$core$IIndexed$_nth$arity$2(coll, n);
-    } else {
-      var x__4011__auto__ = coll == null ? null : coll;
-      return function() {
-        var or__3408__auto__ = cljs.core._nth[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._nth["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = coll;
-      if (and__3396__auto__) {
-        return coll.cljs$core$IIndexed$_nth$arity$3;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return coll.cljs$core$IIndexed$_nth$arity$3(coll, n, not_found);
-    } else {
-      var x__4011__auto__ = coll == null ? null : coll;
-      return function() {
-        var or__3408__auto__ = cljs.core._nth[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._nth["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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 = function() {
-  var obj6979 = {};
-  return obj6979;
-}();
-cljs.core.ISeq = function() {
-  var obj6981 = {};
-  return obj6981;
-}();
-cljs.core._first = function _first(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISeq$_first$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISeq$_first$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._first[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._first["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISeq$_rest$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISeq$_rest$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._rest[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._rest["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ISeq.-rest", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.INext = function() {
-  var obj6983 = {};
-  return obj6983;
-}();
-cljs.core._next = function _next(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$INext$_next$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$INext$_next$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._next[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._next["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "INext.-next", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.ILookup = function() {
-  var obj6985 = {};
-  return obj6985;
-}();
-cljs.core._lookup = function() {
-  var _lookup = null;
-  var _lookup__2 = function(o, k) {
-    if (function() {
-      var and__3396__auto__ = o;
-      if (and__3396__auto__) {
-        return o.cljs$core$ILookup$_lookup$arity$2;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return o.cljs$core$ILookup$_lookup$arity$2(o, k);
-    } else {
-      var x__4011__auto__ = o == null ? null : o;
-      return function() {
-        var or__3408__auto__ = cljs.core._lookup[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._lookup["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = o;
-      if (and__3396__auto__) {
-        return o.cljs$core$ILookup$_lookup$arity$3;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return o.cljs$core$ILookup$_lookup$arity$3(o, k, not_found);
-    } else {
-      var x__4011__auto__ = o == null ? null : o;
-      return function() {
-        var or__3408__auto__ = cljs.core._lookup[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._lookup["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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 = function() {
-  var obj6987 = {};
-  return obj6987;
-}();
-cljs.core._contains_key_QMARK_ = function _contains_key_QMARK_(coll, k) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll, k);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._contains_key_QMARK_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._contains_key_QMARK_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IAssociative$_assoc$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IAssociative$_assoc$arity$3(coll, k, v);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._assoc[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._assoc["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IAssociative.-assoc", coll);
-        }
-      }
-    }().call(null, coll, k, v);
-  }
-};
-cljs.core.IMap = function() {
-  var obj6989 = {};
-  return obj6989;
-}();
-cljs.core._dissoc = function _dissoc(coll, k) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IMap$_dissoc$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IMap$_dissoc$arity$2(coll, k);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._dissoc[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._dissoc["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IMap.-dissoc", coll);
-        }
-      }
-    }().call(null, coll, k);
-  }
-};
-cljs.core.IMapEntry = function() {
-  var obj6991 = {};
-  return obj6991;
-}();
-cljs.core._key = function _key(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IMapEntry$_key$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IMapEntry$_key$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._key[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._key["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IMapEntry$_val$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IMapEntry$_val$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._val[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._val["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IMapEntry.-val", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.ISet = function() {
-  var obj6993 = {};
-  return obj6993;
-}();
-cljs.core._disjoin = function _disjoin(coll, v) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISet$_disjoin$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISet$_disjoin$arity$2(coll, v);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._disjoin[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._disjoin["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ISet.-disjoin", coll);
-        }
-      }
-    }().call(null, coll, v);
-  }
-};
-cljs.core.IStack = function() {
-  var obj6995 = {};
-  return obj6995;
-}();
-cljs.core._peek = function _peek(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IStack$_peek$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IStack$_peek$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._peek[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._peek["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IStack$_pop$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IStack$_pop$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._pop[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._pop["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IStack.-pop", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.IVector = function() {
-  var obj6997 = {};
-  return obj6997;
-}();
-cljs.core._assoc_n = function _assoc_n(coll, n, val) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IVector$_assoc_n$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IVector$_assoc_n$arity$3(coll, n, val);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._assoc_n[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._assoc_n["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IVector.-assoc-n", coll);
-        }
-      }
-    }().call(null, coll, n, val);
-  }
-};
-cljs.core.IDeref = function() {
-  var obj6999 = {};
-  return obj6999;
-}();
-cljs.core._deref = function _deref(o) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IDeref$_deref$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IDeref$_deref$arity$1(o);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._deref[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._deref["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IDeref.-deref", o);
-        }
-      }
-    }().call(null, o);
-  }
-};
-cljs.core.IDerefWithTimeout = function() {
-  var obj7001 = {};
-  return obj7001;
-}();
-cljs.core._deref_with_timeout = function _deref_with_timeout(o, msec, timeout_val) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o, msec, timeout_val);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._deref_with_timeout[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._deref_with_timeout["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IDerefWithTimeout.-deref-with-timeout", o);
-        }
-      }
-    }().call(null, o, msec, timeout_val);
-  }
-};
-cljs.core.IMeta = function() {
-  var obj7003 = {};
-  return obj7003;
-}();
-cljs.core._meta = function _meta(o) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IMeta$_meta$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IMeta$_meta$arity$1(o);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._meta[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._meta["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IMeta.-meta", o);
-        }
-      }
-    }().call(null, o);
-  }
-};
-cljs.core.IWithMeta = function() {
-  var obj7005 = {};
-  return obj7005;
-}();
-cljs.core._with_meta = function _with_meta(o, meta) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IWithMeta$_with_meta$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IWithMeta$_with_meta$arity$2(o, meta);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._with_meta[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._with_meta["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IWithMeta.-with-meta", o);
-        }
-      }
-    }().call(null, o, meta);
-  }
-};
-cljs.core.IReduce = function() {
-  var obj7007 = {};
-  return obj7007;
-}();
-cljs.core._reduce = function() {
-  var _reduce = null;
-  var _reduce__2 = function(coll, f) {
-    if (function() {
-      var and__3396__auto__ = coll;
-      if (and__3396__auto__) {
-        return coll.cljs$core$IReduce$_reduce$arity$2;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return coll.cljs$core$IReduce$_reduce$arity$2(coll, f);
-    } else {
-      var x__4011__auto__ = coll == null ? null : coll;
-      return function() {
-        var or__3408__auto__ = cljs.core._reduce[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._reduce["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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__3396__auto__ = coll;
-      if (and__3396__auto__) {
-        return coll.cljs$core$IReduce$_reduce$arity$3;
-      } else {
-        return and__3396__auto__;
-      }
-    }()) {
-      return coll.cljs$core$IReduce$_reduce$arity$3(coll, f, start);
-    } else {
-      var x__4011__auto__ = coll == null ? null : coll;
-      return function() {
-        var or__3408__auto__ = cljs.core._reduce[goog.typeOf(x__4011__auto__)];
-        if (or__3408__auto__) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = cljs.core._reduce["_"];
-          if (or__3408__auto____$1) {
-            return or__3408__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 = function() {
-  var obj7009 = {};
-  return obj7009;
-}();
-cljs.core._kv_reduce = function _kv_reduce(coll, f, init) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IKVReduce$_kv_reduce$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll, f, init);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._kv_reduce[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._kv_reduce["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IKVReduce.-kv-reduce", coll);
-        }
-      }
-    }().call(null, coll, f, init);
-  }
-};
-cljs.core.IEquiv = function() {
-  var obj7011 = {};
-  return obj7011;
-}();
-cljs.core._equiv = function _equiv(o, other) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IEquiv$_equiv$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IEquiv$_equiv$arity$2(o, other);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._equiv[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._equiv["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IEquiv.-equiv", o);
-        }
-      }
-    }().call(null, o, other);
-  }
-};
-cljs.core.IHash = function() {
-  var obj7013 = {};
-  return obj7013;
-}();
-cljs.core._hash = function _hash(o) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IHash$_hash$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IHash$_hash$arity$1(o);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._hash[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._hash["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IHash.-hash", o);
-        }
-      }
-    }().call(null, o);
-  }
-};
-cljs.core.ISeqable = function() {
-  var obj7015 = {};
-  return obj7015;
-}();
-cljs.core._seq = function _seq(o) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$ISeqable$_seq$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$ISeqable$_seq$arity$1(o);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._seq[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._seq["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ISeqable.-seq", o);
-        }
-      }
-    }().call(null, o);
-  }
-};
-cljs.core.ISequential = function() {
-  var obj7017 = {};
-  return obj7017;
-}();
-cljs.core.IList = function() {
-  var obj7019 = {};
-  return obj7019;
-}();
-cljs.core.IRecord = function() {
-  var obj7021 = {};
-  return obj7021;
-}();
-cljs.core.IReversible = function() {
-  var obj7023 = {};
-  return obj7023;
-}();
-cljs.core._rseq = function _rseq(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IReversible$_rseq$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IReversible$_rseq$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._rseq[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._rseq["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IReversible.-rseq", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.ISorted = function() {
-  var obj7025 = {};
-  return obj7025;
-}();
-cljs.core._sorted_seq = function _sorted_seq(coll, ascending_QMARK_) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISorted$_sorted_seq$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll, ascending_QMARK_);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._sorted_seq[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._sorted_seq["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISorted$_sorted_seq_from$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll, k, ascending_QMARK_);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._sorted_seq_from[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._sorted_seq_from["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISorted$_entry_key$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISorted$_entry_key$arity$2(coll, entry);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._entry_key[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._entry_key["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$ISorted$_comparator$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$ISorted$_comparator$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._comparator[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._comparator["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ISorted.-comparator", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.IWriter = function() {
-  var obj7027 = {};
-  return obj7027;
-}();
-cljs.core._write = function _write(writer, s) {
-  if (function() {
-    var and__3396__auto__ = writer;
-    if (and__3396__auto__) {
-      return writer.cljs$core$IWriter$_write$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return writer.cljs$core$IWriter$_write$arity$2(writer, s);
-  } else {
-    var x__4011__auto__ = writer == null ? null : writer;
-    return function() {
-      var or__3408__auto__ = cljs.core._write[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._write["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = writer;
-    if (and__3396__auto__) {
-      return writer.cljs$core$IWriter$_flush$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return writer.cljs$core$IWriter$_flush$arity$1(writer);
-  } else {
-    var x__4011__auto__ = writer == null ? null : writer;
-    return function() {
-      var or__3408__auto__ = cljs.core._flush[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._flush["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IWriter.-flush", writer);
-        }
-      }
-    }().call(null, writer);
-  }
-};
-cljs.core.IPrintWithWriter = function() {
-  var obj7029 = {};
-  return obj7029;
-}();
-cljs.core._pr_writer = function _pr_writer(o, writer, opts) {
-  if (function() {
-    var and__3396__auto__ = o;
-    if (and__3396__auto__) {
-      return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o, writer, opts);
-  } else {
-    var x__4011__auto__ = o == null ? null : o;
-    return function() {
-      var or__3408__auto__ = cljs.core._pr_writer[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._pr_writer["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IPrintWithWriter.-pr-writer", o);
-        }
-      }
-    }().call(null, o, writer, opts);
-  }
-};
-cljs.core.IPending = function() {
-  var obj7031 = {};
-  return obj7031;
-}();
-cljs.core._realized_QMARK_ = function _realized_QMARK_(d) {
-  if (function() {
-    var and__3396__auto__ = d;
-    if (and__3396__auto__) {
-      return d.cljs$core$IPending$_realized_QMARK_$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return d.cljs$core$IPending$_realized_QMARK_$arity$1(d);
-  } else {
-    var x__4011__auto__ = d == null ? null : d;
-    return function() {
-      var or__3408__auto__ = cljs.core._realized_QMARK_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._realized_QMARK_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IPending.-realized?", d);
-        }
-      }
-    }().call(null, d);
-  }
-};
-cljs.core.IWatchable = function() {
-  var obj7033 = {};
-  return obj7033;
-}();
-cljs.core._notify_watches = function _notify_watches(this$, oldval, newval) {
-  if (function() {
-    var and__3396__auto__ = this$;
-    if (and__3396__auto__) {
-      return this$.cljs$core$IWatchable$_notify_watches$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$, oldval, newval);
-  } else {
-    var x__4011__auto__ = this$ == null ? null : this$;
-    return function() {
-      var or__3408__auto__ = cljs.core._notify_watches[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._notify_watches["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = this$;
-    if (and__3396__auto__) {
-      return this$.cljs$core$IWatchable$_add_watch$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return this$.cljs$core$IWatchable$_add_watch$arity$3(this$, key, f);
-  } else {
-    var x__4011__auto__ = this$ == null ? null : this$;
-    return function() {
-      var or__3408__auto__ = cljs.core._add_watch[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._add_watch["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = this$;
-    if (and__3396__auto__) {
-      return this$.cljs$core$IWatchable$_remove_watch$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$, key);
-  } else {
-    var x__4011__auto__ = this$ == null ? null : this$;
-    return function() {
-      var or__3408__auto__ = cljs.core._remove_watch[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._remove_watch["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IWatchable.-remove-watch", this$);
-        }
-      }
-    }().call(null, this$, key);
-  }
-};
-cljs.core.IEditableCollection = function() {
-  var obj7035 = {};
-  return obj7035;
-}();
-cljs.core._as_transient = function _as_transient(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IEditableCollection$_as_transient$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._as_transient[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._as_transient["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IEditableCollection.-as-transient", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.ITransientCollection = function() {
-  var obj7037 = {};
-  return obj7037;
-}();
-cljs.core._conj_BANG_ = function _conj_BANG_(tcoll, val) {
-  if (function() {
-    var and__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll, val);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._conj_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._conj_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._persistent_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._persistent_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ITransientCollection.-persistent!", tcoll);
-        }
-      }
-    }().call(null, tcoll);
-  }
-};
-cljs.core.ITransientAssociative = function() {
-  var obj7039 = {};
-  return obj7039;
-}();
-cljs.core._assoc_BANG_ = function _assoc_BANG_(tcoll, key, val) {
-  if (function() {
-    var and__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll, key, val);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._assoc_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._assoc_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ITransientAssociative.-assoc!", tcoll);
-        }
-      }
-    }().call(null, tcoll, key, val);
-  }
-};
-cljs.core.ITransientMap = function() {
-  var obj7041 = {};
-  return obj7041;
-}();
-cljs.core._dissoc_BANG_ = function _dissoc_BANG_(tcoll, key) {
-  if (function() {
-    var and__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll, key);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._dissoc_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._dissoc_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ITransientMap.-dissoc!", tcoll);
-        }
-      }
-    }().call(null, tcoll, key);
-  }
-};
-cljs.core.ITransientVector = function() {
-  var obj7043 = {};
-  return obj7043;
-}();
-cljs.core._assoc_n_BANG_ = function _assoc_n_BANG_(tcoll, n, val) {
-  if (function() {
-    var and__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll, n, val);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._assoc_n_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._assoc_n_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._pop_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._pop_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ITransientVector.-pop!", tcoll);
-        }
-      }
-    }().call(null, tcoll);
-  }
-};
-cljs.core.ITransientSet = function() {
-  var obj7045 = {};
-  return obj7045;
-}();
-cljs.core._disjoin_BANG_ = function _disjoin_BANG_(tcoll, v) {
-  if (function() {
-    var and__3396__auto__ = tcoll;
-    if (and__3396__auto__) {
-      return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll, v);
-  } else {
-    var x__4011__auto__ = tcoll == null ? null : tcoll;
-    return function() {
-      var or__3408__auto__ = cljs.core._disjoin_BANG_[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._disjoin_BANG_["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "ITransientSet.-disjoin!", tcoll);
-        }
-      }
-    }().call(null, tcoll, v);
-  }
-};
-cljs.core.IComparable = function() {
-  var obj7047 = {};
-  return obj7047;
-}();
-cljs.core._compare = function _compare(x, y) {
-  if (function() {
-    var and__3396__auto__ = x;
-    if (and__3396__auto__) {
-      return x.cljs$core$IComparable$_compare$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return x.cljs$core$IComparable$_compare$arity$2(x, y);
-  } else {
-    var x__4011__auto__ = x == null ? null : x;
-    return function() {
-      var or__3408__auto__ = cljs.core._compare[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._compare["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IComparable.-compare", x);
-        }
-      }
-    }().call(null, x, y);
-  }
-};
-cljs.core.IChunk = function() {
-  var obj7049 = {};
-  return obj7049;
-}();
-cljs.core._drop_first = function _drop_first(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IChunk$_drop_first$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IChunk$_drop_first$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._drop_first[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._drop_first["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IChunk.-drop-first", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.IChunkedSeq = function() {
-  var obj7051 = {};
-  return obj7051;
-}();
-cljs.core._chunked_first = function _chunked_first(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._chunked_first[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._chunked_first["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._chunked_rest[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._chunked_rest["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IChunkedSeq.-chunked-rest", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.IChunkedNext = function() {
-  var obj7053 = {};
-  return obj7053;
-}();
-cljs.core._chunked_next = function _chunked_next(coll) {
-  if (function() {
-    var and__3396__auto__ = coll;
-    if (and__3396__auto__) {
-      return coll.cljs$core$IChunkedNext$_chunked_next$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll);
-  } else {
-    var x__4011__auto__ = coll == null ? null : coll;
-    return function() {
-      var or__3408__auto__ = cljs.core._chunked_next[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._chunked_next["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IChunkedNext.-chunked-next", coll);
-        }
-      }
-    }().call(null, coll);
-  }
-};
-cljs.core.INamed = function() {
-  var obj7055 = {};
-  return obj7055;
-}();
-cljs.core._name = function _name(x) {
-  if (function() {
-    var and__3396__auto__ = x;
-    if (and__3396__auto__) {
-      return x.cljs$core$INamed$_name$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return x.cljs$core$INamed$_name$arity$1(x);
-  } else {
-    var x__4011__auto__ = x == null ? null : x;
-    return function() {
-      var or__3408__auto__ = cljs.core._name[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._name["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = x;
-    if (and__3396__auto__) {
-      return x.cljs$core$INamed$_namespace$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return x.cljs$core$INamed$_namespace$arity$1(x);
-  } else {
-    var x__4011__auto__ = x == null ? null : x;
-    return function() {
-      var or__3408__auto__ = cljs.core._namespace[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._namespace["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "INamed.-namespace", x);
-        }
-      }
-    }().call(null, x);
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/StringBufferWriter");
-};
-cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_write$arity$2 = function(_, s) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.sb.append(s);
-};
-cljs.core.StringBufferWriter.prototype.cljs$core$IWriter$_flush$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return null;
-};
-cljs.core.__GT_StringBufferWriter = function __GT_StringBufferWriter(sb) {
-  return new cljs.core.StringBufferWriter(sb);
-};
-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;
-};
-cljs.core.hash_symbol = function hash_symbol(sym) {
-  return cljs.core.hash_combine.call(null, cljs.core.hash.call(null, sym.ns), cljs.core.hash.call(null, sym.name));
-};
-cljs.core.compare_symbols = function compare_symbols(a, b) {
-  if (cljs.core.truth_(cljs.core._EQ_.call(null, a, b))) {
-    return 0;
-  } else {
-    if (cljs.core.truth_(function() {
-      var and__3396__auto__ = cljs.core.not.call(null, a.ns);
-      if (and__3396__auto__) {
-        return b.ns;
-      } else {
-        return and__3396__auto__;
-      }
-    }())) {
-      return-1;
-    } else {
-      if (cljs.core.truth_(a.ns)) {
-        if (cljs.core.not.call(null, b.ns)) {
-          return 1;
-        } else {
-          var nsc = cljs.core.compare.call(null, a.ns, b.ns);
-          if (nsc === 0) {
-            return cljs.core.compare.call(null, a.name, b.name);
-          } else {
-            return nsc;
-          }
-        }
-      } else {
-        if (new cljs.core.Keyword(null, "default", "default", 2558708147)) {
-          return cljs.core.compare.call(null, a.name, b.name);
-        } else {
-          return null;
-        }
-      }
-    }
-  }
-};
-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$partition0$ = 2154168321;
-  this.cljs$lang$protocol_mask$partition1$ = 4096;
-};
-cljs.core.Symbol.cljs$lang$type = true;
-cljs.core.Symbol.cljs$lang$ctorStr = "cljs.core/Symbol";
-cljs.core.Symbol.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Symbol");
-};
-cljs.core.Symbol.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(o, writer, _) {
-  var self__ = this;
-  var o__$1 = this;
-  return cljs.core._write.call(null, writer, self__.str);
-};
-cljs.core.Symbol.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.name;
-};
-cljs.core.Symbol.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.ns;
-};
-cljs.core.Symbol.prototype.cljs$core$IHash$_hash$arity$1 = function(sym) {
-  var self__ = this;
-  var sym__$1 = this;
-  var h__3819__auto__ = self__._hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_symbol.call(null, sym__$1);
-    self__._hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.Symbol.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_, new_meta) {
-  var self__ = this;
-  var ___$1 = 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;
-  var ___$1 = this;
-  return self__._meta;
-};
-cljs.core.Symbol.prototype.call = function() {
-  var G__7057 = null;
-  var G__7057__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__7057__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__7057 = function(self__, coll, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7057__2.call(this, self__, coll);
-      case 3:
-        return G__7057__3.call(this, self__, coll, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7057;
-}();
-cljs.core.Symbol.prototype.apply = function(self__, args7056) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7056)));
-};
-cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$1 = function(coll) {
-  var self__ = this;
-  var sym = this;
-  return cljs.core._lookup.call(null, coll, sym, null);
-};
-cljs.core.Symbol.prototype.cljs$core$IFn$_invoke$arity$2 = function(coll, not_found) {
-  var self__ = this;
-  var sym = this;
-  return cljs.core._lookup.call(null, coll, sym, not_found);
-};
-cljs.core.Symbol.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(_, other) {
-  var self__ = this;
-  var ___$1 = 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.__GT_Symbol = function __GT_Symbol(ns, name, str, _hash, _meta) {
-  return new cljs.core.Symbol(ns, name, str, _hash, _meta);
-};
-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, null, 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__7059 = coll;
-      if (G__7059) {
-        var bit__4027__auto__ = G__7059.cljs$lang$protocol_mask$partition0$ & 8388608;
-        if (bit__4027__auto__ || G__7059.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 (typeof coll === "string") {
-          if (coll.length === 0) {
-            return null;
-          } else {
-            return new cljs.core.IndexedSeq(coll, 0);
-          }
-        } else {
-          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, coll)) {
-            return cljs.core._seq.call(null, coll);
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              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__7061 = coll;
-      if (G__7061) {
-        var bit__4027__auto__ = G__7061.cljs$lang$protocol_mask$partition0$ & 64;
-        if (bit__4027__auto__ || G__7061.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__7063 = coll;
-      if (G__7063) {
-        var bit__4027__auto__ = G__7063.cljs$lang$protocol_mask$partition0$ & 64;
-        if (bit__4027__auto__ || G__7063.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) {
-        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__7065 = coll;
-      if (G__7065) {
-        var bit__4027__auto__ = G__7065.cljs$lang$protocol_mask$partition0$ & 128;
-        if (bit__4027__auto__ || G__7065.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) {
-    if (x == null) {
-      return y == null;
-    } else {
-      return x === y || cljs.core._equiv.call(null, x, y);
-    }
-  };
-  var _EQ___3 = function() {
-    var G__7066__delegate = function(x, y, more) {
-      while (true) {
-        if (_EQ_.call(null, x, y)) {
-          if (cljs.core.next.call(null, more)) {
-            var G__7067 = y;
-            var G__7068 = cljs.core.first.call(null, more);
-            var G__7069 = cljs.core.next.call(null, more);
-            x = G__7067;
-            y = G__7068;
-            more = G__7069;
-            continue;
-          } else {
-            return _EQ_.call(null, y, cljs.core.first.call(null, more));
-          }
-        } else {
-          return false;
-        }
-        break;
-      }
-    };
-    var G__7066 = 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__7066__delegate.call(this, x, y, more);
-    };
-    G__7066.cljs$lang$maxFixedArity = 2;
-    G__7066.cljs$lang$applyTo = function(arglist__7070) {
-      var x = cljs.core.first(arglist__7070);
-      arglist__7070 = cljs.core.next(arglist__7070);
-      var y = cljs.core.first(arglist__7070);
-      var more = cljs.core.rest(arglist__7070);
-      return G__7066__delegate(x, y, more);
-    };
-    G__7066.cljs$core$IFn$_invoke$arity$variadic = G__7066__delegate;
-    return G__7066;
-  }();
-  _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.ICounted["null"] = true;
-cljs.core._count["null"] = function(_) {
-  return 0;
-};
-Date.prototype.cljs$core$IEquiv$ = true;
-Date.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
-  var o__$1 = this;
-  return other instanceof Date && o__$1.toString() === other.toString();
-};
-cljs.core.IEquiv["number"] = true;
-cljs.core._equiv["number"] = function(x, o) {
-  return x === o;
-};
-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;
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Reduced");
-};
-cljs.core.Reduced.prototype.cljs$core$IDeref$_deref$arity$1 = function(o) {
-  var self__ = this;
-  var o__$1 = this;
-  return self__.val;
-};
-cljs.core.__GT_Reduced = function __GT_Reduced(val) {
-  return new cljs.core.Reduced(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__7071 = nval;
-            var G__7072 = n + 1;
-            val = G__7071;
-            n = G__7072;
-            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__7073 = nval;
-          var G__7074 = n + 1;
-          val__$1 = G__7073;
-          n = G__7074;
-          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__7075 = nval;
-          var G__7076 = n + 1;
-          val__$1 = G__7075;
-          n = G__7076;
-          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__7077 = nval;
-            var G__7078 = n + 1;
-            val = G__7077;
-            n = G__7078;
-            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__7079 = nval;
-          var G__7080 = n + 1;
-          val__$1 = G__7079;
-          n = G__7080;
-          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__7081 = nval;
-          var G__7082 = n + 1;
-          val__$1 = G__7081;
-          n = G__7082;
-          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__7084 = x;
-  if (G__7084) {
-    var bit__4034__auto__ = G__7084.cljs$lang$protocol_mask$partition0$ & 2;
-    if (bit__4034__auto__ || G__7084.cljs$core$ICounted$) {
-      return true;
-    } else {
-      if (!G__7084.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, G__7084);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, G__7084);
-  }
-};
-cljs.core.indexed_QMARK_ = function indexed_QMARK_(x) {
-  var G__7086 = x;
-  if (G__7086) {
-    var bit__4034__auto__ = G__7086.cljs$lang$protocol_mask$partition0$ & 16;
-    if (bit__4034__auto__ || G__7086.cljs$core$IIndexed$) {
-      return true;
-    } else {
-      if (!G__7086.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, G__7086);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, G__7086);
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/IndexedSeq");
-};
-cljs.core.IndexedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.hash_coll.call(null, coll__$1);
-};
-cljs.core.IndexedSeq.prototype.cljs$core$INext$_next$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-cljs.core.IndexedSeq.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var c = cljs.core._count.call(null, coll__$1);
-  if (c > 0) {
-    return new cljs.core.RSeq(coll__$1, c - 1, null);
-  } else {
-    return null;
-  }
-};
-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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var this$__$1 = this;
-  return this$__$1;
-};
-cljs.core.IndexedSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.arr.length - self__.i;
-};
-cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.arr[self__.i];
-};
-cljs.core.IndexedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  if (self__.i + 1 < self__.arr.length) {
-    return new cljs.core.IndexedSeq(self__.arr, self__.i + 1);
-  } else {
-    return cljs.core.List.EMPTY;
-  }
-};
-cljs.core.IndexedSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.IndexedSeq.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
-  var self__ = this;
-  var coll__$1 = 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 coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.List.EMPTY;
-};
-cljs.core.__GT_IndexedSeq = function __GT_IndexedSeq(arr, i) {
-  return new cljs.core.IndexedSeq(arr, i);
-};
-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.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$ = 32374862;
-};
-cljs.core.RSeq.cljs$lang$type = true;
-cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq";
-cljs.core.RSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/RSeq");
-};
-cljs.core.RSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.hash_coll.call(null, coll__$1);
-};
-cljs.core.RSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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$IReduce$_reduce$arity$2 = function(col, f) {
-  var self__ = this;
-  var col__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, col__$1);
-};
-cljs.core.RSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(col, f, start) {
-  var self__ = this;
-  var col__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, col__$1);
-};
-cljs.core.RSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.RSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.i + 1;
-};
-cljs.core.RSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  if (self__.i > 0) {
-    return new cljs.core.RSeq(self__.ci, self__.i - 1, null);
-  } else {
-    return null;
-  }
-};
-cljs.core.RSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.RSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.RSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_RSeq = function __GT_RSeq(ci, i, meta) {
-  return new cljs.core.RSeq(ci, i, 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__7087 = sn;
-      s = G__7087;
-      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._conj.call(null, cljs.core.List.EMPTY, x);
-    }
-  };
-  var conj__3 = function() {
-    var G__7088__delegate = function(coll, x, xs) {
-      while (true) {
-        if (cljs.core.truth_(xs)) {
-          var G__7089 = conj.call(null, coll, x);
-          var G__7090 = cljs.core.first.call(null, xs);
-          var G__7091 = cljs.core.next.call(null, xs);
-          coll = G__7089;
-          x = G__7090;
-          xs = G__7091;
-          continue;
-        } else {
-          return conj.call(null, coll, x);
-        }
-        break;
-      }
-    };
-    var G__7088 = 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__7088__delegate.call(this, coll, x, xs);
-    };
-    G__7088.cljs$lang$maxFixedArity = 2;
-    G__7088.cljs$lang$applyTo = function(arglist__7092) {
-      var coll = cljs.core.first(arglist__7092);
-      arglist__7092 = cljs.core.next(arglist__7092);
-      var x = cljs.core.first(arglist__7092);
-      var xs = cljs.core.rest(arglist__7092);
-      return G__7088__delegate(coll, x, xs);
-    };
-    G__7088.cljs$core$IFn$_invoke$arity$variadic = G__7088__delegate;
-    return G__7088;
-  }();
-  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) {
-  if (coll == null) {
-    return null;
-  } else {
-    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__7093 = cljs.core.next.call(null, s);
-      var G__7094 = acc + 1;
-      s = G__7093;
-      acc = G__7094;
-      continue;
-    }
-    break;
-  }
-};
-cljs.core.count = function count(coll) {
-  if (!(coll == null)) {
-    if (function() {
-      var G__7096 = coll;
-      if (G__7096) {
-        var bit__4027__auto__ = G__7096.cljs$lang$protocol_mask$partition0$ & 2;
-        if (bit__4027__auto__ || G__7096.cljs$core$ICounted$) {
-          return true;
-        } else {
-          return false;
-        }
-      } else {
-        return false;
-      }
-    }()) {
-      return cljs.core._count.call(null, coll);
-    } else {
-      if (coll instanceof Array) {
-        return coll.length;
-      } else {
-        if (typeof coll === "string") {
-          return coll.length;
-        } else {
-          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, coll)) {
-            return cljs.core._count.call(null, coll);
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              return cljs.core.accumulating_seq_count.call(null, coll);
-            } else {
-              return null;
-            }
-          }
-        }
-      }
-    }
-  } else {
-    return 0;
-  }
-};
-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__7097 = cljs.core.next.call(null, coll);
-              var G__7098 = n - 1;
-              coll = G__7097;
-              n = G__7098;
-              continue;
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                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__7099 = cljs.core.next.call(null, coll);
-              var G__7100 = n - 1;
-              var G__7101 = not_found;
-              coll = G__7099;
-              n = G__7100;
-              not_found = G__7101;
-              continue;
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                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__7106 = coll;
-        if (G__7106) {
-          var bit__4027__auto__ = G__7106.cljs$lang$protocol_mask$partition0$ & 16;
-          if (bit__4027__auto__ || G__7106.cljs$core$IIndexed$) {
-            return true;
-          } else {
-            return false;
-          }
-        } else {
-          return false;
-        }
-      }()) {
-        return cljs.core._nth.call(null, coll, n);
-      } else {
-        if (coll instanceof Array) {
-          if (n < coll.length) {
-            return coll[n];
-          } else {
-            return null;
-          }
-        } else {
-          if (typeof coll === "string") {
-            if (n < coll.length) {
-              return coll[n];
-            } else {
-              return null;
-            }
-          } else {
-            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, coll)) {
-              return cljs.core._nth.call(null, coll, n);
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                if (function() {
-                  var G__7107 = coll;
-                  if (G__7107) {
-                    var bit__4034__auto__ = G__7107.cljs$lang$protocol_mask$partition0$ & 64;
-                    if (bit__4034__auto__ || G__7107.cljs$core$ISeq$) {
-                      return true;
-                    } else {
-                      if (!G__7107.cljs$lang$protocol_mask$partition0$) {
-                        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7107);
-                      } else {
-                        return false;
-                      }
-                    }
-                  } else {
-                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7107);
-                  }
-                }()) {
-                  return cljs.core.linear_traversal_nth.call(null, coll, n);
-                } else {
-                  throw new Error([cljs.core.str("nth not supported on this type "), cljs.core.str(cljs.core.type__GT_str.call(null, cljs.core.type.call(null, coll)))].join(""));
-                }
-              } else {
-                return null;
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var nth__3 = function(coll, n, not_found) {
-    if (!(coll == null)) {
-      if (function() {
-        var G__7108 = coll;
-        if (G__7108) {
-          var bit__4027__auto__ = G__7108.cljs$lang$protocol_mask$partition0$ & 16;
-          if (bit__4027__auto__ || G__7108.cljs$core$IIndexed$) {
-            return true;
-          } else {
-            return false;
-          }
-        } else {
-          return false;
-        }
-      }()) {
-        return cljs.core._nth.call(null, coll, n, not_found);
-      } else {
-        if (coll instanceof Array) {
-          if (n < coll.length) {
-            return coll[n];
-          } else {
-            return not_found;
-          }
-        } else {
-          if (typeof coll === "string") {
-            if (n < coll.length) {
-              return coll[n];
-            } else {
-              return not_found;
-            }
-          } else {
-            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, coll)) {
-              return cljs.core._nth.call(null, coll, n);
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                if (function() {
-                  var G__7109 = coll;
-                  if (G__7109) {
-                    var bit__4034__auto__ = G__7109.cljs$lang$protocol_mask$partition0$ & 64;
-                    if (bit__4034__auto__ || G__7109.cljs$core$ISeq$) {
-                      return true;
-                    } else {
-                      if (!G__7109.cljs$lang$protocol_mask$partition0$) {
-                        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7109);
-                      } else {
-                        return false;
-                      }
-                    }
-                  } else {
-                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7109);
-                  }
-                }()) {
-                  return cljs.core.linear_traversal_nth.call(null, coll, n, not_found);
-                } else {
-                  throw new Error([cljs.core.str("nth not supported on this type "), cljs.core.str(cljs.core.type__GT_str.call(null, cljs.core.type.call(null, coll)))].join(""));
-                }
-              } 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__7112 = o;
-        if (G__7112) {
-          var bit__4027__auto__ = G__7112.cljs$lang$protocol_mask$partition0$ & 256;
-          if (bit__4027__auto__ || G__7112.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 (typeof o === "string") {
-            if (k < o.length) {
-              return o[k];
-            } else {
-              return null;
-            }
-          } else {
-            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, o)) {
-              return cljs.core._lookup.call(null, o, k);
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                return null;
-              } else {
-                return null;
-              }
-            }
-          }
-        }
-      }
-    }
-  };
-  var get__3 = function(o, k, not_found) {
-    if (!(o == null)) {
-      if (function() {
-        var G__7113 = o;
-        if (G__7113) {
-          var bit__4027__auto__ = G__7113.cljs$lang$protocol_mask$partition0$ & 256;
-          if (bit__4027__auto__ || G__7113.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 (typeof o === "string") {
-            if (k < o.length) {
-              return o[k];
-            } else {
-              return not_found;
-            }
-          } else {
-            if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, o)) {
-              return cljs.core._lookup.call(null, o, k, not_found);
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                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.PersistentHashMap.fromArrays.call(null, [k], [v]);
-    }
-  };
-  var assoc__4 = function() {
-    var G__7114__delegate = function(coll, k, v, kvs) {
-      while (true) {
-        var ret = assoc.call(null, coll, k, v);
-        if (cljs.core.truth_(kvs)) {
-          var G__7115 = ret;
-          var G__7116 = cljs.core.first.call(null, kvs);
-          var G__7117 = cljs.core.second.call(null, kvs);
-          var G__7118 = cljs.core.nnext.call(null, kvs);
-          coll = G__7115;
-          k = G__7116;
-          v = G__7117;
-          kvs = G__7118;
-          continue;
-        } else {
-          return ret;
-        }
-        break;
-      }
-    };
-    var G__7114 = 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__7114__delegate.call(this, coll, k, v, kvs);
-    };
-    G__7114.cljs$lang$maxFixedArity = 3;
-    G__7114.cljs$lang$applyTo = function(arglist__7119) {
-      var coll = cljs.core.first(arglist__7119);
-      arglist__7119 = cljs.core.next(arglist__7119);
-      var k = cljs.core.first(arglist__7119);
-      arglist__7119 = cljs.core.next(arglist__7119);
-      var v = cljs.core.first(arglist__7119);
-      var kvs = cljs.core.rest(arglist__7119);
-      return G__7114__delegate(coll, k, v, kvs);
-    };
-    G__7114.cljs$core$IFn$_invoke$arity$variadic = G__7114__delegate;
-    return G__7114;
-  }();
-  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) {
-    if (coll == null) {
-      return null;
-    } else {
-      return cljs.core._dissoc.call(null, coll, k);
-    }
-  };
-  var dissoc__3 = function() {
-    var G__7120__delegate = function(coll, k, ks) {
-      while (true) {
-        if (coll == null) {
-          return null;
-        } else {
-          var ret = dissoc.call(null, coll, k);
-          if (cljs.core.truth_(ks)) {
-            var G__7121 = ret;
-            var G__7122 = cljs.core.first.call(null, ks);
-            var G__7123 = cljs.core.next.call(null, ks);
-            coll = G__7121;
-            k = G__7122;
-            ks = G__7123;
-            continue;
-          } else {
-            return ret;
-          }
-        }
-        break;
-      }
-    };
-    var G__7120 = 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__7120__delegate.call(this, coll, k, ks);
-    };
-    G__7120.cljs$lang$maxFixedArity = 2;
-    G__7120.cljs$lang$applyTo = function(arglist__7124) {
-      var coll = cljs.core.first(arglist__7124);
-      arglist__7124 = cljs.core.next(arglist__7124);
-      var k = cljs.core.first(arglist__7124);
-      var ks = cljs.core.rest(arglist__7124);
-      return G__7120__delegate(coll, k, ks);
-    };
-    G__7120.cljs$core$IFn$_invoke$arity$variadic = G__7120__delegate;
-    return G__7120;
-  }();
-  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__3408__auto__ = goog.isFunction(f);
-  if (or__3408__auto__) {
-    return or__3408__auto__;
-  } else {
-    var G__7128 = f;
-    if (G__7128) {
-      var bit__4034__auto__ = null;
-      if (cljs.core.truth_(function() {
-        var or__3408__auto____$1 = bit__4034__auto__;
-        if (cljs.core.truth_(or__3408__auto____$1)) {
-          return or__3408__auto____$1;
-        } else {
-          return G__7128.cljs$core$Fn$;
-        }
-      }())) {
-        return true;
-      } else {
-        if (!G__7128.cljs$lang$protocol_mask$partition$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.Fn, G__7128);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.Fn, G__7128);
-    }
-  }
-};
-cljs.core.with_meta = function with_meta(o, meta) {
-  if (cljs.core.fn_QMARK_.call(null, o) && !function() {
-    var G__7136 = o;
-    if (G__7136) {
-      var bit__4034__auto__ = G__7136.cljs$lang$protocol_mask$partition0$ & 262144;
-      if (bit__4034__auto__ || G__7136.cljs$core$IWithMeta$) {
-        return true;
-      } else {
-        if (!G__7136.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IWithMeta, G__7136);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IWithMeta, G__7136);
-    }
-  }()) {
-    return with_meta.call(null, function() {
-      if (typeof cljs.core.t7137 !== "undefined") {
-      } else {
-        cljs.core.t7137 = function(meta, o, with_meta, meta7138) {
-          this.meta = meta;
-          this.o = o;
-          this.with_meta = with_meta;
-          this.meta7138 = meta7138;
-          this.cljs$lang$protocol_mask$partition1$ = 0;
-          this.cljs$lang$protocol_mask$partition0$ = 393217;
-        };
-        cljs.core.t7137.cljs$lang$type = true;
-        cljs.core.t7137.cljs$lang$ctorStr = "cljs.core/t7137";
-        cljs.core.t7137.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-          return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/t7137");
-        };
-        cljs.core.t7137.prototype.call = function() {
-          var G__7141__delegate = function(self__, args) {
-            var self____$1 = this;
-            var _ = self____$1;
-            return cljs.core.apply.call(null, self__.o, args);
-          };
-          var G__7141 = 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__7141__delegate.call(this, self__, args);
-          };
-          G__7141.cljs$lang$maxFixedArity = 1;
-          G__7141.cljs$lang$applyTo = function(arglist__7142) {
-            var self__ = cljs.core.first(arglist__7142);
-            var args = cljs.core.rest(arglist__7142);
-            return G__7141__delegate(self__, args);
-          };
-          G__7141.cljs$core$IFn$_invoke$arity$variadic = G__7141__delegate;
-          return G__7141;
-        }();
-        cljs.core.t7137.prototype.apply = function(self__, args7140) {
-          var self__ = this;
-          var self____$1 = this;
-          return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7140)));
-        };
-        cljs.core.t7137.prototype.cljs$core$IFn$_invoke$arity$2 = function() {
-          var G__7143__delegate = function(args) {
-            var _ = this;
-            return cljs.core.apply.call(null, self__.o, args);
-          };
-          var G__7143 = function(var_args) {
-            var self__ = this;
-            var args = null;
-            if (arguments.length > 0) {
-              args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-            }
-            return G__7143__delegate.call(this, args);
-          };
-          G__7143.cljs$lang$maxFixedArity = 0;
-          G__7143.cljs$lang$applyTo = function(arglist__7144) {
-            var args = cljs.core.seq(arglist__7144);
-            return G__7143__delegate(args);
-          };
-          G__7143.cljs$core$IFn$_invoke$arity$variadic = G__7143__delegate;
-          return G__7143;
-        }();
-        cljs.core.t7137.prototype.cljs$core$Fn$ = true;
-        cljs.core.t7137.prototype.cljs$core$IMeta$_meta$arity$1 = function(_7139) {
-          var self__ = this;
-          var _7139__$1 = this;
-          return self__.meta7138;
-        };
-        cljs.core.t7137.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_7139, meta7138__$1) {
-          var self__ = this;
-          var _7139__$1 = this;
-          return new cljs.core.t7137(self__.meta, self__.o, self__.with_meta, meta7138__$1);
-        };
-        cljs.core.__GT_t7137 = function __GT_t7137(meta__$1, o__$1, with_meta__$1, meta7138) {
-          return new cljs.core.t7137(meta__$1, o__$1, with_meta__$1, meta7138);
-        };
-      }
-      return new cljs.core.t7137(meta, o, with_meta, null);
-    }(), meta);
-  } else {
-    if (o == null) {
-      return null;
-    } else {
-      return cljs.core._with_meta.call(null, o, meta);
-    }
-  }
-};
-cljs.core.meta = function meta(o) {
-  if (function() {
-    var and__3396__auto__ = !(o == null);
-    if (and__3396__auto__) {
-      var G__7148 = o;
-      if (G__7148) {
-        var bit__4034__auto__ = G__7148.cljs$lang$protocol_mask$partition0$ & 131072;
-        if (bit__4034__auto__ || G__7148.cljs$core$IMeta$) {
-          return true;
-        } else {
-          if (!G__7148.cljs$lang$protocol_mask$partition0$) {
-            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7148);
-          } else {
-            return false;
-          }
-        }
-      } else {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7148);
-      }
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return cljs.core._meta.call(null, o);
-  } else {
-    return null;
-  }
-};
-cljs.core.peek = function peek(coll) {
-  if (coll == null) {
-    return null;
-  } else {
-    return cljs.core._peek.call(null, coll);
-  }
-};
-cljs.core.pop = function pop(coll) {
-  if (coll == null) {
-    return null;
-  } else {
-    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) {
-    if (coll == null) {
-      return null;
-    } else {
-      return cljs.core._disjoin.call(null, coll, k);
-    }
-  };
-  var disj__3 = function() {
-    var G__7149__delegate = function(coll, k, ks) {
-      while (true) {
-        if (coll == null) {
-          return null;
-        } else {
-          var ret = disj.call(null, coll, k);
-          if (cljs.core.truth_(ks)) {
-            var G__7150 = ret;
-            var G__7151 = cljs.core.first.call(null, ks);
-            var G__7152 = cljs.core.next.call(null, ks);
-            coll = G__7150;
-            k = G__7151;
-            ks = G__7152;
-            continue;
-          } else {
-            return ret;
-          }
-        }
-        break;
-      }
-    };
-    var G__7149 = 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__7149__delegate.call(this, coll, k, ks);
-    };
-    G__7149.cljs$lang$maxFixedArity = 2;
-    G__7149.cljs$lang$applyTo = function(arglist__7153) {
-      var coll = cljs.core.first(arglist__7153);
-      arglist__7153 = cljs.core.next(arglist__7153);
-      var k = cljs.core.first(arglist__7153);
-      var ks = cljs.core.rest(arglist__7153);
-      return G__7149__delegate(coll, k, ks);
-    };
-    G__7149.cljs$core$IFn$_invoke$arity$variadic = G__7149__delegate;
-    return G__7149;
-  }();
-  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 = function() {
-  var obj7155 = {};
-  return obj7155;
-}();
-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 = function() {
-      var obj7159 = {};
-      return obj7159;
-    }();
-    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 hash(o) {
-  if (function() {
-    var G__7161 = o;
-    if (G__7161) {
-      var bit__4027__auto__ = G__7161.cljs$lang$protocol_mask$partition0$ & 4194304;
-      if (bit__4027__auto__ || G__7161.cljs$core$IHash$) {
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      return false;
-    }
-  }()) {
-    return cljs.core._hash.call(null, o);
-  } else {
-    if (typeof o === "number") {
-      return Math.floor(o) % 2147483647;
-    } else {
-      if (o === true) {
-        return 1;
-      } else {
-        if (o === false) {
-          return 0;
-        } else {
-          if (typeof o === "string") {
-            return cljs.core.check_string_hash_cache.call(null, o);
-          } else {
-            if (o == null) {
-              return 0;
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                return cljs.core._hash.call(null, o);
-              } else {
-                return null;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-cljs.core.empty_QMARK_ = function empty_QMARK_(coll) {
-  return coll == null || 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__7163 = x;
-    if (G__7163) {
-      var bit__4034__auto__ = G__7163.cljs$lang$protocol_mask$partition0$ & 8;
-      if (bit__4034__auto__ || G__7163.cljs$core$ICollection$) {
-        return true;
-      } else {
-        if (!G__7163.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICollection, G__7163);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICollection, G__7163);
-    }
-  }
-};
-cljs.core.set_QMARK_ = function set_QMARK_(x) {
-  if (x == null) {
-    return false;
-  } else {
-    var G__7165 = x;
-    if (G__7165) {
-      var bit__4034__auto__ = G__7165.cljs$lang$protocol_mask$partition0$ & 4096;
-      if (bit__4034__auto__ || G__7165.cljs$core$ISet$) {
-        return true;
-      } else {
-        if (!G__7165.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISet, G__7165);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISet, G__7165);
-    }
-  }
-};
-cljs.core.associative_QMARK_ = function associative_QMARK_(x) {
-  var G__7167 = x;
-  if (G__7167) {
-    var bit__4034__auto__ = G__7167.cljs$lang$protocol_mask$partition0$ & 512;
-    if (bit__4034__auto__ || G__7167.cljs$core$IAssociative$) {
-      return true;
-    } else {
-      if (!G__7167.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IAssociative, G__7167);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IAssociative, G__7167);
-  }
-};
-cljs.core.sequential_QMARK_ = function sequential_QMARK_(x) {
-  var G__7169 = x;
-  if (G__7169) {
-    var bit__4034__auto__ = G__7169.cljs$lang$protocol_mask$partition0$ & 16777216;
-    if (bit__4034__auto__ || G__7169.cljs$core$ISequential$) {
-      return true;
-    } else {
-      if (!G__7169.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISequential, G__7169);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISequential, G__7169);
-  }
-};
-cljs.core.sorted_QMARK_ = function sorted_QMARK_(x) {
-  var G__7171 = x;
-  if (G__7171) {
-    var bit__4034__auto__ = G__7171.cljs$lang$protocol_mask$partition0$ & 268435456;
-    if (bit__4034__auto__ || G__7171.cljs$core$ISorted$) {
-      return true;
-    } else {
-      if (!G__7171.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISorted, G__7171);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISorted, G__7171);
-  }
-};
-cljs.core.reduceable_QMARK_ = function reduceable_QMARK_(x) {
-  var G__7173 = x;
-  if (G__7173) {
-    var bit__4034__auto__ = G__7173.cljs$lang$protocol_mask$partition0$ & 524288;
-    if (bit__4034__auto__ || G__7173.cljs$core$IReduce$) {
-      return true;
-    } else {
-      if (!G__7173.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, G__7173);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, G__7173);
-  }
-};
-cljs.core.map_QMARK_ = function map_QMARK_(x) {
-  if (x == null) {
-    return false;
-  } else {
-    var G__7175 = x;
-    if (G__7175) {
-      var bit__4034__auto__ = G__7175.cljs$lang$protocol_mask$partition0$ & 1024;
-      if (bit__4034__auto__ || G__7175.cljs$core$IMap$) {
-        return true;
-      } else {
-        if (!G__7175.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMap, G__7175);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMap, G__7175);
-    }
-  }
-};
-cljs.core.vector_QMARK_ = function vector_QMARK_(x) {
-  var G__7177 = x;
-  if (G__7177) {
-    var bit__4034__auto__ = G__7177.cljs$lang$protocol_mask$partition0$ & 16384;
-    if (bit__4034__auto__ || G__7177.cljs$core$IVector$) {
-      return true;
-    } else {
-      if (!G__7177.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IVector, G__7177);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IVector, G__7177);
-  }
-};
-cljs.core.chunked_seq_QMARK_ = function chunked_seq_QMARK_(x) {
-  var G__7179 = x;
-  if (G__7179) {
-    var bit__4027__auto__ = G__7179.cljs$lang$protocol_mask$partition1$ & 512;
-    if (bit__4027__auto__ || G__7179.cljs$core$IChunkedSeq$) {
-      return true;
-    } else {
-      return false;
-    }
-  } else {
-    return false;
-  }
-};
-cljs.core.js_obj = function() {
-  var js_obj = null;
-  var js_obj__0 = function() {
-    var obj7183 = {};
-    return obj7183;
-  };
-  var js_obj__1 = function() {
-    var G__7184__delegate = function(keyvals) {
-      return cljs.core.apply.call(null, goog.object.create, keyvals);
-    };
-    var G__7184 = function(var_args) {
-      var keyvals = null;
-      if (arguments.length > 0) {
-        keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-      }
-      return G__7184__delegate.call(this, keyvals);
-    };
-    G__7184.cljs$lang$maxFixedArity = 0;
-    G__7184.cljs$lang$applyTo = function(arglist__7185) {
-      var keyvals = cljs.core.seq(arglist__7185);
-      return G__7184__delegate(keyvals);
-    };
-    G__7184.cljs$core$IFn$_invoke$arity$variadic = G__7184__delegate;
-    return G__7184;
-  }();
-  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__7186 = i__$1 + 1;
-      var G__7187 = j__$1 + 1;
-      var G__7188 = len__$1 - 1;
-      i__$1 = G__7186;
-      j__$1 = G__7187;
-      len__$1 = G__7188;
-      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__7189 = i__$1 - 1;
-      var G__7190 = j__$1 - 1;
-      var G__7191 = len__$1 - 1;
-      i__$1 = G__7189;
-      j__$1 = G__7190;
-      len__$1 = G__7191;
-      continue;
-    }
-    break;
-  }
-};
-cljs.core.lookup_sentinel = function() {
-  var obj7193 = {};
-  return obj7193;
-}();
-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__7195 = s;
-    if (G__7195) {
-      var bit__4034__auto__ = G__7195.cljs$lang$protocol_mask$partition0$ & 64;
-      if (bit__4034__auto__ || G__7195.cljs$core$ISeq$) {
-        return true;
-      } else {
-        if (!G__7195.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7195);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__7195);
-    }
-  }
-};
-cljs.core.seqable_QMARK_ = function seqable_QMARK_(s) {
-  var G__7197 = s;
-  if (G__7197) {
-    var bit__4034__auto__ = G__7197.cljs$lang$protocol_mask$partition0$ & 8388608;
-    if (bit__4034__auto__ || G__7197.cljs$core$ISeqable$) {
-      return true;
-    } else {
-      if (!G__7197.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__7197);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__7197);
-  }
-};
-cljs.core.boolean$ = function boolean$(x) {
-  if (cljs.core.truth_(x)) {
-    return true;
-  } else {
-    return false;
-  }
-};
-cljs.core.ifn_QMARK_ = function ifn_QMARK_(f) {
-  var or__3408__auto__ = cljs.core.fn_QMARK_.call(null, f);
-  if (or__3408__auto__) {
-    return or__3408__auto__;
-  } else {
-    var G__7201 = f;
-    if (G__7201) {
-      var bit__4034__auto__ = G__7201.cljs$lang$protocol_mask$partition0$ & 1;
-      if (bit__4034__auto__ || G__7201.cljs$core$IFn$) {
-        return true;
-      } else {
-        if (!G__7201.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IFn, G__7201);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IFn, G__7201);
-    }
-  }
-};
-cljs.core.integer_QMARK_ = function integer_QMARK_(n) {
-  return typeof n === "number" && (!isNaN(n) && (!(n === Infinity) && parseFloat(n) === parseInt(n, 10)));
-};
-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 (!(coll == null) && (cljs.core.associative_QMARK_.call(null, coll) && cljs.core.contains_QMARK_.call(null, coll, k))) {
-    return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k, cljs.core.get.call(null, coll, k)], null);
-  } 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__7202__delegate = function(x, y, more) {
-      if (!cljs.core._EQ_.call(null, x, y)) {
-        var s = cljs.core.PersistentHashSet.fromArray([y, x], 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__7203 = cljs.core.conj.call(null, s, x__$1);
-              var G__7204 = etc;
-              s = G__7203;
-              xs = G__7204;
-              continue;
-            }
-          } else {
-            return true;
-          }
-          break;
-        }
-      } else {
-        return false;
-      }
-    };
-    var G__7202 = 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__7202__delegate.call(this, x, y, more);
-    };
-    G__7202.cljs$lang$maxFixedArity = 2;
-    G__7202.cljs$lang$applyTo = function(arglist__7205) {
-      var x = cljs.core.first(arglist__7205);
-      arglist__7205 = cljs.core.next(arglist__7205);
-      var y = cljs.core.first(arglist__7205);
-      var more = cljs.core.rest(arglist__7205);
-      return G__7202__delegate(x, y, more);
-    };
-    G__7202.cljs$core$IFn$_invoke$arity$variadic = G__7202__delegate;
-    return G__7202;
-  }();
-  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.sequence = function sequence(coll) {
-  if (cljs.core.seq_QMARK_.call(null, coll)) {
-    return coll;
-  } else {
-    var or__3408__auto__ = cljs.core.seq.call(null, coll);
-    if (or__3408__auto__) {
-      return or__3408__auto__;
-    } else {
-      return cljs.core.List.EMPTY;
-    }
-  }
-};
-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__7207 = x;
-            if (G__7207) {
-              var bit__4027__auto__ = G__7207.cljs$lang$protocol_mask$partition1$ & 2048;
-              if (bit__4027__auto__ || G__7207.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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-            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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (d === 0 && n + 1 < len) {
-        var G__7208 = xs;
-        var G__7209 = ys;
-        var G__7210 = len;
-        var G__7211 = n + 1;
-        xs = G__7208;
-        ys = G__7209;
-        len = G__7210;
-        n = G__7211;
-        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__7212 = nval;
-          var G__7213 = cljs.core.next.call(null, coll__$1);
-          val__$1 = G__7212;
-          coll__$1 = G__7213;
-          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__7216 = coll;
-      if (G__7216) {
-        var bit__4027__auto__ = G__7216.cljs$lang$protocol_mask$partition0$ & 524288;
-        if (bit__4027__auto__ || G__7216.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 (typeof coll === "string") {
-          return cljs.core.array_reduce.call(null, coll, f);
-        } else {
-          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, coll)) {
-            return cljs.core._reduce.call(null, coll, f);
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              return cljs.core.seq_reduce.call(null, f, coll);
-            } else {
-              return null;
-            }
-          }
-        }
-      }
-    }
-  };
-  var reduce__3 = function(f, val, coll) {
-    if (function() {
-      var G__7217 = coll;
-      if (G__7217) {
-        var bit__4027__auto__ = G__7217.cljs$lang$protocol_mask$partition0$ & 524288;
-        if (bit__4027__auto__ || G__7217.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 (typeof coll === "string") {
-          return cljs.core.array_reduce.call(null, coll, f, val);
-        } else {
-          if (cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, coll)) {
-            return cljs.core._reduce.call(null, coll, f, val);
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              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) {
-  if (!(coll == null)) {
-    return cljs.core._kv_reduce.call(null, coll, f, init);
-  } else {
-    return 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__7218__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, _PLUS_, x + y, more);
-    };
-    var G__7218 = 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__7218__delegate.call(this, x, y, more);
-    };
-    G__7218.cljs$lang$maxFixedArity = 2;
-    G__7218.cljs$lang$applyTo = function(arglist__7219) {
-      var x = cljs.core.first(arglist__7219);
-      arglist__7219 = cljs.core.next(arglist__7219);
-      var y = cljs.core.first(arglist__7219);
-      var more = cljs.core.rest(arglist__7219);
-      return G__7218__delegate(x, y, more);
-    };
-    G__7218.cljs$core$IFn$_invoke$arity$variadic = G__7218__delegate;
-    return G__7218;
-  }();
-  _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__7220__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, _, x - y, more);
-    };
-    var G__7220 = 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__7220__delegate.call(this, x, y, more);
-    };
-    G__7220.cljs$lang$maxFixedArity = 2;
-    G__7220.cljs$lang$applyTo = function(arglist__7221) {
-      var x = cljs.core.first(arglist__7221);
-      arglist__7221 = cljs.core.next(arglist__7221);
-      var y = cljs.core.first(arglist__7221);
-      var more = cljs.core.rest(arglist__7221);
-      return G__7220__delegate(x, y, more);
-    };
-    G__7220.cljs$core$IFn$_invoke$arity$variadic = G__7220__delegate;
-    return G__7220;
-  }();
-  _ = 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__7222__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, _STAR_, x * y, more);
-    };
-    var G__7222 = 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__7222__delegate.call(this, x, y, more);
-    };
-    G__7222.cljs$lang$maxFixedArity = 2;
-    G__7222.cljs$lang$applyTo = function(arglist__7223) {
-      var x = cljs.core.first(arglist__7223);
-      arglist__7223 = cljs.core.next(arglist__7223);
-      var y = cljs.core.first(arglist__7223);
-      var more = cljs.core.rest(arglist__7223);
-      return G__7222__delegate(x, y, more);
-    };
-    G__7222.cljs$core$IFn$_invoke$arity$variadic = G__7222__delegate;
-    return G__7222;
-  }();
-  _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__7224__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, _SLASH_, _SLASH_.call(null, x, y), more);
-    };
-    var G__7224 = 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__7224__delegate.call(this, x, y, more);
-    };
-    G__7224.cljs$lang$maxFixedArity = 2;
-    G__7224.cljs$lang$applyTo = function(arglist__7225) {
-      var x = cljs.core.first(arglist__7225);
-      arglist__7225 = cljs.core.next(arglist__7225);
-      var y = cljs.core.first(arglist__7225);
-      var more = cljs.core.rest(arglist__7225);
-      return G__7224__delegate(x, y, more);
-    };
-    G__7224.cljs$core$IFn$_invoke$arity$variadic = G__7224__delegate;
-    return G__7224;
-  }();
-  _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__7226__delegate = function(x, y, more) {
-      while (true) {
-        if (x < y) {
-          if (cljs.core.next.call(null, more)) {
-            var G__7227 = y;
-            var G__7228 = cljs.core.first.call(null, more);
-            var G__7229 = cljs.core.next.call(null, more);
-            x = G__7227;
-            y = G__7228;
-            more = G__7229;
-            continue;
-          } else {
-            return y < cljs.core.first.call(null, more);
-          }
-        } else {
-          return false;
-        }
-        break;
-      }
-    };
-    var G__7226 = 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__7226__delegate.call(this, x, y, more);
-    };
-    G__7226.cljs$lang$maxFixedArity = 2;
-    G__7226.cljs$lang$applyTo = function(arglist__7230) {
-      var x = cljs.core.first(arglist__7230);
-      arglist__7230 = cljs.core.next(arglist__7230);
-      var y = cljs.core.first(arglist__7230);
-      var more = cljs.core.rest(arglist__7230);
-      return G__7226__delegate(x, y, more);
-    };
-    G__7226.cljs$core$IFn$_invoke$arity$variadic = G__7226__delegate;
-    return G__7226;
-  }();
-  _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__7231__delegate = function(x, y, more) {
-      while (true) {
-        if (x <= y) {
-          if (cljs.core.next.call(null, more)) {
-            var G__7232 = y;
-            var G__7233 = cljs.core.first.call(null, more);
-            var G__7234 = cljs.core.next.call(null, more);
-            x = G__7232;
-            y = G__7233;
-            more = G__7234;
-            continue;
-          } else {
-            return y <= cljs.core.first.call(null, more);
-          }
-        } else {
-          return false;
-        }
-        break;
-      }
-    };
-    var G__7231 = 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__7231__delegate.call(this, x, y, more);
-    };
-    G__7231.cljs$lang$maxFixedArity = 2;
-    G__7231.cljs$lang$applyTo = function(arglist__7235) {
-      var x = cljs.core.first(arglist__7235);
-      arglist__7235 = cljs.core.next(arglist__7235);
-      var y = cljs.core.first(arglist__7235);
-      var more = cljs.core.rest(arglist__7235);
-      return G__7231__delegate(x, y, more);
-    };
-    G__7231.cljs$core$IFn$_invoke$arity$variadic = G__7231__delegate;
-    return G__7231;
-  }();
-  _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__7236__delegate = function(x, y, more) {
-      while (true) {
-        if (x > y) {
-          if (cljs.core.next.call(null, more)) {
-            var G__7237 = y;
-            var G__7238 = cljs.core.first.call(null, more);
-            var G__7239 = cljs.core.next.call(null, more);
-            x = G__7237;
-            y = G__7238;
-            more = G__7239;
-            continue;
-          } else {
-            return y > cljs.core.first.call(null, more);
-          }
-        } else {
-          return false;
-        }
-        break;
-      }
-    };
-    var G__7236 = 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__7236__delegate.call(this, x, y, more);
-    };
-    G__7236.cljs$lang$maxFixedArity = 2;
-    G__7236.cljs$lang$applyTo = function(arglist__7240) {
-      var x = cljs.core.first(arglist__7240);
-      arglist__7240 = cljs.core.next(arglist__7240);
-      var y = cljs.core.first(arglist__7240);
-      var more = cljs.core.rest(arglist__7240);
-      return G__7236__delegate(x, y, more);
-    };
-    G__7236.cljs$core$IFn$_invoke$arity$variadic = G__7236__delegate;
-    return G__7236;
-  }();
-  _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__7241__delegate = function(x, y, more) {
-      while (true) {
-        if (x >= y) {
-          if (cljs.core.next.call(null, more)) {
-            var G__7242 = y;
-            var G__7243 = cljs.core.first.call(null, more);
-            var G__7244 = cljs.core.next.call(null, more);
-            x = G__7242;
-            y = G__7243;
-            more = G__7244;
-            continue;
-          } else {
-            return y >= cljs.core.first.call(null, more);
-          }
-        } else {
-          return false;
-        }
-        break;
-      }
-    };
-    var G__7241 = 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__7241__delegate.call(this, x, y, more);
-    };
-    G__7241.cljs$lang$maxFixedArity = 2;
-    G__7241.cljs$lang$applyTo = function(arglist__7245) {
-      var x = cljs.core.first(arglist__7245);
-      arglist__7245 = cljs.core.next(arglist__7245);
-      var y = cljs.core.first(arglist__7245);
-      var more = cljs.core.rest(arglist__7245);
-      return G__7241__delegate(x, y, more);
-    };
-    G__7241.cljs$core$IFn$_invoke$arity$variadic = G__7241__delegate;
-    return G__7241;
-  }();
-  _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) {
-    var x__3715__auto__ = x;
-    var y__3716__auto__ = y;
-    return x__3715__auto__ > y__3716__auto__ ? x__3715__auto__ : y__3716__auto__;
-  };
-  var max__3 = function() {
-    var G__7246__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, max, function() {
-        var x__3715__auto__ = x;
-        var y__3716__auto__ = y;
-        return x__3715__auto__ > y__3716__auto__ ? x__3715__auto__ : y__3716__auto__;
-      }(), more);
-    };
-    var G__7246 = 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__7246__delegate.call(this, x, y, more);
-    };
-    G__7246.cljs$lang$maxFixedArity = 2;
-    G__7246.cljs$lang$applyTo = function(arglist__7247) {
-      var x = cljs.core.first(arglist__7247);
-      arglist__7247 = cljs.core.next(arglist__7247);
-      var y = cljs.core.first(arglist__7247);
-      var more = cljs.core.rest(arglist__7247);
-      return G__7246__delegate(x, y, more);
-    };
-    G__7246.cljs$core$IFn$_invoke$arity$variadic = G__7246__delegate;
-    return G__7246;
-  }();
-  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) {
-    var x__3722__auto__ = x;
-    var y__3723__auto__ = y;
-    return x__3722__auto__ < y__3723__auto__ ? x__3722__auto__ : y__3723__auto__;
-  };
-  var min__3 = function() {
-    var G__7248__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, min, function() {
-        var x__3722__auto__ = x;
-        var y__3723__auto__ = y;
-        return x__3722__auto__ < y__3723__auto__ ? x__3722__auto__ : y__3723__auto__;
-      }(), more);
-    };
-    var G__7248 = 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__7248__delegate.call(this, x, y, more);
-    };
-    G__7248.cljs$lang$maxFixedArity = 2;
-    G__7248.cljs$lang$applyTo = function(arglist__7249) {
-      var x = cljs.core.first(arglist__7249);
-      arglist__7249 = cljs.core.next(arglist__7249);
-      var y = cljs.core.first(arglist__7249);
-      var more = cljs.core.rest(arglist__7249);
-      return G__7248__delegate(x, y, more);
-    };
-    G__7248.cljs$core$IFn$_invoke$arity$variadic = G__7248__delegate;
-    return G__7248;
-  }();
-  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 (typeof x === "string" && x.length === 1) {
-      return x;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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__7250__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_add, x + y, more);
-    };
-    var G__7250 = 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__7250__delegate.call(this, x, y, more);
-    };
-    G__7250.cljs$lang$maxFixedArity = 2;
-    G__7250.cljs$lang$applyTo = function(arglist__7251) {
-      var x = cljs.core.first(arglist__7251);
-      arglist__7251 = cljs.core.next(arglist__7251);
-      var y = cljs.core.first(arglist__7251);
-      var more = cljs.core.rest(arglist__7251);
-      return G__7250__delegate(x, y, more);
-    };
-    G__7250.cljs$core$IFn$_invoke$arity$variadic = G__7250__delegate;
-    return G__7250;
-  }();
-  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__7252__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_add_int, x + y, more);
-    };
-    var G__7252 = 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__7252__delegate.call(this, x, y, more);
-    };
-    G__7252.cljs$lang$maxFixedArity = 2;
-    G__7252.cljs$lang$applyTo = function(arglist__7253) {
-      var x = cljs.core.first(arglist__7253);
-      arglist__7253 = cljs.core.next(arglist__7253);
-      var y = cljs.core.first(arglist__7253);
-      var more = cljs.core.rest(arglist__7253);
-      return G__7252__delegate(x, y, more);
-    };
-    G__7252.cljs$core$IFn$_invoke$arity$variadic = G__7252__delegate;
-    return G__7252;
-  }();
-  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__7254__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_divide_int, unchecked_divide_int.call(null, x, y), more);
-    };
-    var G__7254 = 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__7254__delegate.call(this, x, y, more);
-    };
-    G__7254.cljs$lang$maxFixedArity = 2;
-    G__7254.cljs$lang$applyTo = function(arglist__7255) {
-      var x = cljs.core.first(arglist__7255);
-      arglist__7255 = cljs.core.next(arglist__7255);
-      var y = cljs.core.first(arglist__7255);
-      var more = cljs.core.rest(arglist__7255);
-      return G__7254__delegate(x, y, more);
-    };
-    G__7254.cljs$core$IFn$_invoke$arity$variadic = G__7254__delegate;
-    return G__7254;
-  }();
-  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__7256__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_multiply, x * y, more);
-    };
-    var G__7256 = 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__7256__delegate.call(this, x, y, more);
-    };
-    G__7256.cljs$lang$maxFixedArity = 2;
-    G__7256.cljs$lang$applyTo = function(arglist__7257) {
-      var x = cljs.core.first(arglist__7257);
-      arglist__7257 = cljs.core.next(arglist__7257);
-      var y = cljs.core.first(arglist__7257);
-      var more = cljs.core.rest(arglist__7257);
-      return G__7256__delegate(x, y, more);
-    };
-    G__7256.cljs$core$IFn$_invoke$arity$variadic = G__7256__delegate;
-    return G__7256;
-  }();
-  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__7258__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_multiply_int, x * y, more);
-    };
-    var G__7258 = 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__7258__delegate.call(this, x, y, more);
-    };
-    G__7258.cljs$lang$maxFixedArity = 2;
-    G__7258.cljs$lang$applyTo = function(arglist__7259) {
-      var x = cljs.core.first(arglist__7259);
-      arglist__7259 = cljs.core.next(arglist__7259);
-      var y = cljs.core.first(arglist__7259);
-      var more = cljs.core.rest(arglist__7259);
-      return G__7258__delegate(x, y, more);
-    };
-    G__7258.cljs$core$IFn$_invoke$arity$variadic = G__7258__delegate;
-    return G__7258;
-  }();
-  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__7260__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_substract, x - y, more);
-    };
-    var G__7260 = 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__7260__delegate.call(this, x, y, more);
-    };
-    G__7260.cljs$lang$maxFixedArity = 2;
-    G__7260.cljs$lang$applyTo = function(arglist__7261) {
-      var x = cljs.core.first(arglist__7261);
-      arglist__7261 = cljs.core.next(arglist__7261);
-      var y = cljs.core.first(arglist__7261);
-      var more = cljs.core.rest(arglist__7261);
-      return G__7260__delegate(x, y, more);
-    };
-    G__7260.cljs$core$IFn$_invoke$arity$variadic = G__7260__delegate;
-    return G__7260;
-  }();
-  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__7262__delegate = function(x, y, more) {
-      return cljs.core.reduce.call(null, unchecked_substract_int, x - y, more);
-    };
-    var G__7262 = 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__7262__delegate.call(this, x, y, more);
-    };
-    G__7262.cljs$lang$maxFixedArity = 2;
-    G__7262.cljs$lang$applyTo = function(arglist__7263) {
-      var x = cljs.core.first(arglist__7263);
-      arglist__7263 = cljs.core.next(arglist__7263);
-      var y = cljs.core.first(arglist__7263);
-      var more = cljs.core.rest(arglist__7263);
-      return G__7262__delegate(x, y, more);
-    };
-    G__7262.cljs$core$IFn$_invoke$arity$variadic = G__7262__delegate;
-    return G__7262;
-  }();
-  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.unsigned_bit_shift_right = function unsigned_bit_shift_right(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__7264__delegate = function(x, y, more) {
-      while (true) {
-        if (_EQ__EQ_.call(null, x, y)) {
-          if (cljs.core.next.call(null, more)) {
-            var G__7265 = y;
-            var G__7266 = cljs.core.first.call(null, more);
-            var G__7267 = cljs.core.next.call(null, more);
-            x = G__7265;
-            y = G__7266;
-            more = G__7267;
-            continue;
-          } else {
-            return _EQ__EQ_.call(null, y, cljs.core.first.call(null, more));
-          }
-        } else {
-          return false;
-        }
-        break;
-      }
-    };
-    var G__7264 = 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__7264__delegate.call(this, x, y, more);
-    };
-    G__7264.cljs$lang$maxFixedArity = 2;
-    G__7264.cljs$lang$applyTo = function(arglist__7268) {
-      var x = cljs.core.first(arglist__7268);
-      arglist__7268 = cljs.core.next(arglist__7268);
-      var y = cljs.core.first(arglist__7268);
-      var more = cljs.core.rest(arglist__7268);
-      return G__7264__delegate(x, y, more);
-    };
-    G__7264.cljs$core$IFn$_invoke$arity$variadic = G__7264__delegate;
-    return G__7264;
-  }();
-  _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 (xs && n__$1 > 0) {
-      var G__7269 = n__$1 - 1;
-      var G__7270 = cljs.core.next.call(null, xs);
-      n__$1 = G__7269;
-      xs = G__7270;
-      continue;
-    } else {
-      return xs;
-    }
-    break;
-  }
-};
-cljs.core.str = function() {
-  var str = null;
-  var str__0 = function() {
-    return "";
-  };
-  var str__1 = function(x) {
-    if (x == null) {
-      return "";
-    } else {
-      return x.toString();
-    }
-  };
-  var str__2 = function() {
-    var G__7271__delegate = function(x, ys) {
-      var sb = new goog.string.StringBuffer(str.call(null, x));
-      var more = ys;
-      while (true) {
-        if (cljs.core.truth_(more)) {
-          var G__7272 = sb.append(str.call(null, cljs.core.first.call(null, more)));
-          var G__7273 = cljs.core.next.call(null, more);
-          sb = G__7272;
-          more = G__7273;
-          continue;
-        } else {
-          return sb.toString();
-        }
-        break;
-      }
-    };
-    var G__7271 = 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__7271__delegate.call(this, x, ys);
-    };
-    G__7271.cljs$lang$maxFixedArity = 1;
-    G__7271.cljs$lang$applyTo = function(arglist__7274) {
-      var x = cljs.core.first(arglist__7274);
-      var ys = cljs.core.rest(arglist__7274);
-      return G__7271__delegate(x, ys);
-    };
-    G__7271.cljs$core$IFn$_invoke$arity$variadic = G__7271__delegate;
-    return G__7271;
-  }();
-  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.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__7275 = cljs.core.next.call(null, xs);
-            var G__7276 = cljs.core.next.call(null, ys);
-            xs = G__7275;
-            ys = G__7276;
-            continue;
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              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) {
-  if (cljs.core.seq.call(null, coll)) {
-    var res = cljs.core.hash.call(null, cljs.core.first.call(null, coll));
-    var s = cljs.core.next.call(null, coll);
-    while (true) {
-      if (s == null) {
-        return res;
-      } else {
-        var G__7277 = cljs.core.hash_combine.call(null, res, cljs.core.hash.call(null, cljs.core.first.call(null, s)));
-        var G__7278 = cljs.core.next.call(null, s);
-        res = G__7277;
-        s = G__7278;
-        continue;
-      }
-      break;
-    }
-  } else {
-    return 0;
-  }
-};
-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__7279 = (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__7280 = cljs.core.next.call(null, s);
-      h = G__7279;
-      s = G__7280;
-      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__7281 = (h + cljs.core.hash.call(null, e)) % 4503599627370496;
-      var G__7282 = cljs.core.next.call(null, s__$1);
-      h = G__7281;
-      s__$1 = G__7282;
-      continue;
-    } else {
-      return h;
-    }
-    break;
-  }
-};
-cljs.core.extend_object_BANG_ = function extend_object_BANG_(obj, fn_map) {
-  var seq__7289_7295 = cljs.core.seq.call(null, fn_map);
-  var chunk__7290_7296 = null;
-  var count__7291_7297 = 0;
-  var i__7292_7298 = 0;
-  while (true) {
-    if (i__7292_7298 < count__7291_7297) {
-      var vec__7293_7299 = cljs.core._nth.call(null, chunk__7290_7296, i__7292_7298);
-      var key_name_7300 = cljs.core.nth.call(null, vec__7293_7299, 0, null);
-      var f_7301 = cljs.core.nth.call(null, vec__7293_7299, 1, null);
-      var str_name_7302 = cljs.core.name.call(null, key_name_7300);
-      obj[str_name_7302] = f_7301;
-      var G__7303 = seq__7289_7295;
-      var G__7304 = chunk__7290_7296;
-      var G__7305 = count__7291_7297;
-      var G__7306 = i__7292_7298 + 1;
-      seq__7289_7295 = G__7303;
-      chunk__7290_7296 = G__7304;
-      count__7291_7297 = G__7305;
-      i__7292_7298 = G__7306;
-      continue;
-    } else {
-      var temp__4092__auto___7307 = cljs.core.seq.call(null, seq__7289_7295);
-      if (temp__4092__auto___7307) {
-        var seq__7289_7308__$1 = temp__4092__auto___7307;
-        if (cljs.core.chunked_seq_QMARK_.call(null, seq__7289_7308__$1)) {
-          var c__4132__auto___7309 = cljs.core.chunk_first.call(null, seq__7289_7308__$1);
-          var G__7310 = cljs.core.chunk_rest.call(null, seq__7289_7308__$1);
-          var G__7311 = c__4132__auto___7309;
-          var G__7312 = cljs.core.count.call(null, c__4132__auto___7309);
-          var G__7313 = 0;
-          seq__7289_7295 = G__7310;
-          chunk__7290_7296 = G__7311;
-          count__7291_7297 = G__7312;
-          i__7292_7298 = G__7313;
-          continue;
-        } else {
-          var vec__7294_7314 = cljs.core.first.call(null, seq__7289_7308__$1);
-          var key_name_7315 = cljs.core.nth.call(null, vec__7294_7314, 0, null);
-          var f_7316 = cljs.core.nth.call(null, vec__7294_7314, 1, null);
-          var str_name_7317 = cljs.core.name.call(null, key_name_7315);
-          obj[str_name_7317] = f_7316;
-          var G__7318 = cljs.core.next.call(null, seq__7289_7308__$1);
-          var G__7319 = null;
-          var G__7320 = 0;
-          var G__7321 = 0;
-          seq__7289_7295 = G__7318;
-          chunk__7290_7296 = G__7319;
-          count__7291_7297 = G__7320;
-          i__7292_7298 = G__7321;
-          continue;
-        }
-      } else {
-      }
-    }
-    break;
-  }
-  return obj;
-};
-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$ = 65937646;
-};
-cljs.core.List.cljs$lang$type = true;
-cljs.core.List.cljs$lang$ctorStr = "cljs.core/List";
-cljs.core.List.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/List");
-};
-cljs.core.List.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.List.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return new cljs.core.List(self__.meta, o, coll__$1, 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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.List.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.List.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.List.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.count;
-};
-cljs.core.List.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.first;
-};
-cljs.core.List.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._rest.call(null, coll__$1);
-};
-cljs.core.List.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.first;
-};
-cljs.core.List.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.List.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.List.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.List.EMPTY;
-};
-cljs.core.__GT_List = function __GT_List(meta, first, rest, count, __hash) {
-  return new cljs.core.List(meta, first, rest, count, __hash);
-};
-cljs.core.EmptyList = function(meta) {
-  this.meta = meta;
-  this.cljs$lang$protocol_mask$partition1$ = 0;
-  this.cljs$lang$protocol_mask$partition0$ = 65937614;
-};
-cljs.core.EmptyList.cljs$lang$type = true;
-cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList";
-cljs.core.EmptyList.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/EmptyList");
-};
-cljs.core.EmptyList.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return 0;
-};
-cljs.core.EmptyList.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return null;
-};
-cljs.core.EmptyList.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = 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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.EmptyList.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.EmptyList.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return null;
-};
-cljs.core.EmptyList.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return 0;
-};
-cljs.core.EmptyList.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return null;
-};
-cljs.core.EmptyList.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  throw new Error("Can't pop empty list");
-};
-cljs.core.EmptyList.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return null;
-};
-cljs.core.EmptyList.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.List.EMPTY;
-};
-cljs.core.EmptyList.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.EmptyList.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.EmptyList(meta__$1);
-};
-cljs.core.EmptyList.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.EmptyList.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.__GT_EmptyList = function __GT_EmptyList(meta) {
-  return new cljs.core.EmptyList(meta);
-};
-cljs.core.List.EMPTY = new cljs.core.EmptyList(null);
-cljs.core.reversible_QMARK_ = function reversible_QMARK_(coll) {
-  var G__7323 = coll;
-  if (G__7323) {
-    var bit__4034__auto__ = G__7323.cljs$lang$protocol_mask$partition0$ & 134217728;
-    if (bit__4034__auto__ || G__7323.cljs$core$IReversible$) {
-      return true;
-    } else {
-      if (!G__7323.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReversible, G__7323);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReversible, G__7323);
-  }
-};
-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.i === 0 ? 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__7324 = cljs.core._next.call(null, xs__$1);
-          xs__$1 = G__7324;
-          continue;
-        } else {
-          return arr;
-        }
-        break;
-      }
-    }();
-    var i = arr.length;
-    var r = cljs.core.List.EMPTY;
-    while (true) {
-      if (i > 0) {
-        var G__7325 = i - 1;
-        var G__7326 = cljs.core._conj.call(null, r, arr[i - 1]);
-        i = G__7325;
-        r = G__7326;
-        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__7327) {
-    var xs = cljs.core.seq(arglist__7327);
-    return list__delegate(xs);
-  };
-  list.cljs$core$IFn$_invoke$arity$variadic = list__delegate;
-  return list;
-}();
-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$ = 65929452;
-};
-cljs.core.Cons.cljs$lang$type = true;
-cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons";
-cljs.core.Cons.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Cons");
-};
-cljs.core.Cons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.Cons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return new cljs.core.Cons(null, o, coll__$1, 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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.Cons.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.Cons.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.Cons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.first;
-};
-cljs.core.Cons.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.Cons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.Cons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_Cons = function __GT_Cons(meta, first, rest, __hash) {
-  return new cljs.core.Cons(meta, first, rest, __hash);
-};
-cljs.core.cons = function cons(x, coll) {
-  if (function() {
-    var or__3408__auto__ = coll == null;
-    if (or__3408__auto__) {
-      return or__3408__auto__;
-    } else {
-      var G__7331 = coll;
-      if (G__7331) {
-        var bit__4027__auto__ = G__7331.cljs$lang$protocol_mask$partition0$ & 64;
-        if (bit__4027__auto__ || G__7331.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__7333 = x;
-  if (G__7333) {
-    var bit__4034__auto__ = G__7333.cljs$lang$protocol_mask$partition0$ & 33554432;
-    if (bit__4034__auto__ || G__7333.cljs$core$IList$) {
-      return true;
-    } else {
-      if (!G__7333.cljs$lang$protocol_mask$partition0$) {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IList, G__7333);
-      } else {
-        return false;
-      }
-    }
-  } else {
-    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IList, G__7333);
-  }
-};
-cljs.core.Keyword = function(ns, name, fqn, _hash) {
-  this.ns = ns;
-  this.name = name;
-  this.fqn = fqn;
-  this._hash = _hash;
-  this.cljs$lang$protocol_mask$partition0$ = 2153775105;
-  this.cljs$lang$protocol_mask$partition1$ = 4096;
-};
-cljs.core.Keyword.cljs$lang$type = true;
-cljs.core.Keyword.cljs$lang$ctorStr = "cljs.core/Keyword";
-cljs.core.Keyword.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Keyword");
-};
-cljs.core.Keyword.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(o, writer, _) {
-  var self__ = this;
-  var o__$1 = this;
-  return cljs.core._write.call(null, writer, [cljs.core.str(":"), cljs.core.str(self__.fqn)].join(""));
-};
-cljs.core.Keyword.prototype.cljs$core$INamed$_name$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.name;
-};
-cljs.core.Keyword.prototype.cljs$core$INamed$_namespace$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.ns;
-};
-cljs.core.Keyword.prototype.cljs$core$IHash$_hash$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  if (self__._hash == null) {
-    self__._hash = cljs.core.hash_combine.call(null, cljs.core.hash.call(null, self__.ns), cljs.core.hash.call(null, self__.name)) + 2654435769;
-    return self__._hash;
-  } else {
-    return self__._hash;
-  }
-};
-cljs.core.Keyword.prototype.call = function() {
-  var G__7335 = null;
-  var G__7335__2 = function(self__, coll) {
-    var self__ = this;
-    var self____$1 = this;
-    var kw = self____$1;
-    return cljs.core.get.call(null, coll, kw);
-  };
-  var G__7335__3 = function(self__, coll, not_found) {
-    var self__ = this;
-    var self____$1 = this;
-    var kw = self____$1;
-    return cljs.core.get.call(null, coll, kw, not_found);
-  };
-  G__7335 = function(self__, coll, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7335__2.call(this, self__, coll);
-      case 3:
-        return G__7335__3.call(this, self__, coll, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7335;
-}();
-cljs.core.Keyword.prototype.apply = function(self__, args7334) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7334)));
-};
-cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$1 = function(coll) {
-  var self__ = this;
-  var kw = this;
-  return cljs.core.get.call(null, coll, kw);
-};
-cljs.core.Keyword.prototype.cljs$core$IFn$_invoke$arity$2 = function(coll, not_found) {
-  var self__ = this;
-  var kw = this;
-  return cljs.core.get.call(null, coll, kw, not_found);
-};
-cljs.core.Keyword.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(_, other) {
-  var self__ = this;
-  var ___$1 = this;
-  if (other instanceof cljs.core.Keyword) {
-    return self__.fqn === other.fqn;
-  } else {
-    return false;
-  }
-};
-cljs.core.Keyword.prototype.toString = function() {
-  var self__ = this;
-  var _ = this;
-  return[cljs.core.str(":"), cljs.core.str(self__.fqn)].join("");
-};
-cljs.core.__GT_Keyword = function __GT_Keyword(ns, name, fqn, _hash) {
-  return new cljs.core.Keyword(ns, name, fqn, _hash);
-};
-cljs.core.keyword_QMARK_ = function keyword_QMARK_(x) {
-  return x instanceof cljs.core.Keyword;
-};
-cljs.core.keyword_identical_QMARK_ = function keyword_identical_QMARK_(x, y) {
-  if (x === y) {
-    return true;
-  } else {
-    if (x instanceof cljs.core.Keyword && y instanceof cljs.core.Keyword) {
-      return x.fqn === y.fqn;
-    } else {
-      return false;
-    }
-  }
-};
-cljs.core.namespace = function namespace(x) {
-  if (function() {
-    var G__7337 = x;
-    if (G__7337) {
-      var bit__4027__auto__ = G__7337.cljs$lang$protocol_mask$partition1$ & 4096;
-      if (bit__4027__auto__ || G__7337.cljs$core$INamed$) {
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      return false;
-    }
-  }()) {
-    return cljs.core._namespace.call(null, x);
-  } else {
-    throw new Error([cljs.core.str("Doesn't support namespace: "), cljs.core.str(x)].join(""));
-  }
-};
-cljs.core.keyword = function() {
-  var keyword = null;
-  var keyword__1 = function(name) {
-    if (name instanceof cljs.core.Keyword) {
-      return name;
-    } else {
-      if (name instanceof cljs.core.Symbol) {
-        return new cljs.core.Keyword(cljs.core.namespace.call(null, name), cljs.core.name.call(null, name), name.str, null);
-      } else {
-        if (typeof name === "string") {
-          var parts = name.split("/");
-          if (parts.length === 2) {
-            return new cljs.core.Keyword(parts[0], parts[1], name, null);
-          } else {
-            return new cljs.core.Keyword(null, parts[0], name, null);
-          }
-        } else {
-          return null;
-        }
-      }
-    }
-  };
-  var keyword__2 = function(ns, name) {
-    return new cljs.core.Keyword(ns, name, [cljs.core.str(cljs.core.truth_(ns) ? [cljs.core.str(ns), cljs.core.str("/")].join("") : null), cljs.core.str(name)].join(""), null);
-  };
-  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.LazySeq = function(meta, fn, s, __hash) {
-  this.meta = meta;
-  this.fn = fn;
-  this.s = s;
-  this.__hash = __hash;
-  this.cljs$lang$protocol_mask$partition1$ = 0;
-  this.cljs$lang$protocol_mask$partition0$ = 32374988;
-};
-cljs.core.LazySeq.cljs$lang$type = true;
-cljs.core.LazySeq.cljs$lang$ctorStr = "cljs.core/LazySeq";
-cljs.core.LazySeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/LazySeq");
-};
-cljs.core.LazySeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.LazySeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  cljs.core._seq.call(null, coll__$1);
-  if (self__.s == null) {
-    return null;
-  } else {
-    return cljs.core.next.call(null, self__.s);
-  }
-};
-cljs.core.LazySeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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.sval = function() {
-  var self__ = this;
-  var coll = this;
-  if (self__.fn == null) {
-    return self__.s;
-  } else {
-    self__.s = self__.fn.call(null);
-    self__.fn = null;
-    return self__.s;
-  }
-};
-cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.LazySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.LazySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  coll__$1.sval();
-  if (self__.s == null) {
-    return null;
-  } else {
-    var ls = self__.s;
-    while (true) {
-      if (ls instanceof cljs.core.LazySeq) {
-        var G__7338 = ls.sval();
-        ls = G__7338;
-        continue;
-      } else {
-        self__.s = ls;
-        return cljs.core.seq.call(null, self__.s);
-      }
-      break;
-    }
-  }
-};
-cljs.core.LazySeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  cljs.core._seq.call(null, coll__$1);
-  if (self__.s == null) {
-    return null;
-  } else {
-    return cljs.core.first.call(null, self__.s);
-  }
-};
-cljs.core.LazySeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  cljs.core._seq.call(null, coll__$1);
-  if (!(self__.s == null)) {
-    return cljs.core.rest.call(null, self__.s);
-  } else {
-    return cljs.core.List.EMPTY;
-  }
-};
-cljs.core.LazySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.LazySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.LazySeq(meta__$1, self__.fn, self__.s, self__.__hash);
-};
-cljs.core.LazySeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.LazySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_LazySeq = function __GT_LazySeq(meta, fn, s, __hash) {
-  return new cljs.core.LazySeq(meta, fn, s, __hash);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ChunkBuffer");
-};
-cljs.core.ChunkBuffer.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = 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.__GT_ChunkBuffer = function __GT_ChunkBuffer(buf, end) {
-  return new cljs.core.ChunkBuffer(buf, end);
-};
-cljs.core.chunk_buffer = function chunk_buffer(capacity) {
-  return new cljs.core.ChunkBuffer(new Array(capacity), 0);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ArrayChunk");
-};
-cljs.core.ArrayChunk.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  if (i >= 0 && i < self__.end - self__.off) {
-    return self__.arr[self__.off + i];
-  } else {
-    return not_found;
-  }
-};
-cljs.core.ArrayChunk.prototype.cljs$core$ICounted$_count$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.end - self__.off;
-};
-cljs.core.__GT_ArrayChunk = function __GT_ArrayChunk(arr, off, end) {
-  return new cljs.core.ArrayChunk(arr, off, end);
-};
-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;
-}();
-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$ = 31850732;
-  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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ChunkedCons");
-};
-cljs.core.ChunkedCons.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.ChunkedCons.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 {
-    var more__$1 = cljs.core._seq.call(null, self__.more);
-    if (more__$1 == null) {
-      return null;
-    } else {
-      return more__$1;
-    }
-  }
-};
-cljs.core.ChunkedCons.prototype.cljs$core$ICollection$_conj$arity$2 = function(this$, o) {
-  var self__ = this;
-  var this$__$1 = this;
-  return cljs.core.cons.call(null, o, this$__$1);
-};
-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;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.ChunkedCons.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.ChunkedCons.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, m) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.ChunkedCons.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.chunk;
-};
-cljs.core.ChunkedCons.prototype.cljs$core$IChunkedSeq$_chunked_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.more == null) {
-    return cljs.core.List.EMPTY;
-  } else {
-    return self__.more;
-  }
-};
-cljs.core.__GT_ChunkedCons = function __GT_ChunkedCons(chunk, more, meta, __hash) {
-  return new cljs.core.ChunkedCons(chunk, more, meta, __hash);
-};
-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__7340 = s;
-    if (G__7340) {
-      var bit__4027__auto__ = G__7340.cljs$lang$protocol_mask$partition1$ & 1024;
-      if (bit__4027__auto__ || G__7340.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__7341 = cljs.core.next.call(null, s__$1);
-      s__$1 = G__7341;
-      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_7342 = 0;
-  var xs_7343 = cljs.core.seq.call(null, coll);
-  while (true) {
-    if (xs_7343) {
-      ret[i_7342] = cljs.core.to_array.call(null, cljs.core.first.call(null, xs_7343));
-      var G__7344 = i_7342 + 1;
-      var G__7345 = cljs.core.next.call(null, xs_7343);
-      i_7342 = G__7344;
-      xs_7343 = G__7345;
-      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 {
-      return cljs.core.into_array.call(null, size_or_seq);
-    }
-  };
-  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 (s__$1 && i < size) {
-          a[i] = cljs.core.first.call(null, s__$1);
-          var G__7346 = i + 1;
-          var G__7347 = cljs.core.next.call(null, s__$1);
-          i = G__7346;
-          s__$1 = G__7347;
-          continue;
-        } else {
-          return a;
-        }
-        break;
-      }
-    } else {
-      var n__4232__auto___7348 = size;
-      var i_7349 = 0;
-      while (true) {
-        if (i_7349 < n__4232__auto___7348) {
-          a[i_7349] = init_val_or_seq;
-          var G__7350 = i_7349 + 1;
-          i_7349 = G__7350;
-          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 {
-      return cljs.core.into_array.call(null, size_or_seq);
-    }
-  };
-  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 (s__$1 && i < size) {
-          a[i] = cljs.core.first.call(null, s__$1);
-          var G__7351 = i + 1;
-          var G__7352 = cljs.core.next.call(null, s__$1);
-          i = G__7351;
-          s__$1 = G__7352;
-          continue;
-        } else {
-          return a;
-        }
-        break;
-      }
-    } else {
-      var n__4232__auto___7353 = size;
-      var i_7354 = 0;
-      while (true) {
-        if (i_7354 < n__4232__auto___7353) {
-          a[i_7354] = init_val_or_seq;
-          var G__7355 = i_7354 + 1;
-          i_7354 = G__7355;
-          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 {
-      return cljs.core.into_array.call(null, size_or_seq);
-    }
-  };
-  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 (s__$1 && i < size) {
-          a[i] = cljs.core.first.call(null, s__$1);
-          var G__7356 = i + 1;
-          var G__7357 = cljs.core.next.call(null, s__$1);
-          i = G__7356;
-          s__$1 = G__7357;
-          continue;
-        } else {
-          return a;
-        }
-        break;
-      }
-    } else {
-      var n__4232__auto___7358 = size;
-      var i_7359 = 0;
-      while (true) {
-        if (i_7359 < n__4232__auto___7358) {
-          a[i_7359] = init_val_or_seq;
-          var G__7360 = i_7359 + 1;
-          i_7359 = G__7360;
-          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 {
-      return cljs.core.into_array.call(null, size_or_seq);
-    }
-  };
-  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 (s__$1 && i < size) {
-          a[i] = cljs.core.first.call(null, s__$1);
-          var G__7361 = i + 1;
-          var G__7362 = cljs.core.next.call(null, s__$1);
-          i = G__7361;
-          s__$1 = G__7362;
-          continue;
-        } else {
-          return a;
-        }
-        break;
-      }
-    } else {
-      var n__4232__auto___7363 = size;
-      var i_7364 = 0;
-      while (true) {
-        if (i_7364 < n__4232__auto___7363) {
-          a[i_7364] = init_val_or_seq;
-          var G__7365 = i_7364 + 1;
-          i_7364 = G__7365;
-          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 (i > 0 && cljs.core.seq.call(null, s__$1)) {
-        var G__7366 = cljs.core.next.call(null, s__$1);
-        var G__7367 = i - 1;
-        var G__7368 = sum + 1;
-        s__$1 = G__7366;
-        i = G__7367;
-        sum = G__7368;
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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, function() {
-      return null;
-    }, null, null);
-  };
-  var concat__1 = function(x) {
-    return new cljs.core.LazySeq(null, function() {
-      return x;
-    }, null, null);
-  };
-  var concat__2 = function(x, y) {
-    return new cljs.core.LazySeq(null, 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, null);
-  };
-  var concat__3 = function() {
-    var G__7369__delegate = function(x, y, zs) {
-      var cat = function cat(xys, zs__$1) {
-        return new cljs.core.LazySeq(null, 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, null);
-      };
-      return cat.call(null, concat.call(null, x, y), zs);
-    };
-    var G__7369 = 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__7369__delegate.call(this, x, y, zs);
-    };
-    G__7369.cljs$lang$maxFixedArity = 2;
-    G__7369.cljs$lang$applyTo = function(arglist__7370) {
-      var x = cljs.core.first(arglist__7370);
-      arglist__7370 = cljs.core.next(arglist__7370);
-      var y = cljs.core.first(arglist__7370);
-      var zs = cljs.core.rest(arglist__7370);
-      return G__7369__delegate(x, y, zs);
-    };
-    G__7369.cljs$core$IFn$_invoke$arity$variadic = G__7369__delegate;
-    return G__7369;
-  }();
-  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__7371__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__7371 = 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__7371__delegate.call(this, a, b, c, d, more);
-    };
-    G__7371.cljs$lang$maxFixedArity = 4;
-    G__7371.cljs$lang$applyTo = function(arglist__7372) {
-      var a = cljs.core.first(arglist__7372);
-      arglist__7372 = cljs.core.next(arglist__7372);
-      var b = cljs.core.first(arglist__7372);
-      arglist__7372 = cljs.core.next(arglist__7372);
-      var c = cljs.core.first(arglist__7372);
-      arglist__7372 = cljs.core.next(arglist__7372);
-      var d = cljs.core.first(arglist__7372);
-      var more = cljs.core.rest(arglist__7372);
-      return G__7371__delegate(a, b, c, d, more);
-    };
-    G__7371.cljs$core$IFn$_invoke$arity$variadic = G__7371__delegate;
-    return G__7371;
-  }();
-  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__7373__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__7373 = 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__7373__delegate.call(this, f, a, b, c, d, args);
-    };
-    G__7373.cljs$lang$maxFixedArity = 5;
-    G__7373.cljs$lang$applyTo = function(arglist__7374) {
-      var f = cljs.core.first(arglist__7374);
-      arglist__7374 = cljs.core.next(arglist__7374);
-      var a = cljs.core.first(arglist__7374);
-      arglist__7374 = cljs.core.next(arglist__7374);
-      var b = cljs.core.first(arglist__7374);
-      arglist__7374 = cljs.core.next(arglist__7374);
-      var c = cljs.core.first(arglist__7374);
-      arglist__7374 = cljs.core.next(arglist__7374);
-      var d = cljs.core.first(arglist__7374);
-      var args = cljs.core.rest(arglist__7374);
-      return G__7373__delegate(f, a, b, c, d, args);
-    };
-    G__7373.cljs$core$IFn$_invoke$arity$variadic = G__7373__delegate;
-    return G__7373;
-  }();
-  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 = null;
-  var vary_meta__2 = function(obj, f) {
-    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj)));
-  };
-  var vary_meta__3 = function(obj, f, a) {
-    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a));
-  };
-  var vary_meta__4 = function(obj, f, a, b) {
-    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a, b));
-  };
-  var vary_meta__5 = function(obj, f, a, b, c) {
-    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a, b, c));
-  };
-  var vary_meta__6 = function(obj, f, a, b, c, d) {
-    return cljs.core.with_meta.call(null, obj, f.call(null, cljs.core.meta.call(null, obj), a, b, c, d));
-  };
-  var vary_meta__7 = function() {
-    var G__7375__delegate = function(obj, f, a, b, c, d, args) {
-      return cljs.core.with_meta.call(null, obj, cljs.core.apply.call(null, f, cljs.core.meta.call(null, obj), a, b, c, d, args));
-    };
-    var G__7375 = function(obj, f, a, b, c, d, var_args) {
-      var args = null;
-      if (arguments.length > 6) {
-        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 6), 0);
-      }
-      return G__7375__delegate.call(this, obj, f, a, b, c, d, args);
-    };
-    G__7375.cljs$lang$maxFixedArity = 6;
-    G__7375.cljs$lang$applyTo = function(arglist__7376) {
-      var obj = cljs.core.first(arglist__7376);
-      arglist__7376 = cljs.core.next(arglist__7376);
-      var f = cljs.core.first(arglist__7376);
-      arglist__7376 = cljs.core.next(arglist__7376);
-      var a = cljs.core.first(arglist__7376);
-      arglist__7376 = cljs.core.next(arglist__7376);
-      var b = cljs.core.first(arglist__7376);
-      arglist__7376 = cljs.core.next(arglist__7376);
-      var c = cljs.core.first(arglist__7376);
-      arglist__7376 = cljs.core.next(arglist__7376);
-      var d = cljs.core.first(arglist__7376);
-      var args = cljs.core.rest(arglist__7376);
-      return G__7375__delegate(obj, f, a, b, c, d, args);
-    };
-    G__7375.cljs$core$IFn$_invoke$arity$variadic = G__7375__delegate;
-    return G__7375;
-  }();
-  vary_meta = function(obj, f, a, b, c, d, var_args) {
-    var args = var_args;
-    switch(arguments.length) {
-      case 2:
-        return vary_meta__2.call(this, obj, f);
-      case 3:
-        return vary_meta__3.call(this, obj, f, a);
-      case 4:
-        return vary_meta__4.call(this, obj, f, a, b);
-      case 5:
-        return vary_meta__5.call(this, obj, f, a, b, c);
-      case 6:
-        return vary_meta__6.call(this, obj, f, a, b, c, d);
-      default:
-        return vary_meta__7.cljs$core$IFn$_invoke$arity$variadic(obj, f, a, b, c, d, cljs.core.array_seq(arguments, 6));
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  vary_meta.cljs$lang$maxFixedArity = 6;
-  vary_meta.cljs$lang$applyTo = vary_meta__7.cljs$lang$applyTo;
-  vary_meta.cljs$core$IFn$_invoke$arity$2 = vary_meta__2;
-  vary_meta.cljs$core$IFn$_invoke$arity$3 = vary_meta__3;
-  vary_meta.cljs$core$IFn$_invoke$arity$4 = vary_meta__4;
-  vary_meta.cljs$core$IFn$_invoke$arity$5 = vary_meta__5;
-  vary_meta.cljs$core$IFn$_invoke$arity$6 = vary_meta__6;
-  vary_meta.cljs$core$IFn$_invoke$arity$variadic = vary_meta__7.cljs$core$IFn$_invoke$arity$variadic;
-  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__7377__delegate = function(x, y, more) {
-      return cljs.core.not.call(null, cljs.core.apply.call(null, cljs.core._EQ_, x, y, more));
-    };
-    var G__7377 = 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__7377__delegate.call(this, x, y, more);
-    };
-    G__7377.cljs$lang$maxFixedArity = 2;
-    G__7377.cljs$lang$applyTo = function(arglist__7378) {
-      var x = cljs.core.first(arglist__7378);
-      arglist__7378 = cljs.core.next(arglist__7378);
-      var y = cljs.core.first(arglist__7378);
-      var more = cljs.core.rest(arglist__7378);
-      return G__7377__delegate(x, y, more);
-    };
-    G__7377.cljs$core$IFn$_invoke$arity$variadic = G__7377__delegate;
-    return G__7377;
-  }();
-  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__7379 = pred;
-        var G__7380 = cljs.core.next.call(null, coll);
-        pred = G__7379;
-        coll = G__7380;
-        continue;
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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__3408__auto__ = pred.call(null, cljs.core.first.call(null, coll));
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        var G__7381 = pred;
-        var G__7382 = cljs.core.next.call(null, coll);
-        pred = G__7381;
-        coll = G__7382;
-        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__7383 = null;
-    var G__7383__0 = function() {
-      return cljs.core.not.call(null, f.call(null));
-    };
-    var G__7383__1 = function(x) {
-      return cljs.core.not.call(null, f.call(null, x));
-    };
-    var G__7383__2 = function(x, y) {
-      return cljs.core.not.call(null, f.call(null, x, y));
-    };
-    var G__7383__3 = function() {
-      var G__7384__delegate = function(x, y, zs) {
-        return cljs.core.not.call(null, cljs.core.apply.call(null, f, x, y, zs));
-      };
-      var G__7384 = 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__7384__delegate.call(this, x, y, zs);
-      };
-      G__7384.cljs$lang$maxFixedArity = 2;
-      G__7384.cljs$lang$applyTo = function(arglist__7385) {
-        var x = cljs.core.first(arglist__7385);
-        arglist__7385 = cljs.core.next(arglist__7385);
-        var y = cljs.core.first(arglist__7385);
-        var zs = cljs.core.rest(arglist__7385);
-        return G__7384__delegate(x, y, zs);
-      };
-      G__7384.cljs$core$IFn$_invoke$arity$variadic = G__7384__delegate;
-      return G__7384;
-    }();
-    G__7383 = function(x, y, var_args) {
-      var zs = var_args;
-      switch(arguments.length) {
-        case 0:
-          return G__7383__0.call(this);
-        case 1:
-          return G__7383__1.call(this, x);
-        case 2:
-          return G__7383__2.call(this, x, y);
-        default:
-          return G__7383__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2));
-      }
-      throw new Error("Invalid arity: " + arguments.length);
-    };
-    G__7383.cljs$lang$maxFixedArity = 2;
-    G__7383.cljs$lang$applyTo = G__7383__3.cljs$lang$applyTo;
-    return G__7383;
-  }();
-};
-cljs.core.constantly = function constantly(x) {
-  return function() {
-    var G__7386__delegate = function(args) {
-      return x;
-    };
-    var G__7386 = function(var_args) {
-      var args = null;
-      if (arguments.length > 0) {
-        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-      }
-      return G__7386__delegate.call(this, args);
-    };
-    G__7386.cljs$lang$maxFixedArity = 0;
-    G__7386.cljs$lang$applyTo = function(arglist__7387) {
-      var args = cljs.core.seq(arglist__7387);
-      return G__7386__delegate(args);
-    };
-    G__7386.cljs$core$IFn$_invoke$arity$variadic = G__7386__delegate;
-    return G__7386;
-  }();
-};
-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__7388 = null;
-      var G__7388__0 = function() {
-        return f.call(null, g.call(null));
-      };
-      var G__7388__1 = function(x) {
-        return f.call(null, g.call(null, x));
-      };
-      var G__7388__2 = function(x, y) {
-        return f.call(null, g.call(null, x, y));
-      };
-      var G__7388__3 = function(x, y, z) {
-        return f.call(null, g.call(null, x, y, z));
-      };
-      var G__7388__4 = function() {
-        var G__7389__delegate = function(x, y, z, args) {
-          return f.call(null, cljs.core.apply.call(null, g, x, y, z, args));
-        };
-        var G__7389 = 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__7389__delegate.call(this, x, y, z, args);
-        };
-        G__7389.cljs$lang$maxFixedArity = 3;
-        G__7389.cljs$lang$applyTo = function(arglist__7390) {
-          var x = cljs.core.first(arglist__7390);
-          arglist__7390 = cljs.core.next(arglist__7390);
-          var y = cljs.core.first(arglist__7390);
-          arglist__7390 = cljs.core.next(arglist__7390);
-          var z = cljs.core.first(arglist__7390);
-          var args = cljs.core.rest(arglist__7390);
-          return G__7389__delegate(x, y, z, args);
-        };
-        G__7389.cljs$core$IFn$_invoke$arity$variadic = G__7389__delegate;
-        return G__7389;
-      }();
-      G__7388 = function(x, y, z, var_args) {
-        var args = var_args;
-        switch(arguments.length) {
-          case 0:
-            return G__7388__0.call(this);
-          case 1:
-            return G__7388__1.call(this, x);
-          case 2:
-            return G__7388__2.call(this, x, y);
-          case 3:
-            return G__7388__3.call(this, x, y, z);
-          default:
-            return G__7388__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7388.cljs$lang$maxFixedArity = 3;
-      G__7388.cljs$lang$applyTo = G__7388__4.cljs$lang$applyTo;
-      return G__7388;
-    }();
-  };
-  var comp__3 = function(f, g, h) {
-    return function() {
-      var G__7391 = null;
-      var G__7391__0 = function() {
-        return f.call(null, g.call(null, h.call(null)));
-      };
-      var G__7391__1 = function(x) {
-        return f.call(null, g.call(null, h.call(null, x)));
-      };
-      var G__7391__2 = function(x, y) {
-        return f.call(null, g.call(null, h.call(null, x, y)));
-      };
-      var G__7391__3 = function(x, y, z) {
-        return f.call(null, g.call(null, h.call(null, x, y, z)));
-      };
-      var G__7391__4 = function() {
-        var G__7392__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__7392 = 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__7392__delegate.call(this, x, y, z, args);
-        };
-        G__7392.cljs$lang$maxFixedArity = 3;
-        G__7392.cljs$lang$applyTo = function(arglist__7393) {
-          var x = cljs.core.first(arglist__7393);
-          arglist__7393 = cljs.core.next(arglist__7393);
-          var y = cljs.core.first(arglist__7393);
-          arglist__7393 = cljs.core.next(arglist__7393);
-          var z = cljs.core.first(arglist__7393);
-          var args = cljs.core.rest(arglist__7393);
-          return G__7392__delegate(x, y, z, args);
-        };
-        G__7392.cljs$core$IFn$_invoke$arity$variadic = G__7392__delegate;
-        return G__7392;
-      }();
-      G__7391 = function(x, y, z, var_args) {
-        var args = var_args;
-        switch(arguments.length) {
-          case 0:
-            return G__7391__0.call(this);
-          case 1:
-            return G__7391__1.call(this, x);
-          case 2:
-            return G__7391__2.call(this, x, y);
-          case 3:
-            return G__7391__3.call(this, x, y, z);
-          default:
-            return G__7391__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7391.cljs$lang$maxFixedArity = 3;
-      G__7391.cljs$lang$applyTo = G__7391__4.cljs$lang$applyTo;
-      return G__7391;
-    }();
-  };
-  var comp__4 = function() {
-    var G__7394__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__7395__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__7396 = cljs.core.first.call(null, fs__$2).call(null, ret);
-              var G__7397 = cljs.core.next.call(null, fs__$2);
-              ret = G__7396;
-              fs__$2 = G__7397;
-              continue;
-            } else {
-              return ret;
-            }
-            break;
-          }
-        };
-        var G__7395 = function(var_args) {
-          var args = null;
-          if (arguments.length > 0) {
-            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-          }
-          return G__7395__delegate.call(this, args);
-        };
-        G__7395.cljs$lang$maxFixedArity = 0;
-        G__7395.cljs$lang$applyTo = function(arglist__7398) {
-          var args = cljs.core.seq(arglist__7398);
-          return G__7395__delegate(args);
-        };
-        G__7395.cljs$core$IFn$_invoke$arity$variadic = G__7395__delegate;
-        return G__7395;
-      }();
-    };
-    var G__7394 = 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__7394__delegate.call(this, f1, f2, f3, fs);
-    };
-    G__7394.cljs$lang$maxFixedArity = 3;
-    G__7394.cljs$lang$applyTo = function(arglist__7399) {
-      var f1 = cljs.core.first(arglist__7399);
-      arglist__7399 = cljs.core.next(arglist__7399);
-      var f2 = cljs.core.first(arglist__7399);
-      arglist__7399 = cljs.core.next(arglist__7399);
-      var f3 = cljs.core.first(arglist__7399);
-      var fs = cljs.core.rest(arglist__7399);
-      return G__7394__delegate(f1, f2, f3, fs);
-    };
-    G__7394.cljs$core$IFn$_invoke$arity$variadic = G__7394__delegate;
-    return G__7394;
-  }();
-  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__1 = function(f) {
-    return f;
-  };
-  var partial__2 = function(f, arg1) {
-    return function() {
-      var G__7400__delegate = function(args) {
-        return cljs.core.apply.call(null, f, arg1, args);
-      };
-      var G__7400 = function(var_args) {
-        var args = null;
-        if (arguments.length > 0) {
-          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-        }
-        return G__7400__delegate.call(this, args);
-      };
-      G__7400.cljs$lang$maxFixedArity = 0;
-      G__7400.cljs$lang$applyTo = function(arglist__7401) {
-        var args = cljs.core.seq(arglist__7401);
-        return G__7400__delegate(args);
-      };
-      G__7400.cljs$core$IFn$_invoke$arity$variadic = G__7400__delegate;
-      return G__7400;
-    }();
-  };
-  var partial__3 = function(f, arg1, arg2) {
-    return function() {
-      var G__7402__delegate = function(args) {
-        return cljs.core.apply.call(null, f, arg1, arg2, args);
-      };
-      var G__7402 = function(var_args) {
-        var args = null;
-        if (arguments.length > 0) {
-          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-        }
-        return G__7402__delegate.call(this, args);
-      };
-      G__7402.cljs$lang$maxFixedArity = 0;
-      G__7402.cljs$lang$applyTo = function(arglist__7403) {
-        var args = cljs.core.seq(arglist__7403);
-        return G__7402__delegate(args);
-      };
-      G__7402.cljs$core$IFn$_invoke$arity$variadic = G__7402__delegate;
-      return G__7402;
-    }();
-  };
-  var partial__4 = function(f, arg1, arg2, arg3) {
-    return function() {
-      var G__7404__delegate = function(args) {
-        return cljs.core.apply.call(null, f, arg1, arg2, arg3, args);
-      };
-      var G__7404 = function(var_args) {
-        var args = null;
-        if (arguments.length > 0) {
-          args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-        }
-        return G__7404__delegate.call(this, args);
-      };
-      G__7404.cljs$lang$maxFixedArity = 0;
-      G__7404.cljs$lang$applyTo = function(arglist__7405) {
-        var args = cljs.core.seq(arglist__7405);
-        return G__7404__delegate(args);
-      };
-      G__7404.cljs$core$IFn$_invoke$arity$variadic = G__7404__delegate;
-      return G__7404;
-    }();
-  };
-  var partial__5 = function() {
-    var G__7406__delegate = function(f, arg1, arg2, arg3, more) {
-      return function() {
-        var G__7407__delegate = function(args) {
-          return cljs.core.apply.call(null, f, arg1, arg2, arg3, cljs.core.concat.call(null, more, args));
-        };
-        var G__7407 = function(var_args) {
-          var args = null;
-          if (arguments.length > 0) {
-            args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-          }
-          return G__7407__delegate.call(this, args);
-        };
-        G__7407.cljs$lang$maxFixedArity = 0;
-        G__7407.cljs$lang$applyTo = function(arglist__7408) {
-          var args = cljs.core.seq(arglist__7408);
-          return G__7407__delegate(args);
-        };
-        G__7407.cljs$core$IFn$_invoke$arity$variadic = G__7407__delegate;
-        return G__7407;
-      }();
-    };
-    var G__7406 = 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__7406__delegate.call(this, f, arg1, arg2, arg3, more);
-    };
-    G__7406.cljs$lang$maxFixedArity = 4;
-    G__7406.cljs$lang$applyTo = function(arglist__7409) {
-      var f = cljs.core.first(arglist__7409);
-      arglist__7409 = cljs.core.next(arglist__7409);
-      var arg1 = cljs.core.first(arglist__7409);
-      arglist__7409 = cljs.core.next(arglist__7409);
-      var arg2 = cljs.core.first(arglist__7409);
-      arglist__7409 = cljs.core.next(arglist__7409);
-      var arg3 = cljs.core.first(arglist__7409);
-      var more = cljs.core.rest(arglist__7409);
-      return G__7406__delegate(f, arg1, arg2, arg3, more);
-    };
-    G__7406.cljs$core$IFn$_invoke$arity$variadic = G__7406__delegate;
-    return G__7406;
-  }();
-  partial = function(f, arg1, arg2, arg3, var_args) {
-    var more = var_args;
-    switch(arguments.length) {
-      case 1:
-        return partial__1.call(this, f);
-      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$1 = partial__1;
-  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__7410 = null;
-      var G__7410__1 = function(a) {
-        return f.call(null, a == null ? x : a);
-      };
-      var G__7410__2 = function(a, b) {
-        return f.call(null, a == null ? x : a, b);
-      };
-      var G__7410__3 = function(a, b, c) {
-        return f.call(null, a == null ? x : a, b, c);
-      };
-      var G__7410__4 = function() {
-        var G__7411__delegate = function(a, b, c, ds) {
-          return cljs.core.apply.call(null, f, a == null ? x : a, b, c, ds);
-        };
-        var G__7411 = 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__7411__delegate.call(this, a, b, c, ds);
-        };
-        G__7411.cljs$lang$maxFixedArity = 3;
-        G__7411.cljs$lang$applyTo = function(arglist__7412) {
-          var a = cljs.core.first(arglist__7412);
-          arglist__7412 = cljs.core.next(arglist__7412);
-          var b = cljs.core.first(arglist__7412);
-          arglist__7412 = cljs.core.next(arglist__7412);
-          var c = cljs.core.first(arglist__7412);
-          var ds = cljs.core.rest(arglist__7412);
-          return G__7411__delegate(a, b, c, ds);
-        };
-        G__7411.cljs$core$IFn$_invoke$arity$variadic = G__7411__delegate;
-        return G__7411;
-      }();
-      G__7410 = function(a, b, c, var_args) {
-        var ds = var_args;
-        switch(arguments.length) {
-          case 1:
-            return G__7410__1.call(this, a);
-          case 2:
-            return G__7410__2.call(this, a, b);
-          case 3:
-            return G__7410__3.call(this, a, b, c);
-          default:
-            return G__7410__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7410.cljs$lang$maxFixedArity = 3;
-      G__7410.cljs$lang$applyTo = G__7410__4.cljs$lang$applyTo;
-      return G__7410;
-    }();
-  };
-  var fnil__3 = function(f, x, y) {
-    return function() {
-      var G__7413 = null;
-      var G__7413__2 = function(a, b) {
-        return f.call(null, a == null ? x : a, b == null ? y : b);
-      };
-      var G__7413__3 = function(a, b, c) {
-        return f.call(null, a == null ? x : a, b == null ? y : b, c);
-      };
-      var G__7413__4 = function() {
-        var G__7414__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__7414 = 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__7414__delegate.call(this, a, b, c, ds);
-        };
-        G__7414.cljs$lang$maxFixedArity = 3;
-        G__7414.cljs$lang$applyTo = function(arglist__7415) {
-          var a = cljs.core.first(arglist__7415);
-          arglist__7415 = cljs.core.next(arglist__7415);
-          var b = cljs.core.first(arglist__7415);
-          arglist__7415 = cljs.core.next(arglist__7415);
-          var c = cljs.core.first(arglist__7415);
-          var ds = cljs.core.rest(arglist__7415);
-          return G__7414__delegate(a, b, c, ds);
-        };
-        G__7414.cljs$core$IFn$_invoke$arity$variadic = G__7414__delegate;
-        return G__7414;
-      }();
-      G__7413 = function(a, b, c, var_args) {
-        var ds = var_args;
-        switch(arguments.length) {
-          case 2:
-            return G__7413__2.call(this, a, b);
-          case 3:
-            return G__7413__3.call(this, a, b, c);
-          default:
-            return G__7413__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7413.cljs$lang$maxFixedArity = 3;
-      G__7413.cljs$lang$applyTo = G__7413__4.cljs$lang$applyTo;
-      return G__7413;
-    }();
-  };
-  var fnil__4 = function(f, x, y, z) {
-    return function() {
-      var G__7416 = null;
-      var G__7416__2 = function(a, b) {
-        return f.call(null, a == null ? x : a, b == null ? y : b);
-      };
-      var G__7416__3 = function(a, b, c) {
-        return f.call(null, a == null ? x : a, b == null ? y : b, c == null ? z : c);
-      };
-      var G__7416__4 = function() {
-        var G__7417__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__7417 = 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__7417__delegate.call(this, a, b, c, ds);
-        };
-        G__7417.cljs$lang$maxFixedArity = 3;
-        G__7417.cljs$lang$applyTo = function(arglist__7418) {
-          var a = cljs.core.first(arglist__7418);
-          arglist__7418 = cljs.core.next(arglist__7418);
-          var b = cljs.core.first(arglist__7418);
-          arglist__7418 = cljs.core.next(arglist__7418);
-          var c = cljs.core.first(arglist__7418);
-          var ds = cljs.core.rest(arglist__7418);
-          return G__7417__delegate(a, b, c, ds);
-        };
-        G__7417.cljs$core$IFn$_invoke$arity$variadic = G__7417__delegate;
-        return G__7417;
-      }();
-      G__7416 = function(a, b, c, var_args) {
-        var ds = var_args;
-        switch(arguments.length) {
-          case 2:
-            return G__7416__2.call(this, a, b);
-          case 3:
-            return G__7416__3.call(this, a, b, c);
-          default:
-            return G__7416__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7416.cljs$lang$maxFixedArity = 3;
-      G__7416.cljs$lang$applyTo = G__7416__4.cljs$lang$applyTo;
-      return G__7416;
-    }();
-  };
-  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, 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__4232__auto___7419 = size;
-          var i_7420 = 0;
-          while (true) {
-            if (i_7420 < n__4232__auto___7419) {
-              cljs.core.chunk_append.call(null, b, f.call(null, idx + i_7420, cljs.core._nth.call(null, c, i_7420)));
-              var G__7421 = i_7420 + 1;
-              i_7420 = G__7421;
-              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, null);
-  };
-  return mapi.call(null, 0, coll);
-};
-cljs.core.keep = function keep(f, coll) {
-  return new cljs.core.LazySeq(null, 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__4232__auto___7422 = size;
-        var i_7423 = 0;
-        while (true) {
-          if (i_7423 < n__4232__auto___7422) {
-            var x_7424 = f.call(null, cljs.core._nth.call(null, c, i_7423));
-            if (x_7424 == null) {
-            } else {
-              cljs.core.chunk_append.call(null, b, x_7424);
-            }
-            var G__7425 = i_7423 + 1;
-            i_7423 = G__7425;
-            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, null);
-};
-cljs.core.keep_indexed = function keep_indexed(f, coll) {
-  var keepi = function keepi(idx, coll__$1) {
-    return new cljs.core.LazySeq(null, 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__4232__auto___7426 = size;
-          var i_7427 = 0;
-          while (true) {
-            if (i_7427 < n__4232__auto___7426) {
-              var x_7428 = f.call(null, idx + i_7427, cljs.core._nth.call(null, c, i_7427));
-              if (x_7428 == null) {
-              } else {
-                cljs.core.chunk_append.call(null, b, x_7428);
-              }
-              var G__7429 = i_7427 + 1;
-              i_7427 = G__7429;
-              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, 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__3396__auto__ = p.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            return p.call(null, y);
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep1__3 = function(x, y, z) {
-        return cljs.core.boolean$.call(null, function() {
-          var and__3396__auto__ = p.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = p.call(null, y);
-            if (cljs.core.truth_(and__3396__auto____$1)) {
-              return p.call(null, z);
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep1__4 = function() {
-        var G__7436__delegate = function(x, y, z, args) {
-          return cljs.core.boolean$.call(null, ep1.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, p, args));
-        };
-        var G__7436 = 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__7436__delegate.call(this, x, y, z, args);
-        };
-        G__7436.cljs$lang$maxFixedArity = 3;
-        G__7436.cljs$lang$applyTo = function(arglist__7437) {
-          var x = cljs.core.first(arglist__7437);
-          arglist__7437 = cljs.core.next(arglist__7437);
-          var y = cljs.core.first(arglist__7437);
-          arglist__7437 = cljs.core.next(arglist__7437);
-          var z = cljs.core.first(arglist__7437);
-          var args = cljs.core.rest(arglist__7437);
-          return G__7436__delegate(x, y, z, args);
-        };
-        G__7436.cljs$core$IFn$_invoke$arity$variadic = G__7436__delegate;
-        return G__7436;
-      }();
-      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__3396__auto__ = p1.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            return p2.call(null, x);
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep2__2 = function(x, y) {
-        return cljs.core.boolean$.call(null, function() {
-          var and__3396__auto__ = p1.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = p1.call(null, y);
-            if (cljs.core.truth_(and__3396__auto____$1)) {
-              var and__3396__auto____$2 = p2.call(null, x);
-              if (cljs.core.truth_(and__3396__auto____$2)) {
-                return p2.call(null, y);
-              } else {
-                return and__3396__auto____$2;
-              }
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep2__3 = function(x, y, z) {
-        return cljs.core.boolean$.call(null, function() {
-          var and__3396__auto__ = p1.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = p1.call(null, y);
-            if (cljs.core.truth_(and__3396__auto____$1)) {
-              var and__3396__auto____$2 = p1.call(null, z);
-              if (cljs.core.truth_(and__3396__auto____$2)) {
-                var and__3396__auto____$3 = p2.call(null, x);
-                if (cljs.core.truth_(and__3396__auto____$3)) {
-                  var and__3396__auto____$4 = p2.call(null, y);
-                  if (cljs.core.truth_(and__3396__auto____$4)) {
-                    return p2.call(null, z);
-                  } else {
-                    return and__3396__auto____$4;
-                  }
-                } else {
-                  return and__3396__auto____$3;
-                }
-              } else {
-                return and__3396__auto____$2;
-              }
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep2__4 = function() {
-        var G__7438__delegate = function(x, y, z, args) {
-          return cljs.core.boolean$.call(null, ep2.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, function(p1__7430_SHARP_) {
-            var and__3396__auto__ = p1.call(null, p1__7430_SHARP_);
-            if (cljs.core.truth_(and__3396__auto__)) {
-              return p2.call(null, p1__7430_SHARP_);
-            } else {
-              return and__3396__auto__;
-            }
-          }, args));
-        };
-        var G__7438 = 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__7438__delegate.call(this, x, y, z, args);
-        };
-        G__7438.cljs$lang$maxFixedArity = 3;
-        G__7438.cljs$lang$applyTo = function(arglist__7439) {
-          var x = cljs.core.first(arglist__7439);
-          arglist__7439 = cljs.core.next(arglist__7439);
-          var y = cljs.core.first(arglist__7439);
-          arglist__7439 = cljs.core.next(arglist__7439);
-          var z = cljs.core.first(arglist__7439);
-          var args = cljs.core.rest(arglist__7439);
-          return G__7438__delegate(x, y, z, args);
-        };
-        G__7438.cljs$core$IFn$_invoke$arity$variadic = G__7438__delegate;
-        return G__7438;
-      }();
-      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__3396__auto__ = p1.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = p2.call(null, x);
-            if (cljs.core.truth_(and__3396__auto____$1)) {
-              return p3.call(null, x);
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep3__2 = function(x, y) {
-        return cljs.core.boolean$.call(null, function() {
-          var and__3396__auto__ = p1.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = p2.call(null, x);
-            if (cljs.core.truth_(and__3396__auto____$1)) {
-              var and__3396__auto____$2 = p3.call(null, x);
-              if (cljs.core.truth_(and__3396__auto____$2)) {
-                var and__3396__auto____$3 = p1.call(null, y);
-                if (cljs.core.truth_(and__3396__auto____$3)) {
-                  var and__3396__auto____$4 = p2.call(null, y);
-                  if (cljs.core.truth_(and__3396__auto____$4)) {
-                    return p3.call(null, y);
-                  } else {
-                    return and__3396__auto____$4;
-                  }
-                } else {
-                  return and__3396__auto____$3;
-                }
-              } else {
-                return and__3396__auto____$2;
-              }
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep3__3 = function(x, y, z) {
-        return cljs.core.boolean$.call(null, function() {
-          var and__3396__auto__ = p1.call(null, x);
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = p2.call(null, x);
-            if (cljs.core.truth_(and__3396__auto____$1)) {
-              var and__3396__auto____$2 = p3.call(null, x);
-              if (cljs.core.truth_(and__3396__auto____$2)) {
-                var and__3396__auto____$3 = p1.call(null, y);
-                if (cljs.core.truth_(and__3396__auto____$3)) {
-                  var and__3396__auto____$4 = p2.call(null, y);
-                  if (cljs.core.truth_(and__3396__auto____$4)) {
-                    var and__3396__auto____$5 = p3.call(null, y);
-                    if (cljs.core.truth_(and__3396__auto____$5)) {
-                      var and__3396__auto____$6 = p1.call(null, z);
-                      if (cljs.core.truth_(and__3396__auto____$6)) {
-                        var and__3396__auto____$7 = p2.call(null, z);
-                        if (cljs.core.truth_(and__3396__auto____$7)) {
-                          return p3.call(null, z);
-                        } else {
-                          return and__3396__auto____$7;
-                        }
-                      } else {
-                        return and__3396__auto____$6;
-                      }
-                    } else {
-                      return and__3396__auto____$5;
-                    }
-                  } else {
-                    return and__3396__auto____$4;
-                  }
-                } else {
-                  return and__3396__auto____$3;
-                }
-              } else {
-                return and__3396__auto____$2;
-              }
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__auto__;
-          }
-        }());
-      };
-      var ep3__4 = function() {
-        var G__7440__delegate = function(x, y, z, args) {
-          return cljs.core.boolean$.call(null, ep3.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, function(p1__7431_SHARP_) {
-            var and__3396__auto__ = p1.call(null, p1__7431_SHARP_);
-            if (cljs.core.truth_(and__3396__auto__)) {
-              var and__3396__auto____$1 = p2.call(null, p1__7431_SHARP_);
-              if (cljs.core.truth_(and__3396__auto____$1)) {
-                return p3.call(null, p1__7431_SHARP_);
-              } else {
-                return and__3396__auto____$1;
-              }
-            } else {
-              return and__3396__auto__;
-            }
-          }, args));
-        };
-        var G__7440 = 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__7440__delegate.call(this, x, y, z, args);
-        };
-        G__7440.cljs$lang$maxFixedArity = 3;
-        G__7440.cljs$lang$applyTo = function(arglist__7441) {
-          var x = cljs.core.first(arglist__7441);
-          arglist__7441 = cljs.core.next(arglist__7441);
-          var y = cljs.core.first(arglist__7441);
-          arglist__7441 = cljs.core.next(arglist__7441);
-          var z = cljs.core.first(arglist__7441);
-          var args = cljs.core.rest(arglist__7441);
-          return G__7440__delegate(x, y, z, args);
-        };
-        G__7440.cljs$core$IFn$_invoke$arity$variadic = G__7440__delegate;
-        return G__7440;
-      }();
-      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__7442__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__7432_SHARP_) {
-            return p1__7432_SHARP_.call(null, x);
-          }, ps__$1);
-        };
-        var epn__2 = function(x, y) {
-          return cljs.core.every_QMARK_.call(null, function(p1__7433_SHARP_) {
-            var and__3396__auto__ = p1__7433_SHARP_.call(null, x);
-            if (cljs.core.truth_(and__3396__auto__)) {
-              return p1__7433_SHARP_.call(null, y);
-            } else {
-              return and__3396__auto__;
-            }
-          }, ps__$1);
-        };
-        var epn__3 = function(x, y, z) {
-          return cljs.core.every_QMARK_.call(null, function(p1__7434_SHARP_) {
-            var and__3396__auto__ = p1__7434_SHARP_.call(null, x);
-            if (cljs.core.truth_(and__3396__auto__)) {
-              var and__3396__auto____$1 = p1__7434_SHARP_.call(null, y);
-              if (cljs.core.truth_(and__3396__auto____$1)) {
-                return p1__7434_SHARP_.call(null, z);
-              } else {
-                return and__3396__auto____$1;
-              }
-            } else {
-              return and__3396__auto__;
-            }
-          }, ps__$1);
-        };
-        var epn__4 = function() {
-          var G__7443__delegate = function(x, y, z, args) {
-            return cljs.core.boolean$.call(null, epn.call(null, x, y, z) && cljs.core.every_QMARK_.call(null, function(p1__7435_SHARP_) {
-              return cljs.core.every_QMARK_.call(null, p1__7435_SHARP_, args);
-            }, ps__$1));
-          };
-          var G__7443 = 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__7443__delegate.call(this, x, y, z, args);
-          };
-          G__7443.cljs$lang$maxFixedArity = 3;
-          G__7443.cljs$lang$applyTo = function(arglist__7444) {
-            var x = cljs.core.first(arglist__7444);
-            arglist__7444 = cljs.core.next(arglist__7444);
-            var y = cljs.core.first(arglist__7444);
-            arglist__7444 = cljs.core.next(arglist__7444);
-            var z = cljs.core.first(arglist__7444);
-            var args = cljs.core.rest(arglist__7444);
-            return G__7443__delegate(x, y, z, args);
-          };
-          G__7443.cljs$core$IFn$_invoke$arity$variadic = G__7443__delegate;
-          return G__7443;
-        }();
-        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__7442 = 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__7442__delegate.call(this, p1, p2, p3, ps);
-    };
-    G__7442.cljs$lang$maxFixedArity = 3;
-    G__7442.cljs$lang$applyTo = function(arglist__7445) {
-      var p1 = cljs.core.first(arglist__7445);
-      arglist__7445 = cljs.core.next(arglist__7445);
-      var p2 = cljs.core.first(arglist__7445);
-      arglist__7445 = cljs.core.next(arglist__7445);
-      var p3 = cljs.core.first(arglist__7445);
-      var ps = cljs.core.rest(arglist__7445);
-      return G__7442__delegate(p1, p2, p3, ps);
-    };
-    G__7442.cljs$core$IFn$_invoke$arity$variadic = G__7442__delegate;
-    return G__7442;
-  }();
-  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__3408__auto__ = p.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          return p.call(null, y);
-        }
-      };
-      var sp1__3 = function(x, y, z) {
-        var or__3408__auto__ = p.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = p.call(null, y);
-          if (cljs.core.truth_(or__3408__auto____$1)) {
-            return or__3408__auto____$1;
-          } else {
-            return p.call(null, z);
-          }
-        }
-      };
-      var sp1__4 = function() {
-        var G__7452__delegate = function(x, y, z, args) {
-          var or__3408__auto__ = sp1.call(null, x, y, z);
-          if (cljs.core.truth_(or__3408__auto__)) {
-            return or__3408__auto__;
-          } else {
-            return cljs.core.some.call(null, p, args);
-          }
-        };
-        var G__7452 = 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__7452__delegate.call(this, x, y, z, args);
-        };
-        G__7452.cljs$lang$maxFixedArity = 3;
-        G__7452.cljs$lang$applyTo = function(arglist__7453) {
-          var x = cljs.core.first(arglist__7453);
-          arglist__7453 = cljs.core.next(arglist__7453);
-          var y = cljs.core.first(arglist__7453);
-          arglist__7453 = cljs.core.next(arglist__7453);
-          var z = cljs.core.first(arglist__7453);
-          var args = cljs.core.rest(arglist__7453);
-          return G__7452__delegate(x, y, z, args);
-        };
-        G__7452.cljs$core$IFn$_invoke$arity$variadic = G__7452__delegate;
-        return G__7452;
-      }();
-      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__3408__auto__ = p1.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          return p2.call(null, x);
-        }
-      };
-      var sp2__2 = function(x, y) {
-        var or__3408__auto__ = p1.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = p1.call(null, y);
-          if (cljs.core.truth_(or__3408__auto____$1)) {
-            return or__3408__auto____$1;
-          } else {
-            var or__3408__auto____$2 = p2.call(null, x);
-            if (cljs.core.truth_(or__3408__auto____$2)) {
-              return or__3408__auto____$2;
-            } else {
-              return p2.call(null, y);
-            }
-          }
-        }
-      };
-      var sp2__3 = function(x, y, z) {
-        var or__3408__auto__ = p1.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = p1.call(null, y);
-          if (cljs.core.truth_(or__3408__auto____$1)) {
-            return or__3408__auto____$1;
-          } else {
-            var or__3408__auto____$2 = p1.call(null, z);
-            if (cljs.core.truth_(or__3408__auto____$2)) {
-              return or__3408__auto____$2;
-            } else {
-              var or__3408__auto____$3 = p2.call(null, x);
-              if (cljs.core.truth_(or__3408__auto____$3)) {
-                return or__3408__auto____$3;
-              } else {
-                var or__3408__auto____$4 = p2.call(null, y);
-                if (cljs.core.truth_(or__3408__auto____$4)) {
-                  return or__3408__auto____$4;
-                } else {
-                  return p2.call(null, z);
-                }
-              }
-            }
-          }
-        }
-      };
-      var sp2__4 = function() {
-        var G__7454__delegate = function(x, y, z, args) {
-          var or__3408__auto__ = sp2.call(null, x, y, z);
-          if (cljs.core.truth_(or__3408__auto__)) {
-            return or__3408__auto__;
-          } else {
-            return cljs.core.some.call(null, function(p1__7446_SHARP_) {
-              var or__3408__auto____$1 = p1.call(null, p1__7446_SHARP_);
-              if (cljs.core.truth_(or__3408__auto____$1)) {
-                return or__3408__auto____$1;
-              } else {
-                return p2.call(null, p1__7446_SHARP_);
-              }
-            }, args);
-          }
-        };
-        var G__7454 = 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__7454__delegate.call(this, x, y, z, args);
-        };
-        G__7454.cljs$lang$maxFixedArity = 3;
-        G__7454.cljs$lang$applyTo = function(arglist__7455) {
-          var x = cljs.core.first(arglist__7455);
-          arglist__7455 = cljs.core.next(arglist__7455);
-          var y = cljs.core.first(arglist__7455);
-          arglist__7455 = cljs.core.next(arglist__7455);
-          var z = cljs.core.first(arglist__7455);
-          var args = cljs.core.rest(arglist__7455);
-          return G__7454__delegate(x, y, z, args);
-        };
-        G__7454.cljs$core$IFn$_invoke$arity$variadic = G__7454__delegate;
-        return G__7454;
-      }();
-      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__3408__auto__ = p1.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = p2.call(null, x);
-          if (cljs.core.truth_(or__3408__auto____$1)) {
-            return or__3408__auto____$1;
-          } else {
-            return p3.call(null, x);
-          }
-        }
-      };
-      var sp3__2 = function(x, y) {
-        var or__3408__auto__ = p1.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = p2.call(null, x);
-          if (cljs.core.truth_(or__3408__auto____$1)) {
-            return or__3408__auto____$1;
-          } else {
-            var or__3408__auto____$2 = p3.call(null, x);
-            if (cljs.core.truth_(or__3408__auto____$2)) {
-              return or__3408__auto____$2;
-            } else {
-              var or__3408__auto____$3 = p1.call(null, y);
-              if (cljs.core.truth_(or__3408__auto____$3)) {
-                return or__3408__auto____$3;
-              } else {
-                var or__3408__auto____$4 = p2.call(null, y);
-                if (cljs.core.truth_(or__3408__auto____$4)) {
-                  return or__3408__auto____$4;
-                } else {
-                  return p3.call(null, y);
-                }
-              }
-            }
-          }
-        }
-      };
-      var sp3__3 = function(x, y, z) {
-        var or__3408__auto__ = p1.call(null, x);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          var or__3408__auto____$1 = p2.call(null, x);
-          if (cljs.core.truth_(or__3408__auto____$1)) {
-            return or__3408__auto____$1;
-          } else {
-            var or__3408__auto____$2 = p3.call(null, x);
-            if (cljs.core.truth_(or__3408__auto____$2)) {
-              return or__3408__auto____$2;
-            } else {
-              var or__3408__auto____$3 = p1.call(null, y);
-              if (cljs.core.truth_(or__3408__auto____$3)) {
-                return or__3408__auto____$3;
-              } else {
-                var or__3408__auto____$4 = p2.call(null, y);
-                if (cljs.core.truth_(or__3408__auto____$4)) {
-                  return or__3408__auto____$4;
-                } else {
-                  var or__3408__auto____$5 = p3.call(null, y);
-                  if (cljs.core.truth_(or__3408__auto____$5)) {
-                    return or__3408__auto____$5;
-                  } else {
-                    var or__3408__auto____$6 = p1.call(null, z);
-                    if (cljs.core.truth_(or__3408__auto____$6)) {
-                      return or__3408__auto____$6;
-                    } else {
-                      var or__3408__auto____$7 = p2.call(null, z);
-                      if (cljs.core.truth_(or__3408__auto____$7)) {
-                        return or__3408__auto____$7;
-                      } else {
-                        return p3.call(null, z);
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      };
-      var sp3__4 = function() {
-        var G__7456__delegate = function(x, y, z, args) {
-          var or__3408__auto__ = sp3.call(null, x, y, z);
-          if (cljs.core.truth_(or__3408__auto__)) {
-            return or__3408__auto__;
-          } else {
-            return cljs.core.some.call(null, function(p1__7447_SHARP_) {
-              var or__3408__auto____$1 = p1.call(null, p1__7447_SHARP_);
-              if (cljs.core.truth_(or__3408__auto____$1)) {
-                return or__3408__auto____$1;
-              } else {
-                var or__3408__auto____$2 = p2.call(null, p1__7447_SHARP_);
-                if (cljs.core.truth_(or__3408__auto____$2)) {
-                  return or__3408__auto____$2;
-                } else {
-                  return p3.call(null, p1__7447_SHARP_);
-                }
-              }
-            }, args);
-          }
-        };
-        var G__7456 = 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__7456__delegate.call(this, x, y, z, args);
-        };
-        G__7456.cljs$lang$maxFixedArity = 3;
-        G__7456.cljs$lang$applyTo = function(arglist__7457) {
-          var x = cljs.core.first(arglist__7457);
-          arglist__7457 = cljs.core.next(arglist__7457);
-          var y = cljs.core.first(arglist__7457);
-          arglist__7457 = cljs.core.next(arglist__7457);
-          var z = cljs.core.first(arglist__7457);
-          var args = cljs.core.rest(arglist__7457);
-          return G__7456__delegate(x, y, z, args);
-        };
-        G__7456.cljs$core$IFn$_invoke$arity$variadic = G__7456__delegate;
-        return G__7456;
-      }();
-      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__7458__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__7448_SHARP_) {
-            return p1__7448_SHARP_.call(null, x);
-          }, ps__$1);
-        };
-        var spn__2 = function(x, y) {
-          return cljs.core.some.call(null, function(p1__7449_SHARP_) {
-            var or__3408__auto__ = p1__7449_SHARP_.call(null, x);
-            if (cljs.core.truth_(or__3408__auto__)) {
-              return or__3408__auto__;
-            } else {
-              return p1__7449_SHARP_.call(null, y);
-            }
-          }, ps__$1);
-        };
-        var spn__3 = function(x, y, z) {
-          return cljs.core.some.call(null, function(p1__7450_SHARP_) {
-            var or__3408__auto__ = p1__7450_SHARP_.call(null, x);
-            if (cljs.core.truth_(or__3408__auto__)) {
-              return or__3408__auto__;
-            } else {
-              var or__3408__auto____$1 = p1__7450_SHARP_.call(null, y);
-              if (cljs.core.truth_(or__3408__auto____$1)) {
-                return or__3408__auto____$1;
-              } else {
-                return p1__7450_SHARP_.call(null, z);
-              }
-            }
-          }, ps__$1);
-        };
-        var spn__4 = function() {
-          var G__7459__delegate = function(x, y, z, args) {
-            var or__3408__auto__ = spn.call(null, x, y, z);
-            if (cljs.core.truth_(or__3408__auto__)) {
-              return or__3408__auto__;
-            } else {
-              return cljs.core.some.call(null, function(p1__7451_SHARP_) {
-                return cljs.core.some.call(null, p1__7451_SHARP_, args);
-              }, ps__$1);
-            }
-          };
-          var G__7459 = 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__7459__delegate.call(this, x, y, z, args);
-          };
-          G__7459.cljs$lang$maxFixedArity = 3;
-          G__7459.cljs$lang$applyTo = function(arglist__7460) {
-            var x = cljs.core.first(arglist__7460);
-            arglist__7460 = cljs.core.next(arglist__7460);
-            var y = cljs.core.first(arglist__7460);
-            arglist__7460 = cljs.core.next(arglist__7460);
-            var z = cljs.core.first(arglist__7460);
-            var args = cljs.core.rest(arglist__7460);
-            return G__7459__delegate(x, y, z, args);
-          };
-          G__7459.cljs$core$IFn$_invoke$arity$variadic = G__7459__delegate;
-          return G__7459;
-        }();
-        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__7458 = 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__7458__delegate.call(this, p1, p2, p3, ps);
-    };
-    G__7458.cljs$lang$maxFixedArity = 3;
-    G__7458.cljs$lang$applyTo = function(arglist__7461) {
-      var p1 = cljs.core.first(arglist__7461);
-      arglist__7461 = cljs.core.next(arglist__7461);
-      var p2 = cljs.core.first(arglist__7461);
-      arglist__7461 = cljs.core.next(arglist__7461);
-      var p3 = cljs.core.first(arglist__7461);
-      var ps = cljs.core.rest(arglist__7461);
-      return G__7458__delegate(p1, p2, p3, ps);
-    };
-    G__7458.cljs$core$IFn$_invoke$arity$variadic = G__7458__delegate;
-    return G__7458;
-  }();
-  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, 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__4232__auto___7463 = size;
-          var i_7464 = 0;
-          while (true) {
-            if (i_7464 < n__4232__auto___7463) {
-              cljs.core.chunk_append.call(null, b, f.call(null, cljs.core._nth.call(null, c, i_7464)));
-              var G__7465 = i_7464 + 1;
-              i_7464 = G__7465;
-              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, null);
-  };
-  var map__3 = function(f, c1, c2) {
-    return new cljs.core.LazySeq(null, function() {
-      var s1 = cljs.core.seq.call(null, c1);
-      var s2 = cljs.core.seq.call(null, c2);
-      if (s1 && s2) {
-        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, null);
-  };
-  var map__4 = function(f, c1, c2, c3) {
-    return new cljs.core.LazySeq(null, 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 (s1 && (s2 && s3)) {
-        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, null);
-  };
-  var map__5 = function() {
-    var G__7466__delegate = function(f, c1, c2, c3, colls) {
-      var step = function step(cs) {
-        return new cljs.core.LazySeq(null, 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, null);
-      };
-      return map.call(null, function(p1__7462_SHARP_) {
-        return cljs.core.apply.call(null, f, p1__7462_SHARP_);
-      }, step.call(null, cljs.core.conj.call(null, colls, c3, c2, c1)));
-    };
-    var G__7466 = 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__7466__delegate.call(this, f, c1, c2, c3, colls);
-    };
-    G__7466.cljs$lang$maxFixedArity = 4;
-    G__7466.cljs$lang$applyTo = function(arglist__7467) {
-      var f = cljs.core.first(arglist__7467);
-      arglist__7467 = cljs.core.next(arglist__7467);
-      var c1 = cljs.core.first(arglist__7467);
-      arglist__7467 = cljs.core.next(arglist__7467);
-      var c2 = cljs.core.first(arglist__7467);
-      arglist__7467 = cljs.core.next(arglist__7467);
-      var c3 = cljs.core.first(arglist__7467);
-      var colls = cljs.core.rest(arglist__7467);
-      return G__7466__delegate(f, c1, c2, c3, colls);
-    };
-    G__7466.cljs$core$IFn$_invoke$arity$variadic = G__7466__delegate;
-    return G__7466;
-  }();
-  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, 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, 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 (n__$1 > 0 && s) {
-        var G__7468 = n__$1 - 1;
-        var G__7469 = cljs.core.rest.call(null, s);
-        n__$1 = G__7468;
-        coll__$1 = G__7469;
-        continue;
-      } else {
-        return s;
-      }
-      break;
-    }
-  };
-  return new cljs.core.LazySeq(null, function() {
-    return step.call(null, n, coll);
-  }, null, 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__7470 = cljs.core.next.call(null, s);
-      var G__7471 = cljs.core.next.call(null, lead);
-      s = G__7470;
-      lead = G__7471;
-      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__3396__auto__ = s;
-        if (and__3396__auto__) {
-          return pred__$1.call(null, cljs.core.first.call(null, s));
-        } else {
-          return and__3396__auto__;
-        }
-      }())) {
-        var G__7472 = pred__$1;
-        var G__7473 = cljs.core.rest.call(null, s);
-        pred__$1 = G__7472;
-        coll__$1 = G__7473;
-        continue;
-      } else {
-        return s;
-      }
-      break;
-    }
-  };
-  return new cljs.core.LazySeq(null, function() {
-    return step.call(null, pred, coll);
-  }, null, null);
-};
-cljs.core.cycle = function cycle(coll) {
-  return new cljs.core.LazySeq(null, 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, null);
-};
-cljs.core.split_at = function split_at(n, coll) {
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take.call(null, n, coll), cljs.core.drop.call(null, n, coll)], null);
-};
-cljs.core.repeat = function() {
-  var repeat = null;
-  var repeat__1 = function(x) {
-    return new cljs.core.LazySeq(null, function() {
-      return cljs.core.cons.call(null, x, repeat.call(null, x));
-    }, null, 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, function() {
-      return cljs.core.cons.call(null, f.call(null), repeatedly.call(null, f));
-    }, null, 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, function() {
-    return iterate.call(null, f, f.call(null, x));
-  }, null, null));
-};
-cljs.core.interleave = function() {
-  var interleave = null;
-  var interleave__2 = function(c1, c2) {
-    return new cljs.core.LazySeq(null, function() {
-      var s1 = cljs.core.seq.call(null, c1);
-      var s2 = cljs.core.seq.call(null, c2);
-      if (s1 && s2) {
-        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, null);
-  };
-  var interleave__3 = function() {
-    var G__7474__delegate = function(c1, c2, colls) {
-      return new cljs.core.LazySeq(null, 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, null);
-    };
-    var G__7474 = 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__7474__delegate.call(this, c1, c2, colls);
-    };
-    G__7474.cljs$lang$maxFixedArity = 2;
-    G__7474.cljs$lang$applyTo = function(arglist__7475) {
-      var c1 = cljs.core.first(arglist__7475);
-      arglist__7475 = cljs.core.next(arglist__7475);
-      var c2 = cljs.core.first(arglist__7475);
-      var colls = cljs.core.rest(arglist__7475);
-      return G__7474__delegate(c1, c2, colls);
-    };
-    G__7474.cljs$core$IFn$_invoke$arity$variadic = G__7474__delegate;
-    return G__7474;
-  }();
-  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, 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, 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__7476__delegate = function(f, coll, colls) {
-      return cljs.core.flatten1.call(null, cljs.core.apply.call(null, cljs.core.map, f, coll, colls));
-    };
-    var G__7476 = 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__7476__delegate.call(this, f, coll, colls);
-    };
-    G__7476.cljs$lang$maxFixedArity = 2;
-    G__7476.cljs$lang$applyTo = function(arglist__7477) {
-      var f = cljs.core.first(arglist__7477);
-      arglist__7477 = cljs.core.next(arglist__7477);
-      var coll = cljs.core.first(arglist__7477);
-      var colls = cljs.core.rest(arglist__7477);
-      return G__7476__delegate(f, coll, colls);
-    };
-    G__7476.cljs$core$IFn$_invoke$arity$variadic = G__7476__delegate;
-    return G__7476;
-  }();
-  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, 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__4232__auto___7478 = size;
-        var i_7479 = 0;
-        while (true) {
-          if (i_7479 < n__4232__auto___7478) {
-            if (cljs.core.truth_(pred.call(null, cljs.core._nth.call(null, c, i_7479)))) {
-              cljs.core.chunk_append.call(null, b, cljs.core._nth.call(null, c, i_7479));
-            } else {
-            }
-            var G__7480 = i_7479 + 1;
-            i_7479 = G__7480;
-            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, 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, 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, null);
-  };
-  return walk.call(null, root);
-};
-cljs.core.flatten = function flatten(x) {
-  return cljs.core.filter.call(null, function(p1__7481_SHARP_) {
-    return!cljs.core.sequential_QMARK_.call(null, p1__7481_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__7483 = to;
-      if (G__7483) {
-        var bit__4027__auto__ = G__7483.cljs$lang$protocol_mask$partition1$ & 4;
-        if (bit__4027__auto__ || G__7483.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__7484__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__7484 = 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__7484__delegate.call(this, f, c1, c2, c3, colls);
-    };
-    G__7484.cljs$lang$maxFixedArity = 4;
-    G__7484.cljs$lang$applyTo = function(arglist__7485) {
-      var f = cljs.core.first(arglist__7485);
-      arglist__7485 = cljs.core.next(arglist__7485);
-      var c1 = cljs.core.first(arglist__7485);
-      arglist__7485 = cljs.core.next(arglist__7485);
-      var c2 = cljs.core.first(arglist__7485);
-      arglist__7485 = cljs.core.next(arglist__7485);
-      var c3 = cljs.core.first(arglist__7485);
-      var colls = cljs.core.rest(arglist__7485);
-      return G__7484__delegate(f, c1, c2, c3, colls);
-    };
-    G__7484.cljs$core$IFn$_invoke$arity$variadic = G__7484__delegate;
-    return G__7484;
-  }();
-  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, 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, null);
-  };
-  var partition__4 = function(n, step, pad, coll) {
-    return new cljs.core.LazySeq(null, 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._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, n, cljs.core.concat.call(null, p, pad)));
-        }
-      } else {
-        return null;
-      }
-    }, 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__7487 = m__$1;
-          if (G__7487) {
-            var bit__4034__auto__ = G__7487.cljs$lang$protocol_mask$partition0$ & 256;
-            if (bit__4034__auto__ || G__7487.cljs$core$ILookup$) {
-              return true;
-            } else {
-              if (!G__7487.cljs$lang$protocol_mask$partition0$) {
-                return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, G__7487);
-              } else {
-                return false;
-              }
-            }
-          } else {
-            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, G__7487);
-          }
-        }()) {
-          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__7488 = sentinel;
-            var G__7489 = m__$2;
-            var G__7490 = cljs.core.next.call(null, ks__$1);
-            sentinel = G__7488;
-            m__$1 = G__7489;
-            ks__$1 = G__7490;
-            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__7491, v) {
-  var vec__7493 = p__7491;
-  var k = cljs.core.nth.call(null, vec__7493, 0, null);
-  var ks = cljs.core.nthnext.call(null, vec__7493, 1);
-  if (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__7494, f) {
-    var vec__7504 = p__7494;
-    var k = cljs.core.nth.call(null, vec__7504, 0, null);
-    var ks = cljs.core.nthnext.call(null, vec__7504, 1);
-    if (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__7495, f, a) {
-    var vec__7505 = p__7495;
-    var k = cljs.core.nth.call(null, vec__7505, 0, null);
-    var ks = cljs.core.nthnext.call(null, vec__7505, 1);
-    if (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__7496, f, a, b) {
-    var vec__7506 = p__7496;
-    var k = cljs.core.nth.call(null, vec__7506, 0, null);
-    var ks = cljs.core.nthnext.call(null, vec__7506, 1);
-    if (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__7497, f, a, b, c) {
-    var vec__7507 = p__7497;
-    var k = cljs.core.nth.call(null, vec__7507, 0, null);
-    var ks = cljs.core.nthnext.call(null, vec__7507, 1);
-    if (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__7509__delegate = function(m, p__7498, f, a, b, c, args) {
-      var vec__7508 = p__7498;
-      var k = cljs.core.nth.call(null, vec__7508, 0, null);
-      var ks = cljs.core.nthnext.call(null, vec__7508, 1);
-      if (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__7509 = function(m, p__7498, 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__7509__delegate.call(this, m, p__7498, f, a, b, c, args);
-    };
-    G__7509.cljs$lang$maxFixedArity = 6;
-    G__7509.cljs$lang$applyTo = function(arglist__7510) {
-      var m = cljs.core.first(arglist__7510);
-      arglist__7510 = cljs.core.next(arglist__7510);
-      var p__7498 = cljs.core.first(arglist__7510);
-      arglist__7510 = cljs.core.next(arglist__7510);
-      var f = cljs.core.first(arglist__7510);
-      arglist__7510 = cljs.core.next(arglist__7510);
-      var a = cljs.core.first(arglist__7510);
-      arglist__7510 = cljs.core.next(arglist__7510);
-      var b = cljs.core.first(arglist__7510);
-      arglist__7510 = cljs.core.next(arglist__7510);
-      var c = cljs.core.first(arglist__7510);
-      var args = cljs.core.rest(arglist__7510);
-      return G__7509__delegate(m, p__7498, f, a, b, c, args);
-    };
-    G__7509.cljs$core$IFn$_invoke$arity$variadic = G__7509__delegate;
-    return G__7509;
-  }();
-  update_in = function(m, p__7498, f, a, b, c, var_args) {
-    var args = var_args;
-    switch(arguments.length) {
-      case 3:
-        return update_in__3.call(this, m, p__7498, f);
-      case 4:
-        return update_in__4.call(this, m, p__7498, f, a);
-      case 5:
-        return update_in__5.call(this, m, p__7498, f, a, b);
-      case 6:
-        return update_in__6.call(this, m, p__7498, f, a, b, c);
-      default:
-        return update_in__7.cljs$core$IFn$_invoke$arity$variadic(m, p__7498, 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;
-}();
-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__3955__auto__, writer__3956__auto__, opts__3957__auto__) {
-  return cljs.core._write.call(null, writer__3956__auto__, "cljs.core/VectorNode");
-};
-cljs.core.__GT_VectorNode = function __GT_VectorNode(edit, arr) {
-  return new cljs.core.VectorNode(edit, arr);
-};
-cljs.core.pv_fresh_node = function pv_fresh_node(edit) {
-  return new cljs.core.VectorNode(edit, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]);
-};
-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, cljs.core.aclone.call(null, node.arr));
-};
-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__7511 = ll - 5;
-      var G__7512 = r;
-      ll = G__7511;
-      ret = G__7512;
-      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.vector_index_out_of_bounds = function vector_index_out_of_bounds(i, cnt) {
-  throw new Error([cljs.core.str("No item "), cljs.core.str(i), cljs.core.str(" in vector of length "), cljs.core.str(cnt)].join(""));
-};
-cljs.core.array_for = function array_for(pv, i) {
-  if (0 <= i && i < pv.cnt) {
-    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__7513 = cljs.core.pv_aget.call(null, node, i >>> level & 31);
-          var G__7514 = level - 5;
-          node = G__7513;
-          level = G__7514;
-          continue;
-        } else {
-          return node.arr;
-        }
-        break;
-      }
-    }
-  } else {
-    return cljs.core.vector_index_out_of_bounds.call(null, i, pv.cnt);
-  }
-};
-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 (new_child == null && subidx === 0) {
-      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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        var ret = cljs.core.pv_clone_node.call(null, node);
-        cljs.core.pv_aset.call(null, ret, subidx, null);
-        return ret;
-      } else {
-        return null;
-      }
-    }
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentVector");
-};
-cljs.core.PersistentVector.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, k, null);
-};
-cljs.core.PersistentVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, k, not_found);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, k, v) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (0 <= k && k < self__.cnt) {
-    if (cljs.core.tail_off.call(null, coll__$1) <= k) {
-      var new_tail = cljs.core.aclone.call(null, self__.tail);
-      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__$1, self__.shift, self__.root, k, v), self__.tail, null);
-    }
-  } else {
-    if (k === self__.cnt) {
-      return cljs.core._conj.call(null, coll__$1, v);
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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__7516 = null;
-  var G__7516__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
-  };
-  var G__7516__3 = function(self__, k, not_found) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
-  };
-  G__7516 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7516__2.call(this, self__, k);
-      case 3:
-        return G__7516__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7516;
-}();
-cljs.core.PersistentVector.prototype.apply = function(self__, args7515) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7515)));
-};
-cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(v, f, init) {
-  var self__ = this;
-  var v__$1 = this;
-  var step_init = [0, init];
-  var i = 0;
-  while (true) {
-    if (i < self__.cnt) {
-      var arr = cljs.core.array_for.call(null, v__$1, 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__7517 = j + 1;
-              var G__7518 = init__$2;
-              j = G__7517;
-              init__$1 = G__7518;
-              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__7519 = i + step_init[0];
-        i = G__7519;
-        continue;
-      }
-    } else {
-      return step_init[1];
-    }
-    break;
-  }
-};
-cljs.core.PersistentVector.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.cnt - cljs.core.tail_off.call(null, coll__$1) < 32) {
-    var len = self__.tail.length;
-    var new_tail = new Array(len + 1);
-    var n__4232__auto___7520 = len;
-    var i_7521 = 0;
-    while (true) {
-      if (i_7521 < n__4232__auto___7520) {
-        new_tail[i_7521] = self__.tail[i_7521];
-        var G__7522 = i_7521 + 1;
-        i_7521 = G__7522;
-        continue;
-      } else {
-      }
-      break;
-    }
-    new_tail[len] = 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__$1, 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;
-  var coll__$1 = this;
-  if (self__.cnt > 0) {
-    return new cljs.core.RSeq(coll__$1, self__.cnt - 1, null);
-  } else {
-    return null;
-  }
-};
-cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_key$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, 0);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IMapEntry$_val$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, 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;
-  var v__$1 = this;
-  return cljs.core.ci_reduce.call(null, v__$1, f);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IReduce$_reduce$arity$3 = function(v, f, start) {
-  var self__ = this;
-  var v__$1 = this;
-  return cljs.core.ci_reduce.call(null, v__$1, f, start);
-};
-cljs.core.PersistentVector.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.cnt === 0) {
-    return null;
-  } else {
-    if (self__.cnt < 32) {
-      return cljs.core.array_seq.call(null, self__.tail);
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return cljs.core.chunked_seq.call(null, coll__$1, 0, 0);
-      } else {
-        return null;
-      }
-    }
-  }
-};
-cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.cnt;
-};
-cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.cnt > 0) {
-    return cljs.core._nth.call(null, coll__$1, self__.cnt - 1);
-  } else {
-    return null;
-  }
-};
-cljs.core.PersistentVector.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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__$1)) {
-        return new cljs.core.PersistentVector(self__.meta, self__.cnt - 1, self__.shift, self__.root, self__.tail.slice(0, -1), null);
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var new_tail = cljs.core.array_for.call(null, coll__$1, self__.cnt - 2);
-          var nr = cljs.core.pop_tail.call(null, coll__$1, self__.shift, self__.root);
-          var new_root = nr == null ? cljs.core.PersistentVector.EMPTY_NODE : nr;
-          var cnt_1 = self__.cnt - 1;
-          if (5 < self__.shift && cljs.core.pv_aget.call(null, new_root, 1) == null) {
-            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;
-  var coll__$1 = this;
-  return cljs.core._assoc.call(null, coll__$1, n, val);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.array_for.call(null, coll__$1, n)[n & 31];
-};
-cljs.core.PersistentVector.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (0 <= n && n < self__.cnt) {
-    return cljs.core._nth.call(null, coll__$1, n);
-  } else {
-    return not_found;
-  }
-};
-cljs.core.PersistentVector.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta);
-};
-cljs.core.__GT_PersistentVector = function __GT_PersistentVector(meta, cnt, shift, root, tail, __hash) {
-  return new cljs.core.PersistentVector(meta, cnt, shift, root, tail, __hash);
-};
-cljs.core.PersistentVector.EMPTY_NODE = new cljs.core.VectorNode(null, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]);
-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 : cljs.core.aclone.call(null, xs);
-  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__7523 = i + 1;
-        var G__7524 = cljs.core.conj_BANG_.call(null, out, xs__$1[i]);
-        i = G__7523;
-        out = G__7524;
-        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) {
-    if (args instanceof cljs.core.IndexedSeq && args.i === 0) {
-      return cljs.core.PersistentVector.fromArray.call(null, args.arr, true);
-    } else {
-      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__7525) {
-    var args = cljs.core.seq(arglist__7525);
-    return vector__delegate(args);
-  };
-  vector.cljs$core$IFn$_invoke$arity$variadic = vector__delegate;
-  return vector;
-}();
-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$ = 32243948;
-  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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ChunkedSeq");
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 cljs.core._chunked_next.call(null, coll__$1);
-  }
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.ci_reduce.call(null, cljs.core.subvec.call(null, self__.vec, self__.i + self__.off, cljs.core.count.call(null, self__.vec)), f);
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.ci_reduce.call(null, cljs.core.subvec.call(null, self__.vec, self__.i + self__.off, cljs.core.count.call(null, self__.vec)), f, start);
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.node[self__.off];
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 cljs.core._chunked_rest.call(null, coll__$1);
-  }
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$IChunkedNext$_chunked_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, m) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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 coll__$1 = 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.__GT_ChunkedSeq = function __GT_ChunkedSeq(vec, node, i, off, meta, __hash) {
-  return new cljs.core.ChunkedSeq(vec, node, i, off, meta, __hash);
-};
-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;
-}();
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Subvec");
-};
-cljs.core.Subvec.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, k, null);
-};
-cljs.core.Subvec.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, k, not_found);
-};
-cljs.core.Subvec.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(coll, key, val) {
-  var self__ = this;
-  var coll__$1 = 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, function() {
-    var x__3715__auto__ = self__.end;
-    var y__3716__auto__ = v_pos + 1;
-    return x__3715__auto__ > y__3716__auto__ ? x__3715__auto__ : y__3716__auto__;
-  }(), null);
-};
-cljs.core.Subvec.prototype.call = function() {
-  var G__7527 = null;
-  var G__7527__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
-  };
-  var G__7527__3 = function(self__, k, not_found) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
-  };
-  G__7527 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7527__2.call(this, self__, k);
-      case 3:
-        return G__7527__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7527;
-}();
-cljs.core.Subvec.prototype.apply = function(self__, args7526) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7526)));
-};
-cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$IIndexed$_nth$arity$2(null, k);
-};
-cljs.core.Subvec.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$IIndexed$_nth$arity$3(null, k, not_found);
-};
-cljs.core.Subvec.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.ci_reduce.call(null, coll__$1, f);
-};
-cljs.core.Subvec.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start__$1) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.ci_reduce.call(null, coll__$1, f, start__$1);
-};
-cljs.core.Subvec.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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, function() {
-        return subvec_seq.call(null, i + 1);
-      }, null, null));
-    }
-  };
-  return subvec_seq.call(null, self__.start);
-};
-cljs.core.Subvec.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.end - self__.start;
-};
-cljs.core.Subvec.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core._assoc.call(null, coll__$1, n, val);
-};
-cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (n < 0 || self__.end <= self__.start + n) {
-    return cljs.core.vector_index_out_of_bounds.call(null, n, self__.end - self__.start);
-  } else {
-    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;
-  var coll__$1 = this;
-  if (n < 0 || self__.end <= self__.start + n) {
-    return not_found;
-  } else {
-    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;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.PersistentVector.EMPTY, self__.meta);
-};
-cljs.core.__GT_Subvec = function __GT_Subvec(meta, v, start, end, __hash) {
-  return new cljs.core.Subvec(meta, v, start, end, __hash);
-};
-cljs.core.build_subvec = function build_subvec(meta, v, start, end, __hash) {
-  while (true) {
-    if (v instanceof cljs.core.Subvec) {
-      var G__7528 = meta;
-      var G__7529 = v.v;
-      var G__7530 = v.start + start;
-      var G__7531 = v.start + end;
-      var G__7532 = __hash;
-      meta = G__7528;
-      v = G__7529;
-      start = G__7530;
-      end = G__7531;
-      __hash = G__7532;
-      continue;
-    } else {
-      var c = cljs.core.count.call(null, v);
-      if (start < 0 || (end < 0 || (start > c || 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, cljs.core.aclone.call(null, node.arr));
-  }
-};
-cljs.core.tv_editable_root = function tv_editable_root(node) {
-  return new cljs.core.VectorNode(function() {
-    var obj7536 = {};
-    return obj7536;
-  }(), cljs.core.aclone.call(null, node.arr));
-};
-cljs.core.tv_editable_tail = function tv_editable_tail(tl) {
-  var ret = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
-  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 (new_child == null && subidx === 0) {
-      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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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 (0 <= i && i < tv.cnt) {
-    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__7537 = cljs.core.tv_ensure_editable.call(null, root.edit, cljs.core.pv_aget.call(null, node, i >>> level & 31));
-          var G__7538 = level - 5;
-          node = G__7537;
-          level = G__7538;
-          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(""));
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientVector");
-};
-cljs.core.TransientVector.prototype.call = function() {
-  var G__7540 = null;
-  var G__7540__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7540__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(null, k, not_found);
-  };
-  G__7540 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7540__2.call(this, self__, k);
-      case 3:
-        return G__7540__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7540;
-}();
-cljs.core.TransientVector.prototype.apply = function(self__, args7539) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7539)));
-};
-cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, k, null);
-};
-cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._nth.call(null, coll__$1, k, not_found);
-};
-cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.root.edit) {
-    return cljs.core.array_for.call(null, coll__$1, 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;
-  var coll__$1 = this;
-  if (0 <= n && n < self__.cnt) {
-    return cljs.core._nth.call(null, coll__$1, n);
-  } else {
-    return not_found;
-  }
-};
-cljs.core.TransientVector.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var tcoll__$1 = this;
-  if (self__.root.edit) {
-    if (0 <= n && n < self__.cnt) {
-      if (cljs.core.tail_off.call(null, tcoll__$1) <= n) {
-        self__.tail[n & 31] = val;
-        return tcoll__$1;
-      } 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__$1;
-      }
-    } else {
-      if (n === self__.cnt) {
-        return cljs.core._conj_BANG_.call(null, tcoll__$1, val);
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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;
-  var tcoll__$1 = 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__$1;
-      } else {
-        if ((self__.cnt - 1 & 31) > 0) {
-          self__.cnt = self__.cnt - 1;
-          return tcoll__$1;
-        } else {
-          if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-            var new_tail = cljs.core.editable_array_for.call(null, tcoll__$1, self__.cnt - 2);
-            var new_root = function() {
-              var nr = cljs.core.tv_pop_tail.call(null, tcoll__$1, self__.shift, self__.root);
-              if (!(nr == null)) {
-                return nr;
-              } else {
-                return new cljs.core.VectorNode(self__.root.edit, [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null]);
-              }
-            }();
-            if (5 < self__.shift && cljs.core.pv_aget.call(null, new_root, 1) == null) {
-              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__$1;
-            } else {
-              self__.root = new_root;
-              self__.cnt = self__.cnt - 1;
-              self__.tail = new_tail;
-              return tcoll__$1;
-            }
-          } 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;
-  var tcoll__$1 = this;
-  return cljs.core._assoc_n_BANG_.call(null, tcoll__$1, key, val);
-};
-cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  if (self__.root.edit) {
-    if (self__.cnt - cljs.core.tail_off.call(null, tcoll__$1) < 32) {
-      self__.tail[self__.cnt & 31] = o;
-      self__.cnt = self__.cnt + 1;
-      return tcoll__$1;
-    } else {
-      var tail_node = new cljs.core.VectorNode(self__.root.edit, self__.tail);
-      var new_tail = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
-      new_tail[0] = o;
-      self__.tail = new_tail;
-      if (self__.cnt >>> 5 > 1 << self__.shift) {
-        var new_root_array = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
-        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__$1;
-      } else {
-        var new_root = cljs.core.tv_push_tail.call(null, tcoll__$1, self__.shift, self__.root, tail_node);
-        self__.root = new_root;
-        self__.cnt = self__.cnt + 1;
-        return tcoll__$1;
-      }
-    }
-  } else {
-    throw new Error("conj! after persistent!");
-  }
-};
-cljs.core.TransientVector.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  if (self__.root.edit) {
-    self__.root.edit = null;
-    var len = self__.cnt - cljs.core.tail_off.call(null, tcoll__$1);
-    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");
-  }
-};
-cljs.core.__GT_TransientVector = function __GT_TransientVector(cnt, shift, root, tail) {
-  return new cljs.core.TransientVector(cnt, shift, root, tail);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentQueueSeq");
-};
-cljs.core.PersistentQueueSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentQueueSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.PersistentQueueSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 coll__$1 = 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 cljs.core._empty.call(null, coll__$1);
-    } 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.PersistentQueueSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentQueueSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_PersistentQueueSeq = function __GT_PersistentQueueSeq(meta, front, rear, __hash) {
-  return new cljs.core.PersistentQueueSeq(meta, front, rear, __hash);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentQueue");
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentQueue.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = 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__3408__auto__ = self__.rear;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__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 coll__$1 = this;
-  var rear__$1 = cljs.core.seq.call(null, self__.rear);
-  if (cljs.core.truth_(function() {
-    var or__3408__auto__ = self__.front;
-    if (cljs.core.truth_(or__3408__auto__)) {
-      return or__3408__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;
-  var coll__$1 = this;
-  return self__.count;
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IStack$_peek$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.first.call(null, self__.front);
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IStack$_pop$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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__$1;
-  }
-};
-cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.first.call(null, self__.front);
-};
-cljs.core.PersistentQueue.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.rest.call(null, cljs.core.seq.call(null, coll__$1));
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.PersistentQueue.EMPTY;
-};
-cljs.core.__GT_PersistentQueue = function __GT_PersistentQueue(meta, count, front, rear, __hash) {
-  return new cljs.core.PersistentQueue(meta, count, front, rear, __hash);
-};
-cljs.core.PersistentQueue.EMPTY = new cljs.core.PersistentQueue(null, 0, null, cljs.core.PersistentVector.EMPTY, 0);
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/NeverEquiv");
-};
-cljs.core.NeverEquiv.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
-  var self__ = this;
-  var o__$1 = this;
-  return false;
-};
-cljs.core.__GT_NeverEquiv = function __GT_NeverEquiv() {
-  return new cljs.core.NeverEquiv;
-};
-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__7541 = i + incr;
-        i = G__7541;
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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__7542 = i + 1;
-      var G__7543 = cljs.core.assoc_BANG_.call(null, out, k__$1, so[k__$1]);
-      i = G__7542;
-      out = G__7543;
-      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 = function() {
-    var obj7547 = {};
-    return obj7547;
-  }();
-  var l = ks.length;
-  var i_7548 = 0;
-  while (true) {
-    if (i_7548 < l) {
-      var k_7549 = ks[i_7548];
-      new_obj[k_7549] = obj[k_7549];
-      var G__7550 = i_7548 + 1;
-      i_7548 = G__7550;
-      continue;
-    } else {
-    }
-    break;
-  }
-  return new_obj;
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ObjMap");
-};
-cljs.core.ObjMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.transient$.call(null, cljs.core.into.call(null, cljs.core.PersistentHashMap.EMPTY, coll__$1));
-};
-cljs.core.ObjMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._lookup.call(null, coll__$1, k, null);
-};
-cljs.core.ObjMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (goog.isString(k) && !(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
-    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;
-  var coll__$1 = this;
-  if (goog.isString(k)) {
-    if (self__.update_count > cljs.core.ObjMap.HASHMAP_THRESHOLD || self__.keys.length >= cljs.core.ObjMap.HASHMAP_THRESHOLD) {
-      return cljs.core.obj_map__GT_hash_map.call(null, coll__$1, 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 = cljs.core.aclone.call(null, self__.keys);
-        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__$1, k, v);
-  }
-};
-cljs.core.ObjMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (goog.isString(k) && !(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
-    return true;
-  } else {
-    return false;
-  }
-};
-cljs.core.ObjMap.prototype.call = function() {
-  var G__7553 = null;
-  var G__7553__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7553__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(null, k, not_found);
-  };
-  G__7553 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7553__2.call(this, self__, k);
-      case 3:
-        return G__7553__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7553;
-}();
-cljs.core.ObjMap.prototype.apply = function(self__, args7552) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7552)));
-};
-cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
-  var self__ = this;
-  var coll__$1 = 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__7554 = cljs.core.rest.call(null, keys__$1);
-        var G__7555 = init__$2;
-        keys__$1 = G__7554;
-        init__$1 = G__7555;
-        continue;
-      }
-    } else {
-      return init__$1;
-    }
-    break;
-  }
-};
-cljs.core.ObjMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (cljs.core.vector_QMARK_.call(null, entry)) {
-    return cljs.core._assoc.call(null, coll__$1, 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__$1, 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;
-  var coll__$1 = this;
-  if (self__.keys.length > 0) {
-    return cljs.core.map.call(null, function(p1__7551_SHARP_) {
-      return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p1__7551_SHARP_, self__.strobj[p1__7551_SHARP_]], null);
-    }, 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;
-  var coll__$1 = this;
-  return self__.keys.length;
-};
-cljs.core.ObjMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_map.call(null, coll__$1, other);
-};
-cljs.core.ObjMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.ObjMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  if (goog.isString(k) && !(cljs.core.scan_array.call(null, 1, k, self__.keys) == null)) {
-    var new_keys = cljs.core.aclone.call(null, self__.keys);
-    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__$1;
-  }
-};
-cljs.core.__GT_ObjMap = function __GT_ObjMap(meta, keys, strobj, update_count, __hash) {
-  return new cljs.core.ObjMap(meta, keys, strobj, update_count, __hash);
-};
-cljs.core.ObjMap.EMPTY = new cljs.core.ObjMap(null, [], function() {
-  var obj7557 = {};
-  return obj7557;
-}(), 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var G__7558 = i + 2;
-          i = G__7558;
-          continue;
-        } else {
-          return null;
-        }
-      }
-    }
-    break;
-  }
-};
-cljs.core.array_map_index_of_keyword_QMARK_ = function array_map_index_of_keyword_QMARK_(arr, m, k) {
-  var len = arr.length;
-  var kstr = k.fqn;
-  var i = 0;
-  while (true) {
-    if (len <= i) {
-      return-1;
-    } else {
-      if (function() {
-        var k_SINGLEQUOTE_ = arr[i];
-        return k_SINGLEQUOTE_ instanceof cljs.core.Keyword && kstr === k_SINGLEQUOTE_.fqn;
-      }()) {
-        return i;
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var G__7559 = i + 2;
-          i = G__7559;
-          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];
-        return k_SINGLEQUOTE_ instanceof cljs.core.Symbol && kstr === k_SINGLEQUOTE_.str;
-      }()) {
-        return i;
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var G__7560 = i + 2;
-          i = G__7560;
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var G__7561 = i + 2;
-          i = G__7561;
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var G__7562 = i + 2;
-          i = G__7562;
-          continue;
-        } else {
-          return null;
-        }
-      }
-    }
-    break;
-  }
-};
-cljs.core.array_map_index_of = function array_map_index_of(m, k) {
-  var arr = m.arr;
-  if (k instanceof cljs.core.Keyword) {
-    return cljs.core.array_map_index_of_keyword_QMARK_.call(null, arr, m, k);
-  } else {
-    if (goog.isString(k) || 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-            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_7563 = 0;
-  while (true) {
-    if (i_7563 < l) {
-      narr[i_7563] = arr[i_7563];
-      var G__7564 = i_7563 + 1;
-      i_7563 = G__7564;
-      continue;
-    } else {
-    }
-    break;
-  }
-  narr[l] = k;
-  narr[l + 1] = v;
-  return narr;
-};
-cljs.core.PersistentArrayMapSeq = function(arr, i, _meta) {
-  this.arr = arr;
-  this.i = i;
-  this._meta = _meta;
-  this.cljs$lang$protocol_mask$partition1$ = 0;
-  this.cljs$lang$protocol_mask$partition0$ = 32374990;
-};
-cljs.core.PersistentArrayMapSeq.cljs$lang$type = true;
-cljs.core.PersistentArrayMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentArrayMapSeq";
-cljs.core.PersistentArrayMapSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentArrayMapSeq");
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.hash_coll.call(null, coll__$1);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.i < self__.arr.length - 2) {
-    return new cljs.core.PersistentArrayMapSeq(self__.arr, self__.i + 2, self__._meta);
-  } else {
-    return null;
-  }
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-cljs.core.PersistentArrayMapSeq.prototype.toString = function() {
-  var self__ = this;
-  var coll = this;
-  return cljs.core.pr_str_STAR_.call(null, coll);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return(self__.arr.length - self__.i) / 2;
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.arr[self__.i], self__.arr[self__.i + 1]], null);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.i < self__.arr.length - 2) {
-    return new cljs.core.PersistentArrayMapSeq(self__.arr, self__.i + 2, self__._meta);
-  } else {
-    return cljs.core.List.EMPTY;
-  }
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.PersistentArrayMapSeq(self__.arr, self__.i, new_meta);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__._meta;
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__._meta);
-};
-cljs.core.__GT_PersistentArrayMapSeq = function __GT_PersistentArrayMapSeq(arr, i, _meta) {
-  return new cljs.core.PersistentArrayMapSeq(arr, i, _meta);
-};
-cljs.core.persistent_array_map_seq = function persistent_array_map_seq(arr, i, _meta) {
-  if (i <= arr.length - 2) {
-    return new cljs.core.PersistentArrayMapSeq(arr, i, _meta);
-  } else {
-    return null;
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentArrayMap");
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.TransientArrayMap(function() {
-    var obj7567 = {};
-    return obj7567;
-  }(), self__.arr.length, cljs.core.aclone.call(null, self__.arr));
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._lookup.call(null, coll__$1, k, null);
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  var idx = cljs.core.array_map_index_of.call(null, coll__$1, 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 coll__$1 = this;
-  var idx = cljs.core.array_map_index_of.call(null, coll__$1, k);
-  if (idx === -1) {
-    if (self__.cnt < cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
-      var arr__$1 = cljs.core.array_map_extend_kv.call(null, coll__$1, 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__$1), k, v), self__.meta);
-    }
-  } else {
-    if (v === self__.arr[idx + 1]) {
-      return coll__$1;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        var arr__$1 = function() {
-          var G__7568 = cljs.core.aclone.call(null, self__.arr);
-          G__7568[idx + 1] = v;
-          return G__7568;
-        }();
-        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;
-  var coll__$1 = this;
-  return!(cljs.core.array_map_index_of.call(null, coll__$1, k) === -1);
-};
-cljs.core.PersistentArrayMap.prototype.call = function() {
-  var G__7569 = null;
-  var G__7569__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7569__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(null, k, not_found);
-  };
-  G__7569 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7569__2.call(this, self__, k);
-      case 3:
-        return G__7569__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7569;
-}();
-cljs.core.PersistentArrayMap.prototype.apply = function(self__, args7565) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7565)));
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
-  var self__ = this;
-  var coll__$1 = 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__7570 = i + 2;
-        var G__7571 = init__$2;
-        i = G__7570;
-        init__$1 = G__7571;
-        continue;
-      }
-    } else {
-      return init__$1;
-    }
-    break;
-  }
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (cljs.core.vector_QMARK_.call(null, entry)) {
-    return cljs.core._assoc.call(null, coll__$1, 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__$1, 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;
-  var coll__$1 = this;
-  return cljs.core.persistent_array_map_seq.call(null, self__.arr, 0, null);
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.cnt;
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_map.call(null, coll__$1, other);
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 coll__$1 = this;
-  var idx = cljs.core.array_map_index_of.call(null, coll__$1, k);
-  if (idx >= 0) {
-    var len = self__.arr.length;
-    var new_len = len - 2;
-    if (new_len === 0) {
-      return cljs.core._empty.call(null, coll__$1);
-    } 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__7572 = s + 2;
-            var G__7573 = d;
-            s = G__7572;
-            d = G__7573;
-            continue;
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              new_arr[d] = self__.arr[s];
-              new_arr[d + 1] = self__.arr[s + 1];
-              var G__7574 = s + 2;
-              var G__7575 = d + 2;
-              s = G__7574;
-              d = G__7575;
-              continue;
-            } else {
-              return null;
-            }
-          }
-        }
-        break;
-      }
-    }
-  } else {
-    return coll__$1;
-  }
-};
-cljs.core.__GT_PersistentArrayMap = function __GT_PersistentArrayMap(meta, cnt, arr, __hash) {
-  return new cljs.core.PersistentArrayMap(meta, cnt, arr, __hash);
-};
-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, no_check) {
-  var arr__$1 = no_clone ? arr : cljs.core.aclone.call(null, arr);
-  if (no_check) {
-    var cnt = arr__$1.length / 2;
-    return new cljs.core.PersistentArrayMap(null, cnt, arr__$1, null);
-  } else {
-    var len = arr__$1.length;
-    var i = 0;
-    var ret = cljs.core.transient$.call(null, cljs.core.PersistentArrayMap.EMPTY);
-    while (true) {
-      if (i < len) {
-        var G__7576 = i + 2;
-        var G__7577 = cljs.core._assoc_BANG_.call(null, ret, arr__$1[i], arr__$1[i + 1]);
-        i = G__7576;
-        ret = G__7577;
-        continue;
-      } else {
-        return cljs.core._persistent_BANG_.call(null, ret);
-      }
-      break;
-    }
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientArrayMap");
-};
-cljs.core.TransientArrayMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = function(tcoll, key) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  if (cljs.core.truth_(self__.editable_QMARK_)) {
-    var idx = cljs.core.array_map_index_of.call(null, tcoll__$1, key);
-    if (idx >= 0) {
-      self__.arr[idx] = self__.arr[self__.len - 2];
-      self__.arr[idx + 1] = self__.arr[self__.len - 1];
-      var G__7578_7580 = self__.arr;
-      G__7578_7580.pop();
-      G__7578_7580.pop();
-      self__.len = self__.len - 2;
-    } else {
-    }
-    return tcoll__$1;
-  } 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;
-  var tcoll__$1 = this;
-  if (cljs.core.truth_(self__.editable_QMARK_)) {
-    var idx = cljs.core.array_map_index_of.call(null, tcoll__$1, 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__$1;
-      } 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__$1;
-      } else {
-        self__.arr[idx + 1] = val;
-        return tcoll__$1;
-      }
-    }
-  } else {
-    throw new Error("assoc! after persistent!");
-  }
-};
-cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  if (cljs.core.truth_(self__.editable_QMARK_)) {
-    if (function() {
-      var G__7579 = o;
-      if (G__7579) {
-        var bit__4034__auto__ = G__7579.cljs$lang$protocol_mask$partition0$ & 2048;
-        if (bit__4034__auto__ || G__7579.cljs$core$IMapEntry$) {
-          return true;
-        } else {
-          if (!G__7579.cljs$lang$protocol_mask$partition0$) {
-            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7579);
-          } else {
-            return false;
-          }
-        }
-      } else {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7579);
-      }
-    }()) {
-      return cljs.core._assoc_BANG_.call(null, tcoll__$1, cljs.core.key.call(null, o), cljs.core.val.call(null, o));
-    } else {
-      var es = cljs.core.seq.call(null, o);
-      var tcoll__$2 = tcoll__$1;
-      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__7581 = cljs.core.next.call(null, es);
-          var G__7582 = cljs.core._assoc_BANG_.call(null, tcoll__$2, cljs.core.key.call(null, e), cljs.core.val.call(null, e));
-          es = G__7581;
-          tcoll__$2 = G__7582;
-          continue;
-        } else {
-          return tcoll__$2;
-        }
-        break;
-      }
-    }
-  } else {
-    throw new Error("conj! after persistent!");
-  }
-};
-cljs.core.TransientArrayMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
-  var self__ = this;
-  var tcoll__$1 = 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;
-  var tcoll__$1 = this;
-  return cljs.core._lookup.call(null, tcoll__$1, k, null);
-};
-cljs.core.TransientArrayMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, k, not_found) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  if (cljs.core.truth_(self__.editable_QMARK_)) {
-    var idx = cljs.core.array_map_index_of.call(null, tcoll__$1, 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;
-  var tcoll__$1 = 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.__GT_TransientArrayMap = function __GT_TransientArrayMap(editable_QMARK_, len, arr) {
-  return new cljs.core.TransientArrayMap(editable_QMARK_, len, arr);
-};
-cljs.core.array__GT_transient_hash_map = function array__GT_transient_hash_map(len, arr) {
-  var out = cljs.core.transient$.call(null, cljs.core.PersistentHashMap.EMPTY);
-  var i = 0;
-  while (true) {
-    if (i < len) {
-      var G__7583 = cljs.core.assoc_BANG_.call(null, out, arr[i], arr[i + 1]);
-      var G__7584 = i + 2;
-      out = G__7583;
-      i = G__7584;
-      continue;
-    } else {
-      return out;
-    }
-    break;
-  }
-};
-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__3955__auto__, writer__3956__auto__, opts__3957__auto__) {
-  return cljs.core._write.call(null, writer__3956__auto__, "cljs.core/Box");
-};
-cljs.core.__GT_Box = function __GT_Box(val) {
-  return new cljs.core.Box(val);
-};
-cljs.core.key_test = function key_test(key, other) {
-  if (key === other) {
-    return true;
-  } else {
-    if (cljs.core.keyword_identical_QMARK_.call(null, key, other)) {
-      return true;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return cljs.core._EQ_.call(null, key, other);
-      } else {
-        return null;
-      }
-    }
-  }
-};
-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__7587 = cljs.core.aclone.call(null, arr);
-    G__7587[i] = a;
-    return G__7587;
-  };
-  var clone_and_set__5 = function(arr, i, a, j, b) {
-    var G__7588 = cljs.core.aclone.call(null, arr);
-    G__7588[i] = a;
-    G__7588[j] = b;
-    return G__7588;
-  };
-  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__7589 = i + 2;
-        var G__7590 = init__$2;
-        i = G__7589;
-        init__$1 = G__7590;
-        continue;
-      }
-    } else {
-      return init__$1;
-    }
-    break;
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__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 = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
-        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_7591 = 0;
-        var j_7592 = 0;
-        while (true) {
-          if (i_7591 < 32) {
-            if ((self__.bitmap >>> i_7591 & 1) === 0) {
-              var G__7593 = i_7591 + 1;
-              var G__7594 = j_7592;
-              i_7591 = G__7593;
-              j_7592 = G__7594;
-              continue;
-            } else {
-              nodes[i_7591] = !(self__.arr[j_7592] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1, shift + 5, cljs.core.hash.call(null, self__.arr[j_7592]), self__.arr[j_7592], self__.arr[j_7592 + 1], added_leaf_QMARK_) : self__.arr[j_7592 + 1];
-              var G__7595 = i_7591 + 1;
-              var G__7596 = j_7592 + 2;
-              i_7591 = G__7595;
-              j_7592 = G__7596;
-              continue;
-            }
-          } else {
-          }
-          break;
-        }
-        return new cljs.core.ArrayNode(edit__$1, n + 1, nodes);
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [key_or_nil, val_or_node], null);
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 = [null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null];
-      var jdx = hash >>> shift & 31;
-      nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, hash, key, val, added_leaf_QMARK_);
-      var i_7597 = 0;
-      var j_7598 = 0;
-      while (true) {
-        if (i_7597 < 32) {
-          if ((self__.bitmap >>> i_7597 & 1) === 0) {
-            var G__7599 = i_7597 + 1;
-            var G__7600 = j_7598;
-            i_7597 = G__7599;
-            j_7598 = G__7600;
-            continue;
-          } else {
-            nodes[i_7597] = !(self__.arr[j_7598] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, cljs.core.hash.call(null, self__.arr[j_7598]), self__.arr[j_7598], self__.arr[j_7598 + 1], added_leaf_QMARK_) : self__.arr[j_7598 + 1];
-            var G__7601 = i_7597 + 1;
-            var G__7602 = j_7598 + 2;
-            i_7597 = G__7601;
-            j_7598 = G__7602;
-            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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          return not_found;
-        } else {
-          return null;
-        }
-      }
-    }
-  }
-};
-cljs.core.__GT_BitmapIndexedNode = function __GT_BitmapIndexedNode(edit, bitmap, arr) {
-  return new cljs.core.BitmapIndexedNode(edit, bitmap, arr);
-};
-cljs.core.BitmapIndexedNode.EMPTY = new cljs.core.BitmapIndexedNode(null, 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 (!(i === idx) && !(arr[i] == null)) {
-        new_arr[j] = arr[i];
-        var G__7603 = i + 1;
-        var G__7604 = j + 2;
-        var G__7605 = bitmap | 1 << i;
-        i = G__7603;
-        j = G__7604;
-        bitmap = G__7605;
-        continue;
-      } else {
-        var G__7606 = i + 1;
-        var G__7607 = j;
-        var G__7608 = bitmap;
-        i = G__7606;
-        j = G__7607;
-        bitmap = G__7608;
-        continue;
-      }
-    } else {
-      return new cljs.core.BitmapIndexedNode(edit, bitmap, new_arr);
-    }
-    break;
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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, cljs.core.aclone.call(null, self__.arr));
-  }
-};
-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__7609 = i + 1;
-          var G__7610 = init__$2;
-          i = G__7609;
-          init__$1 = G__7610;
-          continue;
-        }
-      } else {
-        var G__7611 = i + 1;
-        var G__7612 = init__$1;
-        i = G__7611;
-        init__$1 = G__7612;
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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.__GT_ArrayNode = function __GT_ArrayNode(edit, cnt, arr) {
-  return new cljs.core.ArrayNode(edit, cnt, arr);
-};
-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__7613 = i + 2;
-        i = G__7613;
-        continue;
-      }
-    } else {
-      return-1;
-    }
-    break;
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__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 new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.arr[idx], self__.arr[idx + 1]], null);
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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 = 2 * self__.cnt;
-      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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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.__GT_HashCollisionNode = function __GT_HashCollisionNode(edit, collision_hash, cnt, arr) {
-  return new cljs.core.HashCollisionNode(edit, collision_hash, cnt, arr);
-};
-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;
-}();
-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$ = 32374860;
-};
-cljs.core.NodeSeq.cljs$lang$type = true;
-cljs.core.NodeSeq.cljs$lang$ctorStr = "cljs.core/NodeSeq";
-cljs.core.NodeSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/NodeSeq");
-};
-cljs.core.NodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.NodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.NodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = this;
-  return this$__$1;
-};
-cljs.core.NodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.s == null) {
-    return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.nodes[self__.i], self__.nodes[self__.i + 1]], null);
-  } else {
-    return cljs.core.first.call(null, self__.s);
-  }
-};
-cljs.core.NodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.NodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.NodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_NodeSeq = function __GT_NodeSeq(meta, nodes, i, s, __hash) {
-  return new cljs.core.NodeSeq(meta, nodes, i, s, __hash);
-};
-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__7614 = j + 2;
-                j = G__7614;
-                continue;
-              }
-            } else {
-              var G__7615 = j + 2;
-              j = G__7615;
-              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;
-}();
-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$ = 32374860;
-};
-cljs.core.ArrayNodeSeq.cljs$lang$type = true;
-cljs.core.ArrayNodeSeq.cljs$lang$ctorStr = "cljs.core/ArrayNodeSeq";
-cljs.core.ArrayNodeSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ArrayNodeSeq");
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = this;
-  return this$__$1;
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.first.call(null, self__.s);
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_ArrayNodeSeq = function __GT_ArrayNodeSeq(meta, nodes, i, s, __hash) {
-  return new cljs.core.ArrayNodeSeq(meta, nodes, i, s, __hash);
-};
-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__7616 = j + 1;
-              j = G__7616;
-              continue;
-            }
-          } else {
-            var G__7617 = j + 1;
-            j = G__7617;
-            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;
-}();
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentHashMap");
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.TransientHashMap(function() {
-    var obj7620 = {};
-    return obj7620;
-  }(), 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 coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._lookup.call(null, coll__$1, k, null);
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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;
-  var coll__$1 = this;
-  if (k == null) {
-    if (self__.has_nil_QMARK_ && v === self__.nil_val) {
-      return coll__$1;
-    } 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__$1;
-    } 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;
-  var coll__$1 = this;
-  if (k == null) {
-    return self__.has_nil_QMARK_;
-  } else {
-    if (self__.root == null) {
-      return false;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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__7621 = null;
-  var G__7621__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7621__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(null, k, not_found);
-  };
-  G__7621 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7621__2.call(this, self__, k);
-      case 3:
-        return G__7621__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7621;
-}();
-cljs.core.PersistentHashMap.prototype.apply = function(self__, args7618) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7618)));
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
-  var self__ = this;
-  var coll__$1 = 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return init__$1;
-      } else {
-        return null;
-      }
-    }
-  }
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, entry) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (cljs.core.vector_QMARK_.call(null, entry)) {
-    return cljs.core._assoc.call(null, coll__$1, 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__$1, 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;
-  var coll__$1 = 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, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [null, self__.nil_val], null), s);
-    } else {
-      return s;
-    }
-  } else {
-    return null;
-  }
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.cnt;
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_map.call(null, coll__$1, other);
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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__$1;
-    }
-  } else {
-    if (self__.root == null) {
-      return coll__$1;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        var new_root = self__.root.inode_without(0, cljs.core.hash.call(null, k), k);
-        if (new_root === self__.root) {
-          return coll__$1;
-        } 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.__GT_PersistentHashMap = function __GT_PersistentHashMap(meta, cnt, root, has_nil_QMARK_, nil_val, __hash) {
-  return new cljs.core.PersistentHashMap(meta, cnt, root, has_nil_QMARK_, nil_val, __hash);
-};
-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__7622 = i + 1;
-      var G__7623 = cljs.core._assoc_BANG_.call(null, out, ks[i], vs[i]);
-      i = G__7622;
-      out = G__7623;
-      continue;
-    } else {
-      return cljs.core.persistent_BANG_.call(null, out);
-    }
-    break;
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientHashMap");
-};
-cljs.core.TransientHashMap.prototype.cljs$core$ITransientMap$_dissoc_BANG_$arity$2 = function(tcoll, key) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  return tcoll__$1.without_BANG_(key);
-};
-cljs.core.TransientHashMap.prototype.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3 = function(tcoll, key, val) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  return tcoll__$1.assoc_BANG_(key, val);
-};
-cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, val) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  return tcoll__$1.conj_BANG_(val);
-};
-cljs.core.TransientHashMap.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  return tcoll__$1.persistent_BANG_();
-};
-cljs.core.TransientHashMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, k) {
-  var self__ = this;
-  var tcoll__$1 = 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;
-  var tcoll__$1 = 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;
-  var coll__$1 = 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__7624 = o;
-      if (G__7624) {
-        var bit__4034__auto__ = G__7624.cljs$lang$protocol_mask$partition0$ & 2048;
-        if (bit__4034__auto__ || G__7624.cljs$core$IMapEntry$) {
-          return true;
-        } else {
-          if (!G__7624.cljs$lang$protocol_mask$partition0$) {
-            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7624);
-          } else {
-            return false;
-          }
-        }
-      } else {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__7624);
-      }
-    }()) {
-      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__7625 = cljs.core.next.call(null, es);
-          var G__7626 = tcoll__$1.assoc_BANG_(cljs.core.key.call(null, e), cljs.core.val.call(null, e));
-          es = G__7625;
-          tcoll__$1 = G__7626;
-          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.__GT_TransientHashMap = function __GT_TransientHashMap(edit, root, count, has_nil_QMARK_, nil_val) {
-  return new cljs.core.TransientHashMap(edit, root, count, has_nil_QMARK_, nil_val);
-};
-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__7627 = ascending_QMARK_ ? t.left : t.right;
-      var G__7628 = cljs.core.conj.call(null, stack__$1, t);
-      t = G__7627;
-      stack__$1 = G__7628;
-      continue;
-    } else {
-      return stack__$1;
-    }
-    break;
-  }
-};
-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$ = 32374862;
-};
-cljs.core.PersistentTreeMapSeq.cljs$lang$type = true;
-cljs.core.PersistentTreeMapSeq.cljs$lang$ctorStr = "cljs.core/PersistentTreeMapSeq";
-cljs.core.PersistentTreeMapSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentTreeMapSeq");
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-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$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = this;
-  return this$__$1;
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (self__.cnt < 0) {
-    return cljs.core.count.call(null, cljs.core.next.call(null, coll__$1)) + 1;
-  } else {
-    return self__.cnt;
-  }
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = 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 this$__$1 = 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;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_PersistentTreeMapSeq = function __GT_PersistentTreeMapSeq(meta, stack, ascending_QMARK_, cnt, __hash) {
-  return new cljs.core.PersistentTreeMapSeq(meta, stack, ascending_QMARK_, cnt, __hash);
-};
-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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (right instanceof cljs.core.RedNode && right.left instanceof cljs.core.BlackNode) {
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (left instanceof cljs.core.RedNode && left.right instanceof cljs.core.BlackNode) {
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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;
-      }
-    }
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/BlackNode");
-};
-cljs.core.BlackNode.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$2 = function(node, k) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core._nth.call(null, node__$1, k, null);
-};
-cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$3 = function(node, k, not_found) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core._nth.call(null, node__$1, k, not_found);
-};
-cljs.core.BlackNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(node, k, v) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.assoc.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), k, v);
-};
-cljs.core.BlackNode.prototype.call = function() {
-  var G__7630 = null;
-  var G__7630__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var node = self____$1;
-    return node.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7630__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(null, k, not_found);
-  };
-  G__7630 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7630__2.call(this, self__, k);
-      case 3:
-        return G__7630__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7630;
-}();
-cljs.core.BlackNode.prototype.apply = function(self__, args7629) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7629)));
-};
-cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var node = this;
-  return node.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var node = this;
-  return node.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.BlackNode.prototype.cljs$core$ICollection$_conj$arity$2 = function(node, o) {
-  var self__ = this;
-  var node__$1 = this;
-  return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val, o], null);
-};
-cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_key$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return self__.key;
-};
-cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_val$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = 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;
-  var node__$1 = this;
-  return cljs.core.ci_reduce.call(null, node__$1, f);
-};
-cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$3 = function(node, f, start) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.ci_reduce.call(null, node__$1, f, start);
-};
-cljs.core.BlackNode.prototype.cljs$core$ISeqable$_seq$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, self__.val), self__.key);
-};
-cljs.core.BlackNode.prototype.cljs$core$ICounted$_count$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return 2;
-};
-cljs.core.BlackNode.prototype.cljs$core$IStack$_peek$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return self__.val;
-};
-cljs.core.BlackNode.prototype.cljs$core$IStack$_pop$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);
-};
-cljs.core.BlackNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(node, n, v) {
-  var self__ = this;
-  var node__$1 = this;
-  return(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null)).cljs$core$IVector$_assoc_n$arity$3(null, n, v);
-};
-cljs.core.BlackNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.BlackNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(node, meta) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.with_meta.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), meta);
-};
-cljs.core.BlackNode.prototype.cljs$core$IMeta$_meta$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return null;
-};
-cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$2 = function(node, n) {
-  var self__ = this;
-  var node__$1 = this;
-  if (n === 0) {
-    return self__.key;
-  } else {
-    if (n === 1) {
-      return self__.val;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return null;
-      } else {
-        return null;
-      }
-    }
-  }
-};
-cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$3 = function(node, n, not_found) {
-  var self__ = this;
-  var node__$1 = this;
-  if (n === 0) {
-    return self__.key;
-  } else {
-    if (n === 1) {
-      return self__.val;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return not_found;
-      } else {
-        return null;
-      }
-    }
-  }
-};
-cljs.core.BlackNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.PersistentVector.EMPTY;
-};
-cljs.core.__GT_BlackNode = function __GT_BlackNode(key, val, left, right, __hash) {
-  return new cljs.core.BlackNode(key, val, left, right, __hash);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/RedNode");
-};
-cljs.core.RedNode.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$2 = function(node, k) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core._nth.call(null, node__$1, k, null);
-};
-cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$3 = function(node, k, not_found) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core._nth.call(null, node__$1, k, not_found);
-};
-cljs.core.RedNode.prototype.cljs$core$IAssociative$_assoc$arity$3 = function(node, k, v) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.assoc.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), k, v);
-};
-cljs.core.RedNode.prototype.call = function() {
-  var G__7632 = null;
-  var G__7632__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var node = self____$1;
-    return node.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7632__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(null, k, not_found);
-  };
-  G__7632 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7632__2.call(this, self__, k);
-      case 3:
-        return G__7632__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7632;
-}();
-cljs.core.RedNode.prototype.apply = function(self__, args7631) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7631)));
-};
-cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var node = this;
-  return node.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var node = this;
-  return node.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.RedNode.prototype.cljs$core$ICollection$_conj$arity$2 = function(node, o) {
-  var self__ = this;
-  var node__$1 = this;
-  return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val, o], null);
-};
-cljs.core.RedNode.prototype.cljs$core$IMapEntry$_key$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return self__.key;
-};
-cljs.core.RedNode.prototype.cljs$core$IMapEntry$_val$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = 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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        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;
-  var node__$1 = this;
-  return cljs.core.ci_reduce.call(null, node__$1, f);
-};
-cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$3 = function(node, f, start) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.ci_reduce.call(null, node__$1, f, start);
-};
-cljs.core.RedNode.prototype.cljs$core$ISeqable$_seq$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, self__.val), self__.key);
-};
-cljs.core.RedNode.prototype.cljs$core$ICounted$_count$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return 2;
-};
-cljs.core.RedNode.prototype.cljs$core$IStack$_peek$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return self__.val;
-};
-cljs.core.RedNode.prototype.cljs$core$IStack$_pop$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key], null);
-};
-cljs.core.RedNode.prototype.cljs$core$IVector$_assoc_n$arity$3 = function(node, n, v) {
-  var self__ = this;
-  var node__$1 = this;
-  return(new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null)).cljs$core$IVector$_assoc_n$arity$3(null, n, v);
-};
-cljs.core.RedNode.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.RedNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(node, meta) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.with_meta.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [self__.key, self__.val], null), meta);
-};
-cljs.core.RedNode.prototype.cljs$core$IMeta$_meta$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return null;
-};
-cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$2 = function(node, n) {
-  var self__ = this;
-  var node__$1 = this;
-  if (n === 0) {
-    return self__.key;
-  } else {
-    if (n === 1) {
-      return self__.val;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return null;
-      } else {
-        return null;
-      }
-    }
-  }
-};
-cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$3 = function(node, n, not_found) {
-  var self__ = this;
-  var node__$1 = this;
-  if (n === 0) {
-    return self__.key;
-  } else {
-    if (n === 1) {
-      return self__.val;
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return not_found;
-      } else {
-        return null;
-      }
-    }
-  }
-};
-cljs.core.RedNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(node) {
-  var self__ = this;
-  var node__$1 = this;
-  return cljs.core.PersistentVector.EMPTY;
-};
-cljs.core.__GT_RedNode = function __GT_RedNode(key, val, left, right, __hash) {
-  return new cljs.core.RedNode(key, val, left, right, __hash);
-};
-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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-            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 (!(del == null) || !(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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          var del = tree_map_remove.call(null, comp, tree.right, k, found);
-          if (!(del == null) || !(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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        return tree.replace(tk, tree.val, tree.left, tree_map_replace.call(null, comp, tree.right, k, v));
-      } else {
-        return null;
-      }
-    }
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentTreeMap");
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_imap.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, k) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._lookup.call(null, coll__$1, k, null);
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, k, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  var n = coll__$1.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 coll__$1 = 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__$1;
-    } 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;
-  var coll__$1 = this;
-  return!(coll__$1.entry_at(k) == null);
-};
-cljs.core.PersistentTreeMap.prototype.call = function() {
-  var G__7634 = null;
-  var G__7634__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7634__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(null, k, not_found);
-  };
-  G__7634 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7634__2.call(this, self__, k);
-      case 3:
-        return G__7634__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7634;
-}();
-cljs.core.PersistentTreeMap.prototype.apply = function(self__, args7633) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7633)));
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3 = function(coll, f, init) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  if (cljs.core.vector_QMARK_.call(null, entry)) {
-    return cljs.core._assoc.call(null, coll__$1, 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__$1, entry);
-  }
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IReversible$_rseq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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__7635 = t.left;
-          t = G__7635;
-          continue;
-        } else {
-          if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-            var G__7636 = t.right;
-            t = G__7636;
-            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;
-  var coll__$1 = 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;
-  var coll__$1 = 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__7637 = cljs.core.conj.call(null, stack, t);
-              var G__7638 = t.left;
-              stack = G__7637;
-              t = G__7638;
-              continue;
-            } else {
-              var G__7639 = stack;
-              var G__7640 = t.right;
-              stack = G__7639;
-              t = G__7640;
-              continue;
-            }
-          } else {
-            if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-              if (c > 0) {
-                var G__7641 = cljs.core.conj.call(null, stack, t);
-                var G__7642 = t.right;
-                stack = G__7641;
-                t = G__7642;
-                continue;
-              } else {
-                var G__7643 = stack;
-                var G__7644 = t.left;
-                stack = G__7643;
-                t = G__7644;
-                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;
-  var coll__$1 = this;
-  return cljs.core.key.call(null, entry);
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_comparator$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__.comp;
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.cnt;
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_map.call(null, coll__$1, other);
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 coll__$1 = 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__$1;
-    } 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.__GT_PersistentTreeMap = function __GT_PersistentTreeMap(comp, tree, cnt, meta, __hash) {
-  return new cljs.core.PersistentTreeMap(comp, tree, cnt, meta, __hash);
-};
-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__7645 = cljs.core.nnext.call(null, in$);
-        var G__7646 = cljs.core.assoc_BANG_.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
-        in$ = G__7645;
-        out = G__7646;
-        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__7647) {
-    var keyvals = cljs.core.seq(arglist__7647);
-    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__7648) {
-    var keyvals = cljs.core.seq(arglist__7648);
-    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 = function() {
-      var obj7652 = {};
-      return obj7652;
-    }();
-    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__7653 = cljs.core.nnext.call(null, kvs);
-        kvs = G__7653;
-        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__7654) {
-    var keyvals = cljs.core.seq(arglist__7654);
-    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__7655 = cljs.core.nnext.call(null, in$);
-        var G__7656 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
-        in$ = G__7655;
-        out = G__7656;
-        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__7657) {
-    var keyvals = cljs.core.seq(arglist__7657);
-    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__7658 = cljs.core.nnext.call(null, in$);
-        var G__7659 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$));
-        in$ = G__7658;
-        out = G__7659;
-        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__7660) {
-    var comparator = cljs.core.first(arglist__7660);
-    var keyvals = cljs.core.rest(arglist__7660);
-    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.KeySeq = function(mseq, _meta) {
-  this.mseq = mseq;
-  this._meta = _meta;
-  this.cljs$lang$protocol_mask$partition1$ = 0;
-  this.cljs$lang$protocol_mask$partition0$ = 32374988;
-};
-cljs.core.KeySeq.cljs$lang$type = true;
-cljs.core.KeySeq.cljs$lang$ctorStr = "cljs.core/KeySeq";
-cljs.core.KeySeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/KeySeq");
-};
-cljs.core.KeySeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.hash_coll.call(null, coll__$1);
-};
-cljs.core.KeySeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var nseq = function() {
-    var G__7661 = self__.mseq;
-    if (G__7661) {
-      var bit__4034__auto__ = G__7661.cljs$lang$protocol_mask$partition0$ & 128;
-      if (bit__4034__auto__ || G__7661.cljs$core$INext$) {
-        return true;
-      } else {
-        if (!G__7661.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7661);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7661);
-    }
-  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
-  if (nseq == null) {
-    return null;
-  } else {
-    return new cljs.core.KeySeq(nseq, self__._meta);
-  }
-};
-cljs.core.KeySeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-cljs.core.KeySeq.prototype.toString = function() {
-  var self__ = this;
-  var coll = this;
-  return cljs.core.pr_str_STAR_.call(null, coll);
-};
-cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.KeySeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.KeySeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.KeySeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var me = cljs.core._first.call(null, self__.mseq);
-  return cljs.core._key.call(null, me);
-};
-cljs.core.KeySeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var nseq = function() {
-    var G__7662 = self__.mseq;
-    if (G__7662) {
-      var bit__4034__auto__ = G__7662.cljs$lang$protocol_mask$partition0$ & 128;
-      if (bit__4034__auto__ || G__7662.cljs$core$INext$) {
-        return true;
-      } else {
-        if (!G__7662.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7662);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7662);
-    }
-  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
-  if (!(nseq == null)) {
-    return new cljs.core.KeySeq(nseq, self__._meta);
-  } else {
-    return cljs.core.List.EMPTY;
-  }
-};
-cljs.core.KeySeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.KeySeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.KeySeq(self__.mseq, new_meta);
-};
-cljs.core.KeySeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__._meta;
-};
-cljs.core.KeySeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__._meta);
-};
-cljs.core.__GT_KeySeq = function __GT_KeySeq(mseq, _meta) {
-  return new cljs.core.KeySeq(mseq, _meta);
-};
-cljs.core.keys = function keys(hash_map) {
-  var temp__4092__auto__ = cljs.core.seq.call(null, hash_map);
-  if (temp__4092__auto__) {
-    var mseq = temp__4092__auto__;
-    return new cljs.core.KeySeq(mseq, null);
-  } else {
-    return null;
-  }
-};
-cljs.core.key = function key(map_entry) {
-  return cljs.core._key.call(null, map_entry);
-};
-cljs.core.ValSeq = function(mseq, _meta) {
-  this.mseq = mseq;
-  this._meta = _meta;
-  this.cljs$lang$protocol_mask$partition1$ = 0;
-  this.cljs$lang$protocol_mask$partition0$ = 32374988;
-};
-cljs.core.ValSeq.cljs$lang$type = true;
-cljs.core.ValSeq.cljs$lang$ctorStr = "cljs.core/ValSeq";
-cljs.core.ValSeq.cljs$lang$ctorPrWriter = function(this__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/ValSeq");
-};
-cljs.core.ValSeq.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.hash_coll.call(null, coll__$1);
-};
-cljs.core.ValSeq.prototype.cljs$core$INext$_next$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var nseq = function() {
-    var G__7663 = self__.mseq;
-    if (G__7663) {
-      var bit__4034__auto__ = G__7663.cljs$lang$protocol_mask$partition0$ & 128;
-      if (bit__4034__auto__ || G__7663.cljs$core$INext$) {
-        return true;
-      } else {
-        if (!G__7663.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7663);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7663);
-    }
-  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
-  if (nseq == null) {
-    return null;
-  } else {
-    return new cljs.core.ValSeq(nseq, self__._meta);
-  }
-};
-cljs.core.ValSeq.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.cons.call(null, o, coll__$1);
-};
-cljs.core.ValSeq.prototype.toString = function() {
-  var self__ = this;
-  var coll = this;
-  return cljs.core.pr_str_STAR_.call(null, coll);
-};
-cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$2 = function(coll, f) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, coll__$1);
-};
-cljs.core.ValSeq.prototype.cljs$core$IReduce$_reduce$arity$3 = function(coll, f, start) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.seq_reduce.call(null, f, start, coll__$1);
-};
-cljs.core.ValSeq.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return coll__$1;
-};
-cljs.core.ValSeq.prototype.cljs$core$ISeq$_first$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var me = cljs.core._first.call(null, self__.mseq);
-  return cljs.core._val.call(null, me);
-};
-cljs.core.ValSeq.prototype.cljs$core$ISeq$_rest$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var nseq = function() {
-    var G__7664 = self__.mseq;
-    if (G__7664) {
-      var bit__4034__auto__ = G__7664.cljs$lang$protocol_mask$partition0$ & 128;
-      if (bit__4034__auto__ || G__7664.cljs$core$INext$) {
-        return true;
-      } else {
-        if (!G__7664.cljs$lang$protocol_mask$partition0$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7664);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__7664);
-    }
-  }() ? cljs.core._next.call(null, self__.mseq) : cljs.core.next.call(null, self__.mseq);
-  if (!(nseq == null)) {
-    return new cljs.core.ValSeq(nseq, self__._meta);
-  } else {
-    return cljs.core.List.EMPTY;
-  }
-};
-cljs.core.ValSeq.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(coll, other) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.equiv_sequential.call(null, coll__$1, other);
-};
-cljs.core.ValSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, new_meta) {
-  var self__ = this;
-  var coll__$1 = this;
-  return new cljs.core.ValSeq(self__.mseq, new_meta);
-};
-cljs.core.ValSeq.prototype.cljs$core$IMeta$_meta$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return self__._meta;
-};
-cljs.core.ValSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__._meta);
-};
-cljs.core.__GT_ValSeq = function __GT_ValSeq(mseq, _meta) {
-  return new cljs.core.ValSeq(mseq, _meta);
-};
-cljs.core.vals = function vals(hash_map) {
-  var temp__4092__auto__ = cljs.core.seq.call(null, hash_map);
-  if (temp__4092__auto__) {
-    var mseq = temp__4092__auto__;
-    return new cljs.core.ValSeq(mseq, null);
-  } else {
-    return null;
-  }
-};
-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__7665_SHARP_, p2__7666_SHARP_) {
-        return cljs.core.conj.call(null, function() {
-          var or__3408__auto__ = p1__7665_SHARP_;
-          if (cljs.core.truth_(or__3408__auto__)) {
-            return or__3408__auto__;
-          } else {
-            return cljs.core.PersistentArrayMap.EMPTY;
-          }
-        }(), p2__7666_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__7667) {
-    var maps = cljs.core.seq(arglist__7667);
-    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__3408__auto__ = m1;
-            if (cljs.core.truth_(or__3408__auto__)) {
-              return or__3408__auto__;
-            } else {
-              return cljs.core.PersistentArrayMap.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__7668) {
-    var f = cljs.core.first(arglist__7668);
-    var maps = cljs.core.rest(arglist__7668);
-    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.PersistentArrayMap.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, new cljs.core.Keyword("cljs.core", "not-found", "cljs.core/not-found", 4155500789));
-      var G__7669 = cljs.core.not_EQ_.call(null, entry, new cljs.core.Keyword("cljs.core", "not-found", "cljs.core/not-found", 4155500789)) ? cljs.core.assoc.call(null, ret, key, entry) : ret;
-      var G__7670 = cljs.core.next.call(null, keys);
-      ret = G__7669;
-      keys = G__7670;
-      continue;
-    } else {
-      return ret;
-    }
-    break;
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentHashSet");
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$IEditableCollection$_as_transient$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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 coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_iset.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, v) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._lookup.call(null, coll__$1, v, null);
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, v, not_found) {
-  var self__ = this;
-  var coll__$1 = this;
-  if (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__7673 = null;
-  var G__7673__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7673__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(null, k, not_found);
-  };
-  G__7673 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7673__2.call(this, self__, k);
-      case 3:
-        return G__7673__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7673;
-}();
-cljs.core.PersistentHashSet.prototype.apply = function(self__, args7672) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7672)));
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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 coll__$1 = this;
-  return cljs.core.set_QMARK_.call(null, other) && (cljs.core.count.call(null, coll__$1) === cljs.core.count.call(null, other) && cljs.core.every_QMARK_.call(null, function(p1__7671_SHARP_) {
-    return cljs.core.contains_QMARK_.call(null, coll__$1, p1__7671_SHARP_);
-  }, other));
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.PersistentHashSet.EMPTY, self__.meta);
-};
-cljs.core.__GT_PersistentHashSet = function __GT_PersistentHashSet(meta, hash_map, __hash) {
-  return new cljs.core.PersistentHashSet(meta, hash_map, __hash);
-};
-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 <= cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) {
-    var arr = no_clone ? items : cljs.core.aclone.call(null, items);
-    var i = 0;
-    var out = cljs.core.transient$.call(null, cljs.core.PersistentArrayMap.EMPTY);
-    while (true) {
-      if (i < len) {
-        var G__7674 = i + 1;
-        var G__7675 = cljs.core._assoc_BANG_.call(null, out, items[i], null);
-        i = G__7674;
-        out = G__7675;
-        continue;
-      } else {
-        return new cljs.core.PersistentHashSet(null, cljs.core._persistent_BANG_.call(null, out), null);
-      }
-      break;
-    }
-  } else {
-    var i = 0;
-    var out = cljs.core.transient$.call(null, cljs.core.PersistentHashSet.EMPTY);
-    while (true) {
-      if (i < len) {
-        var G__7676 = i + 1;
-        var G__7677 = cljs.core._conj_BANG_.call(null, out, items[i]);
-        i = G__7676;
-        out = G__7677;
-        continue;
-      } else {
-        return cljs.core._persistent_BANG_.call(null, out);
-      }
-      break;
-    }
-  }
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/TransientHashSet");
-};
-cljs.core.TransientHashSet.prototype.call = function() {
-  var G__7679 = null;
-  var G__7679__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__7679__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__7679 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7679__2.call(this, self__, k);
-      case 3:
-        return G__7679__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7679;
-}();
-cljs.core.TransientHashSet.prototype.apply = function(self__, args7678) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7678)));
-};
-cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var tcoll = this;
-  if (cljs.core._lookup.call(null, self__.transient_map, k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
-    return null;
-  } else {
-    return k;
-  }
-};
-cljs.core.TransientHashSet.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var tcoll = this;
-  if (cljs.core._lookup.call(null, self__.transient_map, k, cljs.core.lookup_sentinel) === cljs.core.lookup_sentinel) {
-    return not_found;
-  } else {
-    return k;
-  }
-};
-cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(tcoll, v) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  return cljs.core._lookup.call(null, tcoll__$1, v, null);
-};
-cljs.core.TransientHashSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(tcoll, v, not_found) {
-  var self__ = this;
-  var tcoll__$1 = 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;
-  var tcoll__$1 = 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;
-  var tcoll__$1 = this;
-  self__.transient_map = cljs.core.dissoc_BANG_.call(null, self__.transient_map, v);
-  return tcoll__$1;
-};
-cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_conj_BANG_$arity$2 = function(tcoll, o) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  self__.transient_map = cljs.core.assoc_BANG_.call(null, self__.transient_map, o, null);
-  return tcoll__$1;
-};
-cljs.core.TransientHashSet.prototype.cljs$core$ITransientCollection$_persistent_BANG_$arity$1 = function(tcoll) {
-  var self__ = this;
-  var tcoll__$1 = this;
-  return new cljs.core.PersistentHashSet(null, cljs.core.persistent_BANG_.call(null, self__.transient_map), null);
-};
-cljs.core.__GT_TransientHashSet = function __GT_TransientHashSet(transient_map) {
-  return new cljs.core.TransientHashSet(transient_map);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/PersistentTreeSet");
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$IHash$_hash$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_iset.call(null, coll__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$2 = function(coll, v) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core._lookup.call(null, coll__$1, v, null);
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$ILookup$_lookup$arity$3 = function(coll, v, not_found) {
-  var self__ = this;
-  var coll__$1 = 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__7682 = null;
-  var G__7682__2 = function(self__, k) {
-    var self__ = this;
-    var self____$1 = this;
-    var coll = self____$1;
-    return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-  };
-  var G__7682__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(null, k, not_found);
-  };
-  G__7682 = function(self__, k, not_found) {
-    switch(arguments.length) {
-      case 2:
-        return G__7682__2.call(this, self__, k);
-      case 3:
-        return G__7682__3.call(this, self__, k, not_found);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  return G__7682;
-}();
-cljs.core.PersistentTreeSet.prototype.apply = function(self__, args7681) {
-  var self__ = this;
-  var self____$1 = this;
-  return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args7681)));
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$1 = function(k) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$2(null, k);
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$IFn$_invoke$arity$2 = function(k, not_found) {
-  var self__ = this;
-  var coll = this;
-  return coll.cljs$core$ILookup$_lookup$arity$3(null, k, not_found);
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$ICollection$_conj$arity$2 = function(coll, o) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  if (cljs.core.count.call(null, self__.tree_map) > 0) {
-    return cljs.core.map.call(null, cljs.core.key, cljs.core.rseq.call(null, self__.tree_map));
-  } else {
-    return null;
-  }
-};
-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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return entry;
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$ISorted$_comparator$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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;
-  var coll__$1 = 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 coll__$1 = this;
-  return cljs.core.set_QMARK_.call(null, other) && (cljs.core.count.call(null, coll__$1) === cljs.core.count.call(null, other) && cljs.core.every_QMARK_.call(null, function(p1__7680_SHARP_) {
-    return cljs.core.contains_QMARK_.call(null, coll__$1, p1__7680_SHARP_);
-  }, other));
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(coll, meta__$1) {
-  var self__ = this;
-  var coll__$1 = 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;
-  var coll__$1 = this;
-  return self__.meta;
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(coll) {
-  var self__ = this;
-  var coll__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.PersistentTreeSet.EMPTY, self__.meta);
-};
-cljs.core.__GT_PersistentTreeSet = function __GT_PersistentTreeSet(meta, tree_map, __hash) {
-  return new cljs.core.PersistentTreeSet(meta, tree_map, __hash);
-};
-cljs.core.PersistentTreeSet.EMPTY = new cljs.core.PersistentTreeSet(null, cljs.core.PersistentTreeMap.EMPTY, 0);
-cljs.core.set_from_indexed_seq = function set_from_indexed_seq(iseq) {
-  var arr = iseq.arr;
-  var ret = function() {
-    var a__4226__auto__ = arr;
-    var i = 0;
-    var res = cljs.core._as_transient.call(null, cljs.core.PersistentHashSet.EMPTY);
-    while (true) {
-      if (i < a__4226__auto__.length) {
-        var G__7683 = i + 1;
-        var G__7684 = cljs.core._conj_BANG_.call(null, res, arr[i]);
-        i = G__7683;
-        res = G__7684;
-        continue;
-      } else {
-        return res;
-      }
-      break;
-    }
-  }();
-  return cljs.core._persistent_BANG_.call(null, ret);
-};
-cljs.core.set = function set(coll) {
-  var in$ = cljs.core.seq.call(null, coll);
-  if (in$ == null) {
-    return cljs.core.PersistentHashSet.EMPTY;
-  } else {
-    if (in$ instanceof cljs.core.IndexedSeq && in$.i === 0) {
-      return cljs.core.set_from_indexed_seq.call(null, in$);
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        var in$__$1 = in$;
-        var out = cljs.core._as_transient.call(null, cljs.core.PersistentHashSet.EMPTY);
-        while (true) {
-          if (!(in$__$1 == null)) {
-            var G__7685 = cljs.core._next.call(null, in$__$1);
-            var G__7686 = cljs.core._conj_BANG_.call(null, out, cljs.core._first.call(null, in$__$1));
-            in$__$1 = G__7685;
-            out = G__7686;
-            continue;
-          } else {
-            return cljs.core._persistent_BANG_.call(null, out);
-          }
-          break;
-        }
-      } else {
-        return null;
-      }
-    }
-  }
-};
-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__7687__delegate = function(keys) {
-      return cljs.core.set.call(null, keys);
-    };
-    var G__7687 = function(var_args) {
-      var keys = null;
-      if (arguments.length > 0) {
-        keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-      }
-      return G__7687__delegate.call(this, keys);
-    };
-    G__7687.cljs$lang$maxFixedArity = 0;
-    G__7687.cljs$lang$applyTo = function(arglist__7688) {
-      var keys = cljs.core.seq(arglist__7688);
-      return G__7687__delegate(keys);
-    };
-    G__7687.cljs$core$IFn$_invoke$arity$variadic = G__7687__delegate;
-    return G__7687;
-  }();
-  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.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__7689) {
-    var keys = cljs.core.seq(arglist__7689);
-    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__7690) {
-    var comparator = cljs.core.first(arglist__7690);
-    var keys = cljs.core.rest(arglist__7690);
-    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__7691_SHARP_) {
-      var temp__4090__auto__ = cljs.core.find.call(null, smap, p1__7691_SHARP_);
-      if (cljs.core.truth_(temp__4090__auto__)) {
-        var e = temp__4090__auto__;
-        return cljs.core.second.call(null, e);
-      } else {
-        return p1__7691_SHARP_;
-      }
-    }, coll);
-  }
-};
-cljs.core.distinct = function distinct(coll) {
-  var step = function step(xs, seen) {
-    return new cljs.core.LazySeq(null, function() {
-      return function(p__7698, seen__$1) {
-        while (true) {
-          var vec__7699 = p__7698;
-          var f = cljs.core.nth.call(null, vec__7699, 0, null);
-          var xs__$1 = vec__7699;
-          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__7700 = cljs.core.rest.call(null, s);
-              var G__7701 = seen__$1;
-              p__7698 = G__7700;
-              seen__$1 = G__7701;
-              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, 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__7702 = cljs.core.conj.call(null, ret, cljs.core.first.call(null, s__$1));
-      var G__7703 = cljs.core.next.call(null, s__$1);
-      ret = G__7702;
-      s__$1 = G__7703;
-      continue;
-    } else {
-      return cljs.core.seq.call(null, ret);
-    }
-    break;
-  }
-};
-cljs.core.name = function name(x) {
-  if (function() {
-    var G__7705 = x;
-    if (G__7705) {
-      var bit__4027__auto__ = G__7705.cljs$lang$protocol_mask$partition1$ & 4096;
-      if (bit__4027__auto__ || G__7705.cljs$core$INamed$) {
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      return false;
-    }
-  }()) {
-    return cljs.core._name.call(null, x);
-  } else {
-    if (typeof x === "string") {
-      return x;
-    } else {
-      throw new Error([cljs.core.str("Doesn't support name: "), cljs.core.str(x)].join(""));
-    }
-  }
-};
-cljs.core.zipmap = function zipmap(keys, vals) {
-  var map = cljs.core.transient$.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var ks = cljs.core.seq.call(null, keys);
-  var vs = cljs.core.seq.call(null, vals);
-  while (true) {
-    if (ks && vs) {
-      var G__7706 = cljs.core.assoc_BANG_.call(null, map, cljs.core.first.call(null, ks), cljs.core.first.call(null, vs));
-      var G__7707 = cljs.core.next.call(null, ks);
-      var G__7708 = cljs.core.next.call(null, vs);
-      map = G__7706;
-      ks = G__7707;
-      vs = G__7708;
-      continue;
-    } else {
-      return cljs.core.persistent_BANG_.call(null, 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__7711__delegate = function(k, x, y, more) {
-      return cljs.core.reduce.call(null, function(p1__7709_SHARP_, p2__7710_SHARP_) {
-        return max_key.call(null, k, p1__7709_SHARP_, p2__7710_SHARP_);
-      }, max_key.call(null, k, x, y), more);
-    };
-    var G__7711 = 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__7711__delegate.call(this, k, x, y, more);
-    };
-    G__7711.cljs$lang$maxFixedArity = 3;
-    G__7711.cljs$lang$applyTo = function(arglist__7712) {
-      var k = cljs.core.first(arglist__7712);
-      arglist__7712 = cljs.core.next(arglist__7712);
-      var x = cljs.core.first(arglist__7712);
-      arglist__7712 = cljs.core.next(arglist__7712);
-      var y = cljs.core.first(arglist__7712);
-      var more = cljs.core.rest(arglist__7712);
-      return G__7711__delegate(k, x, y, more);
-    };
-    G__7711.cljs$core$IFn$_invoke$arity$variadic = G__7711__delegate;
-    return G__7711;
-  }();
-  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__7715__delegate = function(k, x, y, more) {
-      return cljs.core.reduce.call(null, function(p1__7713_SHARP_, p2__7714_SHARP_) {
-        return min_key.call(null, k, p1__7713_SHARP_, p2__7714_SHARP_);
-      }, min_key.call(null, k, x, y), more);
-    };
-    var G__7715 = 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__7715__delegate.call(this, k, x, y, more);
-    };
-    G__7715.cljs$lang$maxFixedArity = 3;
-    G__7715.cljs$lang$applyTo = function(arglist__7716) {
-      var k = cljs.core.first(arglist__7716);
-      arglist__7716 = cljs.core.next(arglist__7716);
-      var x = cljs.core.first(arglist__7716);
-      arglist__7716 = cljs.core.next(arglist__7716);
-      var y = cljs.core.first(arglist__7716);
-      var more = cljs.core.rest(arglist__7716);
-      return G__7715__delegate(k, x, y, more);
-    };
-    G__7715.cljs$core$IFn$_invoke$arity$variadic = G__7715__delegate;
-    return G__7715;
-  }();
-  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, 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, 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, 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, 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_, cljs.core._GT__EQ_], 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__7719 = temp__4092__auto__;
-        var e = cljs.core.nth.call(null, vec__7719, 0, null);
-        var s = vec__7719;
-        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__7720 = temp__4092__auto__;
-      var e = cljs.core.nth.call(null, vec__7720, 0, null);
-      var s = vec__7720;
-      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_, cljs.core._LT__EQ_], 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__7723 = temp__4092__auto__;
-        var e = cljs.core.nth.call(null, vec__7723, 0, null);
-        var s = vec__7723;
-        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__7724 = temp__4092__auto__;
-      var e = cljs.core.nth.call(null, vec__7724, 0, null);
-      var s = vec__7724;
-      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;
-}();
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Range");
-};
-cljs.core.Range.prototype.cljs$core$IHash$_hash$arity$1 = function(rng) {
-  var self__ = this;
-  var rng__$1 = this;
-  var h__3819__auto__ = self__.__hash;
-  if (!(h__3819__auto__ == null)) {
-    return h__3819__auto__;
-  } else {
-    var h__3819__auto____$1 = cljs.core.hash_coll.call(null, rng__$1);
-    self__.__hash = h__3819__auto____$1;
-    return h__3819__auto____$1;
-  }
-};
-cljs.core.Range.prototype.cljs$core$INext$_next$arity$1 = function(rng) {
-  var self__ = this;
-  var rng__$1 = 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;
-  var rng__$1 = this;
-  return cljs.core.cons.call(null, o, rng__$1);
-};
-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;
-  var rng__$1 = this;
-  return cljs.core.ci_reduce.call(null, rng__$1, f);
-};
-cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$3 = function(rng, f, s) {
-  var self__ = this;
-  var rng__$1 = this;
-  return cljs.core.ci_reduce.call(null, rng__$1, f, s);
-};
-cljs.core.Range.prototype.cljs$core$ISeqable$_seq$arity$1 = function(rng) {
-  var self__ = this;
-  var rng__$1 = this;
-  if (self__.step > 0) {
-    if (self__.start < self__.end) {
-      return rng__$1;
-    } else {
-      return null;
-    }
-  } else {
-    if (self__.start > self__.end) {
-      return rng__$1;
-    } else {
-      return null;
-    }
-  }
-};
-cljs.core.Range.prototype.cljs$core$ICounted$_count$arity$1 = function(rng) {
-  var self__ = this;
-  var rng__$1 = this;
-  if (cljs.core.not.call(null, cljs.core._seq.call(null, rng__$1))) {
-    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;
-  var rng__$1 = this;
-  if (cljs.core._seq.call(null, rng__$1) == null) {
-    return null;
-  } else {
-    return self__.start;
-  }
-};
-cljs.core.Range.prototype.cljs$core$ISeq$_rest$arity$1 = function(rng) {
-  var self__ = this;
-  var rng__$1 = this;
-  if (!(cljs.core._seq.call(null, rng__$1) == 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;
-  var rng__$1 = this;
-  return cljs.core.equiv_sequential.call(null, rng__$1, other);
-};
-cljs.core.Range.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(rng, meta__$1) {
-  var self__ = this;
-  var rng__$1 = 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;
-  var rng__$1 = this;
-  return self__.meta;
-};
-cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$2 = function(rng, n) {
-  var self__ = this;
-  var rng__$1 = this;
-  if (n < cljs.core._count.call(null, rng__$1)) {
-    return self__.start + n * self__.step;
-  } else {
-    if (self__.start > self__.end && self__.step === 0) {
-      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;
-  var rng__$1 = this;
-  if (n < cljs.core._count.call(null, rng__$1)) {
-    return self__.start + n * self__.step;
-  } else {
-    if (self__.start > self__.end && self__.step === 0) {
-      return self__.start;
-    } else {
-      return not_found;
-    }
-  }
-};
-cljs.core.Range.prototype.cljs$core$IEmptyableCollection$_empty$arity$1 = function(rng) {
-  var self__ = this;
-  var rng__$1 = this;
-  return cljs.core.with_meta.call(null, cljs.core.List.EMPTY, self__.meta);
-};
-cljs.core.__GT_Range = function __GT_Range(meta, start, end, step, __hash) {
-  return new cljs.core.Range(meta, start, end, step, __hash);
-};
-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, 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, null);
-};
-cljs.core.split_with = function split_with(pred, coll) {
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.take_while.call(null, pred, coll), cljs.core.drop_while.call(null, pred, coll)], null);
-};
-cljs.core.partition_by = function partition_by(f, coll) {
-  return new cljs.core.LazySeq(null, 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__7725_SHARP_) {
-          return cljs.core._EQ_.call(null, fv, f.call(null, p1__7725_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, 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.PersistentArrayMap.EMPTY), coll));
-};
-cljs.core.reductions = function() {
-  var reductions = null;
-  var reductions__2 = function(f, coll) {
-    return new cljs.core.LazySeq(null, 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._conj.call(null, cljs.core.List.EMPTY, f.call(null));
-      }
-    }, null, null);
-  };
-  var reductions__3 = function(f, init, coll) {
-    return cljs.core.cons.call(null, init, new cljs.core.LazySeq(null, 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, 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__7736 = null;
-      var G__7736__0 = function() {
-        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null)], null);
-      };
-      var G__7736__1 = function(x) {
-        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x)], null);
-      };
-      var G__7736__2 = function(x, y) {
-        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y)], null);
-      };
-      var G__7736__3 = function(x, y, z) {
-        return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y, z)], null);
-      };
-      var G__7736__4 = function() {
-        var G__7737__delegate = function(x, y, z, args) {
-          return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.apply.call(null, f, x, y, z, args)], null);
-        };
-        var G__7737 = 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__7737__delegate.call(this, x, y, z, args);
-        };
-        G__7737.cljs$lang$maxFixedArity = 3;
-        G__7737.cljs$lang$applyTo = function(arglist__7738) {
-          var x = cljs.core.first(arglist__7738);
-          arglist__7738 = cljs.core.next(arglist__7738);
-          var y = cljs.core.first(arglist__7738);
-          arglist__7738 = cljs.core.next(arglist__7738);
-          var z = cljs.core.first(arglist__7738);
-          var args = cljs.core.rest(arglist__7738);
-          return G__7737__delegate(x, y, z, args);
-        };
-        G__7737.cljs$core$IFn$_invoke$arity$variadic = G__7737__delegate;
-        return G__7737;
-      }();
-      G__7736 = function(x, y, z, var_args) {
-        var args = var_args;
-        switch(arguments.length) {
-          case 0:
-            return G__7736__0.call(this);
-          case 1:
-            return G__7736__1.call(this, x);
-          case 2:
-            return G__7736__2.call(this, x, y);
-          case 3:
-            return G__7736__3.call(this, x, y, z);
-          default:
-            return G__7736__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7736.cljs$lang$maxFixedArity = 3;
-      G__7736.cljs$lang$applyTo = G__7736__4.cljs$lang$applyTo;
-      return G__7736;
-    }();
-  };
-  var juxt__2 = function(f, g) {
-    return function() {
-      var G__7739 = null;
-      var G__7739__0 = function() {
-        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null), g.call(null)], null);
-      };
-      var G__7739__1 = function(x) {
-        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x), g.call(null, x)], null);
-      };
-      var G__7739__2 = function(x, y) {
-        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y), g.call(null, x, y)], null);
-      };
-      var G__7739__3 = function(x, y, z) {
-        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y, z), g.call(null, x, y, z)], null);
-      };
-      var G__7739__4 = function() {
-        var G__7740__delegate = function(x, y, z, args) {
-          return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.apply.call(null, f, x, y, z, args), cljs.core.apply.call(null, g, x, y, z, args)], null);
-        };
-        var G__7740 = 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__7740__delegate.call(this, x, y, z, args);
-        };
-        G__7740.cljs$lang$maxFixedArity = 3;
-        G__7740.cljs$lang$applyTo = function(arglist__7741) {
-          var x = cljs.core.first(arglist__7741);
-          arglist__7741 = cljs.core.next(arglist__7741);
-          var y = cljs.core.first(arglist__7741);
-          arglist__7741 = cljs.core.next(arglist__7741);
-          var z = cljs.core.first(arglist__7741);
-          var args = cljs.core.rest(arglist__7741);
-          return G__7740__delegate(x, y, z, args);
-        };
-        G__7740.cljs$core$IFn$_invoke$arity$variadic = G__7740__delegate;
-        return G__7740;
-      }();
-      G__7739 = function(x, y, z, var_args) {
-        var args = var_args;
-        switch(arguments.length) {
-          case 0:
-            return G__7739__0.call(this);
-          case 1:
-            return G__7739__1.call(this, x);
-          case 2:
-            return G__7739__2.call(this, x, y);
-          case 3:
-            return G__7739__3.call(this, x, y, z);
-          default:
-            return G__7739__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7739.cljs$lang$maxFixedArity = 3;
-      G__7739.cljs$lang$applyTo = G__7739__4.cljs$lang$applyTo;
-      return G__7739;
-    }();
-  };
-  var juxt__3 = function(f, g, h) {
-    return function() {
-      var G__7742 = null;
-      var G__7742__0 = function() {
-        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null), g.call(null), h.call(null)], null);
-      };
-      var G__7742__1 = function(x) {
-        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x), g.call(null, x), h.call(null, x)], null);
-      };
-      var G__7742__2 = function(x, y) {
-        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y), g.call(null, x, y), h.call(null, x, y)], null);
-      };
-      var G__7742__3 = function(x, y, z) {
-        return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x, y, z), g.call(null, x, y, z), h.call(null, x, y, z)], null);
-      };
-      var G__7742__4 = function() {
-        var G__7743__delegate = function(x, y, z, args) {
-          return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [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)], null);
-        };
-        var G__7743 = 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__7743__delegate.call(this, x, y, z, args);
-        };
-        G__7743.cljs$lang$maxFixedArity = 3;
-        G__7743.cljs$lang$applyTo = function(arglist__7744) {
-          var x = cljs.core.first(arglist__7744);
-          arglist__7744 = cljs.core.next(arglist__7744);
-          var y = cljs.core.first(arglist__7744);
-          arglist__7744 = cljs.core.next(arglist__7744);
-          var z = cljs.core.first(arglist__7744);
-          var args = cljs.core.rest(arglist__7744);
-          return G__7743__delegate(x, y, z, args);
-        };
-        G__7743.cljs$core$IFn$_invoke$arity$variadic = G__7743__delegate;
-        return G__7743;
-      }();
-      G__7742 = function(x, y, z, var_args) {
-        var args = var_args;
-        switch(arguments.length) {
-          case 0:
-            return G__7742__0.call(this);
-          case 1:
-            return G__7742__1.call(this, x);
-          case 2:
-            return G__7742__2.call(this, x, y);
-          case 3:
-            return G__7742__3.call(this, x, y, z);
-          default:
-            return G__7742__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
-        }
-        throw new Error("Invalid arity: " + arguments.length);
-      };
-      G__7742.cljs$lang$maxFixedArity = 3;
-      G__7742.cljs$lang$applyTo = G__7742__4.cljs$lang$applyTo;
-      return G__7742;
-    }();
-  };
-  var juxt__4 = function() {
-    var G__7745__delegate = function(f, g, h, fs) {
-      var fs__$1 = cljs.core.list_STAR_.call(null, f, g, h, fs);
-      return function() {
-        var G__7746 = null;
-        var G__7746__0 = function() {
-          return cljs.core.reduce.call(null, function(p1__7726_SHARP_, p2__7727_SHARP_) {
-            return cljs.core.conj.call(null, p1__7726_SHARP_, p2__7727_SHARP_.call(null));
-          }, cljs.core.PersistentVector.EMPTY, fs__$1);
-        };
-        var G__7746__1 = function(x) {
-          return cljs.core.reduce.call(null, function(p1__7728_SHARP_, p2__7729_SHARP_) {
-            return cljs.core.conj.call(null, p1__7728_SHARP_, p2__7729_SHARP_.call(null, x));
-          }, cljs.core.PersistentVector.EMPTY, fs__$1);
-        };
-        var G__7746__2 = function(x, y) {
-          return cljs.core.reduce.call(null, function(p1__7730_SHARP_, p2__7731_SHARP_) {
-            return cljs.core.conj.call(null, p1__7730_SHARP_, p2__7731_SHARP_.call(null, x, y));
-          }, cljs.core.PersistentVector.EMPTY, fs__$1);
-        };
-        var G__7746__3 = function(x, y, z) {
-          return cljs.core.reduce.call(null, function(p1__7732_SHARP_, p2__7733_SHARP_) {
-            return cljs.core.conj.call(null, p1__7732_SHARP_, p2__7733_SHARP_.call(null, x, y, z));
-          }, cljs.core.PersistentVector.EMPTY, fs__$1);
-        };
-        var G__7746__4 = function() {
-          var G__7747__delegate = function(x, y, z, args) {
-            return cljs.core.reduce.call(null, function(p1__7734_SHARP_, p2__7735_SHARP_) {
-              return cljs.core.conj.call(null, p1__7734_SHARP_, cljs.core.apply.call(null, p2__7735_SHARP_, x, y, z, args));
-            }, cljs.core.PersistentVector.EMPTY, fs__$1);
-          };
-          var G__7747 = 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__7747__delegate.call(this, x, y, z, args);
-          };
-          G__7747.cljs$lang$maxFixedArity = 3;
-          G__7747.cljs$lang$applyTo = function(arglist__7748) {
-            var x = cljs.core.first(arglist__7748);
-            arglist__7748 = cljs.core.next(arglist__7748);
-            var y = cljs.core.first(arglist__7748);
-            arglist__7748 = cljs.core.next(arglist__7748);
-            var z = cljs.core.first(arglist__7748);
-            var args = cljs.core.rest(arglist__7748);
-            return G__7747__delegate(x, y, z, args);
-          };
-          G__7747.cljs$core$IFn$_invoke$arity$variadic = G__7747__delegate;
-          return G__7747;
-        }();
-        G__7746 = function(x, y, z, var_args) {
-          var args = var_args;
-          switch(arguments.length) {
-            case 0:
-              return G__7746__0.call(this);
-            case 1:
-              return G__7746__1.call(this, x);
-            case 2:
-              return G__7746__2.call(this, x, y);
-            case 3:
-              return G__7746__3.call(this, x, y, z);
-            default:
-              return G__7746__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3));
-          }
-          throw new Error("Invalid arity: " + arguments.length);
-        };
-        G__7746.cljs$lang$maxFixedArity = 3;
-        G__7746.cljs$lang$applyTo = G__7746__4.cljs$lang$applyTo;
-        return G__7746;
-      }();
-    };
-    var G__7745 = 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__7745__delegate.call(this, f, g, h, fs);
-    };
-    G__7745.cljs$lang$maxFixedArity = 3;
-    G__7745.cljs$lang$applyTo = function(arglist__7749) {
-      var f = cljs.core.first(arglist__7749);
-      arglist__7749 = cljs.core.next(arglist__7749);
-      var g = cljs.core.first(arglist__7749);
-      arglist__7749 = cljs.core.next(arglist__7749);
-      var h = cljs.core.first(arglist__7749);
-      var fs = cljs.core.rest(arglist__7749);
-      return G__7745__delegate(f, g, h, fs);
-    };
-    G__7745.cljs$core$IFn$_invoke$arity$variadic = G__7745__delegate;
-    return G__7745;
-  }();
-  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__7750 = cljs.core.next.call(null, coll);
-        coll = G__7750;
-        continue;
-      } else {
-        return null;
-      }
-      break;
-    }
-  };
-  var dorun__2 = function(n, coll) {
-    while (true) {
-      if (cljs.core.seq.call(null, coll) && n > 0) {
-        var G__7751 = n - 1;
-        var G__7752 = cljs.core.next.call(null, coll);
-        n = G__7751;
-        coll = G__7752;
-        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, function() {
-      return cljs.core.cons.call(null, match_data, cljs.core.seq.call(null, post_match) ? re_seq.call(null, re, post_match) : null);
-    }, null, null);
-  } else {
-    return null;
-  }
-};
-cljs.core.re_pattern = function re_pattern(s) {
-  var vec__7754 = cljs.core.re_find.call(null, /^(?:\(\?([idmsux]*)\))?(.*)/, s);
-  var _ = cljs.core.nth.call(null, vec__7754, 0, null);
-  var flags = cljs.core.nth.call(null, vec__7754, 1, null);
-  var pattern = cljs.core.nth.call(null, vec__7754, 2, null);
-  return new RegExp(pattern, flags);
-};
-cljs.core.pr_sequential_writer = function pr_sequential_writer(writer, print_one, begin, sep, end, opts, coll) {
-  var _STAR_print_level_STAR_7756 = cljs.core._STAR_print_level_STAR_;
-  try {
-    cljs.core._STAR_print_level_STAR_ = cljs.core._STAR_print_level_STAR_ == null ? null : cljs.core._STAR_print_level_STAR_ - 1;
-    if (!(cljs.core._STAR_print_level_STAR_ == null) && cljs.core._STAR_print_level_STAR_ < 0) {
-      return cljs.core._write.call(null, writer, "#");
-    } else {
-      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 coll_7757__$1 = cljs.core.next.call(null, coll);
-      var n_7758 = (new cljs.core.Keyword(null, "print-length", "print-length", 3960797560)).cljs$core$IFn$_invoke$arity$1(opts);
-      while (true) {
-        if (coll_7757__$1 && (n_7758 == null || !(n_7758 === 0))) {
-          cljs.core._write.call(null, writer, sep);
-          print_one.call(null, cljs.core.first.call(null, coll_7757__$1), writer, opts);
-          var G__7759 = cljs.core.next.call(null, coll_7757__$1);
-          var G__7760 = n_7758 - 1;
-          coll_7757__$1 = G__7759;
-          n_7758 = G__7760;
-          continue;
-        } else {
-        }
-        break;
-      }
-      if (cljs.core.truth_((new cljs.core.Keyword(null, "print-length", "print-length", 3960797560)).cljs$core$IFn$_invoke$arity$1(opts))) {
-        cljs.core._write.call(null, writer, sep);
-        print_one.call(null, "...", writer, opts);
-      } else {
-      }
-      return cljs.core._write.call(null, writer, end);
-    }
-  } finally {
-    cljs.core._STAR_print_level_STAR_ = _STAR_print_level_STAR_7756;
-  }
-};
-cljs.core.write_all = function() {
-  var write_all__delegate = function(writer, ss) {
-    var seq__7765 = cljs.core.seq.call(null, ss);
-    var chunk__7766 = null;
-    var count__7767 = 0;
-    var i__7768 = 0;
-    while (true) {
-      if (i__7768 < count__7767) {
-        var s = cljs.core._nth.call(null, chunk__7766, i__7768);
-        cljs.core._write.call(null, writer, s);
-        var G__7769 = seq__7765;
-        var G__7770 = chunk__7766;
-        var G__7771 = count__7767;
-        var G__7772 = i__7768 + 1;
-        seq__7765 = G__7769;
-        chunk__7766 = G__7770;
-        count__7767 = G__7771;
-        i__7768 = G__7772;
-        continue;
-      } else {
-        var temp__4092__auto__ = cljs.core.seq.call(null, seq__7765);
-        if (temp__4092__auto__) {
-          var seq__7765__$1 = temp__4092__auto__;
-          if (cljs.core.chunked_seq_QMARK_.call(null, seq__7765__$1)) {
-            var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__7765__$1);
-            var G__7773 = cljs.core.chunk_rest.call(null, seq__7765__$1);
-            var G__7774 = c__4132__auto__;
-            var G__7775 = cljs.core.count.call(null, c__4132__auto__);
-            var G__7776 = 0;
-            seq__7765 = G__7773;
-            chunk__7766 = G__7774;
-            count__7767 = G__7775;
-            i__7768 = G__7776;
-            continue;
-          } else {
-            var s = cljs.core.first.call(null, seq__7765__$1);
-            cljs.core._write.call(null, writer, s);
-            var G__7777 = cljs.core.next.call(null, seq__7765__$1);
-            var G__7778 = null;
-            var G__7779 = 0;
-            var G__7780 = 0;
-            seq__7765 = G__7777;
-            chunk__7766 = G__7778;
-            count__7767 = G__7779;
-            i__7768 = G__7780;
-            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__7781) {
-    var writer = cljs.core.first(arglist__7781);
-    var ss = cljs.core.rest(arglist__7781);
-    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 = function() {
-  var obj7783 = {'"':'\\"', "\\":"\\\\", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t"};
-  return obj7783;
-}();
-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, "#\x3cundefined\x3e");
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        if (cljs.core.truth_(function() {
-          var and__3396__auto__ = cljs.core.get.call(null, opts, new cljs.core.Keyword(null, "meta", "meta", 1017252215));
-          if (cljs.core.truth_(and__3396__auto__)) {
-            var and__3396__auto____$1 = function() {
-              var G__7789 = obj;
-              if (G__7789) {
-                var bit__4034__auto__ = G__7789.cljs$lang$protocol_mask$partition0$ & 131072;
-                if (bit__4034__auto__ || G__7789.cljs$core$IMeta$) {
-                  return true;
-                } else {
-                  if (!G__7789.cljs$lang$protocol_mask$partition0$) {
-                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7789);
-                  } else {
-                    return false;
-                  }
-                }
-              } else {
-                return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__7789);
-              }
-            }();
-            if (and__3396__auto____$1) {
-              return cljs.core.meta.call(null, obj);
-            } else {
-              return and__3396__auto____$1;
-            }
-          } else {
-            return and__3396__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__7790 = obj;
-              if (G__7790) {
-                var bit__4027__auto__ = G__7790.cljs$lang$protocol_mask$partition0$ & 2147483648;
-                if (bit__4027__auto__ || G__7790.cljs$core$IPrintWithWriter$) {
-                  return true;
-                } else {
-                  return false;
-                }
-              } else {
-                return false;
-              }
-            }()) {
-              return cljs.core._pr_writer.call(null, obj, writer, opts);
-            } else {
-              if (cljs.core.type.call(null, obj) === Boolean || typeof obj === "number") {
-                return cljs.core._write.call(null, writer, [cljs.core.str(obj)].join(""));
-              } else {
-                if (cljs.core.object_QMARK_.call(null, obj)) {
-                  cljs.core._write.call(null, writer, "#js ");
-                  return cljs.core.print_map.call(null, cljs.core.map.call(null, function(k) {
-                    return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k), obj[k]], null);
-                  }, cljs.core.js_keys.call(null, obj)), pr_writer, writer, opts);
-                } else {
-                  if (obj instanceof Array) {
-                    return cljs.core.pr_sequential_writer.call(null, writer, pr_writer, "#js [", " ", "]", opts, obj);
-                  } else {
-                    if (goog.isString(obj)) {
-                      if (cljs.core.truth_((new cljs.core.Keyword(null, "readably", "readably", 4441712502)).cljs$core$IFn$_invoke$arity$1(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 {
-                      if (cljs.core.fn_QMARK_.call(null, obj)) {
-                        return cljs.core.write_all.call(null, writer, "#\x3c", [cljs.core.str(obj)].join(""), "\x3e");
-                      } 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__7792 = [cljs.core.str("0"), cljs.core.str(ns)].join("");
-                                ns = G__7792;
-                                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.regexp_QMARK_.call(null, obj)) {
-                            return cljs.core.write_all.call(null, writer, '#"', obj.source, '"');
-                          } else {
-                            if (function() {
-                              var G__7791 = obj;
-                              if (G__7791) {
-                                var bit__4034__auto__ = G__7791.cljs$lang$protocol_mask$partition0$ & 2147483648;
-                                if (bit__4034__auto__ || G__7791.cljs$core$IPrintWithWriter$) {
-                                  return true;
-                                } else {
-                                  if (!G__7791.cljs$lang$protocol_mask$partition0$) {
-                                    return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IPrintWithWriter, G__7791);
-                                  } else {
-                                    return false;
-                                  }
-                                }
-                              } else {
-                                return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IPrintWithWriter, G__7791);
-                              }
-                            }()) {
-                              return cljs.core._pr_writer.call(null, obj, writer, opts);
-                            } else {
-                              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                                return cljs.core.write_all.call(null, writer, "#\x3c", [cljs.core.str(obj)].join(""), "\x3e");
-                              } 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__7797 = cljs.core.seq.call(null, cljs.core.next.call(null, objs));
-  var chunk__7798 = null;
-  var count__7799 = 0;
-  var i__7800 = 0;
-  while (true) {
-    if (i__7800 < count__7799) {
-      var obj = cljs.core._nth.call(null, chunk__7798, i__7800);
-      cljs.core._write.call(null, writer, " ");
-      cljs.core.pr_writer.call(null, obj, writer, opts);
-      var G__7801 = seq__7797;
-      var G__7802 = chunk__7798;
-      var G__7803 = count__7799;
-      var G__7804 = i__7800 + 1;
-      seq__7797 = G__7801;
-      chunk__7798 = G__7802;
-      count__7799 = G__7803;
-      i__7800 = G__7804;
-      continue;
-    } else {
-      var temp__4092__auto__ = cljs.core.seq.call(null, seq__7797);
-      if (temp__4092__auto__) {
-        var seq__7797__$1 = temp__4092__auto__;
-        if (cljs.core.chunked_seq_QMARK_.call(null, seq__7797__$1)) {
-          var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__7797__$1);
-          var G__7805 = cljs.core.chunk_rest.call(null, seq__7797__$1);
-          var G__7806 = c__4132__auto__;
-          var G__7807 = cljs.core.count.call(null, c__4132__auto__);
-          var G__7808 = 0;
-          seq__7797 = G__7805;
-          chunk__7798 = G__7806;
-          count__7799 = G__7807;
-          i__7800 = G__7808;
-          continue;
-        } else {
-          var obj = cljs.core.first.call(null, seq__7797__$1);
-          cljs.core._write.call(null, writer, " ");
-          cljs.core.pr_writer.call(null, obj, writer, opts);
-          var G__7809 = cljs.core.next.call(null, seq__7797__$1);
-          var G__7810 = null;
-          var G__7811 = 0;
-          var G__7812 = 0;
-          seq__7797 = G__7809;
-          chunk__7798 = G__7810;
-          count__7799 = G__7811;
-          i__7800 = G__7812;
-          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, new cljs.core.Keyword(null, "flush-on-newline", "flush-on-newline", 4338025857)))) {
-    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__7813) {
-    var objs = cljs.core.seq(arglist__7813);
-    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__7814) {
-    var objs = cljs.core.seq(arglist__7814);
-    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__7815) {
-    var objs = cljs.core.seq(arglist__7815);
-    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), 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__7816) {
-    var objs = cljs.core.seq(arglist__7816);
-    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), 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__7817) {
-    var objs = cljs.core.seq(arglist__7817);
-    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), false));
-    if (cljs.core.truth_(cljs.core._STAR_print_newline_STAR_)) {
-      return cljs.core.newline.call(null, cljs.core.pr_opts.call(null));
-    } else {
-      return 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__7818) {
-    var objs = cljs.core.seq(arglist__7818);
-    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), new cljs.core.Keyword(null, "readably", "readably", 4441712502), 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__7819) {
-    var objs = cljs.core.seq(arglist__7819);
-    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));
-    if (cljs.core.truth_(cljs.core._STAR_print_newline_STAR_)) {
-      return cljs.core.newline.call(null, cljs.core.pr_opts.call(null));
-    } else {
-      return 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__7820) {
-    var objs = cljs.core.seq(arglist__7820);
-    return prn__delegate(objs);
-  };
-  prn.cljs$core$IFn$_invoke$arity$variadic = prn__delegate;
-  return prn;
-}();
-cljs.core.print_map = function print_map(m, print_one, writer, opts) {
-  return cljs.core.pr_sequential_writer.call(null, writer, function(e, w, opts__$1) {
-    print_one.call(null, cljs.core.key.call(null, e), w, opts__$1);
-    cljs.core._write.call(null, w, " ");
-    return print_one.call(null, cljs.core.val.call(null, e), w, opts__$1);
-  }, "{", ", ", "}", opts, cljs.core.seq.call(null, m));
-};
-cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.KeySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.IndexedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.Subvec.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
-};
-cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.ChunkedCons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentTreeMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
-};
-cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentArrayMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
-};
-cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentQueue.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#queue [", " ", "]", opts, cljs.core.seq.call(null, coll__$1));
-};
-cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.LazySeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.RSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentTreeSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#{", " ", "}", opts, coll__$1);
-};
-cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.NodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.RedNode.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
-};
-cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.ChunkedSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentHashMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
-};
-cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentHashSet.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "#{", " ", "}", opts, coll__$1);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentVector.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
-};
-cljs.core.List.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.List.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentArrayMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.EmptyList.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  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) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "[", " ", "]", opts, coll__$1);
-};
-cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.Cons.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.Range.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.Range.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.ArrayNodeSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.ValSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.ObjMap.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.print_map.call(null, coll__$1, cljs.core.pr_writer, writer, opts);
-};
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$ = true;
-cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(coll, writer, opts) {
-  var coll__$1 = this;
-  return cljs.core.pr_sequential_writer.call(null, writer, cljs.core.pr_writer, "(", " ", ")", opts, coll__$1);
-};
-cljs.core.PersistentVector.prototype.cljs$core$IComparable$ = true;
-cljs.core.PersistentVector.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
-  var x__$1 = this;
-  return cljs.core.compare_indexed.call(null, x__$1, y);
-};
-cljs.core.Subvec.prototype.cljs$core$IComparable$ = true;
-cljs.core.Subvec.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
-  var x__$1 = this;
-  return cljs.core.compare_indexed.call(null, x__$1, y);
-};
-cljs.core.Keyword.prototype.cljs$core$IComparable$ = true;
-cljs.core.Keyword.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
-  var x__$1 = this;
-  return cljs.core.compare_symbols.call(null, x__$1, y);
-};
-cljs.core.Symbol.prototype.cljs$core$IComparable$ = true;
-cljs.core.Symbol.prototype.cljs$core$IComparable$_compare$arity$2 = function(x, y) {
-  var x__$1 = this;
-  return cljs.core.compare_symbols.call(null, x__$1, y);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Atom");
-};
-cljs.core.Atom.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = this;
-  return goog.getUid(this$__$1);
-};
-cljs.core.Atom.prototype.cljs$core$IWatchable$_notify_watches$arity$3 = function(this$, oldval, newval) {
-  var self__ = this;
-  var this$__$1 = this;
-  var seq__7821 = cljs.core.seq.call(null, self__.watches);
-  var chunk__7822 = null;
-  var count__7823 = 0;
-  var i__7824 = 0;
-  while (true) {
-    if (i__7824 < count__7823) {
-      var vec__7825 = cljs.core._nth.call(null, chunk__7822, i__7824);
-      var key = cljs.core.nth.call(null, vec__7825, 0, null);
-      var f = cljs.core.nth.call(null, vec__7825, 1, null);
-      f.call(null, key, this$__$1, oldval, newval);
-      var G__7827 = seq__7821;
-      var G__7828 = chunk__7822;
-      var G__7829 = count__7823;
-      var G__7830 = i__7824 + 1;
-      seq__7821 = G__7827;
-      chunk__7822 = G__7828;
-      count__7823 = G__7829;
-      i__7824 = G__7830;
-      continue;
-    } else {
-      var temp__4092__auto__ = cljs.core.seq.call(null, seq__7821);
-      if (temp__4092__auto__) {
-        var seq__7821__$1 = temp__4092__auto__;
-        if (cljs.core.chunked_seq_QMARK_.call(null, seq__7821__$1)) {
-          var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__7821__$1);
-          var G__7831 = cljs.core.chunk_rest.call(null, seq__7821__$1);
-          var G__7832 = c__4132__auto__;
-          var G__7833 = cljs.core.count.call(null, c__4132__auto__);
-          var G__7834 = 0;
-          seq__7821 = G__7831;
-          chunk__7822 = G__7832;
-          count__7823 = G__7833;
-          i__7824 = G__7834;
-          continue;
-        } else {
-          var vec__7826 = cljs.core.first.call(null, seq__7821__$1);
-          var key = cljs.core.nth.call(null, vec__7826, 0, null);
-          var f = cljs.core.nth.call(null, vec__7826, 1, null);
-          f.call(null, key, this$__$1, oldval, newval);
-          var G__7835 = cljs.core.next.call(null, seq__7821__$1);
-          var G__7836 = null;
-          var G__7837 = 0;
-          var G__7838 = 0;
-          seq__7821 = G__7835;
-          chunk__7822 = G__7836;
-          count__7823 = G__7837;
-          i__7824 = G__7838;
-          continue;
-        }
-      } else {
-        return null;
-      }
-    }
-    break;
-  }
-};
-cljs.core.Atom.prototype.cljs$core$IWatchable$_add_watch$arity$3 = function(this$, key, f) {
-  var self__ = this;
-  var this$__$1 = this;
-  return this$__$1.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;
-  var this$__$1 = this;
-  return this$__$1.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;
-  var a__$1 = this;
-  cljs.core._write.call(null, writer, "#\x3cAtom: ");
-  cljs.core.pr_writer.call(null, self__.state, writer, opts);
-  return cljs.core._write.call(null, writer, "\x3e");
-};
-cljs.core.Atom.prototype.cljs$core$IMeta$_meta$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.meta;
-};
-cljs.core.Atom.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return self__.state;
-};
-cljs.core.Atom.prototype.cljs$core$IEquiv$_equiv$arity$2 = function(o, other) {
-  var self__ = this;
-  var o__$1 = this;
-  return o__$1 === other;
-};
-cljs.core.__GT_Atom = function __GT_Atom(state, meta, validator, watches) {
-  return new cljs.core.Atom(state, meta, validator, watches);
-};
-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__7842__delegate = function(x, p__7839) {
-      var map__7841 = p__7839;
-      var map__7841__$1 = cljs.core.seq_QMARK_.call(null, map__7841) ? cljs.core.apply.call(null, cljs.core.hash_map, map__7841) : map__7841;
-      var validator = cljs.core.get.call(null, map__7841__$1, new cljs.core.Keyword(null, "validator", "validator", 4199087812));
-      var meta = cljs.core.get.call(null, map__7841__$1, new cljs.core.Keyword(null, "meta", "meta", 1017252215));
-      return new cljs.core.Atom(x, meta, validator, null);
-    };
-    var G__7842 = function(x, var_args) {
-      var p__7839 = null;
-      if (arguments.length > 1) {
-        p__7839 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
-      }
-      return G__7842__delegate.call(this, x, p__7839);
-    };
-    G__7842.cljs$lang$maxFixedArity = 1;
-    G__7842.cljs$lang$applyTo = function(arglist__7843) {
-      var x = cljs.core.first(arglist__7843);
-      var p__7839 = cljs.core.rest(arglist__7843);
-      return G__7842__delegate(x, p__7839);
-    };
-    G__7842.cljs$core$IFn$_invoke$arity$variadic = G__7842__delegate;
-    return G__7842;
-  }();
-  atom = function(x, var_args) {
-    var p__7839 = 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 validate_7844 = a.validator;
-  if (validate_7844 == null) {
-  } else {
-    if (cljs.core.truth_(validate_7844.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.list(new cljs.core.Symbol(null, "validate", "validate", 1233162959, null), new cljs.core.Symbol(null, "new-value", "new-value", 972165309, null))))].join(""));
-    }
-  }
-  var old_value_7845 = a.state;
-  a.state = new_value;
-  if (a.watches == null) {
-  } else {
-    cljs.core._notify_watches.call(null, a, old_value_7845, 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__7846__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__7846 = 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__7846__delegate.call(this, a, f, x, y, z, more);
-    };
-    G__7846.cljs$lang$maxFixedArity = 5;
-    G__7846.cljs$lang$applyTo = function(arglist__7847) {
-      var a = cljs.core.first(arglist__7847);
-      arglist__7847 = cljs.core.next(arglist__7847);
-      var f = cljs.core.first(arglist__7847);
-      arglist__7847 = cljs.core.next(arglist__7847);
-      var x = cljs.core.first(arglist__7847);
-      arglist__7847 = cljs.core.next(arglist__7847);
-      var y = cljs.core.first(arglist__7847);
-      arglist__7847 = cljs.core.next(arglist__7847);
-      var z = cljs.core.first(arglist__7847);
-      var more = cljs.core.rest(arglist__7847);
-      return G__7846__delegate(a, f, x, y, z, more);
-    };
-    G__7846.cljs$core$IFn$_invoke$arity$variadic = G__7846__delegate;
-    return G__7846;
-  }();
-  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__7848) {
-    var iref = cljs.core.first(arglist__7848);
-    arglist__7848 = cljs.core.next(arglist__7848);
-    var f = cljs.core.first(arglist__7848);
-    var args = cljs.core.rest(arglist__7848);
-    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;
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/Delay");
-};
-cljs.core.Delay.prototype.cljs$core$IPending$_realized_QMARK_$arity$1 = function(d) {
-  var self__ = this;
-  var d__$1 = this;
-  return(new cljs.core.Keyword(null, "done", "done", 1016993524)).cljs$core$IFn$_invoke$arity$1(cljs.core.deref.call(null, self__.state));
-};
-cljs.core.Delay.prototype.cljs$core$IDeref$_deref$arity$1 = function(_) {
-  var self__ = this;
-  var ___$1 = this;
-  return(new cljs.core.Keyword(null, "value", "value", 1125876963)).cljs$core$IFn$_invoke$arity$1(cljs.core.swap_BANG_.call(null, self__.state, function(p__7849) {
-    var map__7850 = p__7849;
-    var map__7850__$1 = cljs.core.seq_QMARK_.call(null, map__7850) ? cljs.core.apply.call(null, cljs.core.hash_map, map__7850) : map__7850;
-    var curr_state = map__7850__$1;
-    var done = cljs.core.get.call(null, map__7850__$1, new cljs.core.Keyword(null, "done", "done", 1016993524));
-    if (cljs.core.truth_(done)) {
-      return curr_state;
-    } else {
-      return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "done", "done", 1016993524), true, new cljs.core.Keyword(null, "value", "value", 1125876963), self__.f.call(null)], null);
-    }
-  }));
-};
-cljs.core.__GT_Delay = function __GT_Delay(state, f) {
-  return new cljs.core.Delay(state, f);
-};
-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 = function() {
-  var obj7852 = {};
-  return obj7852;
-}();
-cljs.core._clj__GT_js = function _clj__GT_js(x) {
-  if (function() {
-    var and__3396__auto__ = x;
-    if (and__3396__auto__) {
-      return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x);
-  } else {
-    var x__4011__auto__ = x == null ? null : x;
-    return function() {
-      var or__3408__auto__ = cljs.core._clj__GT_js[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._clj__GT_js["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IEncodeJS.-clj-\x3ejs", x);
-        }
-      }
-    }().call(null, x);
-  }
-};
-cljs.core._key__GT_js = function _key__GT_js(x) {
-  if (function() {
-    var and__3396__auto__ = x;
-    if (and__3396__auto__) {
-      return x.cljs$core$IEncodeJS$_key__GT_js$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x);
-  } else {
-    var x__4011__auto__ = x == null ? null : x;
-    return function() {
-      var or__3408__auto__ = cljs.core._key__GT_js[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._key__GT_js["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IEncodeJS.-key-\x3ejs", x);
-        }
-      }
-    }().call(null, x);
-  }
-};
-cljs.core.key__GT_js = function key__GT_js(k) {
-  if (function() {
-    var G__7854 = k;
-    if (G__7854) {
-      var bit__4034__auto__ = null;
-      if (cljs.core.truth_(function() {
-        var or__3408__auto__ = bit__4034__auto__;
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          return G__7854.cljs$core$IEncodeJS$;
-        }
-      }())) {
-        return true;
-      } else {
-        if (!G__7854.cljs$lang$protocol_mask$partition$) {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7854);
-        } else {
-          return false;
-        }
-      }
-    } else {
-      return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7854);
-    }
-  }()) {
-    return cljs.core._clj__GT_js.call(null, k);
-  } else {
-    if (typeof k === "string" || (typeof k === "number" || (k instanceof cljs.core.Keyword || 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__7868 = x;
-      if (G__7868) {
-        var bit__4034__auto__ = null;
-        if (cljs.core.truth_(function() {
-          var or__3408__auto__ = bit__4034__auto__;
-          if (cljs.core.truth_(or__3408__auto__)) {
-            return or__3408__auto__;
-          } else {
-            return G__7868.cljs$core$IEncodeJS$;
-          }
-        }())) {
-          return true;
-        } else {
-          if (!G__7868.cljs$lang$protocol_mask$partition$) {
-            return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7868);
-          } else {
-            return false;
-          }
-        }
-      } else {
-        return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__7868);
-      }
-    }()) {
-      return cljs.core._clj__GT_js.call(null, x);
-    } else {
-      if (x instanceof cljs.core.Keyword) {
-        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 = function() {
-              var obj7870 = {};
-              return obj7870;
-            }();
-            var seq__7871_7881 = cljs.core.seq.call(null, x);
-            var chunk__7872_7882 = null;
-            var count__7873_7883 = 0;
-            var i__7874_7884 = 0;
-            while (true) {
-              if (i__7874_7884 < count__7873_7883) {
-                var vec__7875_7885 = cljs.core._nth.call(null, chunk__7872_7882, i__7874_7884);
-                var k_7886 = cljs.core.nth.call(null, vec__7875_7885, 0, null);
-                var v_7887 = cljs.core.nth.call(null, vec__7875_7885, 1, null);
-                m[cljs.core.key__GT_js.call(null, k_7886)] = clj__GT_js.call(null, v_7887);
-                var G__7888 = seq__7871_7881;
-                var G__7889 = chunk__7872_7882;
-                var G__7890 = count__7873_7883;
-                var G__7891 = i__7874_7884 + 1;
-                seq__7871_7881 = G__7888;
-                chunk__7872_7882 = G__7889;
-                count__7873_7883 = G__7890;
-                i__7874_7884 = G__7891;
-                continue;
-              } else {
-                var temp__4092__auto___7892 = cljs.core.seq.call(null, seq__7871_7881);
-                if (temp__4092__auto___7892) {
-                  var seq__7871_7893__$1 = temp__4092__auto___7892;
-                  if (cljs.core.chunked_seq_QMARK_.call(null, seq__7871_7893__$1)) {
-                    var c__4132__auto___7894 = cljs.core.chunk_first.call(null, seq__7871_7893__$1);
-                    var G__7895 = cljs.core.chunk_rest.call(null, seq__7871_7893__$1);
-                    var G__7896 = c__4132__auto___7894;
-                    var G__7897 = cljs.core.count.call(null, c__4132__auto___7894);
-                    var G__7898 = 0;
-                    seq__7871_7881 = G__7895;
-                    chunk__7872_7882 = G__7896;
-                    count__7873_7883 = G__7897;
-                    i__7874_7884 = G__7898;
-                    continue;
-                  } else {
-                    var vec__7876_7899 = cljs.core.first.call(null, seq__7871_7893__$1);
-                    var k_7900 = cljs.core.nth.call(null, vec__7876_7899, 0, null);
-                    var v_7901 = cljs.core.nth.call(null, vec__7876_7899, 1, null);
-                    m[cljs.core.key__GT_js.call(null, k_7900)] = clj__GT_js.call(null, v_7901);
-                    var G__7902 = cljs.core.next.call(null, seq__7871_7893__$1);
-                    var G__7903 = null;
-                    var G__7904 = 0;
-                    var G__7905 = 0;
-                    seq__7871_7881 = G__7902;
-                    chunk__7872_7882 = G__7903;
-                    count__7873_7883 = G__7904;
-                    i__7874_7884 = G__7905;
-                    continue;
-                  }
-                } else {
-                }
-              }
-              break;
-            }
-            return m;
-          } else {
-            if (cljs.core.coll_QMARK_.call(null, x)) {
-              var arr = [];
-              var seq__7877_7906 = cljs.core.seq.call(null, cljs.core.map.call(null, clj__GT_js, x));
-              var chunk__7878_7907 = null;
-              var count__7879_7908 = 0;
-              var i__7880_7909 = 0;
-              while (true) {
-                if (i__7880_7909 < count__7879_7908) {
-                  var x_7910__$1 = cljs.core._nth.call(null, chunk__7878_7907, i__7880_7909);
-                  arr.push(x_7910__$1);
-                  var G__7911 = seq__7877_7906;
-                  var G__7912 = chunk__7878_7907;
-                  var G__7913 = count__7879_7908;
-                  var G__7914 = i__7880_7909 + 1;
-                  seq__7877_7906 = G__7911;
-                  chunk__7878_7907 = G__7912;
-                  count__7879_7908 = G__7913;
-                  i__7880_7909 = G__7914;
-                  continue;
-                } else {
-                  var temp__4092__auto___7915 = cljs.core.seq.call(null, seq__7877_7906);
-                  if (temp__4092__auto___7915) {
-                    var seq__7877_7916__$1 = temp__4092__auto___7915;
-                    if (cljs.core.chunked_seq_QMARK_.call(null, seq__7877_7916__$1)) {
-                      var c__4132__auto___7917 = cljs.core.chunk_first.call(null, seq__7877_7916__$1);
-                      var G__7918 = cljs.core.chunk_rest.call(null, seq__7877_7916__$1);
-                      var G__7919 = c__4132__auto___7917;
-                      var G__7920 = cljs.core.count.call(null, c__4132__auto___7917);
-                      var G__7921 = 0;
-                      seq__7877_7906 = G__7918;
-                      chunk__7878_7907 = G__7919;
-                      count__7879_7908 = G__7920;
-                      i__7880_7909 = G__7921;
-                      continue;
-                    } else {
-                      var x_7922__$1 = cljs.core.first.call(null, seq__7877_7916__$1);
-                      arr.push(x_7922__$1);
-                      var G__7923 = cljs.core.next.call(null, seq__7877_7916__$1);
-                      var G__7924 = null;
-                      var G__7925 = 0;
-                      var G__7926 = 0;
-                      seq__7877_7906 = G__7923;
-                      chunk__7878_7907 = G__7924;
-                      count__7879_7908 = G__7925;
-                      i__7880_7909 = G__7926;
-                      continue;
-                    }
-                  } else {
-                  }
-                }
-                break;
-              }
-              return arr;
-            } else {
-              if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                return x;
-              } else {
-                return null;
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-};
-cljs.core.IEncodeClojure = function() {
-  var obj7928 = {};
-  return obj7928;
-}();
-cljs.core._js__GT_clj = function _js__GT_clj(x, options) {
-  if (function() {
-    var and__3396__auto__ = x;
-    if (and__3396__auto__) {
-      return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x, options);
-  } else {
-    var x__4011__auto__ = x == null ? null : x;
-    return function() {
-      var or__3408__auto__ = cljs.core._js__GT_clj[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._js__GT_clj["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__auto____$1;
-        } else {
-          throw cljs.core.missing_protocol.call(null, "IEncodeClojure.-js-\x3eclj", 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, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "keywordize-keys", "keywordize-keys", 4191781672), false], null));
-  };
-  var js__GT_clj__2 = function() {
-    var G__7949__delegate = function(x, opts) {
-      if (function() {
-        var G__7939 = x;
-        if (G__7939) {
-          var bit__4034__auto__ = null;
-          if (cljs.core.truth_(function() {
-            var or__3408__auto__ = bit__4034__auto__;
-            if (cljs.core.truth_(or__3408__auto__)) {
-              return or__3408__auto__;
-            } else {
-              return G__7939.cljs$core$IEncodeClojure$;
-            }
-          }())) {
-            return true;
-          } else {
-            if (!G__7939.cljs$lang$protocol_mask$partition$) {
-              return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeClojure, G__7939);
-            } else {
-              return false;
-            }
-          }
-        } else {
-          return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeClojure, G__7939);
-        }
-      }()) {
-        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__7940 = opts;
-          var map__7940__$1 = cljs.core.seq_QMARK_.call(null, map__7940) ? cljs.core.apply.call(null, cljs.core.hash_map, map__7940) : map__7940;
-          var keywordize_keys = cljs.core.get.call(null, map__7940__$1, new cljs.core.Keyword(null, "keywordize-keys", "keywordize-keys", 4191781672));
-          var keyfn = cljs.core.truth_(keywordize_keys) ? cljs.core.keyword : cljs.core.str;
-          var f = function(map__7940, map__7940__$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.PersistentArrayMap.EMPTY, function() {
-                        var iter__4101__auto__ = function(map__7940, map__7940__$1, keywordize_keys, keyfn) {
-                          return function iter__7945(s__7946) {
-                            return new cljs.core.LazySeq(null, function(map__7940, map__7940__$1, keywordize_keys, keyfn) {
-                              return function() {
-                                var s__7946__$1 = s__7946;
-                                while (true) {
-                                  var temp__4092__auto__ = cljs.core.seq.call(null, s__7946__$1);
-                                  if (temp__4092__auto__) {
-                                    var s__7946__$2 = temp__4092__auto__;
-                                    if (cljs.core.chunked_seq_QMARK_.call(null, s__7946__$2)) {
-                                      var c__4099__auto__ = cljs.core.chunk_first.call(null, s__7946__$2);
-                                      var size__4100__auto__ = cljs.core.count.call(null, c__4099__auto__);
-                                      var b__7948 = cljs.core.chunk_buffer.call(null, size__4100__auto__);
-                                      if (function() {
-                                        var i__7947 = 0;
-                                        while (true) {
-                                          if (i__7947 < size__4100__auto__) {
-                                            var k = cljs.core._nth.call(null, c__4099__auto__, i__7947);
-                                            cljs.core.chunk_append.call(null, b__7948, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [keyfn.call(null, k), thisfn.call(null, x__$1[k])], null));
-                                            var G__7950 = i__7947 + 1;
-                                            i__7947 = G__7950;
-                                            continue;
-                                          } else {
-                                            return true;
-                                          }
-                                          break;
-                                        }
-                                      }()) {
-                                        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__7948), iter__7945.call(null, cljs.core.chunk_rest.call(null, s__7946__$2)));
-                                      } else {
-                                        return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__7948), null);
-                                      }
-                                    } else {
-                                      var k = cljs.core.first.call(null, s__7946__$2);
-                                      return cljs.core.cons.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [keyfn.call(null, k), thisfn.call(null, x__$1[k])], null), iter__7945.call(null, cljs.core.rest.call(null, s__7946__$2)));
-                                    }
-                                  } else {
-                                    return null;
-                                  }
-                                  break;
-                                }
-                              };
-                            }(map__7940, map__7940__$1, keywordize_keys, keyfn), null, null);
-                          };
-                        }(map__7940, map__7940__$1, keywordize_keys, keyfn);
-                        return iter__4101__auto__.call(null, cljs.core.js_keys.call(null, x__$1));
-                      }());
-                    } else {
-                      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-                        return x__$1;
-                      } else {
-                        return null;
-                      }
-                    }
-                  }
-                }
-              }
-            };
-          }(map__7940, map__7940__$1, keywordize_keys, keyfn);
-          return f.call(null, x);
-        } else {
-          return null;
-        }
-      }
-    };
-    var G__7949 = 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__7949__delegate.call(this, x, opts);
-    };
-    G__7949.cljs$lang$maxFixedArity = 1;
-    G__7949.cljs$lang$applyTo = function(arglist__7951) {
-      var x = cljs.core.first(arglist__7951);
-      var opts = cljs.core.rest(arglist__7951);
-      return G__7949__delegate(x, opts);
-    };
-    G__7949.cljs$core$IFn$_invoke$arity$variadic = G__7949__delegate;
-    return G__7949;
-  }();
-  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.PersistentArrayMap.EMPTY);
-  return function() {
-    var G__7952__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__7952 = function(var_args) {
-      var args = null;
-      if (arguments.length > 0) {
-        args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-      }
-      return G__7952__delegate.call(this, args);
-    };
-    G__7952.cljs$lang$maxFixedArity = 0;
-    G__7952.cljs$lang$applyTo = function(arglist__7953) {
-      var args = cljs.core.seq(arglist__7953);
-      return G__7952__delegate(args);
-    };
-    G__7952.cljs$core$IFn$_invoke$arity$variadic = G__7952__delegate;
-    return G__7952;
-  }();
-};
-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__7954 = ret;
-        f = G__7954;
-        continue;
-      } else {
-        return ret;
-      }
-      break;
-    }
-  };
-  var trampoline__2 = function() {
-    var G__7955__delegate = function(f, args) {
-      return trampoline.call(null, function() {
-        return cljs.core.apply.call(null, f, args);
-      });
-    };
-    var G__7955 = 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__7955__delegate.call(this, f, args);
-    };
-    G__7955.cljs$lang$maxFixedArity = 1;
-    G__7955.cljs$lang$applyTo = function(arglist__7956) {
-      var f = cljs.core.first(arglist__7956);
-      var args = cljs.core.rest(arglist__7956);
-      return G__7955__delegate(f, args);
-    };
-    G__7955.cljs$core$IFn$_invoke$arity$variadic = G__7955__delegate;
-    return G__7955;
-  }();
-  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.PersistentArrayMap.EMPTY, coll);
-};
-cljs.core.make_hierarchy = function make_hierarchy() {
-  return new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "parents", "parents", 4515496059), cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "descendants", "descendants", 768214664), cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442), cljs.core.PersistentArrayMap.EMPTY], null);
-};
-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__7957) {
-    var f = cljs.core.first(arglist__7957);
-    var args = cljs.core.rest(arglist__7957);
-    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__3408__auto__ = cljs.core._EQ_.call(null, child, parent);
-    if (or__3408__auto__) {
-      return or__3408__auto__;
-    } else {
-      var or__3408__auto____$1 = cljs.core.contains_QMARK_.call(null, (new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(h).call(null, child), parent);
-      if (or__3408__auto____$1) {
-        return or__3408__auto____$1;
-      } else {
-        var and__3396__auto__ = cljs.core.vector_QMARK_.call(null, parent);
-        if (and__3396__auto__) {
-          var and__3396__auto____$1 = cljs.core.vector_QMARK_.call(null, child);
-          if (and__3396__auto____$1) {
-            var and__3396__auto____$2 = cljs.core.count.call(null, parent) === cljs.core.count.call(null, child);
-            if (and__3396__auto____$2) {
-              var ret = true;
-              var i = 0;
-              while (true) {
-                if (!ret || i === cljs.core.count.call(null, parent)) {
-                  return ret;
-                } else {
-                  var G__7958 = isa_QMARK_.call(null, h, child.call(null, i), parent.call(null, i));
-                  var G__7959 = i + 1;
-                  ret = G__7958;
-                  i = G__7959;
-                  continue;
-                }
-                break;
-              }
-            } else {
-              return and__3396__auto____$2;
-            }
-          } else {
-            return and__3396__auto____$1;
-          }
-        } else {
-          return and__3396__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(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(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(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(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(null, "descendants", "descendants", 768214664)).cljs$core$IFn$_invoke$arity$1(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.list(new cljs.core.Symbol(null, "namespace", "namespace", -388313324, null), new cljs.core.Symbol(null, "parent", "parent", 1659011683, null))))].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.list(new cljs.core.Symbol(null, "not\x3d", "not\x3d", -1637144189, null), new cljs.core.Symbol(null, "tag", "tag", -1640416941, null), new cljs.core.Symbol(null, "parent", "parent", 1659011683, null))))].join(""));
-    }
-    var tp = (new cljs.core.Keyword(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(h);
-    var td = (new cljs.core.Keyword(null, "descendants", "descendants", 768214664)).cljs$core$IFn$_invoke$arity$1(h);
-    var ta = (new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(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__3408__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 new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "parents", "parents", 4515496059), cljs.core.assoc.call(null, (new cljs.core.Keyword(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(h), tag, cljs.core.conj.call(null, cljs.core.get.call(null, tp, tag, cljs.core.PersistentHashSet.EMPTY), parent)), new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442), tf.call(null, (new cljs.core.Keyword(null, "ancestors", "ancestors", 889955442)).cljs$core$IFn$_invoke$arity$1(h), 
-      tag, td, parent, ta), new cljs.core.Keyword(null, "descendants", "descendants", 768214664), tf.call(null, (new cljs.core.Keyword(null, "descendants", "descendants", 768214664)).cljs$core$IFn$_invoke$arity$1(h), parent, ta, tag, td)], null);
-    }();
-    if (cljs.core.truth_(or__3408__auto__)) {
-      return or__3408__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(null, "parents", "parents", 4515496059)).cljs$core$IFn$_invoke$arity$1(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__7960_SHARP_) {
-        return cljs.core.cons.call(null, cljs.core.first.call(null, p1__7960_SHARP_), cljs.core.interpose.call(null, cljs.core.first.call(null, p1__7960_SHARP_), cljs.core.second.call(null, p1__7960_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__7961_SHARP_, p2__7962_SHARP_) {
-        return cljs.core.apply.call(null, cljs.core.derive, p1__7961_SHARP_, p2__7962_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__3408__auto__ = cljs.core.truth_(function() {
-    var and__3396__auto__ = xprefs;
-    if (cljs.core.truth_(and__3396__auto__)) {
-      return xprefs.call(null, y);
-    } else {
-      return and__3396__auto__;
-    }
-  }()) ? true : null;
-  if (cljs.core.truth_(or__3408__auto__)) {
-    return or__3408__auto__;
-  } else {
-    var or__3408__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__7963 = cljs.core.rest.call(null, ps);
-          ps = G__7963;
-          continue;
-        } else {
-          return null;
-        }
-        break;
-      }
-    }();
-    if (cljs.core.truth_(or__3408__auto____$1)) {
-      return or__3408__auto____$1;
-    } else {
-      var or__3408__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__7964 = cljs.core.rest.call(null, ps);
-            ps = G__7964;
-            continue;
-          } else {
-            return null;
-          }
-          break;
-        }
-      }();
-      if (cljs.core.truth_(or__3408__auto____$2)) {
-        return or__3408__auto____$2;
-      } else {
-        return false;
-      }
-    }
-  }
-};
-cljs.core.dominates = function dominates(x, y, prefer_table) {
-  var or__3408__auto__ = cljs.core.prefers_STAR_.call(null, x, y, prefer_table);
-  if (cljs.core.truth_(or__3408__auto__)) {
-    return or__3408__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__7967) {
-    var vec__7968 = p__7967;
-    var k = cljs.core.nth.call(null, vec__7968, 0, null);
-    var _ = cljs.core.nth.call(null, vec__7968, 1, null);
-    var e = vec__7968;
-    if (cljs.core.isa_QMARK_.call(null, cljs.core.deref.call(null, hierarchy), dispatch_val, k)) {
-      var be2 = cljs.core.truth_(function() {
-        var or__3408__auto__ = be == null;
-        if (or__3408__auto__) {
-          return or__3408__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(" -\x3e "), 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 = function() {
-  var obj7970 = {};
-  return obj7970;
-}();
-cljs.core._reset = function _reset(mf) {
-  if (function() {
-    var and__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_reset$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_reset$arity$1(mf);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._reset[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._reset["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_add_method$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_add_method$arity$3(mf, dispatch_val, method);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._add_method[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._add_method["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_remove_method$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf, dispatch_val);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._remove_method[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._remove_method["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_prefer_method$arity$3;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf, dispatch_val, dispatch_val_y);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._prefer_method[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._prefer_method["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_get_method$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_get_method$arity$2(mf, dispatch_val);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._get_method[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._get_method["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_methods$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_methods$arity$1(mf);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._methods[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._methods["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_prefers$arity$1;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_prefers$arity$1(mf);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._prefers[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._prefers["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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__3396__auto__ = mf;
-    if (and__3396__auto__) {
-      return mf.cljs$core$IMultiFn$_dispatch$arity$2;
-    } else {
-      return and__3396__auto__;
-    }
-  }()) {
-    return mf.cljs$core$IMultiFn$_dispatch$arity$2(mf, args);
-  } else {
-    var x__4011__auto__ = mf == null ? null : mf;
-    return function() {
-      var or__3408__auto__ = cljs.core._dispatch[goog.typeOf(x__4011__auto__)];
-      if (or__3408__auto__) {
-        return or__3408__auto__;
-      } else {
-        var or__3408__auto____$1 = cljs.core._dispatch["_"];
-        if (or__3408__auto____$1) {
-          return or__3408__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, name, 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(name), cljs.core.str("' for dispatch value: "), cljs.core.str(dispatch_val)].join(""));
-  }
-  return cljs.core.apply.call(null, target_fn, args);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/MultiFn");
-};
-cljs.core.MultiFn.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = this;
-  return goog.getUid(this$__$1);
-};
-cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_reset$arity$1 = function(mf) {
-  var self__ = this;
-  var mf__$1 = this;
-  cljs.core.swap_BANG_.call(null, self__.method_table, function(mf__$2) {
-    return cljs.core.PersistentArrayMap.EMPTY;
-  });
-  cljs.core.swap_BANG_.call(null, self__.method_cache, function(mf__$2) {
-    return cljs.core.PersistentArrayMap.EMPTY;
-  });
-  cljs.core.swap_BANG_.call(null, self__.prefer_table, function(mf__$2) {
-    return cljs.core.PersistentArrayMap.EMPTY;
-  });
-  cljs.core.swap_BANG_.call(null, self__.cached_hierarchy, function(mf__$2) {
-    return null;
-  });
-  return mf__$1;
-};
-cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_add_method$arity$3 = function(mf, dispatch_val, method) {
-  var self__ = this;
-  var mf__$1 = 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__$1;
-};
-cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_remove_method$arity$2 = function(mf, dispatch_val) {
-  var self__ = this;
-  var mf__$1 = 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__$1;
-};
-cljs.core.MultiFn.prototype.cljs$core$IMultiFn$_get_method$arity$2 = function(mf, dispatch_val) {
-  var self__ = this;
-  var mf__$1 = 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;
-  var mf__$1 = 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;
-  var mf__$1 = 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;
-  var mf__$1 = 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;
-  var mf__$1 = this;
-  return cljs.core.do_dispatch.call(null, mf__$1, self__.name, self__.dispatch_fn, args);
-};
-cljs.core.__GT_MultiFn = function __GT_MultiFn(name, dispatch_fn, default_dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy) {
-  return new cljs.core.MultiFn(name, dispatch_fn, default_dispatch_val, hierarchy, method_table, prefer_table, method_cache, cached_hierarchy);
-};
-cljs.core.MultiFn.prototype.call = function() {
-  var G__7971__delegate = function(_, args) {
-    var self = this;
-    return cljs.core._dispatch.call(null, self, args);
-  };
-  var G__7971 = function(_, var_args) {
-    var args = null;
-    if (arguments.length > 1) {
-      args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
-    }
-    return G__7971__delegate.call(this, _, args);
-  };
-  G__7971.cljs$lang$maxFixedArity = 1;
-  G__7971.cljs$lang$applyTo = function(arglist__7972) {
-    var _ = cljs.core.first(arglist__7972);
-    var args = cljs.core.rest(arglist__7972);
-    return G__7971__delegate(_, args);
-  };
-  G__7971.cljs$core$IFn$_invoke$arity$variadic = G__7971__delegate;
-  return G__7971;
-}();
-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);
-};
-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__3952__auto__, writer__3953__auto__, opt__3954__auto__) {
-  return cljs.core._write.call(null, writer__3953__auto__, "cljs.core/UUID");
-};
-cljs.core.UUID.prototype.cljs$core$IHash$_hash$arity$1 = function(this$) {
-  var self__ = this;
-  var this$__$1 = this;
-  return goog.string.hashCode(cljs.core.pr_str.call(null, this$__$1));
-};
-cljs.core.UUID.prototype.cljs$core$IPrintWithWriter$_pr_writer$arity$3 = function(_, writer, ___$1) {
-  var self__ = this;
-  var ___$2 = 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 ___$1 = this;
-  return other instanceof cljs.core.UUID && self__.uuid === other.uuid;
-};
-cljs.core.__GT_UUID = function __GT_UUID(uuid) {
-  return new cljs.core.UUID(uuid);
-};
-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__3955__auto__, writer__3956__auto__, opts__3957__auto__) {
-  return cljs.core._write.call(null, writer__3956__auto__, "cljs.core/ExceptionInfo");
-};
-cljs.core.__GT_ExceptionInfo = function __GT_ExceptionInfo(message, data, cause) {
-  return new cljs.core.ExceptionInfo(message, data, cause);
-};
-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 (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          return 0;
-        } else {
-          return null;
-        }
-      }
-    }
-  };
-};
-cljs.core.special_symbol_QMARK_ = function special_symbol_QMARK_(x) {
-  return cljs.core.contains_QMARK_.call(null, new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 19, [new cljs.core.Symbol(null, "deftype*", "deftype*", -978581244, null), null, new cljs.core.Symbol(null, "new", "new", -1640422567, null), null, new cljs.core.Symbol(null, "quote", "quote", -1532577739, null), null, new cljs.core.Symbol(null, "\x26", "\x26", -1640531489, null), null, new cljs.core.Symbol(null, "set!", "set!", -1637004872, null), null, new cljs.core.Symbol(null, 
-  "recur", "recur", -1532142362, null), null, new cljs.core.Symbol(null, ".", ".", -1640531481, null), null, new cljs.core.Symbol(null, "ns", "ns", -1640528002, null), null, new cljs.core.Symbol(null, "do", "do", -1640528316, null), null, new cljs.core.Symbol(null, "fn*", "fn*", -1640430053, null), null, new cljs.core.Symbol(null, "throw", "throw", -1530191713, null), null, new cljs.core.Symbol(null, "letfn*", "letfn*", 1548249632, null), null, new cljs.core.Symbol(null, "js*", "js*", -1640426054, 
-  null), null, new cljs.core.Symbol(null, "defrecord*", "defrecord*", 774272013, null), null, new cljs.core.Symbol(null, "let*", "let*", -1637213400, null), null, new cljs.core.Symbol(null, "loop*", "loop*", -1537374273, null), null, new cljs.core.Symbol(null, "try", "try", -1640416396, null), null, new cljs.core.Symbol(null, "if", "if", -1640528170, null), null, new cljs.core.Symbol(null, "def", "def", -1640432194, null), null], null), null), x);
-};
-goog.provide("nonaga.setup");
-goog.require("cljs.core");
-nonaga.setup.set_pre_BANG_ = function set_pre_BANG_(output) {
-  var new_text = document.createTextNode(output);
-  var output__$1 = document.getElementById("test-output");
-  return output__$1.appendChild(new_text);
-};
-cljs.core.set_print_fn_BANG_.call(null, function(p1__5232_SHARP_) {
-  return nonaga.setup.set_pre_BANG_.call(null, p1__5232_SHARP_);
-});
-goog.provide("nonaga.rules.coord");
-goog.require("cljs.core");
-nonaga.rules.coord.nw = function nw(p__19832) {
-  var vec__19834 = p__19832;
-  var x = cljs.core.nth.call(null, vec__19834, 0, null);
-  var y = cljs.core.nth.call(null, vec__19834, 1, null);
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.odd_QMARK_.call(null, y) ? x : x - 1, y + 1], null);
-};
-nonaga.rules.coord.ne = function ne(p__19835) {
-  var vec__19837 = p__19835;
-  var x = cljs.core.nth.call(null, vec__19837, 0, null);
-  var y = cljs.core.nth.call(null, vec__19837, 1, null);
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.even_QMARK_.call(null, y) ? x : x + 1, y + 1], null);
-};
-nonaga.rules.coord.w = function w(p__19838) {
-  var vec__19840 = p__19838;
-  var x = cljs.core.nth.call(null, vec__19840, 0, null);
-  var y = cljs.core.nth.call(null, vec__19840, 1, null);
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [x - 1, y], null);
-};
-nonaga.rules.coord.e = function e(p__19841) {
-  var vec__19843 = p__19841;
-  var x = cljs.core.nth.call(null, vec__19843, 0, null);
-  var y = cljs.core.nth.call(null, vec__19843, 1, null);
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [x + 1, y], null);
-};
-nonaga.rules.coord.sw = function sw(p__19844) {
-  var vec__19846 = p__19844;
-  var x = cljs.core.nth.call(null, vec__19846, 0, null);
-  var y = cljs.core.nth.call(null, vec__19846, 1, null);
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.odd_QMARK_.call(null, y) ? x : x - 1, y - 1], null);
-};
-nonaga.rules.coord.se = function se(p__19847) {
-  var vec__19849 = p__19847;
-  var x = cljs.core.nth.call(null, vec__19849, 0, null);
-  var y = cljs.core.nth.call(null, vec__19849, 1, null);
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.even_QMARK_.call(null, y) ? x : x + 1, y - 1], null);
-};
-nonaga.rules.coord.directions = new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.nw, nonaga.rules.coord.ne, nonaga.rules.coord.e, nonaga.rules.coord.se, nonaga.rules.coord.sw, nonaga.rules.coord.w], null);
-nonaga.rules.coord.side_by_side_directions = new cljs.core.PersistentVector(null, 6, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.nw, nonaga.rules.coord.ne], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.ne, nonaga.rules.coord.e], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.e, 
-nonaga.rules.coord.se], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.se, nonaga.rules.coord.sw], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.sw, nonaga.rules.coord.w], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.w, nonaga.rules.coord.nw], null)], null);
-nonaga.rules.coord.neighbouring_directions = new cljs.core.PersistentArrayMap.fromArray([nonaga.rules.coord.nw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.ne, nonaga.rules.coord.w], null), nonaga.rules.coord.ne, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.nw, nonaga.rules.coord.e], null), nonaga.rules.coord.w, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[nonaga.rules.coord.nw, nonaga.rules.coord.sw], null), nonaga.rules.coord.e, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.ne, nonaga.rules.coord.se], null), nonaga.rules.coord.sw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.se, nonaga.rules.coord.w], null), nonaga.rules.coord.se, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.sw, 
-nonaga.rules.coord.e], null)], true, false);
-nonaga.rules.coord.neighbours = function neighbours(cell) {
-  return cljs.core.into.call(null, cljs.core.PersistentHashSet.EMPTY, cljs.core.apply.call(null, cljs.core.juxt, nonaga.rules.coord.directions).call(null, cell));
-};
-nonaga.rules.coord.distance = function distance(p__19850, p__19851) {
-  var vec__19854 = p__19850;
-  var x1 = cljs.core.nth.call(null, vec__19854, 0, null);
-  var y1 = cljs.core.nth.call(null, vec__19854, 1, null);
-  var vec__19855 = p__19851;
-  var x2 = cljs.core.nth.call(null, vec__19855, 0, null);
-  var y2 = cljs.core.nth.call(null, vec__19855, 1, null);
-  var xdiff = Math.abs.call(null, x1 - x2);
-  var ydiff = Math.abs.call(null, y1 - y2);
-  var halfy = ydiff / 2 | 0;
-  if (xdiff > halfy) {
-    return xdiff + halfy;
-  } else {
-    return ydiff;
-  }
-};
-nonaga.rules.coord.tag_with_distance = function tag_with_distance(destination, source) {
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [nonaga.rules.coord.distance.call(null, source, destination), source], null);
-};
-goog.provide("nonaga.rules.ball");
-goog.require("cljs.core");
-goog.require("nonaga.rules.coord");
-goog.require("nonaga.rules.coord");
-nonaga.rules.ball.invalid_space_QMARK_ = function invalid_space_QMARK_(p__6589, coord) {
-  var map__6591 = p__6589;
-  var map__6591__$1 = cljs.core.seq_QMARK_.call(null, map__6591) ? cljs.core.apply.call(null, cljs.core.hash_map, map__6591) : map__6591;
-  var blue = cljs.core.get.call(null, map__6591__$1, new cljs.core.Keyword(null, "blue", "blue", 1016931276));
-  var red = cljs.core.get.call(null, map__6591__$1, new cljs.core.Keyword(null, "red", "red", 1014017027));
-  var rings = cljs.core.get.call(null, map__6591__$1, new cljs.core.Keyword(null, "rings", "rings", 1122422709));
-  return cljs.core.not.call(null, function() {
-    var and__3396__auto__ = rings.call(null, coord);
-    if (cljs.core.truth_(and__3396__auto__)) {
-      return cljs.core.not.call(null, function() {
-        var or__3408__auto__ = red.call(null, coord);
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          return blue.call(null, coord);
-        }
-      }());
-    } else {
-      return and__3396__auto__;
-    }
-  }());
-};
-nonaga.rules.ball.move = function move(board, coord, direction) {
-  return cljs.core.first.call(null, function() {
-    var iter__4101__auto__ = function iter__6596(s__6597) {
-      return new cljs.core.LazySeq(null, function() {
-        var s__6597__$1 = s__6597;
-        while (true) {
-          var temp__4092__auto__ = cljs.core.seq.call(null, s__6597__$1);
-          if (temp__4092__auto__) {
-            var s__6597__$2 = temp__4092__auto__;
-            if (cljs.core.chunked_seq_QMARK_.call(null, s__6597__$2)) {
-              var c__4099__auto__ = cljs.core.chunk_first.call(null, s__6597__$2);
-              var size__4100__auto__ = cljs.core.count.call(null, c__4099__auto__);
-              var b__6599 = cljs.core.chunk_buffer.call(null, size__4100__auto__);
-              if (function() {
-                var i__6598 = 0;
-                while (true) {
-                  if (i__6598 < size__4100__auto__) {
-                    var step = cljs.core._nth.call(null, c__4099__auto__, i__6598);
-                    if (nonaga.rules.ball.invalid_space_QMARK_.call(null, board, direction.call(null, step))) {
-                      cljs.core.chunk_append.call(null, b__6599, step);
-                      var G__6600 = i__6598 + 1;
-                      i__6598 = G__6600;
-                      continue;
-                    } else {
-                      var G__6601 = i__6598 + 1;
-                      i__6598 = G__6601;
-                      continue;
-                    }
-                  } else {
-                    return true;
-                  }
-                  break;
-                }
-              }()) {
-                return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__6599), iter__6596.call(null, cljs.core.chunk_rest.call(null, s__6597__$2)));
-              } else {
-                return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__6599), null);
-              }
-            } else {
-              var step = cljs.core.first.call(null, s__6597__$2);
-              if (nonaga.rules.ball.invalid_space_QMARK_.call(null, board, direction.call(null, step))) {
-                return cljs.core.cons.call(null, step, iter__6596.call(null, cljs.core.rest.call(null, s__6597__$2)));
-              } else {
-                var G__6602 = cljs.core.rest.call(null, s__6597__$2);
-                s__6597__$1 = G__6602;
-                continue;
-              }
-            }
-          } else {
-            return null;
-          }
-          break;
-        }
-      }, null, null);
-    };
-    return iter__4101__auto__.call(null, cljs.core.iterate.call(null, direction, coord));
-  }());
-};
-nonaga.rules.ball.valid_destinations = function valid_destinations(board, coord) {
-  return cljs.core.disj.call(null, cljs.core.into.call(null, cljs.core.PersistentHashSet.EMPTY, cljs.core.map.call(null, cljs.core.partial.call(null, nonaga.rules.ball.move, board, coord), nonaga.rules.coord.directions)), coord);
-};
-goog.provide("nonaga.core");
-goog.require("cljs.core");
-nonaga.core.initial_game = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, 
-cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), 
-cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
-nonaga.core.enclosing_ring = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 
-5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), 
-new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
-nonaga.core.move_ball = function move_ball(game, color, from, to) {
-  return cljs.core.update_in.call(null, game, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [color], null), function(p1__20842_SHARP_) {
-    return cljs.core.conj.call(null, cljs.core.disj.call(null, p1__20842_SHARP_, from), to);
-  });
-};
-nonaga.core.move_ring = function move_ring(game, from, to) {
-  return cljs.core.update_in.call(null, game, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "rings", "rings", 1122422709)], null), function(p1__20843_SHARP_) {
-    return cljs.core.conj.call(null, cljs.core.disj.call(null, p1__20843_SHARP_, from), to);
-  });
-};
-goog.provide("clojure.string");
-goog.require("cljs.core");
-goog.require("goog.string.StringBuffer");
-goog.require("goog.string.StringBuffer");
-goog.require("goog.string");
-goog.require("goog.string");
-clojure.string.seq_reverse = function seq_reverse(coll) {
-  return cljs.core.reduce.call(null, cljs.core.conj, cljs.core.List.EMPTY, coll);
-};
-clojure.string.reverse = function reverse(s) {
-  return s.split("").reverse().join("");
-};
-clojure.string.replace = function replace(s, match, replacement) {
-  if (typeof match === "string") {
-    return s.replace(new RegExp(goog.string.regExpEscape(match), "g"), replacement);
-  } else {
-    if (cljs.core.truth_(match.hasOwnProperty("source"))) {
-      return s.replace(new RegExp(match.source, "g"), replacement);
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw[cljs.core.str("Invalid match arg: "), cljs.core.str(match)].join("");
-      } else {
-        return null;
-      }
-    }
-  }
-};
-clojure.string.replace_first = function replace_first(s, match, replacement) {
-  return s.replace(match, replacement);
-};
-clojure.string.join = function() {
-  var join = null;
-  var join__1 = function(coll) {
-    return cljs.core.apply.call(null, cljs.core.str, coll);
-  };
-  var join__2 = function(separator, coll) {
-    return cljs.core.apply.call(null, cljs.core.str, cljs.core.interpose.call(null, separator, coll));
-  };
-  join = function(separator, coll) {
-    switch(arguments.length) {
-      case 1:
-        return join__1.call(this, separator);
-      case 2:
-        return join__2.call(this, separator, coll);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  join.cljs$core$IFn$_invoke$arity$1 = join__1;
-  join.cljs$core$IFn$_invoke$arity$2 = join__2;
-  return join;
-}();
-clojure.string.upper_case = function upper_case(s) {
-  return s.toUpperCase();
-};
-clojure.string.lower_case = function lower_case(s) {
-  return s.toLowerCase();
-};
-clojure.string.capitalize = function capitalize(s) {
-  if (cljs.core.count.call(null, s) < 2) {
-    return clojure.string.upper_case.call(null, s);
-  } else {
-    return[cljs.core.str(clojure.string.upper_case.call(null, cljs.core.subs.call(null, s, 0, 1))), cljs.core.str(clojure.string.lower_case.call(null, cljs.core.subs.call(null, s, 1)))].join("");
-  }
-};
-clojure.string.pop_last_while_empty = function pop_last_while_empty(v) {
-  var v__$1 = v;
-  while (true) {
-    if (cljs.core._EQ_.call(null, "", cljs.core.peek.call(null, v__$1))) {
-      var G__8049 = cljs.core.pop.call(null, v__$1);
-      v__$1 = G__8049;
-      continue;
-    } else {
-      return v__$1;
-    }
-    break;
-  }
-};
-clojure.string.discard_trailing_if_needed = function discard_trailing_if_needed(limit, v) {
-  if (cljs.core._EQ_.call(null, 0, limit)) {
-    return clojure.string.pop_last_while_empty.call(null, v);
-  } else {
-    return v;
-  }
-};
-clojure.string.split_with_empty_regex = function split_with_empty_regex(s, limit) {
-  if (limit <= 0 || limit >= 2 + cljs.core.count.call(null, s)) {
-    return cljs.core.conj.call(null, cljs.core.vec.call(null, cljs.core.cons.call(null, "", cljs.core.map.call(null, cljs.core.str, cljs.core.seq.call(null, s)))), "");
-  } else {
-    var pred__8053 = cljs.core._EQ_;
-    var expr__8054 = limit;
-    if (cljs.core.truth_(pred__8053.call(null, 1, expr__8054))) {
-      return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [s], null);
-    } else {
-      if (cljs.core.truth_(pred__8053.call(null, 2, expr__8054))) {
-        return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, ["", s], null);
-      } else {
-        var c = limit - 2;
-        return cljs.core.conj.call(null, cljs.core.vec.call(null, cljs.core.cons.call(null, "", cljs.core.subvec.call(null, cljs.core.vec.call(null, cljs.core.map.call(null, cljs.core.str, cljs.core.seq.call(null, s))), 0, c))), cljs.core.subs.call(null, s, c));
-      }
-    }
-  }
-};
-clojure.string.split = function() {
-  var split = null;
-  var split__2 = function(s, re) {
-    return split.call(null, s, re, 0);
-  };
-  var split__3 = function(s, re, limit) {
-    return clojure.string.discard_trailing_if_needed.call(null, limit, cljs.core._EQ_.call(null, [cljs.core.str(re)].join(""), "/(?:)/") ? clojure.string.split_with_empty_regex.call(null, s, limit) : limit < 1 ? cljs.core.vec.call(null, [cljs.core.str(s)].join("").split(re)) : function() {
-      var s__$1 = s;
-      var limit__$1 = limit;
-      var parts = cljs.core.PersistentVector.EMPTY;
-      while (true) {
-        if (cljs.core._EQ_.call(null, limit__$1, 1)) {
-          return cljs.core.conj.call(null, parts, s__$1);
-        } else {
-          var temp__4090__auto__ = cljs.core.re_find.call(null, re, s__$1);
-          if (cljs.core.truth_(temp__4090__auto__)) {
-            var m = temp__4090__auto__;
-            var index = s__$1.indexOf(m);
-            var G__8056 = s__$1.substring(index + cljs.core.count.call(null, m));
-            var G__8057 = limit__$1 - 1;
-            var G__8058 = cljs.core.conj.call(null, parts, s__$1.substring(0, index));
-            s__$1 = G__8056;
-            limit__$1 = G__8057;
-            parts = G__8058;
-            continue;
-          } else {
-            return cljs.core.conj.call(null, parts, s__$1);
-          }
-        }
-        break;
-      }
-    }());
-  };
-  split = function(s, re, limit) {
-    switch(arguments.length) {
-      case 2:
-        return split__2.call(this, s, re);
-      case 3:
-        return split__3.call(this, s, re, limit);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  split.cljs$core$IFn$_invoke$arity$2 = split__2;
-  split.cljs$core$IFn$_invoke$arity$3 = split__3;
-  return split;
-}();
-clojure.string.split_lines = function split_lines(s) {
-  return clojure.string.split.call(null, s, /\n|\r\n/);
-};
-clojure.string.trim = function trim(s) {
-  return goog.string.trim(s);
-};
-clojure.string.triml = function triml(s) {
-  return goog.string.trimLeft(s);
-};
-clojure.string.trimr = function trimr(s) {
-  return goog.string.trimRight(s);
-};
-clojure.string.trim_newline = function trim_newline(s) {
-  var index = s.length;
-  while (true) {
-    if (index === 0) {
-      return "";
-    } else {
-      var ch = cljs.core.get.call(null, s, index - 1);
-      if (cljs.core._EQ_.call(null, ch, "\n") || cljs.core._EQ_.call(null, ch, "\r")) {
-        var G__8059 = index - 1;
-        index = G__8059;
-        continue;
-      } else {
-        return s.substring(0, index);
-      }
-    }
-    break;
-  }
-};
-clojure.string.blank_QMARK_ = function blank_QMARK_(s) {
-  return goog.string.isEmptySafe(s);
-};
-clojure.string.escape = function escape__$1(s, cmap) {
-  var buffer = new goog.string.StringBuffer;
-  var length = s.length;
-  var index = 0;
-  while (true) {
-    if (cljs.core._EQ_.call(null, length, index)) {
-      return buffer.toString();
-    } else {
-      var ch = s.charAt(index);
-      var temp__4090__auto___8060 = cljs.core.get.call(null, cmap, ch);
-      if (cljs.core.truth_(temp__4090__auto___8060)) {
-        var replacement_8061 = temp__4090__auto___8060;
-        buffer.append([cljs.core.str(replacement_8061)].join(""));
-      } else {
-        buffer.append(ch);
-      }
-      var G__8062 = index + 1;
-      index = G__8062;
-      continue;
-    }
-    break;
-  }
-};
-goog.provide("cemerick.cljs.test");
-goog.require("cljs.core");
-goog.require("clojure.string");
-goog.require("clojure.string");
-cemerick.cljs.test._STAR_report_counters_STAR_ = null;
-cemerick.cljs.test._STAR_initial_report_counters_STAR_ = new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "test", "test", 1017460740), 0, new cljs.core.Keyword(null, "pass", "pass", 1017337731), 0, new cljs.core.Keyword(null, "fail", "fail", 1017039504), 0, new cljs.core.Keyword(null, "error", "error", 1110689146), 0], null);
-cemerick.cljs.test._STAR_testing_vars_STAR_ = cljs.core.List.EMPTY;
-cemerick.cljs.test._STAR_testing_contexts_STAR_ = cljs.core.List.EMPTY;
-cemerick.cljs.test._STAR_test_print_fn_STAR_ = null;
-cemerick.cljs.test.registered_tests = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-cemerick.cljs.test.registered_test_hooks = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-cemerick.cljs.test.registered_fixtures = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-cemerick.cljs.test.register_test_BANG_ = function register_test_BANG_(ns, name) {
-  return cljs.core.swap_BANG_.call(null, cemerick.cljs.test.registered_tests, cljs.core.update_in, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns], null), cljs.core.fnil.call(null, cljs.core.conj, cljs.core.PersistentHashSet.EMPTY), name);
-};
-cemerick.cljs.test.register_test_ns_hook_BANG_ = function register_test_ns_hook_BANG_(ns, name) {
-  return cljs.core.swap_BANG_.call(null, cemerick.cljs.test.registered_test_hooks, cljs.core.assoc, ns, name);
-};
-cemerick.cljs.test.testing_vars_str = function testing_vars_str(m) {
-  var map__8004 = m;
-  var map__8004__$1 = cljs.core.seq_QMARK_.call(null, map__8004) ? cljs.core.apply.call(null, cljs.core.hash_map, map__8004) : map__8004;
-  var line = cljs.core.get.call(null, map__8004__$1, new cljs.core.Keyword(null, "line", "line", 1017226086));
-  var file = cljs.core.get.call(null, map__8004__$1, new cljs.core.Keyword(null, "file", "file", 1017047278));
-  return[cljs.core.str(cljs.core.pr_str.call(null, cljs.core.reverse.call(null, cemerick.cljs.test._STAR_testing_vars_STAR_))), cljs.core.str(" ("), cljs.core.str(file), cljs.core.str(":"), cljs.core.str(line), cljs.core.str(")")].join("");
-};
-cemerick.cljs.test.testing_contexts_str = function testing_contexts_str() {
-  return cljs.core.apply.call(null, cljs.core.str, cljs.core.interpose.call(null, " ", cljs.core.reverse.call(null, cemerick.cljs.test._STAR_testing_contexts_STAR_)));
-};
-cemerick.cljs.test.inc_report_counter = function inc_report_counter(name) {
-  if (cljs.core.truth_(cemerick.cljs.test._STAR_report_counters_STAR_)) {
-    return cljs.core.swap_BANG_.call(null, cemerick.cljs.test._STAR_report_counters_STAR_, cljs.core.update_in, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [name], null), cljs.core.fnil.call(null, cljs.core.inc, 0));
-  } else {
-    return null;
-  }
-};
-cemerick.cljs.test.report = function() {
-  var method_table__4242__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var prefer_table__4243__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var method_cache__4244__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var cached_hierarchy__4245__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var hierarchy__4246__auto__ = cljs.core.get.call(null, cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "hierarchy", "hierarchy", 3129050535), cljs.core.get_global_hierarchy.call(null));
-  return new cljs.core.MultiFn("report", new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "default", "default", 2558708147), hierarchy__4246__auto__, method_table__4242__auto__, prefer_table__4243__auto__, method_cache__4244__auto__, cached_hierarchy__4245__auto__);
-}();
-cemerick.cljs.test.file_and_line = function file_and_line(error) {
-  return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "file", "file", 1017047278), error.fileName, new cljs.core.Keyword(null, "line", "line", 1017226086), error.lineNumber], null);
-};
-cemerick.cljs.test.do_report = function do_report(m) {
-  return cemerick.cljs.test.report.call(null, function() {
-    var G__8006 = (new cljs.core.Keyword(null, "type", "type", 1017479852)).cljs$core$IFn$_invoke$arity$1(m);
-    if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "error", "error", 1110689146), G__8006)) {
-      return cljs.core.merge.call(null, cemerick.cljs.test.file_and_line.call(null, (new cljs.core.Keyword(null, "actual", "actual", 3885931776)).cljs$core$IFn$_invoke$arity$1(m)), m);
-    } else {
-      if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "fail", "fail", 1017039504), G__8006)) {
-        return cljs.core.merge.call(null, cemerick.cljs.test.file_and_line.call(null, Error()), m);
-      } else {
-        if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-          return m;
-        } else {
-          return null;
-        }
-      }
-    }
-  }());
-};
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "default", "default", 2558708147), function(m) {
-  var _STAR_print_fn_STAR_8007 = cljs.core._STAR_print_fn_STAR_;
-  try {
-    cljs.core._STAR_print_fn_STAR_ = function() {
-      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return cljs.core._STAR_print_fn_STAR_;
-      }
-    }();
-    return cljs.core.prn.call(null, m);
-  } finally {
-    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8007;
-  }
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "pass", "pass", 1017337731), function(m) {
-  var _STAR_print_fn_STAR_8008 = cljs.core._STAR_print_fn_STAR_;
-  try {
-    cljs.core._STAR_print_fn_STAR_ = function() {
-      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return cljs.core._STAR_print_fn_STAR_;
-      }
-    }();
-    return cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "pass", "pass", 1017337731));
-  } finally {
-    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8008;
-  }
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "fail", "fail", 1017039504), function(m) {
-  var _STAR_print_fn_STAR_8009 = cljs.core._STAR_print_fn_STAR_;
-  try {
-    cljs.core._STAR_print_fn_STAR_ = function() {
-      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return cljs.core._STAR_print_fn_STAR_;
-      }
-    }();
-    cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "fail", "fail", 1017039504));
-    cljs.core.println.call(null, "\nFAIL in", cemerick.cljs.test.testing_vars_str.call(null, m));
-    if (cljs.core.seq.call(null, cemerick.cljs.test._STAR_testing_contexts_STAR_)) {
-      cljs.core.println.call(null, cemerick.cljs.test.testing_contexts_str.call(null));
-    } else {
-    }
-    var temp__4092__auto___8010 = (new cljs.core.Keyword(null, "message", "message", 1968829305)).cljs$core$IFn$_invoke$arity$1(m);
-    if (cljs.core.truth_(temp__4092__auto___8010)) {
-      var message_8011 = temp__4092__auto___8010;
-      cljs.core.println.call(null, message_8011);
-    } else {
-    }
-    cljs.core.println.call(null, "expected:", cljs.core.pr_str.call(null, (new cljs.core.Keyword(null, "expected", "expected", 3373152810)).cljs$core$IFn$_invoke$arity$1(m)));
-    return cljs.core.println.call(null, "  actual:", cljs.core.pr_str.call(null, (new cljs.core.Keyword(null, "actual", "actual", 3885931776)).cljs$core$IFn$_invoke$arity$1(m)));
-  } finally {
-    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8009;
-  }
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "error", "error", 1110689146), function(m) {
-  var _STAR_print_fn_STAR_8012 = cljs.core._STAR_print_fn_STAR_;
-  try {
-    cljs.core._STAR_print_fn_STAR_ = function() {
-      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return cljs.core._STAR_print_fn_STAR_;
-      }
-    }();
-    cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "error", "error", 1110689146));
-    cljs.core.println.call(null, "\nERROR in", cemerick.cljs.test.testing_vars_str.call(null, m));
-    if (cljs.core.seq.call(null, cemerick.cljs.test._STAR_testing_contexts_STAR_)) {
-      cljs.core.println.call(null, cemerick.cljs.test.testing_contexts_str.call(null));
-    } else {
-    }
-    var temp__4092__auto___8013 = (new cljs.core.Keyword(null, "message", "message", 1968829305)).cljs$core$IFn$_invoke$arity$1(m);
-    if (cljs.core.truth_(temp__4092__auto___8013)) {
-      var message_8014 = temp__4092__auto___8013;
-      cljs.core.println.call(null, message_8014);
-    } else {
-    }
-    cljs.core.println.call(null, "expected:", cljs.core.pr_str.call(null, (new cljs.core.Keyword(null, "expected", "expected", 3373152810)).cljs$core$IFn$_invoke$arity$1(m)));
-    cljs.core.print.call(null, "  actual: ");
-    var actual = (new cljs.core.Keyword(null, "actual", "actual", 3885931776)).cljs$core$IFn$_invoke$arity$1(m);
-    if (actual instanceof Error) {
-      return cljs.core.println.call(null, actual.stack);
-    } else {
-      return cljs.core.prn.call(null, actual);
-    }
-  } finally {
-    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8012;
-  }
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "summary", "summary", 3451231E3), function(m) {
-  var _STAR_print_fn_STAR_8015 = cljs.core._STAR_print_fn_STAR_;
-  try {
-    cljs.core._STAR_print_fn_STAR_ = function() {
-      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return cljs.core._STAR_print_fn_STAR_;
-      }
-    }();
-    cljs.core.println.call(null, "\nRan", (new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(m), "tests containing", (new cljs.core.Keyword(null, "pass", "pass", 1017337731)).cljs$core$IFn$_invoke$arity$1(m) + (new cljs.core.Keyword(null, "fail", "fail", 1017039504)).cljs$core$IFn$_invoke$arity$1(m) + (new cljs.core.Keyword(null, "error", "error", 1110689146)).cljs$core$IFn$_invoke$arity$1(m), "assertions.");
-    return cljs.core.println.call(null, (new cljs.core.Keyword(null, "fail", "fail", 1017039504)).cljs$core$IFn$_invoke$arity$1(m), "failures,", (new cljs.core.Keyword(null, "error", "error", 1110689146)).cljs$core$IFn$_invoke$arity$1(m), "errors.");
-  } finally {
-    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8015;
-  }
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "begin-test-ns", "begin-test-ns", 1359210286), function(m) {
-  var _STAR_print_fn_STAR_8016 = cljs.core._STAR_print_fn_STAR_;
-  try {
-    cljs.core._STAR_print_fn_STAR_ = function() {
-      var or__3408__auto__ = cemerick.cljs.test._STAR_test_print_fn_STAR_;
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return cljs.core._STAR_print_fn_STAR_;
-      }
-    }();
-    return cljs.core.println.call(null, "\nTesting", (new cljs.core.Keyword(null, "ns", "ns", 1013907767)).cljs$core$IFn$_invoke$arity$1(m));
-  } finally {
-    cljs.core._STAR_print_fn_STAR_ = _STAR_print_fn_STAR_8016;
-  }
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "end-test-ns", "end-test-ns", 3401491808), function(m) {
-  return null;
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "begin-test-var", "begin-test-var", 3128464258), function(m) {
-  return null;
-});
-cljs.core._add_method.call(null, cemerick.cljs.test.report, new cljs.core.Keyword(null, "end-test-var", "end-test-var", 2014682E3), function(m) {
-  return null;
-});
-cemerick.cljs.test.register_fixtures_BANG_ = function() {
-  var register_fixtures_BANG___delegate = function(ns_sym, fixture_type, fixture_fns) {
-    return cljs.core.swap_BANG_.call(null, cemerick.cljs.test.registered_fixtures, cljs.core.update_in, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [ns_sym, fixture_type], null), cljs.core.constantly.call(null, fixture_fns));
-  };
-  var register_fixtures_BANG_ = function(ns_sym, fixture_type, var_args) {
-    var fixture_fns = null;
-    if (arguments.length > 2) {
-      fixture_fns = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
-    }
-    return register_fixtures_BANG___delegate.call(this, ns_sym, fixture_type, fixture_fns);
-  };
-  register_fixtures_BANG_.cljs$lang$maxFixedArity = 2;
-  register_fixtures_BANG_.cljs$lang$applyTo = function(arglist__8017) {
-    var ns_sym = cljs.core.first(arglist__8017);
-    arglist__8017 = cljs.core.next(arglist__8017);
-    var fixture_type = cljs.core.first(arglist__8017);
-    var fixture_fns = cljs.core.rest(arglist__8017);
-    return register_fixtures_BANG___delegate(ns_sym, fixture_type, fixture_fns);
-  };
-  register_fixtures_BANG_.cljs$core$IFn$_invoke$arity$variadic = register_fixtures_BANG___delegate;
-  return register_fixtures_BANG_;
-}();
-cemerick.cljs.test.default_fixture = function default_fixture(f) {
-  return f.call(null);
-};
-cemerick.cljs.test.compose_fixtures = function compose_fixtures(f1, f2) {
-  return function(g) {
-    return f1.call(null, function() {
-      return f2.call(null, g);
-    });
-  };
-};
-cemerick.cljs.test.join_fixtures = function join_fixtures(fixtures) {
-  return cljs.core.reduce.call(null, cemerick.cljs.test.compose_fixtures, cemerick.cljs.test.default_fixture, fixtures);
-};
-cemerick.cljs.test.test_function = function test_function(v) {
-  if (cljs.core.fn_QMARK_.call(null, v)) {
-  } else {
-    throw new Error([cljs.core.str("Assert failed: "), cljs.core.str("test-var must be passed the function to be tested (not a symbol naming it)"), cljs.core.str("\n"), cljs.core.str(cljs.core.pr_str.call(null, cljs.core.list(new cljs.core.Symbol(null, "fn?", "fn?", -1640430032, null), new cljs.core.Symbol(null, "v", "v", -1640531409, null))))].join(""));
-  }
-  var temp__4092__auto__ = (new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v));
-  if (cljs.core.truth_(temp__4092__auto__)) {
-    var t = temp__4092__auto__;
-    var _STAR_testing_vars_STAR_8020 = cemerick.cljs.test._STAR_testing_vars_STAR_;
-    try {
-      cemerick.cljs.test._STAR_testing_vars_STAR_ = cljs.core.conj.call(null, cemerick.cljs.test._STAR_testing_vars_STAR_, function() {
-        var or__3408__auto__ = (new cljs.core.Keyword(null, "name", "name", 1017277949)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v));
-        if (cljs.core.truth_(or__3408__auto__)) {
-          return or__3408__auto__;
-        } else {
-          return v;
-        }
-      }());
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "begin-test-var", "begin-test-var", 3128464258), new cljs.core.Keyword(null, "var", "var", 1014020761), v], null));
-      cemerick.cljs.test.inc_report_counter.call(null, new cljs.core.Keyword(null, "test", "test", 1017460740));
-      try {
-        t.call(null);
-      } catch (e8021) {
-        if (e8021 instanceof Error) {
-          var e_8022 = e8021;
-          cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), "Uncaught exception, not in assertion.", new cljs.core.Keyword(null, "expected", "expected", 3373152810), null, new cljs.core.Keyword(null, "actual", "actual", 3885931776), e_8022], null));
-        } else {
-          if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-            throw e8021;
-          } else {
-          }
-        }
-      }
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "end-test-var", "end-test-var", 2014682E3), new cljs.core.Keyword(null, "var", "var", 1014020761), v], null));
-    } finally {
-      cemerick.cljs.test._STAR_testing_vars_STAR_ = _STAR_testing_vars_STAR_8020;
-    }
-  } else {
-    return null;
-  }
-};
-cemerick.cljs.test.test_all_vars = function test_all_vars(ns_sym) {
-  var once_fixture_fn = cemerick.cljs.test.join_fixtures.call(null, (new cljs.core.Keyword(null, "once", "once", 1017319923)).cljs$core$IFn$_invoke$arity$1(ns_sym.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_fixtures))));
-  var each_fixture_fn = cemerick.cljs.test.join_fixtures.call(null, (new cljs.core.Keyword(null, "each", "each", 1017009523)).cljs$core$IFn$_invoke$arity$1(ns_sym.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_fixtures))));
-  return once_fixture_fn.call(null, function() {
-    var seq__8027 = cljs.core.seq.call(null, cljs.core.get.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_tests), ns_sym));
-    var chunk__8028 = null;
-    var count__8029 = 0;
-    var i__8030 = 0;
-    while (true) {
-      if (i__8030 < count__8029) {
-        var v = cljs.core._nth.call(null, chunk__8028, i__8030);
-        if (cljs.core.truth_((new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v)))) {
-          each_fixture_fn.call(null, function(seq__8027, chunk__8028, count__8029, i__8030, v) {
-            return function() {
-              return cemerick.cljs.test.test_function.call(null, v);
-            };
-          }(seq__8027, chunk__8028, count__8029, i__8030, v));
-        } else {
-        }
-        var G__8031 = seq__8027;
-        var G__8032 = chunk__8028;
-        var G__8033 = count__8029;
-        var G__8034 = i__8030 + 1;
-        seq__8027 = G__8031;
-        chunk__8028 = G__8032;
-        count__8029 = G__8033;
-        i__8030 = G__8034;
-        continue;
-      } else {
-        var temp__4092__auto__ = cljs.core.seq.call(null, seq__8027);
-        if (temp__4092__auto__) {
-          var seq__8027__$1 = temp__4092__auto__;
-          if (cljs.core.chunked_seq_QMARK_.call(null, seq__8027__$1)) {
-            var c__4132__auto__ = cljs.core.chunk_first.call(null, seq__8027__$1);
-            var G__8035 = cljs.core.chunk_rest.call(null, seq__8027__$1);
-            var G__8036 = c__4132__auto__;
-            var G__8037 = cljs.core.count.call(null, c__4132__auto__);
-            var G__8038 = 0;
-            seq__8027 = G__8035;
-            chunk__8028 = G__8036;
-            count__8029 = G__8037;
-            i__8030 = G__8038;
-            continue;
-          } else {
-            var v = cljs.core.first.call(null, seq__8027__$1);
-            if (cljs.core.truth_((new cljs.core.Keyword(null, "test", "test", 1017460740)).cljs$core$IFn$_invoke$arity$1(cljs.core.meta.call(null, v)))) {
-              each_fixture_fn.call(null, function(seq__8027, chunk__8028, count__8029, i__8030, v, seq__8027__$1, temp__4092__auto__) {
-                return function() {
-                  return cemerick.cljs.test.test_function.call(null, v);
-                };
-              }(seq__8027, chunk__8028, count__8029, i__8030, v, seq__8027__$1, temp__4092__auto__));
-            } else {
-            }
-            var G__8039 = cljs.core.next.call(null, seq__8027__$1);
-            var G__8040 = null;
-            var G__8041 = 0;
-            var G__8042 = 0;
-            seq__8027 = G__8039;
-            chunk__8028 = G__8040;
-            count__8029 = G__8041;
-            i__8030 = G__8042;
-            continue;
-          }
-        } else {
-          return null;
-        }
-      }
-      break;
-    }
-  });
-};
-cemerick.cljs.test.test_ns = function test_ns(ns_sym) {
-  var _STAR_report_counters_STAR_8044 = cemerick.cljs.test._STAR_report_counters_STAR_;
-  try {
-    cemerick.cljs.test._STAR_report_counters_STAR_ = cljs.core.atom.call(null, cemerick.cljs.test._STAR_initial_report_counters_STAR_);
-    cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "begin-test-ns", "begin-test-ns", 1359210286), new cljs.core.Keyword(null, "ns", "ns", 1013907767), ns_sym], null));
-    var temp__4090__auto___8045 = cljs.core.get.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_test_hooks), ns_sym);
-    if (cljs.core.truth_(temp__4090__auto___8045)) {
-      var test_hook_8046 = temp__4090__auto___8045;
-      test_hook_8046.call(null);
-    } else {
-      cemerick.cljs.test.test_all_vars.call(null, ns_sym);
-    }
-    cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "end-test-ns", "end-test-ns", 3401491808), new cljs.core.Keyword(null, "ns", "ns", 1013907767), ns_sym], null));
-    return cljs.core.deref.call(null, cemerick.cljs.test._STAR_report_counters_STAR_);
-  } finally {
-    cemerick.cljs.test._STAR_report_counters_STAR_ = _STAR_report_counters_STAR_8044;
-  }
-};
-cemerick.cljs.test.run_tests_STAR_ = function() {
-  var run_tests_STAR___delegate = function(namespaces) {
-    var summary = cljs.core.assoc.call(null, cljs.core.apply.call(null, cljs.core.merge_with, cljs.core._PLUS_, cljs.core.map.call(null, cemerick.cljs.test.test_ns, namespaces)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "summary", "summary", 3451231E3));
-    cemerick.cljs.test.do_report.call(null, summary);
-    return summary;
-  };
-  var run_tests_STAR_ = function(var_args) {
-    var namespaces = null;
-    if (arguments.length > 0) {
-      namespaces = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-    }
-    return run_tests_STAR___delegate.call(this, namespaces);
-  };
-  run_tests_STAR_.cljs$lang$maxFixedArity = 0;
-  run_tests_STAR_.cljs$lang$applyTo = function(arglist__8047) {
-    var namespaces = cljs.core.seq(arglist__8047);
-    return run_tests_STAR___delegate(namespaces);
-  };
-  run_tests_STAR_.cljs$core$IFn$_invoke$arity$variadic = run_tests_STAR___delegate;
-  return run_tests_STAR_;
-}();
-goog.exportSymbol("cemerick.cljs.test.run_tests_STAR_", cemerick.cljs.test.run_tests_STAR_);
-cemerick.cljs.test.run_all_tests = function() {
-  var run_all_tests = null;
-  var run_all_tests__0 = function() {
-    return cljs.core.apply.call(null, cemerick.cljs.test.run_tests_STAR_, cljs.core.keys.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_tests)));
-  };
-  var run_all_tests__1 = function(re) {
-    return cljs.core.apply.call(null, cemerick.cljs.test.run_tests_STAR_, cljs.core.filter.call(null, function(p1__8048_SHARP_) {
-      return cljs.core.re_matches.call(null, re, cljs.core.name.call(null, p1__8048_SHARP_));
-    }, cljs.core.keys.call(null, cljs.core.deref.call(null, cemerick.cljs.test.registered_tests))));
-  };
-  run_all_tests = function(re) {
-    switch(arguments.length) {
-      case 0:
-        return run_all_tests__0.call(this);
-      case 1:
-        return run_all_tests__1.call(this, re);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  run_all_tests.cljs$core$IFn$_invoke$arity$0 = run_all_tests__0;
-  run_all_tests.cljs$core$IFn$_invoke$arity$1 = run_all_tests__1;
-  return run_all_tests;
-}();
-goog.exportSymbol("cemerick.cljs.test.run_all_tests", cemerick.cljs.test.run_all_tests);
-cemerick.cljs.test.successful_QMARK_ = function successful_QMARK_(summary) {
-  return(new cljs.core.Keyword(null, "fail", "fail", 1017039504)).cljs$core$IFn$_invoke$arity$2(summary, 0) === 0 && (new cljs.core.Keyword(null, "error", "error", 1110689146)).cljs$core$IFn$_invoke$arity$2(summary, 0) === 0;
-};
-goog.exportSymbol("cemerick.cljs.test.successful_QMARK_", cemerick.cljs.test.successful_QMARK_);
-cemerick.cljs.test.set_print_fn_BANG_ = function set_print_fn_BANG_(f) {
-  return cljs.core._STAR_print_fn_STAR_ = f;
-};
-goog.exportSymbol("cemerick.cljs.test.set_print_fn_BANG_", cemerick.cljs.test.set_print_fn_BANG_);
-goog.provide("nonaga.ball_test");
-goog.require("cljs.core");
-goog.require("nonaga.core");
-goog.require("nonaga.rules.ball");
-goog.require("nonaga.rules.coord");
-goog.require("cemerick.cljs.test");
-goog.require("cemerick.cljs.test");
-goog.require("nonaga.rules.coord");
-goog.require("nonaga.rules.ball");
-goog.require("nonaga.core");
-nonaga.ball_test.invalid_space = function invalid_space() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.ball_test.invalid_space);
-};
-nonaga.ball_test.invalid_space = cljs.core.vary_meta.call(null, nonaga.ball_test.invalid_space, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "invalid-space", "invalid-space", 386194281, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function invalid_space_test() {
-  try {
-    var values__6663__auto___6810 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.invalid_space_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null))), true);
-    var result__6664__auto___6811 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6810);
-    if (cljs.core.truth_(result__6664__auto___6811)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6810), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6810)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], 
-      null)))], null));
-    }
-  } catch (e6807) {
-    if (e6807 instanceof Error) {
-      var t__6700__auto___6812 = e6807;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6812, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, 
-      cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6807;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__6663__auto___6813 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.invalid_space_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))), true);
-    var result__6664__auto___6814 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6813);
-    if (cljs.core.truth_(result__6664__auto___6814)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6813), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6813)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], 
-      null)))], null));
-    }
-  } catch (e6808) {
-    if (e6808 instanceof Error) {
-      var t__6700__auto___6815 = e6808;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6815, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, 
-      cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6808;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.invalid_space_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))), false);
-    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
-    if (cljs.core.truth_(result__6664__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], 
-      null)))], null));
-    }
-    return result__6664__auto__;
-  } catch (e6809) {
-    if (e6809 instanceof Error) {
-      var t__6700__auto__ = e6809;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "invalid-space?", "invalid-space?", 1058426440, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6809;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.ball-test", "nonaga.ball-test", -2131830151, null), nonaga.ball_test.invalid_space);
-nonaga.ball_test.movement = function movement() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.ball_test.movement);
-};
-nonaga.ball_test.movement = cljs.core.vary_meta.call(null, nonaga.ball_test.movement, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "movement", "movement", -1744209304, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function movement_test() {
-  try {
-    var values__6663__auto___6824 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.move.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), nonaga.rules.coord.nw)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null));
-    var result__6664__auto___6825 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6824);
-    if (cljs.core.truth_(result__6664__auto___6825)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6824), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6824)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null)))], null));
-    }
-  } catch (e6820) {
-    if (e6820 instanceof Error) {
-      var t__6700__auto___6826 = e6820;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6826, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6820;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__6663__auto___6827 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.move.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), nonaga.rules.coord.e)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null));
-    var result__6664__auto___6828 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6827);
-    if (cljs.core.truth_(result__6664__auto___6828)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6827), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6827)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
-    }
-  } catch (e6821) {
-    if (e6821 instanceof Error) {
-      var t__6700__auto___6829 = e6821;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6829, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6821;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__6663__auto___6830 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.move.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), nonaga.rules.coord.e)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null));
-    var result__6664__auto___6831 = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto___6830);
-    if (cljs.core.truth_(result__6664__auto___6831)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto___6830), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto___6830)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
-    }
-  } catch (e6822) {
-    if (e6822 instanceof Error) {
-      var t__6700__auto___6832 = e6822;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto___6832, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), cljs.core.list(new cljs.core.Symbol(null, "move", "move", -1637173878, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.Symbol(null, "e", "e", -1640531426, null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6822;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.ball.valid_destinations.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 
-    4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true));
-    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
-    if (cljs.core.truth_(result__6664__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), new cljs.core.Symbol(null, 
-      "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    }
-    return result__6664__auto__;
-  } catch (e6823) {
-    if (e6823 instanceof Error) {
-      var t__6700__auto__ = e6823;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), new cljs.core.Symbol(null, "initial-game", "initial-game", 
-      -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6823;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.ball-test", "nonaga.ball-test", -2131830151, null), nonaga.ball_test.movement);
-goog.provide("nonaga.core_test");
-goog.require("cljs.core");
-goog.require("cemerick.cljs.test");
-goog.require("cemerick.cljs.test");
-goog.require("nonaga.core");
-goog.require("nonaga.core");
-nonaga.core_test.after_red_move = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), 
-cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
-nonaga.core_test.ball_move = function ball_move() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.core_test.ball_move);
-};
-nonaga.core_test.ball_move = cljs.core.vary_meta.call(null, nonaga.core_test.ball_move, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "ball-move", "ball-move", -925517672, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function ball_move_test() {
-  try {
-    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.core.move_ball.call(null, nonaga.core.initial_game, new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))), nonaga.core_test.after_red_move);
-    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
-    if (cljs.core.truth_(result__6664__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-red-move", "after-red-move", 492316183, null), cljs.core.list(new cljs.core.Symbol("c", "move-ball", "c/move-ball", -618776209, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [3, 0], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-red-move", "after-red-move", 492316183, null), cljs.core.list(new cljs.core.Symbol("c", "move-ball", "c/move-ball", -618776209, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.Keyword(null, 
-      "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)))], null));
-    }
-    return result__6664__auto__;
-  } catch (e6801) {
-    if (e6801 instanceof Error) {
-      var t__6700__auto__ = e6801;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      new cljs.core.Symbol(null, "after-red-move", "after-red-move", 492316183, null), cljs.core.list(new cljs.core.Symbol("c", "move-ball", "c/move-ball", -618776209, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)))], 
-      null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6801;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.core-test", "nonaga.core-test", -185125671, null), nonaga.core_test.ball_move);
-nonaga.core_test.after_ring_move = new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true), new cljs.core.Keyword(null, "red", "red", 1014017027), 
-cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.Keyword(null, "blue", "blue", 1016931276), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], true)], null);
-nonaga.core_test.ring_move = function ring_move() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.core_test.ring_move);
-};
-nonaga.core_test.ring_move = cljs.core.vary_meta.call(null, nonaga.core_test.ring_move, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "ring-move", "ring-move", -1385542905, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function ring_move_test() {
-  try {
-    var values__6663__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.core.move_ring.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null))), nonaga.core_test.after_ring_move);
-    var result__6664__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__6663__auto__);
-    if (cljs.core.truth_(result__6664__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__6663__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-ring-move", "after-ring-move", 320966742, null), cljs.core.list(new cljs.core.Symbol("c", "move-ring", "c/move-ring", -618291874, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__6663__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.Symbol(null, "after-ring-move", "after-ring-move", 320966742, null), cljs.core.list(new cljs.core.Symbol("c", "move-ring", "c/move-ring", -618291874, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null)))], null));
-    }
-    return result__6664__auto__;
-  } catch (e6803) {
-    if (e6803 instanceof Error) {
-      var t__6700__auto__ = e6803;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__6700__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      new cljs.core.Symbol(null, "after-ring-move", "after-ring-move", 320966742, null), cljs.core.list(new cljs.core.Symbol("c", "move-ring", "c/move-ring", -618291874, null), new cljs.core.Symbol("c", "initial-game", "c/initial-game", -2096590065, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6803;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.core-test", "nonaga.core-test", -185125671, null), nonaga.core_test.ring_move);
-goog.provide("nonaga.rules.coord_test");
-goog.require("cljs.core");
-goog.require("nonaga.rules.coord");
-goog.require("cemerick.cljs.test");
-goog.require("cemerick.cljs.test");
-goog.require("nonaga.rules.coord");
-nonaga.rules.coord_test.directional_functions = function directional_functions() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.coord_test.directional_functions);
-};
-nonaga.rules.coord_test.directional_functions = cljs.core.vary_meta.call(null, nonaga.rules.coord_test.directional_functions, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "directional-functions", "directional-functions", 5781297, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function directional_functions_test() {
-  try {
-    var values__5008__auto___6195 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.nw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)], null));
-    var result__5009__auto___6196 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6195);
-    if (cljs.core.truth_(result__5009__auto___6196)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6195), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 
-      3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6195)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
-      "nw", "nw", -1640527998, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))))], null));
-    }
-  } catch (e6189) {
-    if (e6189 instanceof Error) {
-      var t__5045__auto___6197 = e6189;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6197, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [1, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "nw", "nw", -1640527998, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6189;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6198 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.ne, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)], null));
-    var result__5009__auto___6199 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6198);
-    if (cljs.core.truth_(result__5009__auto___6199)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6198), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 
-      3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6198)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
-      "ne", "ne", -1640528016, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null))))], null));
-    }
-  } catch (e6190) {
-    if (e6190 instanceof Error) {
-      var t__5045__auto___6200 = e6190;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6200, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [3, 4], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6190;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6201 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.e, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], null));
-    var result__5009__auto___6202 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6201);
-    if (cljs.core.truth_(result__5009__auto___6202)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6201), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 
-      2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "e", "e", -1640531426, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6201)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
-      "e", "e", -1640531426, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null))))], null));
-    }
-  } catch (e6191) {
-    if (e6191 instanceof Error) {
-      var t__5045__auto___6203 = e6191;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6203, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "e", "e", -1640531426, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6191;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6204 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.se, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], null));
-    var result__5009__auto___6205 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6204);
-    if (cljs.core.truth_(result__5009__auto___6205)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6204), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 
-      1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "se", "se", -1640527861, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6204)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
-      "se", "se", -1640527861, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))))], null));
-    }
-  } catch (e6192) {
-    if (e6192 instanceof Error) {
-      var t__5045__auto___6206 = e6192;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6206, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [3, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "se", "se", -1640527861, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6192;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6207 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.sw, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)], null));
-    var result__5009__auto___6208 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6207);
-    if (cljs.core.truth_(result__5009__auto___6208)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6207), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 
-      1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "sw", "sw", -1640527843, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6207)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
-      "sw", "sw", -1640527843, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null))))], null));
-    }
-  } catch (e6193) {
-    if (e6193 instanceof Error) {
-      var t__5045__auto___6209 = e6193;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6209, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 
-      5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [1, 0], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "sw", "sw", -1640527843, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6193;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.take.call(null, 5, cljs.core.iterate.call(null, nonaga.rules.coord.w, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null));
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 
-      2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "w", "w", -1640531408, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, 
-      "w", "w", -1640531408, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))))], null));
-    }
-    return result__5009__auto__;
-  } catch (e6194) {
-    if (e6194 instanceof Error) {
-      var t__5045__auto__ = e6194;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      new cljs.core.PersistentVector(null, 5, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], null), cljs.core.list(new cljs.core.Symbol(null, "take", "take", -1636979136, null), 5, cljs.core.list(new cljs.core.Symbol(null, "iterate", "iterate", 475824691, null), new cljs.core.Symbol(null, "w", "w", -1640531408, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6194;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.coord-test", "nonaga.rules.coord-test", -522322342, null), nonaga.rules.coord_test.directional_functions);
-nonaga.rules.coord_test.neighbouring_cells = function neighbouring_cells() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.coord_test.neighbouring_cells);
-};
-nonaga.rules.coord_test.neighbouring_cells = cljs.core.vary_meta.call(null, nonaga.rules.coord_test.neighbouring_cells, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "neighbouring-cells", "neighbouring-cells", -580156446, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function neighbouring_cells_test() {
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.neighbours.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null))), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true));
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "neighbours", "neighbours", -1345037905, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "neighbours", "neighbours", -1345037905, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [2, 2], null)))], null));
-    }
-    return result__5009__auto__;
-  } catch (e6211) {
-    if (e6211 instanceof Error) {
-      var t__5045__auto__ = e6211;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)], true), cljs.core.list(new cljs.core.Symbol(null, "neighbours", "neighbours", -1345037905, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6211;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.coord-test", "nonaga.rules.coord-test", -522322342, null), nonaga.rules.coord_test.neighbouring_cells);
-nonaga.rules.coord_test.distances = function distances() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.coord_test.distances);
-};
-nonaga.rules.coord_test.distances = cljs.core.vary_meta.call(null, nonaga.rules.coord_test.distances, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "distances", "distances", -1288213289, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function distances_test() {
-  try {
-    var values__5008__auto___6228 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 0], null))), 12);
-    var result__5009__auto___6229 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6228);
-    if (cljs.core.truth_(result__5009__auto___6229)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6228), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 12, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 0], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6228)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 12, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 
-      0], null)))], null));
-    }
-  } catch (e6220) {
-    if (e6220 instanceof Error) {
-      var t__5045__auto___6230 = e6220;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6230, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 12, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 0], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6220;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6231 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 7], null))), 17);
-    var result__5009__auto___6232 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6231);
-    if (cljs.core.truth_(result__5009__auto___6232)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6231), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 7], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6231)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 
-      7], null)))], null));
-    }
-  } catch (e6221) {
-    if (e6221 instanceof Error) {
-      var t__5045__auto___6233 = e6221;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6233, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [14, 7], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6221;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6234 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 11], null))), 17);
-    var result__5009__auto___6235 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6234);
-    if (cljs.core.truth_(result__5009__auto___6235)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6234), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 11], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6234)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 
-      11], null)))], null));
-    }
-  } catch (e6222) {
-    if (e6222 instanceof Error) {
-      var t__5045__auto___6236 = e6222;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6236, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 17, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [12, 11], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6222;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6237 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 5], null))), 5);
-    var result__5009__auto___6238 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6237);
-    if (cljs.core.truth_(result__5009__auto___6238)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6237), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 5, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 5], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6237)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 5, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 
-      5], null)))], null));
-    }
-  } catch (e6223) {
-    if (e6223 instanceof Error) {
-      var t__5045__auto___6239 = e6223;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6239, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 5, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 5], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6223;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6240 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 10], null))), 10);
-    var result__5009__auto___6241 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6240);
-    if (cljs.core.truth_(result__5009__auto___6241)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6240), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 10, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 10], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6240)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 10, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 
-      10], null)))], null));
-    }
-  } catch (e6224) {
-    if (e6224 instanceof Error) {
-      var t__5045__auto___6242 = e6224;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6242, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 10, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 10], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6224;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6243 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 8], null))), 8);
-    var result__5009__auto___6244 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6243);
-    if (cljs.core.truth_(result__5009__auto___6244)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6243), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 8, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 8], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6243)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 8, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
-      8], null)))], null));
-    }
-  } catch (e6225) {
-    if (e6225 instanceof Error) {
-      var t__5045__auto___6245 = e6225;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6245, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 8, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 8], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6225;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___6246 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 8], null))), 9);
-    var result__5009__auto___6247 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___6246);
-    if (cljs.core.truth_(result__5009__auto___6247)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___6246), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 9, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 8], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___6246)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 9, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 
-      8], null)))], null));
-    }
-  } catch (e6226) {
-    if (e6226 instanceof Error) {
-      var t__5045__auto___6248 = e6226;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___6248, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 9, 
-      cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 8], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6226;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.distance.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, -9], null))), 20);
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 20, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, -9], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 20, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, 
-      -9], null)))], null));
-    }
-    return result__5009__auto__;
-  } catch (e6227) {
-    if (e6227 instanceof Error) {
-      var t__5045__auto__ = e6227;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      20, cljs.core.list(new cljs.core.Symbol(null, "distance", "distance", -1352071762, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-16, -9], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e6227;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.coord-test", "nonaga.rules.coord-test", -522322342, null), nonaga.rules.coord_test.distances);
-goog.provide("clojure.set");
-goog.require("cljs.core");
-clojure.set.bubble_max_key = function bubble_max_key(k, coll) {
-  var max = cljs.core.apply.call(null, cljs.core.max_key, k, coll);
-  return cljs.core.cons.call(null, max, cljs.core.remove.call(null, function(p1__7973_SHARP_) {
-    return max === p1__7973_SHARP_;
-  }, coll));
-};
-clojure.set.union = function() {
-  var union = null;
-  var union__0 = function() {
-    return cljs.core.PersistentHashSet.EMPTY;
-  };
-  var union__1 = function(s1) {
-    return s1;
-  };
-  var union__2 = function(s1, s2) {
-    if (cljs.core.count.call(null, s1) < cljs.core.count.call(null, s2)) {
-      return cljs.core.reduce.call(null, cljs.core.conj, s2, s1);
-    } else {
-      return cljs.core.reduce.call(null, cljs.core.conj, s1, s2);
-    }
-  };
-  var union__3 = function() {
-    var G__7974__delegate = function(s1, s2, sets) {
-      var bubbled_sets = clojure.set.bubble_max_key.call(null, cljs.core.count, cljs.core.conj.call(null, sets, s2, s1));
-      return cljs.core.reduce.call(null, cljs.core.into, cljs.core.first.call(null, bubbled_sets), cljs.core.rest.call(null, bubbled_sets));
-    };
-    var G__7974 = function(s1, s2, var_args) {
-      var sets = null;
-      if (arguments.length > 2) {
-        sets = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
-      }
-      return G__7974__delegate.call(this, s1, s2, sets);
-    };
-    G__7974.cljs$lang$maxFixedArity = 2;
-    G__7974.cljs$lang$applyTo = function(arglist__7975) {
-      var s1 = cljs.core.first(arglist__7975);
-      arglist__7975 = cljs.core.next(arglist__7975);
-      var s2 = cljs.core.first(arglist__7975);
-      var sets = cljs.core.rest(arglist__7975);
-      return G__7974__delegate(s1, s2, sets);
-    };
-    G__7974.cljs$core$IFn$_invoke$arity$variadic = G__7974__delegate;
-    return G__7974;
-  }();
-  union = function(s1, s2, var_args) {
-    var sets = var_args;
-    switch(arguments.length) {
-      case 0:
-        return union__0.call(this);
-      case 1:
-        return union__1.call(this, s1);
-      case 2:
-        return union__2.call(this, s1, s2);
-      default:
-        return union__3.cljs$core$IFn$_invoke$arity$variadic(s1, s2, cljs.core.array_seq(arguments, 2));
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  union.cljs$lang$maxFixedArity = 2;
-  union.cljs$lang$applyTo = union__3.cljs$lang$applyTo;
-  union.cljs$core$IFn$_invoke$arity$0 = union__0;
-  union.cljs$core$IFn$_invoke$arity$1 = union__1;
-  union.cljs$core$IFn$_invoke$arity$2 = union__2;
-  union.cljs$core$IFn$_invoke$arity$variadic = union__3.cljs$core$IFn$_invoke$arity$variadic;
-  return union;
-}();
-clojure.set.intersection = function() {
-  var intersection = null;
-  var intersection__1 = function(s1) {
-    return s1;
-  };
-  var intersection__2 = function(s1, s2) {
-    while (true) {
-      if (cljs.core.count.call(null, s2) < cljs.core.count.call(null, s1)) {
-        var G__7977 = s2;
-        var G__7978 = s1;
-        s1 = G__7977;
-        s2 = G__7978;
-        continue;
-      } else {
-        return cljs.core.reduce.call(null, function(s1, s2) {
-          return function(result, item) {
-            if (cljs.core.contains_QMARK_.call(null, s2, item)) {
-              return result;
-            } else {
-              return cljs.core.disj.call(null, result, item);
-            }
-          };
-        }(s1, s2), s1, s1);
-      }
-      break;
-    }
-  };
-  var intersection__3 = function() {
-    var G__7979__delegate = function(s1, s2, sets) {
-      var bubbled_sets = clojure.set.bubble_max_key.call(null, function(p1__7976_SHARP_) {
-        return-cljs.core.count.call(null, p1__7976_SHARP_);
-      }, cljs.core.conj.call(null, sets, s2, s1));
-      return cljs.core.reduce.call(null, intersection, cljs.core.first.call(null, bubbled_sets), cljs.core.rest.call(null, bubbled_sets));
-    };
-    var G__7979 = function(s1, s2, var_args) {
-      var sets = null;
-      if (arguments.length > 2) {
-        sets = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
-      }
-      return G__7979__delegate.call(this, s1, s2, sets);
-    };
-    G__7979.cljs$lang$maxFixedArity = 2;
-    G__7979.cljs$lang$applyTo = function(arglist__7980) {
-      var s1 = cljs.core.first(arglist__7980);
-      arglist__7980 = cljs.core.next(arglist__7980);
-      var s2 = cljs.core.first(arglist__7980);
-      var sets = cljs.core.rest(arglist__7980);
-      return G__7979__delegate(s1, s2, sets);
-    };
-    G__7979.cljs$core$IFn$_invoke$arity$variadic = G__7979__delegate;
-    return G__7979;
-  }();
-  intersection = function(s1, s2, var_args) {
-    var sets = var_args;
-    switch(arguments.length) {
-      case 1:
-        return intersection__1.call(this, s1);
-      case 2:
-        return intersection__2.call(this, s1, s2);
-      default:
-        return intersection__3.cljs$core$IFn$_invoke$arity$variadic(s1, s2, cljs.core.array_seq(arguments, 2));
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  intersection.cljs$lang$maxFixedArity = 2;
-  intersection.cljs$lang$applyTo = intersection__3.cljs$lang$applyTo;
-  intersection.cljs$core$IFn$_invoke$arity$1 = intersection__1;
-  intersection.cljs$core$IFn$_invoke$arity$2 = intersection__2;
-  intersection.cljs$core$IFn$_invoke$arity$variadic = intersection__3.cljs$core$IFn$_invoke$arity$variadic;
-  return intersection;
-}();
-clojure.set.difference = function() {
-  var difference = null;
-  var difference__1 = function(s1) {
-    return s1;
-  };
-  var difference__2 = function(s1, s2) {
-    if (cljs.core.count.call(null, s1) < cljs.core.count.call(null, s2)) {
-      return cljs.core.reduce.call(null, function(result, item) {
-        if (cljs.core.contains_QMARK_.call(null, s2, item)) {
-          return cljs.core.disj.call(null, result, item);
-        } else {
-          return result;
-        }
-      }, s1, s1);
-    } else {
-      return cljs.core.reduce.call(null, cljs.core.disj, s1, s2);
-    }
-  };
-  var difference__3 = function() {
-    var G__7981__delegate = function(s1, s2, sets) {
-      return cljs.core.reduce.call(null, difference, s1, cljs.core.conj.call(null, sets, s2));
-    };
-    var G__7981 = function(s1, s2, var_args) {
-      var sets = null;
-      if (arguments.length > 2) {
-        sets = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0);
-      }
-      return G__7981__delegate.call(this, s1, s2, sets);
-    };
-    G__7981.cljs$lang$maxFixedArity = 2;
-    G__7981.cljs$lang$applyTo = function(arglist__7982) {
-      var s1 = cljs.core.first(arglist__7982);
-      arglist__7982 = cljs.core.next(arglist__7982);
-      var s2 = cljs.core.first(arglist__7982);
-      var sets = cljs.core.rest(arglist__7982);
-      return G__7981__delegate(s1, s2, sets);
-    };
-    G__7981.cljs$core$IFn$_invoke$arity$variadic = G__7981__delegate;
-    return G__7981;
-  }();
-  difference = function(s1, s2, var_args) {
-    var sets = var_args;
-    switch(arguments.length) {
-      case 1:
-        return difference__1.call(this, s1);
-      case 2:
-        return difference__2.call(this, s1, s2);
-      default:
-        return difference__3.cljs$core$IFn$_invoke$arity$variadic(s1, s2, cljs.core.array_seq(arguments, 2));
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  difference.cljs$lang$maxFixedArity = 2;
-  difference.cljs$lang$applyTo = difference__3.cljs$lang$applyTo;
-  difference.cljs$core$IFn$_invoke$arity$1 = difference__1;
-  difference.cljs$core$IFn$_invoke$arity$2 = difference__2;
-  difference.cljs$core$IFn$_invoke$arity$variadic = difference__3.cljs$core$IFn$_invoke$arity$variadic;
-  return difference;
-}();
-clojure.set.select = function select(pred, xset) {
-  return cljs.core.reduce.call(null, function(s, k) {
-    if (cljs.core.truth_(pred.call(null, k))) {
-      return s;
-    } else {
-      return cljs.core.disj.call(null, s, k);
-    }
-  }, xset, xset);
-};
-clojure.set.project = function project(xrel, ks) {
-  return cljs.core.set.call(null, cljs.core.map.call(null, function(p1__7983_SHARP_) {
-    return cljs.core.select_keys.call(null, p1__7983_SHARP_, ks);
-  }, xrel));
-};
-clojure.set.rename_keys = function rename_keys(map, kmap) {
-  return cljs.core.reduce.call(null, function(m, p__7986) {
-    var vec__7987 = p__7986;
-    var old = cljs.core.nth.call(null, vec__7987, 0, null);
-    var new$ = cljs.core.nth.call(null, vec__7987, 1, null);
-    if (cljs.core.not_EQ_.call(null, old, new$) && cljs.core.contains_QMARK_.call(null, m, old)) {
-      return cljs.core.dissoc.call(null, cljs.core.assoc.call(null, m, new$, cljs.core.get.call(null, m, old)), old);
-    } else {
-      return m;
-    }
-  }, map, kmap);
-};
-clojure.set.rename = function rename(xrel, kmap) {
-  return cljs.core.set.call(null, cljs.core.map.call(null, function(p1__7988_SHARP_) {
-    return clojure.set.rename_keys.call(null, p1__7988_SHARP_, kmap);
-  }, xrel));
-};
-clojure.set.index = function index(xrel, ks) {
-  return cljs.core.reduce.call(null, function(m, x) {
-    var ik = cljs.core.select_keys.call(null, x, ks);
-    return cljs.core.assoc.call(null, m, ik, cljs.core.conj.call(null, cljs.core.get.call(null, m, ik, cljs.core.PersistentHashSet.EMPTY), x));
-  }, cljs.core.PersistentArrayMap.EMPTY, xrel);
-};
-clojure.set.map_invert = function map_invert(m) {
-  return cljs.core.reduce.call(null, function(m__$1, p__7991) {
-    var vec__7992 = p__7991;
-    var k = cljs.core.nth.call(null, vec__7992, 0, null);
-    var v = cljs.core.nth.call(null, vec__7992, 1, null);
-    return cljs.core.assoc.call(null, m__$1, v, k);
-  }, cljs.core.PersistentArrayMap.EMPTY, m);
-};
-clojure.set.join = function() {
-  var join = null;
-  var join__2 = function(xrel, yrel) {
-    if (cljs.core.seq.call(null, xrel) && cljs.core.seq.call(null, yrel)) {
-      var ks = clojure.set.intersection.call(null, cljs.core.set.call(null, cljs.core.keys.call(null, cljs.core.first.call(null, xrel))), cljs.core.set.call(null, cljs.core.keys.call(null, cljs.core.first.call(null, yrel))));
-      var vec__7999 = cljs.core.count.call(null, xrel) <= cljs.core.count.call(null, yrel) ? new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel, yrel], null) : new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel, xrel], null);
-      var r = cljs.core.nth.call(null, vec__7999, 0, null);
-      var s = cljs.core.nth.call(null, vec__7999, 1, null);
-      var idx = clojure.set.index.call(null, r, ks);
-      return cljs.core.reduce.call(null, function(ret, x) {
-        var found = idx.call(null, cljs.core.select_keys.call(null, x, ks));
-        if (cljs.core.truth_(found)) {
-          return cljs.core.reduce.call(null, function(p1__7993_SHARP_, p2__7994_SHARP_) {
-            return cljs.core.conj.call(null, p1__7993_SHARP_, cljs.core.merge.call(null, p2__7994_SHARP_, x));
-          }, ret, found);
-        } else {
-          return ret;
-        }
-      }, cljs.core.PersistentHashSet.EMPTY, s);
-    } else {
-      return cljs.core.PersistentHashSet.EMPTY;
-    }
-  };
-  var join__3 = function(xrel, yrel, km) {
-    var vec__8000 = cljs.core.count.call(null, xrel) <= cljs.core.count.call(null, yrel) ? new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [xrel, yrel, clojure.set.map_invert.call(null, km)], null) : new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [yrel, xrel, km], null);
-    var r = cljs.core.nth.call(null, vec__8000, 0, null);
-    var s = cljs.core.nth.call(null, vec__8000, 1, null);
-    var k = cljs.core.nth.call(null, vec__8000, 2, null);
-    var idx = clojure.set.index.call(null, r, cljs.core.vals.call(null, k));
-    return cljs.core.reduce.call(null, function(ret, x) {
-      var found = idx.call(null, clojure.set.rename_keys.call(null, cljs.core.select_keys.call(null, x, cljs.core.keys.call(null, k)), k));
-      if (cljs.core.truth_(found)) {
-        return cljs.core.reduce.call(null, function(p1__7995_SHARP_, p2__7996_SHARP_) {
-          return cljs.core.conj.call(null, p1__7995_SHARP_, cljs.core.merge.call(null, p2__7996_SHARP_, x));
-        }, ret, found);
-      } else {
-        return ret;
-      }
-    }, cljs.core.PersistentHashSet.EMPTY, s);
-  };
-  join = function(xrel, yrel, km) {
-    switch(arguments.length) {
-      case 2:
-        return join__2.call(this, xrel, yrel);
-      case 3:
-        return join__3.call(this, xrel, yrel, km);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  join.cljs$core$IFn$_invoke$arity$2 = join__2;
-  join.cljs$core$IFn$_invoke$arity$3 = join__3;
-  return join;
-}();
-clojure.set.subset_QMARK_ = function subset_QMARK_(set1, set2) {
-  return cljs.core.count.call(null, set1) <= cljs.core.count.call(null, set2) && cljs.core.every_QMARK_.call(null, function(p1__8001_SHARP_) {
-    return cljs.core.contains_QMARK_.call(null, set2, p1__8001_SHARP_);
-  }, set1);
-};
-clojure.set.superset_QMARK_ = function superset_QMARK_(set1, set2) {
-  return cljs.core.count.call(null, set1) >= cljs.core.count.call(null, set2) && cljs.core.every_QMARK_.call(null, function(p1__8002_SHARP_) {
-    return cljs.core.contains_QMARK_.call(null, set1, p1__8002_SHARP_);
-  }, set2);
-};
-goog.provide("nonaga.rules.rings");
-goog.require("cljs.core");
-goog.require("clojure.set");
-goog.require("nonaga.rules.coord");
-goog.require("nonaga.rules.coord");
-goog.require("clojure.set");
-nonaga.rules.rings.valid_slide_QMARK_ = function valid_slide_QMARK_(rings, coord, direction) {
-  var sliding_into_ring_QMARK_ = rings.call(null, direction.call(null, coord));
-  var gap_too_small_QMARK_ = cljs.core.apply.call(null, function(sliding_into_ring_QMARK_) {
-    return function(p1__21360_SHARP_, p2__21361_SHARP_) {
-      var and__3396__auto__ = p1__21360_SHARP_;
-      if (cljs.core.truth_(and__3396__auto__)) {
-        return p2__21361_SHARP_;
-      } else {
-        return and__3396__auto__;
-      }
-    };
-  }(sliding_into_ring_QMARK_), cljs.core.map.call(null, rings, cljs.core.map.call(null, function(sliding_into_ring_QMARK_) {
-    return function(p1__21362_SHARP_) {
-      return p1__21362_SHARP_.call(null, coord);
-    };
-  }(sliding_into_ring_QMARK_), nonaga.rules.coord.neighbouring_directions.call(null, direction))));
-  return cljs.core.not.call(null, function() {
-    var or__3408__auto__ = sliding_into_ring_QMARK_;
-    if (cljs.core.truth_(or__3408__auto__)) {
-      return or__3408__auto__;
-    } else {
-      return gap_too_small_QMARK_;
-    }
-  }());
-};
-nonaga.rules.rings.valid_slides = function valid_slides(rings, coord) {
-  return cljs.core.filter.call(null, cljs.core.partial.call(null, nonaga.rules.rings.valid_slide_QMARK_, rings, coord), cljs.core.keys.call(null, nonaga.rules.coord.neighbouring_directions));
-};
-nonaga.rules.rings.neighbour_distances = function neighbour_distances(rings, source, destination) {
-  return cljs.core.map.call(null, cljs.core.partial.call(null, nonaga.rules.coord.tag_with_distance, destination), cljs.core.map.call(null, function(p1__21363_SHARP_) {
-    return p1__21363_SHARP_.call(null, source);
-  }, nonaga.rules.rings.valid_slides.call(null, rings, source)));
-};
-nonaga.rules.rings.can_move_to_QMARK_ = function() {
-  var can_move_to_QMARK_ = null;
-  var can_move_to_QMARK___3 = function(rings, source, destination) {
-    if (cljs.core.truth_(rings.call(null, destination))) {
-      return false;
-    } else {
-      return can_move_to_QMARK_.call(null, rings, cljs.core.sorted_set.call(null, nonaga.rules.coord.tag_with_distance.call(null, destination, source)), cljs.core.sorted_set.call(null), destination, 0);
-    }
-  };
-  var can_move_to_QMARK___5 = function(rings, unexploded, exploded, destination, count) {
-    while (true) {
-      var next_choice = cljs.core.first.call(null, unexploded);
-      var vec__21365 = next_choice;
-      var _ = cljs.core.nth.call(null, vec__21365, 0, null);
-      var source = cljs.core.nth.call(null, vec__21365, 1, null);
-      var explosion = nonaga.rules.rings.neighbour_distances.call(null, rings, source, destination);
-      var new_exploded = cljs.core.conj.call(null, exploded, next_choice);
-      var new_unexploded = clojure.set.difference.call(null, cljs.core.into.call(null, unexploded, explosion), new_exploded);
-      if (cljs.core.truth_(new_unexploded.call(null, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, destination], null)))) {
-        return true;
-      } else {
-        if (cljs.core.empty_QMARK_.call(null, new_unexploded)) {
-          return false;
-        } else {
-          if (count > 100) {
-            return false;
-          } else {
-            var G__21366 = rings;
-            var G__21367 = new_unexploded;
-            var G__21368 = new_exploded;
-            var G__21369 = destination;
-            var G__21370 = count + 1;
-            rings = G__21366;
-            unexploded = G__21367;
-            exploded = G__21368;
-            destination = G__21369;
-            count = G__21370;
-            continue;
-          }
-        }
-      }
-      break;
-    }
-  };
-  can_move_to_QMARK_ = function(rings, unexploded, exploded, destination, count) {
-    switch(arguments.length) {
-      case 3:
-        return can_move_to_QMARK___3.call(this, rings, unexploded, exploded);
-      case 5:
-        return can_move_to_QMARK___5.call(this, rings, unexploded, exploded, destination, count);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  can_move_to_QMARK_.cljs$core$IFn$_invoke$arity$3 = can_move_to_QMARK___3;
-  can_move_to_QMARK_.cljs$core$IFn$_invoke$arity$5 = can_move_to_QMARK___5;
-  return can_move_to_QMARK_;
-}();
-nonaga.rules.rings.valid_destinations = function valid_destinations(rings, source) {
-  var other_rings = cljs.core.disj.call(null, rings, source);
-  var candidates = cljs.core.into.call(null, cljs.core.PersistentHashSet.EMPTY, cljs.core.map.call(null, cljs.core.first, cljs.core.filter.call(null, function(other_rings) {
-    return function(p__21373) {
-      var vec__21374 = p__21373;
-      var cell = cljs.core.nth.call(null, vec__21374, 0, null);
-      var neighbours = cljs.core.nth.call(null, vec__21374, 1, null);
-      return 1 < neighbours && neighbours < 6;
-    };
-  }(other_rings), cljs.core.frequencies.call(null, cljs.core.mapcat.call(null, nonaga.rules.coord.neighbours, other_rings)))));
-  var availables = clojure.set.difference.call(null, candidates, rings);
-  var slidables = cljs.core.filter.call(null, cljs.core.partial.call(null, nonaga.rules.rings.can_move_to_QMARK_, rings, source), availables);
-  return cljs.core.set.call(null, slidables);
-};
-nonaga.rules.rings.has_double_gap_QMARK_ = function has_double_gap_QMARK_(rings, coord) {
-  return!cljs.core.empty_QMARK_.call(null, cljs.core.filter.call(null, cljs.core.empty_QMARK_, cljs.core.map.call(null, cljs.core.partial.call(null, clojure.set.intersection, rings), cljs.core.map.call(null, cljs.core.set, cljs.core.apply.call(null, cljs.core.juxt, cljs.core.map.call(null, cljs.core.partial.call(null, cljs.core.apply, cljs.core.juxt), nonaga.rules.coord.side_by_side_directions)).call(null, coord)))));
-};
-nonaga.rules.rings.can_be_moved_QMARK_ = function can_be_moved_QMARK_(p__21375, coord) {
-  var map__21377 = p__21375;
-  var map__21377__$1 = cljs.core.seq_QMARK_.call(null, map__21377) ? cljs.core.apply.call(null, cljs.core.hash_map, map__21377) : map__21377;
-  var blue = cljs.core.get.call(null, map__21377__$1, new cljs.core.Keyword(null, "blue", "blue", 1016931276));
-  var red = cljs.core.get.call(null, map__21377__$1, new cljs.core.Keyword(null, "red", "red", 1014017027));
-  var rings = cljs.core.get.call(null, map__21377__$1, new cljs.core.Keyword(null, "rings", "rings", 1122422709));
-  var num_neighbours = cljs.core.count.call(null, clojure.set.intersection.call(null, nonaga.rules.coord.neighbours.call(null, coord), rings));
-  var and__3396__auto__ = rings.call(null, coord);
-  if (cljs.core.truth_(and__3396__auto__)) {
-    return cljs.core.not.call(null, function() {
-      var or__3408__auto__ = red.call(null, coord);
-      if (cljs.core.truth_(or__3408__auto__)) {
-        return or__3408__auto__;
-      } else {
-        return blue.call(null, coord);
-      }
-    }()) && (num_neighbours < 5 && nonaga.rules.rings.has_double_gap_QMARK_.call(null, rings, coord));
-  } else {
-    return and__3396__auto__;
-  }
-};
-goog.provide("nonaga.react");
-goog.require("cljs.core");
-nonaga.react.div = function() {
-  var div__delegate = function(props, children) {
-    return React.DOM.div(cljs.core.clj__GT_js.call(null, props), cljs.core.clj__GT_js.call(null, children));
-  };
-  var div = function(props, var_args) {
-    var children = null;
-    if (arguments.length > 1) {
-      children = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
-    }
-    return div__delegate.call(this, props, children);
-  };
-  div.cljs$lang$maxFixedArity = 1;
-  div.cljs$lang$applyTo = function(arglist__8511) {
-    var props = cljs.core.first(arglist__8511);
-    var children = cljs.core.rest(arglist__8511);
-    return div__delegate(props, children);
-  };
-  div.cljs$core$IFn$_invoke$arity$variadic = div__delegate;
-  return div;
-}();
-nonaga.react.p = function() {
-  var p__delegate = function(props, children) {
-    return React.DOM.p(cljs.core.clj__GT_js.call(null, props), cljs.core.clj__GT_js.call(null, children));
-  };
-  var p = function(props, var_args) {
-    var children = null;
-    if (arguments.length > 1) {
-      children = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
-    }
-    return p__delegate.call(this, props, children);
-  };
-  p.cljs$lang$maxFixedArity = 1;
-  p.cljs$lang$applyTo = function(arglist__8512) {
-    var props = cljs.core.first(arglist__8512);
-    var children = cljs.core.rest(arglist__8512);
-    return p__delegate(props, children);
-  };
-  p.cljs$core$IFn$_invoke$arity$variadic = p__delegate;
-  return p;
-}();
-nonaga.react.svg = function() {
-  var svg__delegate = function(props, children) {
-    return React.DOM.svg(cljs.core.clj__GT_js.call(null, props), cljs.core.clj__GT_js.call(null, children));
-  };
-  var svg = function(props, var_args) {
-    var children = null;
-    if (arguments.length > 1) {
-      children = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0);
-    }
-    return svg__delegate.call(this, props, children);
-  };
-  svg.cljs$lang$maxFixedArity = 1;
-  svg.cljs$lang$applyTo = function(arglist__8513) {
-    var props = cljs.core.first(arglist__8513);
-    var children = cljs.core.rest(arglist__8513);
-    return svg__delegate(props, children);
-  };
-  svg.cljs$core$IFn$_invoke$arity$variadic = svg__delegate;
-  return svg;
-}();
-nonaga.react.circle = function circle(props) {
-  return React.DOM.circle(cljs.core.clj__GT_js.call(null, props));
-};
-nonaga.react.create_class = function() {
-  var create_class__delegate = function(p__8514) {
-    var map__8516 = p__8514;
-    var map__8516__$1 = cljs.core.seq_QMARK_.call(null, map__8516) ? cljs.core.apply.call(null, cljs.core.hash_map, map__8516) : map__8516;
-    var config = map__8516__$1;
-    return React.createClass(cljs.core.clj__GT_js.call(null, config));
-  };
-  var create_class = function(var_args) {
-    var p__8514 = null;
-    if (arguments.length > 0) {
-      p__8514 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0);
-    }
-    return create_class__delegate.call(this, p__8514);
-  };
-  create_class.cljs$lang$maxFixedArity = 0;
-  create_class.cljs$lang$applyTo = function(arglist__8517) {
-    var p__8514 = cljs.core.seq(arglist__8517);
-    return create_class__delegate(p__8514);
-  };
-  create_class.cljs$core$IFn$_invoke$arity$variadic = create_class__delegate;
-  return create_class;
-}();
-nonaga.react.render_component = function render_component(component, node) {
-  return React.renderComponent(component, node);
-};
-goog.provide("nonaga.draw");
-goog.require("cljs.core");
-goog.require("nonaga.react");
-goog.require("nonaga.rules.rings");
-goog.require("nonaga.rules.rings");
-goog.require("nonaga.rules.ball");
-goog.require("nonaga.rules.ball");
-goog.require("nonaga.core");
-goog.require("nonaga.core");
-goog.require("nonaga.react");
-nonaga.draw.hex__GT_svg = function hex__GT_svg(p__22287) {
-  var vec__22289 = p__22287;
-  var hex_x = cljs.core.nth.call(null, vec__22289, 0, null);
-  var hex_y = cljs.core.nth.call(null, vec__22289, 1, null);
-  var width = 40;
-  var half = width / 2;
-  var svg_x = 160 + width * hex_x + (cljs.core.odd_QMARK_.call(null, hex_y) ? half : 0);
-  var svg_y = 160 + width * hex_y;
-  return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [svg_x, svg_y], null);
-};
-nonaga.draw.ring = function() {
-  var ring = null;
-  var ring__2 = function(color, coord) {
-    return ring.call(null, color, null, coord);
-  };
-  var ring__3 = function(color, click, p__22290) {
-    var vec__22292 = p__22290;
-    var x = cljs.core.nth.call(null, vec__22292, 0, null);
-    var y = cljs.core.nth.call(null, vec__22292, 1, null);
-    var coord = vec__22292;
-    return nonaga.react.circle.call(null, cljs.core.PersistentHashMap.fromArrays(["fill", "onClick", "strokeWidth", "style", "r", "cx", "cy", "stroke", "key"], ["transparent", click, "7px", new cljs.core.PersistentArrayMap(null, 1, ["cursor", cljs.core.truth_(click) ? "pointer" : null], null), 14, x, y, color, [cljs.core.str("ring:"), cljs.core.str(x), cljs.core.str(","), cljs.core.str(y)].join("")]));
-  };
-  ring = function(color, click, p__22290) {
-    switch(arguments.length) {
-      case 2:
-        return ring__2.call(this, color, click);
-      case 3:
-        return ring__3.call(this, color, click, p__22290);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  ring.cljs$core$IFn$_invoke$arity$2 = ring__2;
-  ring.cljs$core$IFn$_invoke$arity$3 = ring__3;
-  return ring;
-}();
-nonaga.draw.marble = function() {
-  var marble = null;
-  var marble__2 = function(color, coord) {
-    return marble.call(null, color, null, coord);
-  };
-  var marble__3 = function(color, click, p__22293) {
-    var vec__22295 = p__22293;
-    var x = cljs.core.nth.call(null, vec__22295, 0, null);
-    var y = cljs.core.nth.call(null, vec__22295, 1, null);
-    var coord = vec__22295;
-    return nonaga.react.circle.call(null, new cljs.core.PersistentArrayMap(null, 7, ["cx", x, "cy", y, "r", 8, "fill", cljs.core.name.call(null, color), "onClick", click, "style", new cljs.core.PersistentArrayMap(null, 1, ["cursor", cljs.core.truth_(click) ? "pointer" : null], null), "key", [cljs.core.str("marble"), cljs.core.str(x), cljs.core.str(","), cljs.core.str(y)].join("")], null));
-  };
-  marble = function(color, click, p__22293) {
-    switch(arguments.length) {
-      case 2:
-        return marble__2.call(this, color, click);
-      case 3:
-        return marble__3.call(this, color, click, p__22293);
-    }
-    throw new Error("Invalid arity: " + arguments.length);
-  };
-  marble.cljs$core$IFn$_invoke$arity$2 = marble__2;
-  marble.cljs$core$IFn$_invoke$arity$3 = marble__3;
-  return marble;
-}();
-nonaga.draw.opposite = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.Keyword(null, "blue", "blue", 1016931276), new cljs.core.Keyword(null, "blue", "blue", 1016931276), new cljs.core.Keyword(null, "red", "red", 1014017027)], null);
-nonaga.draw.light_colors = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "red", "red", 1014017027), new cljs.core.Keyword(null, "pink", "pink", 1017345256), new cljs.core.Keyword(null, "blue", "blue", 1016931276), new cljs.core.Keyword(null, "lightblue", "lightblue", 1699995106)], null);
-nonaga.draw.update_state = function update_state(component, update_fn) {
-  return function() {
-    var old_state = component.state.wrapper;
-    return component.setState({"wrapper":update_fn.call(null, old_state)});
-  };
-};
-nonaga.draw.move_marble = function move_marble(component, color, from, to) {
-  return nonaga.draw.update_state.call(null, component, function(p1__22296_SHARP_) {
-    return cljs.core.assoc.call(null, nonaga.core.move_ball.call(null, p1__22296_SHARP_, color, from, to), new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "marble-moved", "marble-moved", 2104727445), color], null));
-  });
-};
-nonaga.draw.draw_valid_marble_moves = function draw_valid_marble_moves(component, state) {
-  var vec__22299 = (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state);
-  var type = cljs.core.nth.call(null, vec__22299, 0, null);
-  var event_data = cljs.core.nthnext.call(null, vec__22299, 1);
-  if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885), type)) {
-    var vec__22300 = event_data;
-    var color = cljs.core.nth.call(null, vec__22300, 0, null);
-    var selected = cljs.core.nth.call(null, vec__22300, 1, null);
-    return cljs.core.map.call(null, function(hex) {
-      return nonaga.draw.marble.call(null, nonaga.draw.light_colors.call(null, color), nonaga.draw.move_marble.call(null, component, color, selected, hex), nonaga.draw.hex__GT_svg.call(null, hex));
-    }, nonaga.rules.ball.valid_destinations.call(null, state, selected));
-  } else {
-    return null;
-  }
-};
-nonaga.draw.start_marble_move = function start_marble_move(component, color, coord) {
-  return nonaga.draw.update_state.call(null, component, function(p1__22301_SHARP_) {
-    return cljs.core.assoc.call(null, p1__22301_SHARP_, new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885), color, coord], null));
-  });
-};
-nonaga.draw.draw_marbles = function draw_marbles(component, state, color) {
-  var etype = cljs.core.get_in.call(null, state, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "event", "event", 1110795788), 0], null));
-  var cp = cljs.core.get_in.call(null, state, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "event", "event", 1110795788), 1], null));
-  var coords = color.call(null, state);
-  var click = cljs.core.partial.call(null, nonaga.draw.start_marble_move, component);
-  return cljs.core.map.call(null, function(hex, svg) {
-    return nonaga.draw.marble.call(null, color, (cljs.core._EQ_.call(null, etype, new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291)) || cljs.core._EQ_.call(null, etype, new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885))) && cljs.core._EQ_.call(null, cp, color) ? click.call(null, color, hex) : null, svg);
-  }, coords, cljs.core.map.call(null, nonaga.draw.hex__GT_svg, coords));
-};
-nonaga.draw.ring_selected = function ring_selected(component, color, coord) {
-  return nonaga.draw.update_state.call(null, component, function(p1__22302_SHARP_) {
-    return cljs.core.assoc.call(null, p1__22302_SHARP_, new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), color, coord], null));
-  });
-};
-nonaga.draw.draw_rings = function draw_rings(component, state) {
-  var vec__22305 = (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state);
-  var type = cljs.core.nth.call(null, vec__22305, 0, null);
-  var event_data = cljs.core.nthnext.call(null, vec__22305, 1);
-  var coords = (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(state);
-  return cljs.core.map.call(null, function(hex, svg) {
-    if (cljs.core.truth_(function() {
-      var and__3396__auto__ = cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "marble-moved", "marble-moved", 2104727445), type) || cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), type);
-      if (and__3396__auto__) {
-        return nonaga.rules.rings.can_be_moved_QMARK_.call(null, state, hex);
-      } else {
-        return and__3396__auto__;
-      }
-    }())) {
-      var vec__22306 = event_data;
-      var color = cljs.core.nth.call(null, vec__22306, 0, null);
-      return nonaga.draw.ring.call(null, "#444", nonaga.draw.ring_selected.call(null, component, color, hex), svg);
-    } else {
-      return nonaga.draw.ring.call(null, "#999", svg);
-    }
-  }, coords, cljs.core.map.call(null, nonaga.draw.hex__GT_svg, coords));
-};
-nonaga.draw.move_ring = function move_ring(component, color, from, to) {
-  return nonaga.draw.update_state.call(null, component, function(p1__22307_SHARP_) {
-    return cljs.core.assoc.call(null, cljs.core.assoc.call(null, nonaga.core.move_ring.call(null, p1__22307_SHARP_, from, to), new cljs.core.Keyword(null, "last-ring", "last-ring", 2980977273), to), new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291), nonaga.draw.opposite.call(null, color)], null));
-  });
-};
-nonaga.draw.draw_potential_rings = function draw_potential_rings(component, state) {
-  var vec__22310 = (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state);
-  var type = cljs.core.nth.call(null, vec__22310, 0, null);
-  var event_data = cljs.core.nthnext.call(null, vec__22310, 1);
-  var coords = (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(state);
-  if (cljs.core._EQ_.call(null, new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), type)) {
-    var vec__22311 = event_data;
-    var color = cljs.core.nth.call(null, vec__22311, 0, null);
-    var source = cljs.core.nth.call(null, vec__22311, 1, null);
-    var destinations = nonaga.rules.rings.valid_destinations.call(null, coords, source);
-    return cljs.core.map.call(null, function(hex, svg) {
-      return nonaga.draw.ring.call(null, "#DDD", nonaga.draw.move_ring.call(null, component, color, source, hex), svg);
-    }, destinations, cljs.core.map.call(null, nonaga.draw.hex__GT_svg, destinations));
-  } else {
-    return null;
-  }
-};
-nonaga.draw.color_name = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "red", "red", 1014017027), "Red", new cljs.core.Keyword(null, "blue", "blue", 1016931276), "Blue"], null);
-nonaga.draw.instructions = function() {
-  var method_table__4242__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var prefer_table__4243__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var method_cache__4244__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var cached_hierarchy__4245__auto__ = cljs.core.atom.call(null, cljs.core.PersistentArrayMap.EMPTY);
-  var hierarchy__4246__auto__ = cljs.core.get.call(null, cljs.core.PersistentArrayMap.EMPTY, new cljs.core.Keyword(null, "hierarchy", "hierarchy", 3129050535), cljs.core.get_global_hierarchy.call(null));
-  return new cljs.core.MultiFn("instructions", cljs.core.first, new cljs.core.Keyword(null, "default", "default", 2558708147), hierarchy__4246__auto__, method_table__4242__auto__, prefer_table__4243__auto__, method_cache__4244__auto__, cached_hierarchy__4245__auto__);
-}();
-cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291), function(p__22312) {
-  var vec__22313 = p__22312;
-  var type = cljs.core.nth.call(null, vec__22313, 0, null);
-  var color = cljs.core.nth.call(null, vec__22313, 1, null);
-  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects a marble to move.")].join("");
-});
-cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "marble-selected", "marble-selected", 3301001885), function(p__22314) {
-  var vec__22315 = p__22314;
-  var type = cljs.core.nth.call(null, vec__22315, 0, null);
-  var color = cljs.core.nth.call(null, vec__22315, 1, null);
-  var source = cljs.core.nth.call(null, vec__22315, 2, null);
-  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects where to move the marble.")].join("");
-});
-cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "marble-moved", "marble-moved", 2104727445), function(p__22316) {
-  var vec__22317 = p__22316;
-  var type = cljs.core.nth.call(null, vec__22317, 0, null);
-  var color = cljs.core.nth.call(null, vec__22317, 1, null);
-  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects a ring to move.")].join("");
-});
-cljs.core._add_method.call(null, nonaga.draw.instructions, new cljs.core.Keyword(null, "ring-selected", "ring-selected", 897807626), function(p__22318) {
-  var vec__22319 = p__22318;
-  var type = cljs.core.nth.call(null, vec__22319, 0, null);
-  var color = cljs.core.nth.call(null, vec__22319, 1, null);
-  var source = cljs.core.nth.call(null, vec__22319, 2, null);
-  return[cljs.core.str(nonaga.draw.color_name.call(null, color)), cljs.core.str(" selects where to move the ring.")].join("");
-});
-nonaga.draw.board = nonaga.react.create_class.call(null, "getInitialState", function() {
-  var this$ = this;
-  var initial_state = cljs.core.assoc.call(null, nonaga.core.initial_game, new cljs.core.Keyword(null, "event", "event", 1110795788), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "turn-began", "turn-began", 4304334291), new cljs.core.Keyword(null, "red", "red", 1014017027)], null));
-  return{"wrapper":initial_state};
-}, "render", function() {
-  var this$ = this;
-  var state = this$.state.wrapper;
-  return nonaga.react.div.call(null, cljs.core.PersistentArrayMap.EMPTY, nonaga.react.p.call(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "id", "id", 1013907597), "instructions"], null), nonaga.draw.instructions.call(null, (new cljs.core.Keyword(null, "event", "event", 1110795788)).cljs$core$IFn$_invoke$arity$1(state))), nonaga.react.svg.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "width", "width", 1127031096), 480, new cljs.core.Keyword(null, 
-  "height", "height", 4087841945), 480], null), nonaga.draw.draw_rings.call(null, this$, state), nonaga.draw.draw_potential_rings.call(null, this$, state), function() {
-    var temp__4090__auto__ = (new cljs.core.Keyword(null, "last-ring", "last-ring", 2980977273)).cljs$core$IFn$_invoke$arity$1(state);
-    if (cljs.core.truth_(temp__4090__auto__)) {
-      var last_ring = temp__4090__auto__;
-      return nonaga.draw.ring.call(null, "#000", nonaga.draw.hex__GT_svg.call(null, last_ring));
-    } else {
-      return null;
-    }
-  }(), nonaga.draw.draw_marbles.call(null, this$, state, new cljs.core.Keyword(null, "red", "red", 1014017027)), nonaga.draw.draw_marbles.call(null, this$, state, new cljs.core.Keyword(null, "blue", "blue", 1016931276)), nonaga.draw.draw_valid_marble_moves.call(null, this$, state)));
-});
-nonaga.draw.start = function start() {
-  return nonaga.react.render_component.call(null, nonaga.draw.board.call(null), document.getElementById("content"));
-};
-goog.provide("nonaga.rules.ring_test");
-goog.require("cljs.core");
-goog.require("nonaga.core");
-goog.require("clojure.set");
-goog.require("nonaga.rules.rings");
-goog.require("nonaga.rules.coord");
-goog.require("cemerick.cljs.test");
-goog.require("cemerick.cljs.test");
-goog.require("clojure.set");
-goog.require("nonaga.rules.coord");
-goog.require("nonaga.rules.rings");
-goog.require("nonaga.core");
-nonaga.rules.ring_test.board_with_gap = cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true);
-nonaga.rules.ring_test.which_slides_are_valid = function which_slides_are_valid() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.which_slides_are_valid);
-};
-nonaga.rules.ring_test.which_slides_are_valid = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.which_slides_are_valid, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "which-slides-are-valid", "which-slides-are-valid", 1667419009, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function which_slides_are_valid_test() {
-  try {
-    var values__5008__auto___22185 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_slide_QMARK_.call(null, (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(nonaga.core.initial_game), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), nonaga.rules.coord.ne)), false);
-    var result__5009__auto___22186 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22185);
-    if (cljs.core.truth_(result__5009__auto___22186)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22185), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22185)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
-    }
-  } catch (e22181) {
-    if (e22181 instanceof Error) {
-      var t__5045__auto___22187 = e22181;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22187, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22181;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22188 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_slide_QMARK_.call(null, (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(nonaga.core.initial_game), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), nonaga.rules.coord.se)), true);
-    var result__5009__auto___22189 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22188);
-    if (cljs.core.truth_(result__5009__auto___22189)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22188), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "se", "se", -1640527861, null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22188)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "se", "se", -1640527861, null)))], null));
-    }
-  } catch (e22182) {
-    if (e22182 instanceof Error) {
-      var t__5045__auto___22190 = e22182;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22190, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      true, cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "se", "se", -1640527861, null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22182;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22191 = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_slide_QMARK_.call(null, nonaga.rules.ring_test.board_with_gap, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), nonaga.rules.coord.ne));
-    var result__5009__auto___22192 = cljs.core.apply.call(null, cljs.core.not, values__5008__auto___22191);
-    if (cljs.core.truth_(result__5009__auto___22192)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto___22191), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto___22191)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), new cljs.core.Symbol(null, 
-      "ne", "ne", -1640528016, null)))], null));
-    }
-  } catch (e22183) {
-    if (e22183 instanceof Error) {
-      var t__5045__auto___22193 = e22183;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22193, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
-      "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22183;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.coord.ne), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null)), nonaga.rules.ring_test.board_with_gap);
-    var result__5009__auto__ = cljs.core.apply.call(null, nonaga.rules.rings.valid_slide_QMARK_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, nonaga.rules.rings.valid_slide_QMARK_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", 
-      "fail", 1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null))], null));
-    }
-    return result__5009__auto__;
-  } catch (e22184) {
-    if (e22184 instanceof Error) {
-      var t__5045__auto__ = e22184;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "valid-slide?", "valid-slide?", 513612120, 
-      null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.Symbol(null, "ne", "ne", -1640528016, null))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22184;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.which_slides_are_valid);
-nonaga.rules.ring_test.enumerate_valid_directions_to_slide = function enumerate_valid_directions_to_slide() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.enumerate_valid_directions_to_slide);
-};
-nonaga.rules.ring_test.enumerate_valid_directions_to_slide = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.enumerate_valid_directions_to_slide, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "enumerate-valid-directions-to-slide", "enumerate-valid-directions-to-slide", -9756425, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function enumerate_valid_directions_to_slide_test() {
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.count.call(null, nonaga.rules.rings.valid_slides.call(null, nonaga.rules.ring_test.board_with_gap, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null)))), 3);
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), 3, cljs.core.list(new cljs.core.Symbol(null, "count", "count", -1545680184, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slides", "valid-slides", 513612172, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null))))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 3, cljs.core.list(new cljs.core.Symbol(null, "count", "count", -1545680184, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slides", "valid-slides", 513612172, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null))))], null));
-    }
-    return result__5009__auto__;
-  } catch (e22195) {
-    if (e22195 instanceof Error) {
-      var t__5045__auto__ = e22195;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      3, cljs.core.list(new cljs.core.Symbol(null, "count", "count", -1545680184, null), cljs.core.list(new cljs.core.Symbol(null, "valid-slides", "valid-slides", 513612172, null), new cljs.core.Symbol(null, "board-with-gap", "board-with-gap", -56012273, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null))))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22195;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.enumerate_valid_directions_to_slide);
-nonaga.rules.ring_test.path_finding = function path_finding() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.path_finding);
-};
-nonaga.rules.ring_test.path_finding = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.path_finding, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "path-finding", "path-finding", 1667655578, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function path_finding_test() {
-  try {
-    var values__5008__auto___22212 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), 
-    true);
-    var result__5009__auto___22213 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22212);
-    if (cljs.core.truth_(result__5009__auto___22213)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22212), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22212)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-  } catch (e22204) {
-    if (e22204 instanceof Error) {
-      var t__5045__auto___22214 = e22204;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22214, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22204;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22215 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), false);
-    var result__5009__auto___22216 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22215);
-    if (cljs.core.truth_(result__5009__auto___22216)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22215), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22215)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-  } catch (e22205) {
-    if (e22205 instanceof Error) {
-      var t__5045__auto___22217 = e22205;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22217, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22205;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22218 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), true);
-    var result__5009__auto___22219 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22218);
-    if (cljs.core.truth_(result__5009__auto___22219)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22218), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22218)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-  } catch (e22206) {
-    if (e22206 instanceof Error) {
-      var t__5045__auto___22220 = e22206;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22220, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22206;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22221 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-    [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), true);
-    var result__5009__auto___22222 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22221);
-    if (cljs.core.truth_(result__5009__auto___22222)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22221), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22221)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
-      2], null)))], null));
-    }
-  } catch (e22207) {
-    if (e22207 instanceof Error) {
-      var t__5045__auto___22223 = e22207;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22223, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      true, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 3], null), 
-      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22207;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22224 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-    [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 
-    2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), false);
-    var result__5009__auto___22225 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22224);
-    if (cljs.core.truth_(result__5009__auto___22225)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22224), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22224)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-  } catch (e22208) {
-    if (e22208 instanceof Error) {
-      var t__5045__auto___22226 = e22208;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22226, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), 
-      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22208;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22227 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-    [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
-    2], null))), false);
-    var result__5009__auto___22228 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22227);
-    if (cljs.core.truth_(result__5009__auto___22228)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22227), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22227)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], 
-      null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-  } catch (e22209) {
-    if (e22209 instanceof Error) {
-      var t__5045__auto___22229 = e22209;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22229, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-2, 3], 
-      null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 4], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], 
-      null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22209;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22230 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-    [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
-    2], null))), false);
-    var result__5009__auto___22231 = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto___22230);
-    if (cljs.core.truth_(result__5009__auto___22231)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto___22230), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 
-      2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto___22230)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], 
-      true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-  } catch (e22210) {
-    if (e22210 instanceof Error) {
-      var t__5045__auto___22232 = e22210;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22232, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), 
-      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], 
-      null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22210;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_move_to_QMARK_.call(null, cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-    [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null))), false);
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 
-      2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    }
-    return result__5009__auto__;
-  } catch (e22211) {
-    if (e22211 instanceof Error) {
-      var t__5045__auto__ = e22211;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      false, cljs.core.list(new cljs.core.Symbol(null, "can-move-to?", "can-move-to?", 64841790, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [6, 2], null), 
-      new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [5, 3], null)], true), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22211;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.path_finding);
-nonaga.rules.ring_test.knows_where_you_can_go = function knows_where_you_can_go() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.knows_where_you_can_go);
-};
-nonaga.rules.ring_test.knows_where_you_can_go = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.knows_where_you_can_go, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "knows-where-you-can-go", "knows-where-you-can-go", -538163273, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function knows_where_you_can_go_test() {
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.valid_destinations.call(null, (new cljs.core.Keyword(null, "rings", "rings", 1122422709)).cljs$core$IFn$_invoke$arity$1(nonaga.core.initial_game), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], 
-    null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 
-    2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, -1], null)], true));
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core._EQ_, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core._EQ_, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [2, -1], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, -1], null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 
-      2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    }
-    return result__5009__auto__;
-  } catch (e22234) {
-    if (e22234 instanceof Error) {
-      var t__5045__auto__ = e22234;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "\x3d", "\x3d", -1640531466, null), 
-      cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, -1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-      [-1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 5], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [-1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 0], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, -1], 
-      null)], true), cljs.core.list(new cljs.core.Symbol(null, "valid-destinations", "valid-destinations", -1542969841, null), cljs.core.list(new cljs.core.Keyword(null, "rings", "rings", 1122422709), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null)), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22234;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.knows_where_you_can_go);
-nonaga.rules.ring_test.knows_what_can_moved = function knows_what_can_moved() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.knows_what_can_moved);
-};
-nonaga.rules.ring_test.knows_what_can_moved = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.knows_what_can_moved, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "knows-what-can-moved", "knows-what-can-moved", -1622980213, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function knows_what_can_moved_test() {
-  try {
-    var values__5008__auto___22239 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null)), nonaga.core.initial_game);
-    var result__5009__auto___22240 = cljs.core.apply.call(null, nonaga.rules.rings.can_be_moved_QMARK_, values__5008__auto___22239);
-    if (cljs.core.truth_(result__5009__auto___22240)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, nonaga.rules.rings.can_be_moved_QMARK_, values__5008__auto___22239), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), values__5008__auto___22239)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, 
-      "fail", "fail", 1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))], null));
-    }
-  } catch (e22237) {
-    if (e22237 instanceof Error) {
-      var t__5045__auto___22241 = e22237;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22241, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, 
-      null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 4], null))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22237;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.can_be_moved_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)));
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core.not, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 1017039504), 
-      new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    }
-    return result__5009__auto__;
-  } catch (e22238) {
-    if (e22238 instanceof Error) {
-      var t__5045__auto__ = e22238;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
-      "can-be-moved?", "can-be-moved?", 2067106994, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22238;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.knows_what_can_moved);
-nonaga.rules.ring_test.one_each_way = new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "rings", "rings", 1122422709), cljs.core.PersistentHashSet.fromArray([new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 0], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, 
-[0, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [0, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 0], null), new cljs.core.PersistentVector(null, 
-2, 5, cljs.core.PersistentVector.EMPTY_NODE, [3, 1], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [4, 2], null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 0], null)], true)], null);
-nonaga.rules.ring_test.has_double_gap_QMARK__test = function has_double_gap_QMARK__test() {
-  return cemerick.cljs.test.test_function.call(null, nonaga.rules.ring_test.has_double_gap_QMARK__test);
-};
-nonaga.rules.ring_test.has_double_gap_QMARK__test = cljs.core.vary_meta.call(null, nonaga.rules.ring_test.has_double_gap_QMARK__test, cljs.core.assoc, new cljs.core.Keyword(null, "name", "name", 1017277949), new cljs.core.Symbol(null, "has-double-gap?-test", "has-double-gap?-test", 1097403718, null), new cljs.core.Keyword(null, "test", "test", 1017460740), function has_double_gap_QMARK__test_test() {
-  try {
-    var values__5008__auto___22248 = cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null)), nonaga.core.initial_game);
-    var result__5009__auto___22249 = cljs.core.apply.call(null, nonaga.rules.rings.has_double_gap_QMARK_, values__5008__auto___22248);
-    if (cljs.core.truth_(result__5009__auto___22249)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, nonaga.rules.rings.has_double_gap_QMARK_, values__5008__auto___22248), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), values__5008__auto___22248)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, 
-      "fail", "fail", 1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))], null));
-    }
-  } catch (e22245) {
-    if (e22245 instanceof Error) {
-      var t__5045__auto___22250 = e22245;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22250, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", 
-      -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 4], null))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22245;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto___22251 = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.has_double_gap_QMARK_.call(null, nonaga.core.initial_game, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)));
-    var result__5009__auto___22252 = cljs.core.apply.call(null, cljs.core.not, values__5008__auto___22251);
-    if (cljs.core.truth_(result__5009__auto___22252)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto___22251), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto___22251)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 
-      1017039504), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], 
-      null));
-    }
-  } catch (e22246) {
-    if (e22246 instanceof Error) {
-      var t__5045__auto___22253 = e22246;
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto___22253, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
-      "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "initial-game", "initial-game", -2096596332, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [2, 2], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22246;
-      } else {
-      }
-    }
-  }
-  try {
-    var values__5008__auto__ = cljs.core._conj.call(null, cljs.core.List.EMPTY, nonaga.rules.rings.has_double_gap_QMARK_.call(null, nonaga.rules.ring_test.one_each_way, new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)));
-    var result__5009__auto__ = cljs.core.apply.call(null, cljs.core.not, values__5008__auto__);
-    if (cljs.core.truth_(result__5009__auto__)) {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core.cons.call(null, cljs.core.not, values__5008__auto__), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "pass", "pass", 1017337731), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, 
-      "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "one-each-way", "one-each-way", 358013539, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)))], null));
-    } else {
-      cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), cljs.core._conj.call(null, cljs.core._conj.call(null, cljs.core.List.EMPTY, cljs.core.cons.call(null, new cljs.core.Symbol(null, "not", "not", -1640422260, null), values__5008__auto__)), new cljs.core.Symbol(null, "not", "not", -1640422260, null)), new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "fail", "fail", 1017039504), 
-      new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "one-each-way", "one-each-way", 358013539, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)))], null));
-    }
-    return result__5009__auto__;
-  } catch (e22247) {
-    if (e22247 instanceof Error) {
-      var t__5045__auto__ = e22247;
-      return cemerick.cljs.test.do_report.call(null, new cljs.core.PersistentArrayMap(null, 4, [new cljs.core.Keyword(null, "actual", "actual", 3885931776), t__5045__auto__, new cljs.core.Keyword(null, "type", "type", 1017479852), new cljs.core.Keyword(null, "error", "error", 1110689146), new cljs.core.Keyword(null, "message", "message", 1968829305), null, new cljs.core.Keyword(null, "expected", "expected", 3373152810), cljs.core.list(new cljs.core.Symbol(null, "not", "not", -1640422260, null), cljs.core.list(new cljs.core.Symbol(null, 
-      "has-double-gap?", "has-double-gap?", -800672853, null), new cljs.core.Symbol(null, "one-each-way", "one-each-way", 358013539, null), new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [1, 3], null)))], null));
-    } else {
-      if (new cljs.core.Keyword(null, "else", "else", 1017020587)) {
-        throw e22247;
-      } else {
-        return null;
-      }
-    }
-  }
-});
-cemerick.cljs.test.register_test_BANG_.call(null, new cljs.core.Symbol(null, "nonaga.rules.ring-test", "nonaga.rules.ring-test", 1139943601, null), nonaga.rules.ring_test.has_double_gap_QMARK__test);

From 4efddc47c9f9162a289d305a202f72e3f5f0db15 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Mon, 20 Jan 2014 18:22:47 +1100
Subject: [PATCH 06/39] fixed failing test data

---
 test/nonaga/rules/ball_test.cljs  |  2 +-
 test/nonaga/rules/rings_test.cljs | 17 ++++++++---------
 test/nonaga/setup.cljs            |  2 +-
 3 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/test/nonaga/rules/ball_test.cljs b/test/nonaga/rules/ball_test.cljs
index 95d93bb..3ae34c5 100644
--- a/test/nonaga/rules/ball_test.cljs
+++ b/test/nonaga/rules/ball_test.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.ball-test
+(ns nonaga.rules.ball-test
   (:require-macros [cemerick.cljs.test :refer (deftest is are)])
   (:use [nonaga.core :only [initial-game]]
         [nonaga.rules.ball :only [invalid-space? move valid-destinations]]
diff --git a/test/nonaga/rules/rings_test.cljs b/test/nonaga/rules/rings_test.cljs
index c71a01c..20b89d7 100644
--- a/test/nonaga/rules/rings_test.cljs
+++ b/test/nonaga/rules/rings_test.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.rules.ring-test
+(ns nonaga.rules.rings-test
   (:require-macros [cemerick.cljs.test :refer (deftest is are)])
   (:use [nonaga.core :only [initial-game]]
         [nonaga.rules.rings :only [valid-slide? valid-slides can-move-to?
@@ -86,15 +86,14 @@
 
 
 (def one-each-way
-  {:rings
-    #{   [1 4]       [3 4]  
-             [1 3] [2 3] [3 3]
-     [0 2] [1 2] [2 2] [3 2] [4 2] 
-       [0 1] [1 1] [2 1] [3 1] 
-         [1 0] [2 0] [3 0]}})
+  #{   [1 4]       [3 4]  
+           [1 3] [2 3] [3 3]
+   [0 2] [1 2] [2 2] [3 2] [4 2] 
+     [0 1] [1 1] [2 1] [3 1] 
+       [1 0] [2 0] [3 0]})
 
 (deftest has-double-gap?-test
-  (is (has-double-gap?      initial-game [1 4]))
-  (is (not (has-double-gap? initial-game [2 2])))
+  (is (has-double-gap?      one-each-way [1 4]))
+  (is (not (has-double-gap? one-each-way [2 2])))
   (is (not (has-double-gap? one-each-way [1 3]))))
 
diff --git a/test/nonaga/setup.cljs b/test/nonaga/setup.cljs
index 04a550e..fa7b66e 100644
--- a/test/nonaga/setup.cljs
+++ b/test/nonaga/setup.cljs
@@ -5,5 +5,5 @@
         output (js/document.getElementById "test-output")]
     (.appendChild output new-text)))
 
-(set-print-fn! #(set-pre! %))
+(set-print-fn! set-pre!)
 

From aee38ae4059b8219f8b0f5f33cb1c9f1b20f964b Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Mon, 20 Jan 2014 18:46:22 +1100
Subject: [PATCH 07/39] removed events comments

---
 src/nonaga/draw.cljs | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index bc100b8..ef73dd2 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -5,30 +5,6 @@
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
-; Events
-;
-; [:turn-began :red]
-; - Clickable red marbles
-; [:marble-selected :red coords]
-; - Clickable red marbles
-; - Clickable pink marbles
-; [:marble-moved :red]
-; - Clickable moveable rings
-; [:ring-selected :ring coords]
-; - Clickable moveable rings
-; - Clickable light grey rings
-;
-; [:turn-began :blue]
-; - Clickable blue marbles
-; [:marble-selected :blue coords]
-; - Clickable blue marbles
-; - Clickable pink marbles
-; [:marble-moved :blue]
-; - Clickable moveable rings
-; [:ring-selected :ring coords]
-; - Clickable moveable rings
-; - Clickable light grey rings
-
 (defn hex->svg [[hex-x hex-y]]
   (let [width  40
         half (/ width 2)

From 028a7f7a992c7de7482b95833ba26f5c62a16ed8 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:24:14 +1100
Subject: [PATCH 08/39] added piggieback for clojurescript support in vim

---
 project.clj | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 658751f..f1c3abf 100644
--- a/project.clj
+++ b/project.clj
@@ -7,10 +7,13 @@
   :dependencies [[org.clojure/clojure "1.5.1"]
                  [org.clojure/clojurescript "6969"]
                  [prismatic/dommy "0.1.1"]
-                 [com.cemerick/clojurescript.test "0.2.1"]]
+                 [com.cemerick/clojurescript.test "0.2.1"]
+                 [com.cemerick/piggieback "0.1.2"]]
   :plugins [[lein-cljsbuild "1.0.1"]
             [com.cemerick/clojurescript.test "0.2.1"]]
+  :externs ["externs/react.js"]
   :hooks  [leiningen.cljsbuild]
+  :repl-options {:nrepl-middleware [cemerick.piggieback/wrap-cljs-repl]}
   :cljsbuild {:builds {:dev {:source-paths ["src"]
                              :compiler {:output-to "resources/js/main.js"
                                         :optimizations :whitespace

From 00a8a9d3c5489b578f9931a2ca25ccc0b1dec096 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:24:44 +1100
Subject: [PATCH 09/39] moved instructions into own ns

---
 .gitignore                        |   1 +
 externs/react.js                  | 909 ++++++++++++++++++++++++++++++
 src/nonaga/draw.cljs              |  21 +-
 src/nonaga/draw/instructions.cljs |  19 +
 4 files changed, 931 insertions(+), 19 deletions(-)
 create mode 100644 externs/react.js
 create mode 100644 src/nonaga/draw/instructions.cljs

diff --git a/.gitignore b/.gitignore
index a69a86d..9c621b4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -9,3 +9,4 @@ pom.xml.asc
 /.nrepl-port
 /resources/js/main.js
 /resources/js/test.js
+/.repl
diff --git a/externs/react.js b/externs/react.js
new file mode 100644
index 0000000..478753e
--- /dev/null
+++ b/externs/react.js
@@ -0,0 +1,909 @@
+/**
+ * @fileoverview Externs for React 0.5.1.
+ *
+ * @see http://facebook.github.io/react
+ * @externs
+ */
+
+/**
+ * @type {Object}
+ * @const
+ */
+var React = {};
+
+/**
+ * @type {string}
+ */
+React.version;
+
+/**
+ * @param {boolean} shouldUseTouch
+ */
+React.initializeTouchEvents = function(shouldUseTouch) {};
+
+/**
+ * @param {Object} specification
+ * @return {function(
+      Object=,
+      (string|React.ReactComponent|Array.<React.ReactComponent>)=
+    ): React.ReactComponent}
+ */
+React.createClass = function(specification) {};
+
+/**
+ * @param {*} componentClass
+ * @return {boolean}
+ */
+React.isValidClass = function(componentClass) {};
+
+/**
+ * @param {React.ReactComponent} container
+ * @param {Element} mountPoint
+ * @param {Function=} callback
+ * @return {React.ReactComponent}
+ */
+React.renderComponent = function(container, mountPoint, callback) {};
+
+/**
+ * @param {Element} container
+ */
+React.unmountComponentAtNode = function(container) {};
+
+/**
+ * @param {React.ReactComponent} component
+ * @param {Function} callback
+ */
+React.renderComponentToString = function(component, callback) {};
+
+/**
+ * Constructs a component instance of `constructor` with `initialProps` and
+ * renders it into the supplied `container`.
+ *
+ * @param {Function} constructor React component constructor.
+ * @param {Object} props Initial props of the component instance.
+ * @param {Element} container DOM element to render into.
+ * @return {React.ReactComponent} Component instance rendered in `container`.
+ */
+React.constructAndRenderComponent = function(constructor, props, container) {};
+
+/**
+ * Constructs a component instance of `constructor` with `initialProps` and
+ * renders it into a container node identified by supplied `id`.
+ *
+ * @param {Function} componentConstructor React component constructor
+ * @param {Object} props Initial props of the component instance.
+ * @param {string} id ID of the DOM element to render into.
+ * @return {React.ReactComponent} Component instance rendered in the container node.
+ */
+React.constructAndRenderComponentByID = function(componentConstructor, props, id) {};
+
+/**
+ * @interface
+ */
+React.ReactComponent = function() {};
+
+/**
+ * @type {Object}
+ */
+React.ReactComponent.prototype.props;
+
+/**
+ * @type {Object}
+ */
+React.ReactComponent.prototype.state;
+
+/**
+ * @type {Object}
+ */
+React.ReactComponent.prototype.refs;
+
+/**
+ * @type {Object}
+ */
+React.ReactComponent.prototype.context;
+
+/**
+ * @type {Object}
+ * @protected
+ */
+React.ReactComponent.prototype.propTypes;
+
+/**
+ * @type {Object}
+ * @protected
+ */
+React.ReactComponent.prototype.contextTypes;
+
+/**
+ * @param {Object} nextProps
+ * @param {Function=} callback
+ */
+React.ReactComponent.prototype.setProps = function(nextProps, callback) {};
+
+/**
+ * @return {Object}
+ */
+React.ReactComponent.prototype.getInitialState = function() {};
+
+/**
+ * @return {Object}
+ */
+React.ReactComponent.prototype.getDefaultProps = function() {};
+
+/**
+ * @return {Object}
+ */
+React.ReactComponent.prototype.getChildContext = function() {};
+
+/**
+ * @return {Element}
+ */
+React.ReactComponent.prototype.getDOMNode = function() {};
+
+/**
+ * @param {Object} nextProps
+ * @param {Function=} callback
+ */
+React.ReactComponent.prototype.replaceProps = function(nextProps, callback) {};
+
+/**
+ * @param {React.ReactComponent} targetComponent
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.ReactComponent.prototype.transferPropsTo = function(targetComponent) {};
+
+/**
+ * @param {Function=} callback
+ * @protected
+ */
+React.ReactComponent.prototype.forceUpdate = function(callback) {};
+
+/**
+ * @param {Object} nextState
+ * @param {Function=} callback
+ * @protected
+ */
+React.ReactComponent.prototype.setState = function(nextState, callback) {};
+
+/**
+ * @param {Object} nextState
+ * @param {Function=} callback
+ * @protected
+ */
+React.ReactComponent.prototype.replaceState = function(nextState, callback) {};
+
+/**
+ * @param {Element} element
+ * @protected
+ */
+React.ReactComponent.prototype.componentDidMount = function(element) {};
+
+/**
+ * @param {Object} nextProps
+ * @protected
+ */
+React.ReactComponent.prototype.componentWillReceiveProps = function(
+  nextProps) {};
+
+/**
+ * @param {Object} nextProps
+ * @param {Object} nextState
+ * @return {boolean}
+ * @protected
+ */
+React.ReactComponent.prototype.shouldComponentUpdate = function(
+  nextProps, nextState) {};
+
+/**
+ * @param {Object} nextProps
+ * @param {Object} nextState
+ * @protected
+ */
+React.ReactComponent.prototype.componentWillUpdate = function(
+  nextProps, nextState) {};
+
+/**
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.ReactComponent.prototype.render = function() {};
+
+/**
+ * @param {Object} prevProps
+ * @param {Object} prevState
+ * @param {Element} element
+ * @protected
+ */
+React.ReactComponent.prototype.componentDidUpdate = function(
+  prevProps, prevState, element) {};
+
+/**
+ * @protected
+ */
+React.ReactComponent.prototype.componentWillUnmount = function() {};
+
+/**
+ * There is no such thing like ReactAttribute, we just need to preserve
+ * some React attributes after advanced compilation.
+ * @interface
+ */
+React.ReactAtrribute = function() {};
+
+/**
+ * @type {Object}
+ */
+React.ReactAtrribute.dangerouslySetInnerHTML;
+
+/**
+ * @type {string}
+ */
+React.ReactAtrribute.__html;
+
+/**
+ * @type {string}
+ */
+React.ReactAtrribute.key;
+
+/**
+ * @type {string}
+ */
+React.ReactAtrribute.ref;
+
+/**
+ * @type {Object}
+ * @const
+ */
+React.DOM = {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.a = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.article = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.abbr = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.address = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.audio = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.b = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.body = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.br = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.button = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.code = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.col = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.colgroup = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.dd = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.div = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.section = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.dl = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.dt = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.em = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.embed = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.fieldset = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.footer = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.form = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.h1 = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.h2 = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.h3 = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.h4 = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.h5 = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.h6 = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.header = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.hr = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.i = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.iframe = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.img = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.input = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.label = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.legend = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.li = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.line = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.nav = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.object = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.ol = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.optgroup = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.option = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.p = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.param = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.pre = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.select = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.small = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.source = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.span = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.sub = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.sup = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.strong = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.table = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.tbody = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.td = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.textarea = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.tfoot = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.th = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.thead = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.time = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.title = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.tr = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.u = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.ul = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.video = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.wbr = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.circle = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.g = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.path = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.polygon = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.polyline = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.rect = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.svg = function(props, children) {};
+
+/**
+ * @param {Object=} props
+ * @param {...string|React.ReactComponent|Array.<React.ReactComponent>} children
+ * @return {React.ReactComponent}
+ * @protected
+ */
+React.DOM.text = function(props, children) {};
+
+/**
+ * @typedef {function(boolean, boolean, Object, string, string, string): boolean} React.ChainableTypeChecker
+ */
+React.ChainableTypeChecker;
+
+/**
+ * @type {React.ChainableTypeChecker}
+ */
+React.ChainableTypeChecker.weak;
+
+/**
+ * @type {React.ChainableTypeChecker}
+ */
+React.ChainableTypeChecker.weak.isRequired;
+
+/**
+ * @type {React.ChainableTypeChecker}
+ */
+React.ChainableTypeChecker.isRequired;
+
+/**
+ * @type {React.ChainableTypeChecker}
+ */
+React.ChainableTypeChecker.isRequired.weak;
+
+/**
+ * @type {Object}
+ * @const
+ */
+React.PropTypes = {
+      /** @type {React.ChainableTypeChecker} */
+      "array": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "boolean": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "func": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "number": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "object": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "string": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "oneOf": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "oneOfType": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "instanceOf": function () {},
+      /** @type {React.ChainableTypeChecker} */
+      "renderable": function () {}
+};
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index ef73dd2..a378124 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,5 +1,6 @@
 (ns nonaga.draw
-  (:use [nonaga.react :only [circle div p svg create-class render-component]])
+  (:use [nonaga.react :only [circle div p svg create-class render-component]]
+        [nonaga.draw.instructions :only [instructions]])
   (:require [nonaga.core :as n]
             [nonaga.rules.ball :as b]
             [nonaga.rules.rings :as r])
@@ -114,24 +115,6 @@
                (ring "#DDD" (move-ring component color source hex) svg))
              destinations (map hex->svg destinations))))))
 
-(def color-name
-  {:red "Red"
-   :blue "Blue"})
-
-(defmulti instructions first)
-
-(defmethod instructions :turn-began [[type color]]
-  (str (color-name color) " selects a marble to move."))
-
-(defmethod instructions :marble-selected [[type color source]]
-  (str (color-name color) " selects where to move the marble."))
-
-(defmethod instructions :marble-moved [[type color]]
-  (str (color-name color) " selects a ring to move."))
-
-(defmethod instructions :ring-selected [[type color source]]
-  (str (color-name color) " selects where to move the ring."))
-
 (def board
   (create-class
     "getInitialState"
diff --git a/src/nonaga/draw/instructions.cljs b/src/nonaga/draw/instructions.cljs
new file mode 100644
index 0000000..010af1e
--- /dev/null
+++ b/src/nonaga/draw/instructions.cljs
@@ -0,0 +1,19 @@
+(ns nonaga.draw.instructions)
+
+(def color-name
+  {:red "Red"
+   :blue "Blue"})
+
+(defmulti instructions first)
+
+(defmethod instructions :turn-began [[type color]]
+  (str (color-name color) " selects a marble to move."))
+
+(defmethod instructions :marble-selected [[type color source]]
+  (str (color-name color) " selects where to move the marble."))
+
+(defmethod instructions :marble-moved [[type color]]
+  (str (color-name color) " selects a ring to move."))
+
+(defmethod instructions :ring-selected [[type color source]]
+  (str (color-name color) " selects where to move the ring."))

From 4219e5cdb7896a6ed0f42e5d0624c07d04e93392 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:41:00 +1100
Subject: [PATCH 10/39] notes on splitting up draw ns.

---
 src/nonaga/draw.cljs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index a378124..0425110 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -6,6 +6,7 @@
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
+; Used all over the place. Perhaps util?
 (defn hex->svg [[hex-x hex-y]]
   (let [width  40
         half (/ width 2)
@@ -13,6 +14,7 @@
         svg-y (+ 160 (* width hex-y))]
     [svg-x svg-y]))
 
+; draw-rings, draw-potential-rings, drawing last ring
 (defn ring
   ([color coord] (ring color nil coord))
   ([color click [x y :as coord]]
@@ -26,6 +28,7 @@
             "onClick"     click
             "key"         (str "ring:" x "," y)})))
 
+; draw-marbles, draw-valid-marble-moves
 (defn marble
   ([color coord] (marble color nil coord))
   ([color click [x y :as coord]]
@@ -37,24 +40,30 @@
             "style"   {"cursor" (if click "pointer")}
             "key"     (str "marble" x "," y)})))
 
+; move-ring
 (def opposite
   {:red :blue
    :blue :red})
 
+; draw-valid-marble-moves
 (def light-colors
   {:red :pink
    :blue :lightblue})
 
+; Used quite a bit. Perhaps should switch to using atoms then this will all be
+; a bit more natural.
 (defn update-state [component update-fn]
   (fn []
     (let [old-state (.-wrapper (.-state component))]
       (.setState component #js {:wrapper (update-fn old-state)}))))
 
+; draw-valid-marble-moves
 (defn move-marble [component color from to]
   (update-state component
                 #(-> % (n/move-ball color from to)
                      (assoc :event [:marble-moved color]))))
 
+; render, own namespace?
 (defn draw-valid-marble-moves [component state]
   (let [[type & event-data] (:event state)]
     (when (= :marble-selected type)
@@ -65,9 +74,11 @@
                        (hex->svg hex)))
               (b/valid-destinations state selected))))))
 
+; draw-marbles
 (defn start-marble-move [component color coord]
   (update-state component #(assoc % :event [:marble-selected color coord])))
 
+; render, own ns?
 (defn draw-marbles [component state color]
   (let [etype  (get-in state [:event 0])
         cp     (get-in state [:event 1])
@@ -81,9 +92,11 @@
          coords (map hex->svg coords))))
 
 ; This is the same as start-marble-move
+; draw-rings
 (defn ring-selected [component color coord]
   (update-state component #(assoc % :event [:ring-selected color coord])))
 
+; render. own ns?
 (defn draw-rings [component state]
   (let [[type & event-data] (:event state)
         coords (:rings state)]
@@ -97,6 +110,7 @@
          coords (map hex->svg coords))))
 
 ; Same as move-marble
+; draw-potential-rings
 (defn move-ring [component color from to]
   (update-state component
                 #(-> % (n/move-ring from to)
@@ -105,6 +119,7 @@
 
 ; These things should be a multi method that dispatches on state. Or I could
 ; have state records with a draw protocol.
+; render. own ns.
 (defn draw-potential-rings [component state]
   (let [[type & event-data] (:event state)
         coords (:rings state)]

From c9920886421b3a0981b8e45deec4e1db4224e339 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:50:19 +1100
Subject: [PATCH 11/39] hex->svg to draw/util

---
 src/nonaga/draw.cljs      | 11 ++---------
 src/nonaga/draw/util.cljs |  9 +++++++++
 2 files changed, 11 insertions(+), 9 deletions(-)
 create mode 100644 src/nonaga/draw/util.cljs

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 0425110..96ed0ce 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,19 +1,12 @@
 (ns nonaga.draw
   (:use [nonaga.react :only [circle div p svg create-class render-component]]
-        [nonaga.draw.instructions :only [instructions]])
+        [nonaga.draw.instructions :only [instructions]]
+        [nonaga.draw.util :only [hex->svg]])
   (:require [nonaga.core :as n]
             [nonaga.rules.ball :as b]
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
-; Used all over the place. Perhaps util?
-(defn hex->svg [[hex-x hex-y]]
-  (let [width  40
-        half (/ width 2)
-        svg-x (+ 160 (* width hex-x) (if (odd? hex-y) half 0))
-        svg-y (+ 160 (* width hex-y))]
-    [svg-x svg-y]))
-
 ; draw-rings, draw-potential-rings, drawing last ring
 (defn ring
   ([color coord] (ring color nil coord))
diff --git a/src/nonaga/draw/util.cljs b/src/nonaga/draw/util.cljs
new file mode 100644
index 0000000..e0a20be
--- /dev/null
+++ b/src/nonaga/draw/util.cljs
@@ -0,0 +1,9 @@
+(ns nonaga.draw.util)
+
+(defn hex->svg [[hex-x hex-y]]
+  (let [width  40
+        half (/ width 2)
+        svg-x (+ 160 (* width hex-x) (if (odd? hex-y) half 0))
+        svg-y (+ 160 (* width hex-y))]
+    [svg-x svg-y]))
+

From f6acf3ba3524a54f497f0e04eb890f875ef7bbc5 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:51:12 +1100
Subject: [PATCH 12/39] ring, marble to draw/util

---
 src/nonaga/draw.cljs      | 28 +---------------------------
 src/nonaga/draw/util.cljs | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 96ed0ce..c41e786 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,38 +1,12 @@
 (ns nonaga.draw
   (:use [nonaga.react :only [circle div p svg create-class render-component]]
         [nonaga.draw.instructions :only [instructions]]
-        [nonaga.draw.util :only [hex->svg]])
+        [nonaga.draw.util :only [hex->svg ring marble]])
   (:require [nonaga.core :as n]
             [nonaga.rules.ball :as b]
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
-; draw-rings, draw-potential-rings, drawing last ring
-(defn ring
-  ([color coord] (ring color nil coord))
-  ([color click [x y :as coord]]
-   (circle {"cx"          x
-            "cy"          y
-            "r"           14
-            "fill"        "transparent"
-            "stroke"      color
-            "strokeWidth" "7px"
-            "style"       {"cursor" (if click "pointer")}
-            "onClick"     click
-            "key"         (str "ring:" x "," y)})))
-
-; draw-marbles, draw-valid-marble-moves
-(defn marble
-  ([color coord] (marble color nil coord))
-  ([color click [x y :as coord]]
-   (circle {"cx"      x
-            "cy"      y
-            "r"       8
-            "fill"    (name color)
-            "onClick" click
-            "style"   {"cursor" (if click "pointer")}
-            "key"     (str "marble" x "," y)})))
-
 ; move-ring
 (def opposite
   {:red :blue
diff --git a/src/nonaga/draw/util.cljs b/src/nonaga/draw/util.cljs
index e0a20be..3f28590 100644
--- a/src/nonaga/draw/util.cljs
+++ b/src/nonaga/draw/util.cljs
@@ -7,3 +7,29 @@
         svg-y (+ 160 (* width hex-y))]
     [svg-x svg-y]))
 
+
+; draw-rings, draw-potential-rings, drawing last ring
+(defn ring
+  ([color coord] (ring color nil coord))
+  ([color click [x y :as coord]]
+   (circle {"cx"          x
+            "cy"          y
+            "r"           14
+            "fill"        "transparent"
+            "stroke"      color
+            "strokeWidth" "7px"
+            "style"       {"cursor" (if click "pointer")}
+            "onClick"     click
+            "key"         (str "ring:" x "," y)})))
+
+; draw-marbles, draw-valid-marble-moves
+(defn marble
+  ([color coord] (marble color nil coord))
+  ([color click [x y :as coord]]
+   (circle {"cx"      x
+            "cy"      y
+            "r"       8
+            "fill"    (name color)
+            "onClick" click
+            "style"   {"cursor" (if click "pointer")}
+            "key"     (str "marble" x "," y)})))

From a2d3b0dadbc93de9a005b166292c279850983f7e Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:57:36 +1100
Subject: [PATCH 13/39] marble selected extracted from draw

---
 src/nonaga/draw.cljs                 | 42 +++++-----------------------
 src/nonaga/draw/marble_selected.cljs | 26 +++++++++++++++++
 src/nonaga/draw/util.cljs            | 10 ++++++-
 3 files changed, 42 insertions(+), 36 deletions(-)
 create mode 100644 src/nonaga/draw/marble_selected.cljs

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index c41e786..66c1b04 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,46 +1,13 @@
 (ns nonaga.draw
   (:use [nonaga.react :only [circle div p svg create-class render-component]]
         [nonaga.draw.instructions :only [instructions]]
-        [nonaga.draw.util :only [hex->svg ring marble]])
+        [nonaga.draw.util :only [hex->svg ring marble update-state]]
+        [nonaga.draw.marble-selected :only [draw-valid-marble-moves]])
   (:require [nonaga.core :as n]
             [nonaga.rules.ball :as b]
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
-; move-ring
-(def opposite
-  {:red :blue
-   :blue :red})
-
-; draw-valid-marble-moves
-(def light-colors
-  {:red :pink
-   :blue :lightblue})
-
-; Used quite a bit. Perhaps should switch to using atoms then this will all be
-; a bit more natural.
-(defn update-state [component update-fn]
-  (fn []
-    (let [old-state (.-wrapper (.-state component))]
-      (.setState component #js {:wrapper (update-fn old-state)}))))
-
-; draw-valid-marble-moves
-(defn move-marble [component color from to]
-  (update-state component
-                #(-> % (n/move-ball color from to)
-                     (assoc :event [:marble-moved color]))))
-
-; render, own namespace?
-(defn draw-valid-marble-moves [component state]
-  (let [[type & event-data] (:event state)]
-    (when (= :marble-selected type)
-      (let [[color selected] event-data]
-        (map (fn [hex]
-               (marble (light-colors color)
-                       (move-marble component color selected hex)
-                       (hex->svg hex)))
-              (b/valid-destinations state selected))))))
-
 ; draw-marbles
 (defn start-marble-move [component color coord]
   (update-state component #(assoc % :event [:marble-selected color coord])))
@@ -76,6 +43,11 @@
              (ring "#999" svg)))
          coords (map hex->svg coords))))
 
+; move-ring
+(def opposite
+  {:red :blue
+   :blue :red})
+
 ; Same as move-marble
 ; draw-potential-rings
 (defn move-ring [component color from to]
diff --git a/src/nonaga/draw/marble_selected.cljs b/src/nonaga/draw/marble_selected.cljs
new file mode 100644
index 0000000..adfea95
--- /dev/null
+++ b/src/nonaga/draw/marble_selected.cljs
@@ -0,0 +1,26 @@
+(ns nonaga.draw.marble-selected
+  (:require [nonaga.rules.ball :as b]
+            [nonaga.core :as n])
+  (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
+
+; draw-valid-marble-moves
+(def light-colors
+  {:red :pink
+   :blue :lightblue})
+
+; draw-valid-marble-moves
+(defn move-marble [component color from to]
+  (update-state component
+                #(-> % (n/move-ball color from to)
+                     (assoc :event [:marble-moved color]))))
+
+; render, own namespace?
+(defn draw-valid-marble-moves [component state]
+  (let [[type & event-data] (:event state)]
+    (when (= :marble-selected type)
+      (let [[color selected] event-data]
+        (map (fn [hex]
+               (marble (light-colors color)
+                       (move-marble component color selected hex)
+                       (hex->svg hex)))
+              (b/valid-destinations state selected))))))
diff --git a/src/nonaga/draw/util.cljs b/src/nonaga/draw/util.cljs
index 3f28590..9476595 100644
--- a/src/nonaga/draw/util.cljs
+++ b/src/nonaga/draw/util.cljs
@@ -1,4 +1,5 @@
-(ns nonaga.draw.util)
+(ns nonaga.draw.util
+  (:use [nonaga.react :only [circle]]))
 
 (defn hex->svg [[hex-x hex-y]]
   (let [width  40
@@ -33,3 +34,10 @@
             "onClick" click
             "style"   {"cursor" (if click "pointer")}
             "key"     (str "marble" x "," y)})))
+
+; Used quite a bit. Perhaps should switch to using atoms then this will all be
+; a bit more natural.
+(defn update-state [component update-fn]
+  (fn []
+    (let [old-state (.-wrapper (.-state component))]
+      (.setState component #js {:wrapper (update-fn old-state)}))))

From f3f58b34a591f8e698fb8aff4394403174541478 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 22:59:40 +1100
Subject: [PATCH 14/39] draw marbles to own ns

---
 src/nonaga/draw.cljs              | 20 ++------------------
 src/nonaga/draw/draw_marbles.cljs | 19 +++++++++++++++++++
 2 files changed, 21 insertions(+), 18 deletions(-)
 create mode 100644 src/nonaga/draw/draw_marbles.cljs

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 66c1b04..b5ac721 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -2,29 +2,13 @@
   (:use [nonaga.react :only [circle div p svg create-class render-component]]
         [nonaga.draw.instructions :only [instructions]]
         [nonaga.draw.util :only [hex->svg ring marble update-state]]
-        [nonaga.draw.marble-selected :only [draw-valid-marble-moves]])
+        [nonaga.draw.marble-selected :only [draw-valid-marble-moves]]
+        [nonaga.draw.draw-marbles :only [draw-marbles]])
   (:require [nonaga.core :as n]
             [nonaga.rules.ball :as b]
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
-; draw-marbles
-(defn start-marble-move [component color coord]
-  (update-state component #(assoc % :event [:marble-selected color coord])))
-
-; render, own ns?
-(defn draw-marbles [component state color]
-  (let [etype  (get-in state [:event 0])
-        cp     (get-in state [:event 1])
-        coords (color state)
-        click  (partial start-marble-move component)]
-    (map (fn [hex svg]
-           (marble color (if (and (or (= etype :turn-began)
-                                      (= etype :marble-selected))
-                                  (= cp color))
-                           (click color hex)) svg))
-         coords (map hex->svg coords))))
-
 ; This is the same as start-marble-move
 ; draw-rings
 (defn ring-selected [component color coord]
diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/draw_marbles.cljs
new file mode 100644
index 0000000..55f5cbc
--- /dev/null
+++ b/src/nonaga/draw/draw_marbles.cljs
@@ -0,0 +1,19 @@
+(ns nonaga.draw.draw-marbles
+  (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
+
+; draw-marbles
+(defn start-marble-move [component color coord]
+  (update-state component #(assoc % :event [:marble-selected color coord])))
+
+; render, own ns?
+(defn draw-marbles [component state color]
+  (let [etype  (get-in state [:event 0])
+        cp     (get-in state [:event 1])
+        coords (color state)
+        click  (partial start-marble-move component)]
+    (map (fn [hex svg]
+           (marble color (if (and (or (= etype :turn-began)
+                                      (= etype :marble-selected))
+                                  (= cp color))
+                           (click color hex)) svg))
+         coords (map hex->svg coords))))

From c7078b094047a0456598b8bae8787c363a7627e8 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:02:46 +1100
Subject: [PATCH 15/39] pulled draw rings

---
 src/nonaga/draw.cljs            | 21 ++-------------------
 src/nonaga/draw/draw_rings.cljs | 22 ++++++++++++++++++++++
 2 files changed, 24 insertions(+), 19 deletions(-)
 create mode 100644 src/nonaga/draw/draw_rings.cljs

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index b5ac721..ef7d31f 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -3,30 +3,13 @@
         [nonaga.draw.instructions :only [instructions]]
         [nonaga.draw.util :only [hex->svg ring marble update-state]]
         [nonaga.draw.marble-selected :only [draw-valid-marble-moves]]
-        [nonaga.draw.draw-marbles :only [draw-marbles]])
+        [nonaga.draw.draw-marbles :only [draw-marbles]]
+        [nonaga.draw.draw-rings :only [draw-rings]])
   (:require [nonaga.core :as n]
             [nonaga.rules.ball :as b]
             [nonaga.rules.rings :as r])
   (:use-macros [dommy.macros :only [sel1]]))
 
-; This is the same as start-marble-move
-; draw-rings
-(defn ring-selected [component color coord]
-  (update-state component #(assoc % :event [:ring-selected color coord])))
-
-; render. own ns?
-(defn draw-rings [component state]
-  (let [[type & event-data] (:event state)
-        coords (:rings state)]
-    (map (fn [hex svg]
-           (if (and (or (= :marble-moved type)
-                        (= :ring-selected type))
-                    (r/can-be-moved? state hex))
-             (let [[color] event-data]
-               (ring "#444" (ring-selected component color hex) svg))
-             (ring "#999" svg)))
-         coords (map hex->svg coords))))
-
 ; move-ring
 (def opposite
   {:red :blue
diff --git a/src/nonaga/draw/draw_rings.cljs b/src/nonaga/draw/draw_rings.cljs
new file mode 100644
index 0000000..ddf01d5
--- /dev/null
+++ b/src/nonaga/draw/draw_rings.cljs
@@ -0,0 +1,22 @@
+(ns nonaga.draw.draw-rings
+  (:require [nonaga.rules.rings :as r])
+  (:use [nonaga.draw.util :only [hex->svg ring update-state]]))
+
+; This is the same as start-marble-move
+; draw-rings
+(defn ring-selected [component color coord]
+  (update-state component #(assoc % :event [:ring-selected color coord])))
+
+; render. own ns?
+(defn draw-rings [component state]
+  (let [[type & event-data] (:event state)
+        coords (:rings state)]
+    (map (fn [hex svg]
+           (if (and (or (= :marble-moved type)
+                        (= :ring-selected type))
+                    (r/can-be-moved? state hex))
+             (let [[color] event-data]
+               (ring "#444" (ring-selected component color hex) svg))
+             (ring "#999" svg)))
+         coords (map hex->svg coords))))
+

From b1727897b4b2164939e79987060680c352db77ee Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:09:19 +1100
Subject: [PATCH 16/39] potential and last rings to own ns

---
 project.clj                               |  1 -
 src/nonaga/draw.cljs                      | 43 ++++-------------------
 src/nonaga/draw/draw_last_ring.cljs       |  6 ++++
 src/nonaga/draw/draw_potential_rings.cljs | 30 ++++++++++++++++
 4 files changed, 43 insertions(+), 37 deletions(-)
 create mode 100644 src/nonaga/draw/draw_last_ring.cljs
 create mode 100644 src/nonaga/draw/draw_potential_rings.cljs

diff --git a/project.clj b/project.clj
index f1c3abf..fc76386 100644
--- a/project.clj
+++ b/project.clj
@@ -6,7 +6,6 @@
             :url "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure "1.5.1"]
                  [org.clojure/clojurescript "6969"]
-                 [prismatic/dommy "0.1.1"]
                  [com.cemerick/clojurescript.test "0.2.1"]
                  [com.cemerick/piggieback "0.1.2"]]
   :plugins [[lein-cljsbuild "1.0.1"]
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index ef7d31f..8d6df68 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,40 +1,12 @@
 (ns nonaga.draw
-  (:use [nonaga.react :only [circle div p svg create-class render-component]]
+  (:use [nonaga.react :only [div p svg create-class render-component]]
         [nonaga.draw.instructions :only [instructions]]
-        [nonaga.draw.util :only [hex->svg ring marble update-state]]
         [nonaga.draw.marble-selected :only [draw-valid-marble-moves]]
         [nonaga.draw.draw-marbles :only [draw-marbles]]
-        [nonaga.draw.draw-rings :only [draw-rings]])
-  (:require [nonaga.core :as n]
-            [nonaga.rules.ball :as b]
-            [nonaga.rules.rings :as r])
-  (:use-macros [dommy.macros :only [sel1]]))
-
-; move-ring
-(def opposite
-  {:red :blue
-   :blue :red})
-
-; Same as move-marble
-; draw-potential-rings
-(defn move-ring [component color from to]
-  (update-state component
-                #(-> % (n/move-ring from to)
-                     (assoc :last-ring to)
-                     (assoc :event [:turn-began (opposite color)]))))
-
-; These things should be a multi method that dispatches on state. Or I could
-; have state records with a draw protocol.
-; render. own ns.
-(defn draw-potential-rings [component state]
-  (let [[type & event-data] (:event state)
-        coords (:rings state)]
-    (if (= :ring-selected type)
-      (let [[color source] event-data
-            destinations (r/valid-destinations coords source)]
-        (map (fn [hex svg]
-               (ring "#DDD" (move-ring component color source hex) svg))
-             destinations (map hex->svg destinations))))))
+        [nonaga.draw.draw-rings :only [draw-rings]]
+        [nonaga.draw.draw-potential-rings :only [draw-potential-rings]]
+        [nonaga.draw.draw-last-ring :only [draw-last-ring]])
+  (:require [nonaga.core :as n]))
 
 (def board
   (create-class
@@ -54,12 +26,11 @@
                       (svg {:width 480 :height 480}
                            (draw-rings this state)
                            (draw-potential-rings this state)
-                           (if-let [last-ring (:last-ring state)]
-                             (ring "#000" (hex->svg last-ring)))      
+                           (draw-last-ring state)
                            (draw-marbles this state :red)
                            (draw-marbles this state :blue)
                            (draw-valid-marble-moves this state))))))))
 
 (defn start []
-  (render-component (board) (sel1 :#content)))
+  (render-component (board) (js/document.getElementById "content")))
 
diff --git a/src/nonaga/draw/draw_last_ring.cljs b/src/nonaga/draw/draw_last_ring.cljs
new file mode 100644
index 0000000..ebf9e7a
--- /dev/null
+++ b/src/nonaga/draw/draw_last_ring.cljs
@@ -0,0 +1,6 @@
+(ns nonaga.draw.draw-last-ring
+  (:use [nonaga.draw.util :only [hex->svg ring]]))
+
+(defn draw-last-ring [state]
+  (if-let [last-ring (:last-ring state)]
+    (ring "#000" (hex->svg last-ring))))      
diff --git a/src/nonaga/draw/draw_potential_rings.cljs b/src/nonaga/draw/draw_potential_rings.cljs
new file mode 100644
index 0000000..f48e5f9
--- /dev/null
+++ b/src/nonaga/draw/draw_potential_rings.cljs
@@ -0,0 +1,30 @@
+(ns nonaga.draw.draw-potential-rings
+  (:require [nonaga.core :as n]
+            [nonaga.rules.rings :as r])
+  (:use [nonaga.draw.util :only [hex->svg ring update-state]]))
+
+; move-ring
+(def opposite
+  {:red :blue
+   :blue :red})
+
+; Same as move-marble
+; draw-potential-rings
+(defn move-ring [component color from to]
+  (update-state component
+                #(-> % (n/move-ring from to)
+                     (assoc :last-ring to)
+                     (assoc :event [:turn-began (opposite color)]))))
+
+; These things should be a multi method that dispatches on state. Or I could
+; have state records with a draw protocol.
+; render. own ns.
+(defn draw-potential-rings [component state]
+  (let [[type & event-data] (:event state)
+        coords (:rings state)]
+    (if (= :ring-selected type)
+      (let [[color source] event-data
+            destinations (r/valid-destinations coords source)]
+        (map (fn [hex svg]
+               (ring "#DDD" (move-ring component color source hex) svg))
+             destinations (map hex->svg destinations))))))

From 14c768d669209d9843c6ce5a5381c252e9212b41 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:11:01 +1100
Subject: [PATCH 17/39] alignment of uses

---
 src/nonaga/draw.cljs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 8d6df68..df2ec85 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,11 +1,11 @@
 (ns nonaga.draw
   (:use [nonaga.react :only [div p svg create-class render-component]]
-        [nonaga.draw.instructions :only [instructions]]
-        [nonaga.draw.marble-selected :only [draw-valid-marble-moves]]
-        [nonaga.draw.draw-marbles :only [draw-marbles]]
-        [nonaga.draw.draw-rings :only [draw-rings]]
+        [nonaga.draw.instructions         :only [instructions]]
+        [nonaga.draw.marble-selected      :only [draw-valid-marble-moves]]
+        [nonaga.draw.draw-marbles         :only [draw-marbles]]
+        [nonaga.draw.draw-rings           :only [draw-rings]]
         [nonaga.draw.draw-potential-rings :only [draw-potential-rings]]
-        [nonaga.draw.draw-last-ring :only [draw-last-ring]])
+        [nonaga.draw.draw-last-ring       :only [draw-last-ring]])
   (:require [nonaga.core :as n]))
 
 (def board

From 6509d40d53d0d58df3d0b7b77b2a20cd1b4e66f0 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:12:18 +1100
Subject: [PATCH 18/39] removed refactoring use notes

---
 src/nonaga/draw/draw_marbles.cljs         | 2 --
 src/nonaga/draw/draw_potential_rings.cljs | 4 ----
 src/nonaga/draw/draw_rings.cljs           | 3 ---
 src/nonaga/draw/marble_selected.cljs      | 3 ---
 src/nonaga/draw/util.cljs                 | 4 ----
 5 files changed, 16 deletions(-)

diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/draw_marbles.cljs
index 55f5cbc..1cff697 100644
--- a/src/nonaga/draw/draw_marbles.cljs
+++ b/src/nonaga/draw/draw_marbles.cljs
@@ -1,11 +1,9 @@
 (ns nonaga.draw.draw-marbles
   (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
 
-; draw-marbles
 (defn start-marble-move [component color coord]
   (update-state component #(assoc % :event [:marble-selected color coord])))
 
-; render, own ns?
 (defn draw-marbles [component state color]
   (let [etype  (get-in state [:event 0])
         cp     (get-in state [:event 1])
diff --git a/src/nonaga/draw/draw_potential_rings.cljs b/src/nonaga/draw/draw_potential_rings.cljs
index f48e5f9..ed4c169 100644
--- a/src/nonaga/draw/draw_potential_rings.cljs
+++ b/src/nonaga/draw/draw_potential_rings.cljs
@@ -3,13 +3,10 @@
             [nonaga.rules.rings :as r])
   (:use [nonaga.draw.util :only [hex->svg ring update-state]]))
 
-; move-ring
 (def opposite
   {:red :blue
    :blue :red})
 
-; Same as move-marble
-; draw-potential-rings
 (defn move-ring [component color from to]
   (update-state component
                 #(-> % (n/move-ring from to)
@@ -18,7 +15,6 @@
 
 ; These things should be a multi method that dispatches on state. Or I could
 ; have state records with a draw protocol.
-; render. own ns.
 (defn draw-potential-rings [component state]
   (let [[type & event-data] (:event state)
         coords (:rings state)]
diff --git a/src/nonaga/draw/draw_rings.cljs b/src/nonaga/draw/draw_rings.cljs
index ddf01d5..eabddc4 100644
--- a/src/nonaga/draw/draw_rings.cljs
+++ b/src/nonaga/draw/draw_rings.cljs
@@ -2,12 +2,9 @@
   (:require [nonaga.rules.rings :as r])
   (:use [nonaga.draw.util :only [hex->svg ring update-state]]))
 
-; This is the same as start-marble-move
-; draw-rings
 (defn ring-selected [component color coord]
   (update-state component #(assoc % :event [:ring-selected color coord])))
 
-; render. own ns?
 (defn draw-rings [component state]
   (let [[type & event-data] (:event state)
         coords (:rings state)]
diff --git a/src/nonaga/draw/marble_selected.cljs b/src/nonaga/draw/marble_selected.cljs
index adfea95..fc3b7cf 100644
--- a/src/nonaga/draw/marble_selected.cljs
+++ b/src/nonaga/draw/marble_selected.cljs
@@ -3,18 +3,15 @@
             [nonaga.core :as n])
   (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
 
-; draw-valid-marble-moves
 (def light-colors
   {:red :pink
    :blue :lightblue})
 
-; draw-valid-marble-moves
 (defn move-marble [component color from to]
   (update-state component
                 #(-> % (n/move-ball color from to)
                      (assoc :event [:marble-moved color]))))
 
-; render, own namespace?
 (defn draw-valid-marble-moves [component state]
   (let [[type & event-data] (:event state)]
     (when (= :marble-selected type)
diff --git a/src/nonaga/draw/util.cljs b/src/nonaga/draw/util.cljs
index 9476595..d883384 100644
--- a/src/nonaga/draw/util.cljs
+++ b/src/nonaga/draw/util.cljs
@@ -9,7 +9,6 @@
     [svg-x svg-y]))
 
 
-; draw-rings, draw-potential-rings, drawing last ring
 (defn ring
   ([color coord] (ring color nil coord))
   ([color click [x y :as coord]]
@@ -23,7 +22,6 @@
             "onClick"     click
             "key"         (str "ring:" x "," y)})))
 
-; draw-marbles, draw-valid-marble-moves
 (defn marble
   ([color coord] (marble color nil coord))
   ([color click [x y :as coord]]
@@ -35,8 +33,6 @@
             "style"   {"cursor" (if click "pointer")}
             "key"     (str "marble" x "," y)})))
 
-; Used quite a bit. Perhaps should switch to using atoms then this will all be
-; a bit more natural.
 (defn update-state [component update-fn]
   (fn []
     (let [old-state (.-wrapper (.-state component))]

From 5a7820c0293c361ad8a0981630939607637c03be Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:14:20 +1100
Subject: [PATCH 19/39] renamed marble selected to draw valid marble moves

---
 src/nonaga/draw.cljs                                 | 12 ++++++------
 ...le_selected.cljs => draw_valid_marble_moves.cljs} |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)
 rename src/nonaga/draw/{marble_selected.cljs => draw_valid_marble_moves.cljs} (95%)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index df2ec85..85cc982 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,11 +1,11 @@
 (ns nonaga.draw
   (:use [nonaga.react :only [div p svg create-class render-component]]
-        [nonaga.draw.instructions         :only [instructions]]
-        [nonaga.draw.marble-selected      :only [draw-valid-marble-moves]]
-        [nonaga.draw.draw-marbles         :only [draw-marbles]]
-        [nonaga.draw.draw-rings           :only [draw-rings]]
-        [nonaga.draw.draw-potential-rings :only [draw-potential-rings]]
-        [nonaga.draw.draw-last-ring       :only [draw-last-ring]])
+        [nonaga.draw.instructions            :only [instructions]]
+        [nonaga.draw.draw-valid-marble-moves :only [draw-valid-marble-moves]]
+        [nonaga.draw.draw-marbles            :only [draw-marbles]]
+        [nonaga.draw.draw-rings              :only [draw-rings]]
+        [nonaga.draw.draw-potential-rings    :only [draw-potential-rings]]
+        [nonaga.draw.draw-last-ring          :only [draw-last-ring]])
   (:require [nonaga.core :as n]))
 
 (def board
diff --git a/src/nonaga/draw/marble_selected.cljs b/src/nonaga/draw/draw_valid_marble_moves.cljs
similarity index 95%
rename from src/nonaga/draw/marble_selected.cljs
rename to src/nonaga/draw/draw_valid_marble_moves.cljs
index fc3b7cf..07d5e31 100644
--- a/src/nonaga/draw/marble_selected.cljs
+++ b/src/nonaga/draw/draw_valid_marble_moves.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.draw.marble-selected
+(ns nonaga.draw.draw-valid-marble-moves
   (:require [nonaga.rules.ball :as b]
             [nonaga.core :as n])
   (:use [nonaga.draw.util :only [hex->svg marble update-state]]))

From 566c22fd6a0b6bba5a6e50094cb980805eb08346 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:17:37 +1100
Subject: [PATCH 20/39] notes on further changes

---
 src/nonaga/draw.cljs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 85cc982..621d410 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -8,6 +8,16 @@
         [nonaga.draw.draw-last-ring          :only [draw-last-ring]])
   (:require [nonaga.core :as n]))
 
+; So at the moment each type of thing that is drawn on the board has it's own
+; ns. Some of those draw functions have conditional logic in them for what to
+; render based on the :event. Perhaps there should be created a default ns that
+; has simple renderings for everything. And then a namespace for each phase
+; where it overwrites the appropriate draw functions.
+
+; To implement win detection it would be quite convenient to have the game
+; state in an atom. This would allow for a win detection watcher that would
+; spot that someone has one and would change the :event to end the game.
+
 (def board
   (create-class
     "getInitialState"

From 9de0dd637d00673a8fe1cca5aa36963a8a969417 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:29:20 +1100
Subject: [PATCH 21/39] change ddraw potential rings to be multi method

---
 src/nonaga/draw/draw_last_ring.cljs       |  1 +
 src/nonaga/draw/draw_potential_rings.cljs | 23 ++++++++++++-----------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/nonaga/draw/draw_last_ring.cljs b/src/nonaga/draw/draw_last_ring.cljs
index ebf9e7a..8c45dfa 100644
--- a/src/nonaga/draw/draw_last_ring.cljs
+++ b/src/nonaga/draw/draw_last_ring.cljs
@@ -4,3 +4,4 @@
 (defn draw-last-ring [state]
   (if-let [last-ring (:last-ring state)]
     (ring "#000" (hex->svg last-ring))))      
+
diff --git a/src/nonaga/draw/draw_potential_rings.cljs b/src/nonaga/draw/draw_potential_rings.cljs
index ed4c169..006c46b 100644
--- a/src/nonaga/draw/draw_potential_rings.cljs
+++ b/src/nonaga/draw/draw_potential_rings.cljs
@@ -13,14 +13,15 @@
                      (assoc :last-ring to)
                      (assoc :event [:turn-began (opposite color)]))))
 
-; These things should be a multi method that dispatches on state. Or I could
-; have state records with a draw protocol.
-(defn draw-potential-rings [component state]
-  (let [[type & event-data] (:event state)
-        coords (:rings state)]
-    (if (= :ring-selected type)
-      (let [[color source] event-data
-            destinations (r/valid-destinations coords source)]
-        (map (fn [hex svg]
-               (ring "#DDD" (move-ring component color source hex) svg))
-             destinations (map hex->svg destinations))))))
+; Could probably use an event type method
+(defmulti draw-potential-rings (fn [_ state] (first (:event state))))
+
+(defmethod draw-potential-rings :default [_ _])
+
+(defmethod draw-potential-rings :ring-selected
+  [component {[t color source] :event coords :rings}]
+  (let [destinations (r/valid-destinations coords source)]
+    (map (fn [hex svg]
+           (ring "#DDD" (move-ring component color source hex) svg))
+         destinations (map hex->svg destinations))))
+

From e76e815f23310722b0c8c6dddd305cee78f71e57 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:31:32 +1100
Subject: [PATCH 22/39] added event type to util

---
 src/nonaga/draw/draw_potential_rings.cljs | 4 ++--
 src/nonaga/draw/util.cljs                 | 3 +++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/nonaga/draw/draw_potential_rings.cljs b/src/nonaga/draw/draw_potential_rings.cljs
index 006c46b..61b7107 100644
--- a/src/nonaga/draw/draw_potential_rings.cljs
+++ b/src/nonaga/draw/draw_potential_rings.cljs
@@ -1,7 +1,7 @@
 (ns nonaga.draw.draw-potential-rings
   (:require [nonaga.core :as n]
             [nonaga.rules.rings :as r])
-  (:use [nonaga.draw.util :only [hex->svg ring update-state]]))
+  (:use [nonaga.draw.util :only [hex->svg ring update-state event-type]]))
 
 (def opposite
   {:red :blue
@@ -14,7 +14,7 @@
                      (assoc :event [:turn-began (opposite color)]))))
 
 ; Could probably use an event type method
-(defmulti draw-potential-rings (fn [_ state] (first (:event state))))
+(defmulti draw-potential-rings #(event-type %2))
 
 (defmethod draw-potential-rings :default [_ _])
 
diff --git a/src/nonaga/draw/util.cljs b/src/nonaga/draw/util.cljs
index d883384..4d5d7a9 100644
--- a/src/nonaga/draw/util.cljs
+++ b/src/nonaga/draw/util.cljs
@@ -1,6 +1,9 @@
 (ns nonaga.draw.util
   (:use [nonaga.react :only [circle]]))
 
+(defn event-type [state]
+  (first (:event state)))
+
 (defn hex->svg [[hex-x hex-y]]
   (let [width  40
         half (/ width 2)

From b3dc8d1895c356353020f715e800afdeccf2ea15 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:31:43 +1100
Subject: [PATCH 23/39] - comment

---
 src/nonaga/draw/draw_potential_rings.cljs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/nonaga/draw/draw_potential_rings.cljs b/src/nonaga/draw/draw_potential_rings.cljs
index 61b7107..7bdf64f 100644
--- a/src/nonaga/draw/draw_potential_rings.cljs
+++ b/src/nonaga/draw/draw_potential_rings.cljs
@@ -13,7 +13,6 @@
                      (assoc :last-ring to)
                      (assoc :event [:turn-began (opposite color)]))))
 
-; Could probably use an event type method
 (defmulti draw-potential-rings #(event-type %2))
 
 (defmethod draw-potential-rings :default [_ _])

From 1777f7f179829b8d5888f226fa0e0d46d4689243 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:35:59 +1100
Subject: [PATCH 24/39] valid marble moves to multi method

---
 src/nonaga/draw/draw_valid_marble_moves.cljs | 25 +++++++++++---------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/nonaga/draw/draw_valid_marble_moves.cljs b/src/nonaga/draw/draw_valid_marble_moves.cljs
index 07d5e31..ac1c4b5 100644
--- a/src/nonaga/draw/draw_valid_marble_moves.cljs
+++ b/src/nonaga/draw/draw_valid_marble_moves.cljs
@@ -1,10 +1,10 @@
 (ns nonaga.draw.draw-valid-marble-moves
   (:require [nonaga.rules.ball :as b]
             [nonaga.core :as n])
-  (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
+  (:use [nonaga.draw.util :only [hex->svg marble update-state event-type]]))
 
 (def light-colors
-  {:red :pink
+  {:red  :pink
    :blue :lightblue})
 
 (defn move-marble [component color from to]
@@ -12,12 +12,15 @@
                 #(-> % (n/move-ball color from to)
                      (assoc :event [:marble-moved color]))))
 
-(defn draw-valid-marble-moves [component state]
-  (let [[type & event-data] (:event state)]
-    (when (= :marble-selected type)
-      (let [[color selected] event-data]
-        (map (fn [hex]
-               (marble (light-colors color)
-                       (move-marble component color selected hex)
-                       (hex->svg hex)))
-              (b/valid-destinations state selected))))))
+(defmulti draw-valid-marble-moves #(event-type %2))
+
+(defmethod draw-valid-marble-moves :default [_ _])
+
+(defmethod draw-valid-marble-moves :marble-selected
+  [component {[t color selected] :event :as state}]
+  (map (fn [hex]
+         (marble (light-colors color)
+                 (move-marble component color selected hex)
+                 (hex->svg hex)))
+       (b/valid-destinations state selected)))
+

From 7f5871be76e240759fddfe9cf8d5fce189b43360 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Tue, 21 Jan 2014 23:48:38 +1100
Subject: [PATCH 25/39] split draw-rings into multi method

---
 src/nonaga/draw/draw_marbles.cljs |  1 +
 src/nonaga/draw/draw_rings.cljs   | 29 +++++++++++++++++------------
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/draw_marbles.cljs
index 1cff697..2aa0482 100644
--- a/src/nonaga/draw/draw_marbles.cljs
+++ b/src/nonaga/draw/draw_marbles.cljs
@@ -15,3 +15,4 @@
                                   (= cp color))
                            (click color hex)) svg))
          coords (map hex->svg coords))))
+
diff --git a/src/nonaga/draw/draw_rings.cljs b/src/nonaga/draw/draw_rings.cljs
index eabddc4..5cafaaa 100644
--- a/src/nonaga/draw/draw_rings.cljs
+++ b/src/nonaga/draw/draw_rings.cljs
@@ -1,19 +1,24 @@
 (ns nonaga.draw.draw-rings
   (:require [nonaga.rules.rings :as r])
-  (:use [nonaga.draw.util :only [hex->svg ring update-state]]))
+  (:use [nonaga.draw.util :only [hex->svg ring update-state event-type]]))
 
 (defn ring-selected [component color coord]
   (update-state component #(assoc % :event [:ring-selected color coord])))
 
-(defn draw-rings [component state]
-  (let [[type & event-data] (:event state)
-        coords (:rings state)]
-    (map (fn [hex svg]
-           (if (and (or (= :marble-moved type)
-                        (= :ring-selected type))
-                    (r/can-be-moved? state hex))
-             (let [[color] event-data]
-               (ring "#444" (ring-selected component color hex) svg))
-             (ring "#999" svg)))
-         coords (map hex->svg coords))))
+(derive :marble-moved  ::ring-selectable)
+(derive :ring-selected ::ring-selectable)
+
+(defmulti draw-rings #(event-type %2))
+
+(defmethod draw-rings :default
+  [component {:keys [rings]}]
+  (map (partial ring "#999") (map hex->svg rings)))
+
+(defmethod draw-rings ::ring-selectable
+  [component {[t color] :event rings :rings :as state}]
+  (map (fn [hex svg]
+         (if (r/can-be-moved? state hex)
+           (ring "#444" (ring-selected component color hex) svg)
+           (ring "#999" svg)))
+       rings (map hex->svg rings)))
 

From e51486cfa8708a4066accedb31aa888d6da992de Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:00:36 +1100
Subject: [PATCH 26/39] draw-marbles to multi method

---
 src/nonaga/draw/draw_marbles.cljs | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/draw_marbles.cljs
index 2aa0482..443ad0b 100644
--- a/src/nonaga/draw/draw_marbles.cljs
+++ b/src/nonaga/draw/draw_marbles.cljs
@@ -1,18 +1,24 @@
 (ns nonaga.draw.draw-marbles
-  (:use [nonaga.draw.util :only [hex->svg marble update-state]]))
+  (:use [nonaga.draw.util :only [hex->svg marble update-state event-type]]))
 
 (defn start-marble-move [component color coord]
   (update-state component #(assoc % :event [:marble-selected color coord])))
 
-(defn draw-marbles [component state color]
-  (let [etype  (get-in state [:event 0])
-        cp     (get-in state [:event 1])
-        coords (color state)
+(derive :turn-began      ::marble-selectable)
+(derive :marble-selected ::marble-selectable)
+
+(defmulti draw-marbles (fn [_ state _] (event-type state)))
+
+(defmethod draw-marbles :default [component state color]
+  (let [marbles (color state)]
+    (map (partial marble color) (map hex->svg marbles))))
+
+; Color and cp are badly named. Should be color-of-marbles-being-drawn and
+; current player.
+(defmethod draw-marbles ::marble-selectable
+  [component {[t cp] :event :as state} color]
+  (let [coords (color state)
         click  (partial start-marble-move component)]
-    (map (fn [hex svg]
-           (marble color (if (and (or (= etype :turn-began)
-                                      (= etype :marble-selected))
-                                  (= cp color))
-                           (click color hex)) svg))
+    (map (fn [hex svg] (marble color (if (= cp color) (click color hex)) svg))
          coords (map hex->svg coords))))
 

From ba8bcf6f201a264e2e6706f6195f8d3da4246ad8 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:04:41 +1100
Subject: [PATCH 27/39] removed enclosing ring and note about large default
 draw

---
 src/nonaga/core.cljs | 22 ----------------------
 src/nonaga/draw.cljs |  6 ------
 2 files changed, 28 deletions(-)

diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 89a2f05..75b2403 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -22,28 +22,6 @@
        
                      [3 0]}})
 
-(def enclosing-ring
-  {:rings
-    #{   [1 4] [2 4] [3 4]  
-       [0 3]             [3 3]
-     [0 2]                   [4 2] 
-       [0 1] [1 1]       [3 1] 
-         [1 0]       [3 0]}
-  
-   :red
-    #{   [1 4]
-    
-                             [4 2] 
-     
-         [1 0]}
-  
-   :blue
-    #{               [3 4]  
-       
-     [0 2]
-       
-                     [3 0]}})
-
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))
 
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 621d410..181cc1b 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -8,12 +8,6 @@
         [nonaga.draw.draw-last-ring          :only [draw-last-ring]])
   (:require [nonaga.core :as n]))
 
-; So at the moment each type of thing that is drawn on the board has it's own
-; ns. Some of those draw functions have conditional logic in them for what to
-; render based on the :event. Perhaps there should be created a default ns that
-; has simple renderings for everything. And then a namespace for each phase
-; where it overwrites the appropriate draw functions.
-
 ; To implement win detection it would be quite convenient to have the game
 ; state in an atom. This would allow for a win detection watcher that would
 ; spot that someone has one and would change the :event to end the game.

From eb5a7fd7ae651bd11b052c5b8a0fb5e1b7d55455 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:06:45 +1100
Subject: [PATCH 28/39] renamed cp and color in draw-marbles

---
 src/nonaga/draw/draw_marbles.cljs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/draw_marbles.cljs
index 443ad0b..0a7c241 100644
--- a/src/nonaga/draw/draw_marbles.cljs
+++ b/src/nonaga/draw/draw_marbles.cljs
@@ -13,12 +13,14 @@
   (let [marbles (color state)]
     (map (partial marble color) (map hex->svg marbles))))
 
-; Color and cp are badly named. Should be color-of-marbles-being-drawn and
-; current player.
 (defmethod draw-marbles ::marble-selectable
-  [component {[t cp] :event :as state} color]
-  (let [coords (color state)
+  [component {[t current-player] :event :as state} marble-color]
+  (let [coords (marble-color state)
         click  (partial start-marble-move component)]
-    (map (fn [hex svg] (marble color (if (= cp color) (click color hex)) svg))
+    (map (fn [hex svg]
+           (marble marble-color
+                   (if (= current-player marble-color)
+                     (click marble-color hex))
+                   svg))
          coords (map hex->svg coords))))
 

From 3654c7c545b30c2beaffd5c1a0caea3d124c976f Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:07:23 +1100
Subject: [PATCH 29/39] deriving nearer multimethods that care

---
 src/nonaga/draw/draw_marbles.cljs | 6 +++---
 src/nonaga/draw/draw_rings.cljs   | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/draw_marbles.cljs
index 0a7c241..40aaa39 100644
--- a/src/nonaga/draw/draw_marbles.cljs
+++ b/src/nonaga/draw/draw_marbles.cljs
@@ -4,15 +4,15 @@
 (defn start-marble-move [component color coord]
   (update-state component #(assoc % :event [:marble-selected color coord])))
 
-(derive :turn-began      ::marble-selectable)
-(derive :marble-selected ::marble-selectable)
-
 (defmulti draw-marbles (fn [_ state _] (event-type state)))
 
 (defmethod draw-marbles :default [component state color]
   (let [marbles (color state)]
     (map (partial marble color) (map hex->svg marbles))))
 
+(derive :turn-began      ::marble-selectable)
+(derive :marble-selected ::marble-selectable)
+
 (defmethod draw-marbles ::marble-selectable
   [component {[t current-player] :event :as state} marble-color]
   (let [coords (marble-color state)
diff --git a/src/nonaga/draw/draw_rings.cljs b/src/nonaga/draw/draw_rings.cljs
index 5cafaaa..1910085 100644
--- a/src/nonaga/draw/draw_rings.cljs
+++ b/src/nonaga/draw/draw_rings.cljs
@@ -5,15 +5,15 @@
 (defn ring-selected [component color coord]
   (update-state component #(assoc % :event [:ring-selected color coord])))
 
-(derive :marble-moved  ::ring-selectable)
-(derive :ring-selected ::ring-selectable)
-
 (defmulti draw-rings #(event-type %2))
 
 (defmethod draw-rings :default
   [component {:keys [rings]}]
   (map (partial ring "#999") (map hex->svg rings)))
 
+(derive :marble-moved  ::ring-selectable)
+(derive :ring-selected ::ring-selectable)
+
 (defmethod draw-rings ::ring-selectable
   [component {[t color] :event rings :rings :as state}]
   (map (fn [hex svg]

From 5299f536f6423ad7f2fdce31048222c8a0fbefc4 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:08:16 +1100
Subject: [PATCH 30/39] whitespace

---
 src/nonaga/draw/instructions.cljs | 1 +
 src/nonaga/draw/util.cljs         | 1 +
 src/nonaga/rules/coord.cljs       | 1 -
 3 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/nonaga/draw/instructions.cljs b/src/nonaga/draw/instructions.cljs
index 010af1e..34f2b62 100644
--- a/src/nonaga/draw/instructions.cljs
+++ b/src/nonaga/draw/instructions.cljs
@@ -17,3 +17,4 @@
 
 (defmethod instructions :ring-selected [[type color source]]
   (str (color-name color) " selects where to move the ring."))
+
diff --git a/src/nonaga/draw/util.cljs b/src/nonaga/draw/util.cljs
index 4d5d7a9..411b9a1 100644
--- a/src/nonaga/draw/util.cljs
+++ b/src/nonaga/draw/util.cljs
@@ -40,3 +40,4 @@
   (fn []
     (let [old-state (.-wrapper (.-state component))]
       (.setState component #js {:wrapper (update-fn old-state)}))))
+
diff --git a/src/nonaga/rules/coord.cljs b/src/nonaga/rules/coord.cljs
index c3e27a3..535417e 100644
--- a/src/nonaga/rules/coord.cljs
+++ b/src/nonaga/rules/coord.cljs
@@ -32,4 +32,3 @@
 (defn tag-with-distance [destination source]
   [(distance source destination) source])
 
-

From 873318ab88b26cd119a0bf242946a3fc1e410101 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:11:11 +1100
Subject: [PATCH 31/39] removed redundant draws from ns names

---
 src/nonaga/draw.cljs                                 | 12 ++++++------
 .../draw/{draw_last_ring.cljs => last_ring.cljs}     |  2 +-
 src/nonaga/draw/{draw_marbles.cljs => marbles.cljs}  |  2 +-
 ...raw_potential_rings.cljs => potential_rings.cljs} |  2 +-
 src/nonaga/draw/{draw_rings.cljs => rings.cljs}      |  2 +-
 ...lid_marble_moves.cljs => valid_marble_moves.cljs} |  2 +-
 6 files changed, 11 insertions(+), 11 deletions(-)
 rename src/nonaga/draw/{draw_last_ring.cljs => last_ring.cljs} (84%)
 rename src/nonaga/draw/{draw_marbles.cljs => marbles.cljs} (96%)
 rename src/nonaga/draw/{draw_potential_rings.cljs => potential_rings.cljs} (95%)
 rename src/nonaga/draw/{draw_rings.cljs => rings.cljs} (96%)
 rename src/nonaga/draw/{draw_valid_marble_moves.cljs => valid_marble_moves.cljs} (95%)

diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 181cc1b..b1242f2 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -1,11 +1,11 @@
 (ns nonaga.draw
   (:use [nonaga.react :only [div p svg create-class render-component]]
-        [nonaga.draw.instructions            :only [instructions]]
-        [nonaga.draw.draw-valid-marble-moves :only [draw-valid-marble-moves]]
-        [nonaga.draw.draw-marbles            :only [draw-marbles]]
-        [nonaga.draw.draw-rings              :only [draw-rings]]
-        [nonaga.draw.draw-potential-rings    :only [draw-potential-rings]]
-        [nonaga.draw.draw-last-ring          :only [draw-last-ring]])
+        [nonaga.draw.instructions       :only [instructions]]
+        [nonaga.draw.valid-marble-moves :only [draw-valid-marble-moves]]
+        [nonaga.draw.marbles            :only [draw-marbles]]
+        [nonaga.draw.rings              :only [draw-rings]]
+        [nonaga.draw.potential-rings    :only [draw-potential-rings]]
+        [nonaga.draw.last-ring          :only [draw-last-ring]])
   (:require [nonaga.core :as n]))
 
 ; To implement win detection it would be quite convenient to have the game
diff --git a/src/nonaga/draw/draw_last_ring.cljs b/src/nonaga/draw/last_ring.cljs
similarity index 84%
rename from src/nonaga/draw/draw_last_ring.cljs
rename to src/nonaga/draw/last_ring.cljs
index 8c45dfa..f6cb954 100644
--- a/src/nonaga/draw/draw_last_ring.cljs
+++ b/src/nonaga/draw/last_ring.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.draw.draw-last-ring
+(ns nonaga.draw.last-ring
   (:use [nonaga.draw.util :only [hex->svg ring]]))
 
 (defn draw-last-ring [state]
diff --git a/src/nonaga/draw/draw_marbles.cljs b/src/nonaga/draw/marbles.cljs
similarity index 96%
rename from src/nonaga/draw/draw_marbles.cljs
rename to src/nonaga/draw/marbles.cljs
index 40aaa39..b770c92 100644
--- a/src/nonaga/draw/draw_marbles.cljs
+++ b/src/nonaga/draw/marbles.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.draw.draw-marbles
+(ns nonaga.draw.marbles
   (:use [nonaga.draw.util :only [hex->svg marble update-state event-type]]))
 
 (defn start-marble-move [component color coord]
diff --git a/src/nonaga/draw/draw_potential_rings.cljs b/src/nonaga/draw/potential_rings.cljs
similarity index 95%
rename from src/nonaga/draw/draw_potential_rings.cljs
rename to src/nonaga/draw/potential_rings.cljs
index 7bdf64f..76d13a4 100644
--- a/src/nonaga/draw/draw_potential_rings.cljs
+++ b/src/nonaga/draw/potential_rings.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.draw.draw-potential-rings
+(ns nonaga.draw.potential-rings
   (:require [nonaga.core :as n]
             [nonaga.rules.rings :as r])
   (:use [nonaga.draw.util :only [hex->svg ring update-state event-type]]))
diff --git a/src/nonaga/draw/draw_rings.cljs b/src/nonaga/draw/rings.cljs
similarity index 96%
rename from src/nonaga/draw/draw_rings.cljs
rename to src/nonaga/draw/rings.cljs
index 1910085..5a5be5f 100644
--- a/src/nonaga/draw/draw_rings.cljs
+++ b/src/nonaga/draw/rings.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.draw.draw-rings
+(ns nonaga.draw.rings
   (:require [nonaga.rules.rings :as r])
   (:use [nonaga.draw.util :only [hex->svg ring update-state event-type]]))
 
diff --git a/src/nonaga/draw/draw_valid_marble_moves.cljs b/src/nonaga/draw/valid_marble_moves.cljs
similarity index 95%
rename from src/nonaga/draw/draw_valid_marble_moves.cljs
rename to src/nonaga/draw/valid_marble_moves.cljs
index ac1c4b5..714c120 100644
--- a/src/nonaga/draw/draw_valid_marble_moves.cljs
+++ b/src/nonaga/draw/valid_marble_moves.cljs
@@ -1,4 +1,4 @@
-(ns nonaga.draw.draw-valid-marble-moves
+(ns nonaga.draw.valid-marble-moves
   (:require [nonaga.rules.ball :as b]
             [nonaga.core :as n])
   (:use [nonaga.draw.util :only [hex->svg marble update-state event-type]]))

From c7e463f24167ccdc48791c51b3672475b7fe4f59 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:19:20 +1100
Subject: [PATCH 32/39] cross linking

---
 README.md            | 2 ++
 resources/index.html | 5 +++++
 2 files changed, 7 insertions(+)

diff --git a/README.md b/README.md
index 2198001..2718683 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 
 A Clojure implementation of the game Spanish table top game [Nonaga] [bgg].
 
+A playable copy is available at [http://logaan.net/nonaga].
+
 ## License
 
 Copyright © 2013 Logan Campbell
diff --git a/resources/index.html b/resources/index.html
index 30a72c5..431577c 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -55,6 +55,11 @@
       <p>
         <em>The current implementation does not detect wins.</em>
       </p>
+
+      <p>
+        The code can be found on
+        <a href="https://github.com/logaan/nonaga">Github</a>.
+      </p>
     </div>
     <script src="js/react-0.8.0.js"></script>
     <script src="js/main.js"></script>

From f32377bf94a1e2ddcadbaf097d3bcc59007a97d4 Mon Sep 17 00:00:00 2001
From: Logan Campbell <colin@logaan.net>
Date: Wed, 22 Jan 2014 00:19:57 +1100
Subject: [PATCH 33/39] removed []

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2718683..2d2e621 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 A Clojure implementation of the game Spanish table top game [Nonaga] [bgg].
 
-A playable copy is available at [http://logaan.net/nonaga].
+A playable copy is available at http://logaan.net/nonaga.
 
 ## License
 

From e3bd09ca35578718df60e7a7ecbd79a73c84522e Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Tue, 14 Jan 2014 23:43:08 +1100
Subject: [PATCH 34/39] --core.cljs added red winning example board

--draw.cljs
added winner

--index.html
added winner div

--ball.cljs
added function find-winner
---
 resources/index.html       |  3 +++
 src/nonaga/core.cljs       | 40 ++++++++++++++++++++++++++++++++++++++
 src/nonaga/draw.cljs       | 11 +++++++++++
 src/nonaga/rules/ball.cljs | 34 +++++++++++++++++++++++++++++++-
 4 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/resources/index.html b/resources/index.html
index 431577c..77c71db 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -22,6 +22,9 @@
       }
       #instructions {
         text-align: center;
+      }
+	  #game_resolve {
+        text-align: center;
       }
       #content {
         border: 1px solid #AAA;
diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 75b2403..08ca7c7 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -22,6 +22,46 @@
        
                      [3 0]}})
 
+(def enclosing-ring
+  {:rings
+    #{   [1 4] [2 4] [3 4]  
+       [0 3]             [3 3]
+     [0 2]                   [4 2] 
+       [0 1] [1 1]       [3 1] 
+         [1 0]       [3 0]}
+  
+   :red
+    #{   [1 4]
+    
+                             [4 2] 
+     
+         [1 0]}
+  
+   :blue
+    #{               [3 4]  
+       
+     [0 2]
+       
+                     [3 0]}})
+					 
+(def red-wins
+  {:rings
+    #{   [1 4] [2 4] [3 4]  
+       [0 3] [1 3] [2 3] [3 3]
+     [0 2] [1 2] [2 2] [3 2] [4 2] 
+       [0 1] [1 1] [2 1] [3 1] 
+         [1 0] [2 0] [3 0]}
+  
+   :red
+    #{   [1 4] [2 4] [3 4]   }
+  
+   :blue
+    #{                 
+						 [3 3]	
+     [0 2]
+       
+                     [3 0]}})			 
+
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))
 
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index b1242f2..238479c 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -12,6 +12,15 @@
 ; state in an atom. This would allow for a win detection watcher that would
 ; spot that someone has one and would change the :event to end the game.
 
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
 (def board
   (create-class
     "getInitialState"
@@ -27,6 +36,8 @@
                  (div {}
                       (p {:id "instructions"}
                          (instructions (:event state)))      
+					  (p {:id "game_resolve"}
+                         (game-resolve state))
                       (svg {:width 480 :height 480}
                            (draw-rings this state)
                            (draw-potential-rings this state)
diff --git a/src/nonaga/rules/ball.cljs b/src/nonaga/rules/ball.cljs
index c6171d8..d0b11e9 100644
--- a/src/nonaga/rules/ball.cljs
+++ b/src/nonaga/rules/ball.cljs
@@ -1,5 +1,5 @@
 (ns nonaga.rules.ball
-  (:use [nonaga.rules.coord :only [directions]]))
+  (:use [nonaga.rules.coord :only [directions neighbours]]))
 
 (defn invalid-space? [{:keys [rings red blue]} coord]
   (not (and (rings coord)
@@ -12,6 +12,38 @@
           :when (invalid-space? board (direction step))]
       step)))
 
+(defn find-winner [{:keys [rings red blue]}]
+	(let 
+		[
+			allconnected
+			(fn [marble-color] 
+				(> 
+					(count 
+						(reduce clojure.set/union
+							(for [coord marble-color coord' marble-color] 
+								(clojure.set/intersection 
+									#{coord}
+									(neighbours coord')
+								)
+							)
+						)
+					)
+					2
+				)
+			)
+		]
+		(
+			if (allconnected red)
+			:red 
+			(
+				if (allconnected blue)
+				:blue 
+				nil
+			)
+		)
+	)
+)
+	  
 (defn valid-destinations [board coord]
   (disj (into #{} (map (partial move board coord) directions)) coord))
 

From 6692521770c70154626619c82e49a345ca7f2877 Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Tue, 14 Jan 2014 23:43:08 +1100
Subject: [PATCH 35/39] --core.cljs added red winning example board

--draw.cljs
added winner

--index.html
added winner div

--ball.cljs
added function find-winner
---
 resources/index.html | 4 ----
 src/nonaga/draw.cljs | 9 +++++++++
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/resources/index.html b/resources/index.html
index 77c71db..bbf9b94 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -55,10 +55,6 @@
 
       <p>A player wins when any of their marbles touches both other marbles.</p>
 
-      <p>
-        <em>The current implementation does not detect wins.</em>
-      </p>
-
       <p>
         The code can be found on
         <a href="https://github.com/logaan/nonaga">Github</a>.
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index 238479c..38ee63c 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -21,6 +21,15 @@
   ))
 
 
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
 (def board
   (create-class
     "getInitialState"

From a61f7de867f202b3b0d10f068588ae411a08c837 Mon Sep 17 00:00:00 2001
From: alan hawkins <hawk.alan@gmail.com>
Date: Wed, 22 Jan 2014 12:07:41 +1100
Subject: [PATCH 36/39] my changes

---
 resources/index.html       |  7 +++----
 src/nonaga/core.cljs       | 40 ++++++++++++++++++++++++++++++++++++++
 src/nonaga/draw.cljs       | 29 +++++++++++++++++++++++++++
 src/nonaga/rules/ball.cljs | 34 +++++++++++++++++++++++++++++++-
 4 files changed, 105 insertions(+), 5 deletions(-)

diff --git a/resources/index.html b/resources/index.html
index 431577c..bbf9b94 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -22,6 +22,9 @@
       }
       #instructions {
         text-align: center;
+      }
+	  #game_resolve {
+        text-align: center;
       }
       #content {
         border: 1px solid #AAA;
@@ -52,10 +55,6 @@
 
       <p>A player wins when any of their marbles touches both other marbles.</p>
 
-      <p>
-        <em>The current implementation does not detect wins.</em>
-      </p>
-
       <p>
         The code can be found on
         <a href="https://github.com/logaan/nonaga">Github</a>.
diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 75b2403..08ca7c7 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -22,6 +22,46 @@
        
                      [3 0]}})
 
+(def enclosing-ring
+  {:rings
+    #{   [1 4] [2 4] [3 4]  
+       [0 3]             [3 3]
+     [0 2]                   [4 2] 
+       [0 1] [1 1]       [3 1] 
+         [1 0]       [3 0]}
+  
+   :red
+    #{   [1 4]
+    
+                             [4 2] 
+     
+         [1 0]}
+  
+   :blue
+    #{               [3 4]  
+       
+     [0 2]
+       
+                     [3 0]}})
+					 
+(def red-wins
+  {:rings
+    #{   [1 4] [2 4] [3 4]  
+       [0 3] [1 3] [2 3] [3 3]
+     [0 2] [1 2] [2 2] [3 2] [4 2] 
+       [0 1] [1 1] [2 1] [3 1] 
+         [1 0] [2 0] [3 0]}
+  
+   :red
+    #{   [1 4] [2 4] [3 4]   }
+  
+   :blue
+    #{                 
+						 [3 3]	
+     [0 2]
+       
+                     [3 0]}})			 
+
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))
 
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index b1242f2..df6fc2f 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -12,6 +12,33 @@
 ; state in an atom. This would allow for a win detection watcher that would
 ; spot that someone has one and would change the :event to end the game.
 
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
+(defn game-resolve [state]
+  (let [winner (b/find-winner state)] 
+	(if (nil? winner)
+      (str "")
+	  (str (color-name winner) " wins")
+	)
+  ))
+
+
 (def board
   (create-class
     "getInitialState"
@@ -27,6 +54,8 @@
                  (div {}
                       (p {:id "instructions"}
                          (instructions (:event state)))      
+					  (p {:id "game_resolve"}
+                         (game-resolve state))
                       (svg {:width 480 :height 480}
                            (draw-rings this state)
                            (draw-potential-rings this state)
diff --git a/src/nonaga/rules/ball.cljs b/src/nonaga/rules/ball.cljs
index c6171d8..d0b11e9 100644
--- a/src/nonaga/rules/ball.cljs
+++ b/src/nonaga/rules/ball.cljs
@@ -1,5 +1,5 @@
 (ns nonaga.rules.ball
-  (:use [nonaga.rules.coord :only [directions]]))
+  (:use [nonaga.rules.coord :only [directions neighbours]]))
 
 (defn invalid-space? [{:keys [rings red blue]} coord]
   (not (and (rings coord)
@@ -12,6 +12,38 @@
           :when (invalid-space? board (direction step))]
       step)))
 
+(defn find-winner [{:keys [rings red blue]}]
+	(let 
+		[
+			allconnected
+			(fn [marble-color] 
+				(> 
+					(count 
+						(reduce clojure.set/union
+							(for [coord marble-color coord' marble-color] 
+								(clojure.set/intersection 
+									#{coord}
+									(neighbours coord')
+								)
+							)
+						)
+					)
+					2
+				)
+			)
+		]
+		(
+			if (allconnected red)
+			:red 
+			(
+				if (allconnected blue)
+				:blue 
+				nil
+			)
+		)
+	)
+)
+	  
 (defn valid-destinations [board coord]
   (disj (into #{} (map (partial move board coord) directions)) coord))
 

From c3412cc93d86231d4ab7208e1a75ab4a5576af85 Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Wed, 22 Jan 2014 14:19:50 +1100
Subject: [PATCH 37/39] --draw.cljs removed game-resolve function removed
 game-resolve element

--valid_marble_moves.cljs
utilised game state :game-won

--ball.cljs
condensed parentheses
converted tabs to spaces

--index.html
removed game resolve style

--core.cljs
changed red-wins to blue wins

--instructions.cljs
added new instructions for game-won event
---
 resources/index.html                    |  3 --
 src/nonaga/core.cljs                    | 12 +++----
 src/nonaga/draw.cljs                    | 29 ----------------
 src/nonaga/draw/instructions.cljs       |  3 ++
 src/nonaga/draw/valid_marble_moves.cljs |  7 ++--
 src/nonaga/rules/ball.cljs              | 45 +++++++++----------------
 6 files changed, 29 insertions(+), 70 deletions(-)

diff --git a/resources/index.html b/resources/index.html
index bbf9b94..96c51d1 100644
--- a/resources/index.html
+++ b/resources/index.html
@@ -22,9 +22,6 @@
       }
       #instructions {
         text-align: center;
-      }
-	  #game_resolve {
-        text-align: center;
       }
       #content {
         border: 1px solid #AAA;
diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 08ca7c7..d34e440 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -44,23 +44,23 @@
        
                      [3 0]}})
 					 
-(def red-wins
+(def blue-wins
   {:rings
     #{   [1 4] [2 4] [3 4]  
        [0 3] [1 3] [2 3] [3 3]
      [0 2] [1 2] [2 2] [3 2] [4 2] 
        [0 1] [1 1] [2 1] [3 1] 
          [1 0] [2 0] [3 0]}
-  
+     
    :red
-    #{   [1 4] [2 4] [3 4]   }
-  
-   :blue
     #{                 
 						 [3 3]	
      [0 2]
        
-                     [3 0]}})			 
+                     [3 0]}
+    :blue   
+    #{   [1 4] [2 4] [3 4]   }})
+                     
 
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))
diff --git a/src/nonaga/draw.cljs b/src/nonaga/draw.cljs
index df6fc2f..b1242f2 100644
--- a/src/nonaga/draw.cljs
+++ b/src/nonaga/draw.cljs
@@ -12,33 +12,6 @@
 ; state in an atom. This would allow for a win detection watcher that would
 ; spot that someone has one and would change the :event to end the game.
 
-(defn game-resolve [state]
-  (let [winner (b/find-winner state)] 
-	(if (nil? winner)
-      (str "")
-	  (str (color-name winner) " wins")
-	)
-  ))
-
-
-(defn game-resolve [state]
-  (let [winner (b/find-winner state)] 
-	(if (nil? winner)
-      (str "")
-	  (str (color-name winner) " wins")
-	)
-  ))
-
-
-(defn game-resolve [state]
-  (let [winner (b/find-winner state)] 
-	(if (nil? winner)
-      (str "")
-	  (str (color-name winner) " wins")
-	)
-  ))
-
-
 (def board
   (create-class
     "getInitialState"
@@ -54,8 +27,6 @@
                  (div {}
                       (p {:id "instructions"}
                          (instructions (:event state)))      
-					  (p {:id "game_resolve"}
-                         (game-resolve state))
                       (svg {:width 480 :height 480}
                            (draw-rings this state)
                            (draw-potential-rings this state)
diff --git a/src/nonaga/draw/instructions.cljs b/src/nonaga/draw/instructions.cljs
index 34f2b62..8e408cb 100644
--- a/src/nonaga/draw/instructions.cljs
+++ b/src/nonaga/draw/instructions.cljs
@@ -18,3 +18,6 @@
 (defmethod instructions :ring-selected [[type color source]]
   (str (color-name color) " selects where to move the ring."))
 
+(defmethod instructions :game-won [[type color]]
+  (str (color-name color) " wins."))
+
diff --git a/src/nonaga/draw/valid_marble_moves.cljs b/src/nonaga/draw/valid_marble_moves.cljs
index 714c120..9696a4a 100644
--- a/src/nonaga/draw/valid_marble_moves.cljs
+++ b/src/nonaga/draw/valid_marble_moves.cljs
@@ -9,8 +9,11 @@
 
 (defn move-marble [component color from to]
   (update-state component
-                #(-> % (n/move-ball color from to)
-                     (assoc :event [:marble-moved color]))))
+    (fn [s] (let [s' (n/move-ball s color from to) 
+                  winner (b/find-winner s)]
+      (if (nil? winner)
+        (assoc s' :event [:marble-moved color])
+        (assoc s' :event [:game-won winner]))))))
 
 (defmulti draw-valid-marble-moves #(event-type %2))
 
diff --git a/src/nonaga/rules/ball.cljs b/src/nonaga/rules/ball.cljs
index d0b11e9..9f4c0f4 100644
--- a/src/nonaga/rules/ball.cljs
+++ b/src/nonaga/rules/ball.cljs
@@ -13,36 +13,21 @@
       step)))
 
 (defn find-winner [{:keys [rings red blue]}]
-	(let 
-		[
-			allconnected
-			(fn [marble-color] 
-				(> 
-					(count 
-						(reduce clojure.set/union
-							(for [coord marble-color coord' marble-color] 
-								(clojure.set/intersection 
-									#{coord}
-									(neighbours coord')
-								)
-							)
-						)
-					)
-					2
-				)
-			)
-		]
-		(
-			if (allconnected red)
-			:red 
-			(
-				if (allconnected blue)
-				:blue 
-				nil
-			)
-		)
-	)
-)
+  (let [all-connected
+	(fn [marble-color] 
+	  (> 
+	    (count 
+		  (reduce clojure.set/union
+		    (for [coord marble-color coord' marble-color] 
+			  (clojure.set/intersection 
+			    #{coord}
+				(neighbours coord')))))
+        2))]
+      (if (all-connected red)
+	    :red 
+		  (if (all-connected blue)
+		    :blue 
+			nil))))
 	  
 (defn valid-destinations [board coord]
   (disj (into #{} (map (partial move board coord) directions)) coord))

From 8416dd7374992780ef4213ecfa1fb7e3647e4766 Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Wed, 22 Jan 2014 14:23:19 +1100
Subject: [PATCH 38/39] removed examples

---
 src/nonaga/core.cljs | 42 +-----------------------------------------
 1 file changed, 1 insertion(+), 41 deletions(-)

diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index d34e440..8a43163 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -20,47 +20,7 @@
        
      [0 2]
        
-                     [3 0]}})
-
-(def enclosing-ring
-  {:rings
-    #{   [1 4] [2 4] [3 4]  
-       [0 3]             [3 3]
-     [0 2]                   [4 2] 
-       [0 1] [1 1]       [3 1] 
-         [1 0]       [3 0]}
-  
-   :red
-    #{   [1 4]
-    
-                             [4 2] 
-     
-         [1 0]}
-  
-   :blue
-    #{               [3 4]  
-       
-     [0 2]
-       
-                     [3 0]}})
-					 
-(def blue-wins
-  {:rings
-    #{   [1 4] [2 4] [3 4]  
-       [0 3] [1 3] [2 3] [3 3]
-     [0 2] [1 2] [2 2] [3 2] [4 2] 
-       [0 1] [1 1] [2 1] [3 1] 
-         [1 0] [2 0] [3 0]}
-     
-   :red
-    #{                 
-						 [3 3]	
-     [0 2]
-       
-                     [3 0]}
-    :blue   
-    #{   [1 4] [2 4] [3 4]   }})
-                     
+                     [3 0]}})                   
 
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))

From 652cf02aedc2d66c145b02658479fc49000ce60f Mon Sep 17 00:00:00 2001
From: Alan Hawkins <hawk.alan@gmail.com>
Date: Wed, 22 Jan 2014 14:24:26 +1100
Subject: [PATCH 39/39] removed whitespace

---
 src/nonaga/core.cljs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/nonaga/core.cljs b/src/nonaga/core.cljs
index 8a43163..75b2403 100644
--- a/src/nonaga/core.cljs
+++ b/src/nonaga/core.cljs
@@ -20,7 +20,7 @@
        
      [0 2]
        
-                     [3 0]}})                   
+                     [3 0]}})
 
 (defn move-ball [game color from to]
   (update-in game [color] #(-> % (disj from) (conj to))))