diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e04714b --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +/target +/classes +/checkouts +pom.xml +pom.xml.asc +*.jar +*.class +/.lein-* +/.nrepl-port diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..786edf6 --- /dev/null +++ b/LICENSE @@ -0,0 +1,214 @@ +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC +LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM +CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +1. DEFINITIONS + +"Contribution" means: + +a) in the case of the initial Contributor, the initial code and +documentation distributed under this Agreement, and + +b) in the case of each subsequent Contributor: + +i) changes to the Program, and + +ii) additions to the Program; + +where such changes and/or additions to the Program originate from and are +distributed by that particular Contributor. A Contribution 'originates' from +a Contributor if it was added to the Program by such Contributor itself or +anyone acting on such Contributor's behalf. Contributions do not include +additions to the Program which: (i) are separate modules of software +distributed in conjunction with the Program under their own license +agreement, and (ii) are not derivative works of the Program. + +"Contributor" means any person or entity that distributes the Program. + +"Licensed Patents" mean patent claims licensable by a Contributor which are +necessarily infringed by the use or sale of its Contribution alone or when +combined with the Program. + +"Program" means the Contributions distributed in accordance with this +Agreement. + +"Recipient" means anyone who receives the Program under this Agreement, +including all Contributors. + +2. GRANT OF RIGHTS + +a) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free copyright license to +reproduce, prepare derivative works of, publicly display, publicly perform, +distribute and sublicense the Contribution of such Contributor, if any, and +such derivative works, in source code and object code form. + +b) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free patent license under +Licensed Patents to make, use, sell, offer to sell, import and otherwise +transfer the Contribution of such Contributor, if any, in source code and +object code form. This patent license shall apply to the combination of the +Contribution and the Program if, at the time the Contribution is added by the +Contributor, such addition of the Contribution causes such combination to be +covered by the Licensed Patents. The patent license shall not apply to any +other combinations which include the Contribution. No hardware per se is +licensed hereunder. + +c) Recipient understands that although each Contributor grants the licenses +to its Contributions set forth herein, no assurances are provided by any +Contributor that the Program does not infringe the patent or other +intellectual property rights of any other entity. Each Contributor disclaims +any liability to Recipient for claims brought by any other entity based on +infringement of intellectual property rights or otherwise. As a condition to +exercising the rights and licenses granted hereunder, each Recipient hereby +assumes sole responsibility to secure any other intellectual property rights +needed, if any. For example, if a third party patent license is required to +allow Recipient to distribute the Program, it is Recipient's responsibility +to acquire that license before distributing the Program. + +d) Each Contributor represents that to its knowledge it has sufficient +copyright rights in its Contribution, if any, to grant the copyright license +set forth in this Agreement. + +3. REQUIREMENTS + +A Contributor may choose to distribute the Program in object code form under +its own license agreement, provided that: + +a) it complies with the terms and conditions of this Agreement; and + +b) its license agreement: + +i) effectively disclaims on behalf of all Contributors all warranties and +conditions, express and implied, including warranties or conditions of title +and non-infringement, and implied warranties or conditions of merchantability +and fitness for a particular purpose; + +ii) effectively excludes on behalf of all Contributors all liability for +damages, including direct, indirect, special, incidental and consequential +damages, such as lost profits; + +iii) states that any provisions which differ from this Agreement are offered +by that Contributor alone and not by any other party; and + +iv) states that source code for the Program is available from such +Contributor, and informs licensees how to obtain it in a reasonable manner on +or through a medium customarily used for software exchange. + +When the Program is made available in source code form: + +a) it must be made available under this Agreement; and + +b) a copy of this Agreement must be included with each copy of the Program. + +Contributors may not remove or alter any copyright notices contained within +the Program. + +Each Contributor must identify itself as the originator of its Contribution, +if any, in a manner that reasonably allows subsequent Recipients to identify +the originator of the Contribution. + +4. COMMERCIAL DISTRIBUTION + +Commercial distributors of software may accept certain responsibilities with +respect to end users, business partners and the like. While this license is +intended to facilitate the commercial use of the Program, the Contributor who +includes the Program in a commercial product offering should do so in a +manner which does not create potential liability for other Contributors. +Therefore, if a Contributor includes the Program in a commercial product +offering, such Contributor ("Commercial Contributor") hereby agrees to defend +and indemnify every other Contributor ("Indemnified Contributor") against any +losses, damages and costs (collectively "Losses") arising from claims, +lawsuits and other legal actions brought by a third party against the +Indemnified Contributor to the extent caused by the acts or omissions of such +Commercial Contributor in connection with its distribution of the Program in +a commercial product offering. The obligations in this section do not apply +to any claims or Losses relating to any actual or alleged intellectual +property infringement. In order to qualify, an Indemnified Contributor must: +a) promptly notify the Commercial Contributor in writing of such claim, and +b) allow the Commercial Contributor tocontrol, and cooperate with the +Commercial Contributor in, the defense and any related settlement +negotiations. The Indemnified Contributor may participate in any such claim +at its own expense. + +For example, a Contributor might include the Program in a commercial product +offering, Product X. That Contributor is then a Commercial Contributor. If +that Commercial Contributor then makes performance claims, or offers +warranties related to Product X, those performance claims and warranties are +such Commercial Contributor's responsibility alone. Under this section, the +Commercial Contributor would have to defend claims against the other +Contributors related to those performance claims and warranties, and if a +court requires any other Contributor to pay any damages as a result, the +Commercial Contributor must pay those damages. + +5. NO WARRANTY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON +AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER +EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR +CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A +PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the +appropriateness of using and distributing the Program and assumes all risks +associated with its exercise of rights under this Agreement , including but +not limited to the risks and costs of program errors, compliance with +applicable laws, damage to or loss of data, programs or equipment, and +unavailability or interruption of operations. + +6. DISCLAIMER OF LIABILITY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY +CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION +LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE +EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY +OF SUCH DAMAGES. + +7. GENERAL + +If any provision of this Agreement is invalid or unenforceable under +applicable law, it shall not affect the validity or enforceability of the +remainder of the terms of this Agreement, and without further action by the +parties hereto, such provision shall be reformed to the minimum extent +necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Program itself +(excluding combinations of the Program with other software or hardware) +infringes such Recipient's patent(s), then such Recipient's rights granted +under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to +comply with any of the material terms or conditions of this Agreement and +does not cure such failure in a reasonable period of time after becoming +aware of such noncompliance. If all Recipient's rights under this Agreement +terminate, Recipient agrees to cease use and distribution of the Program as +soon as reasonably practicable. However, Recipient's obligations under this +Agreement and any licenses granted by Recipient relating to the Program shall +continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in +order to avoid inconsistency the Agreement is copyrighted and may only be +modified in the following manner. The Agreement Steward reserves the right to +publish new versions (including revisions) of this Agreement from time to +time. No one other than the Agreement Steward has the right to modify this +Agreement. The Eclipse Foundation is the initial Agreement Steward. The +Eclipse Foundation may assign the responsibility to serve as the Agreement +Steward to a suitable separate entity. Each new version of the Agreement will +be given a distinguishing version number. The Program (including +Contributions) may always be distributed subject to the version of the +Agreement under which it was received. In addition, after a new version of +the Agreement is published, Contributor may elect to distribute the Program +(including its Contributions) under the new version. Except as expressly +stated in Sections 2(a) and 2(b) above, Recipient receives no rights or +licenses to the intellectual property of any Contributor under this +Agreement, whether expressly, by implication, estoppel or otherwise. All +rights in the Program not expressly granted under this Agreement are +reserved. + +This Agreement is governed by the laws of the State of Washington and the +intellectual property laws of the United States of America. No party to this +Agreement will bring a legal action under this Agreement more than one year +after the cause of action arose. Each party waives its rights to a jury trial +in any resulting litigation. diff --git a/README.md b/README.md new file mode 100644 index 0000000..129b395 --- /dev/null +++ b/README.md @@ -0,0 +1,14 @@ +# sudorace-cljs + +A Clojure library designed to ... well, that part is up to you. + +## Usage + +FIXME + +## License + +Copyright © 2014 FIXME + +Distributed under the Eclipse Public License either version 1.0 or (at +your option) any later version. diff --git a/doc/intro.md b/doc/intro.md new file mode 100644 index 0000000..918289c --- /dev/null +++ b/doc/intro.md @@ -0,0 +1,3 @@ +# Introduction to sudorace-cljs + +TODO: write [great documentation](http://jacobian.org/writing/great-documentation/what-to-write/) diff --git a/out/cljs/core.cljs b/out/cljs/core.cljs new file mode 100644 index 0000000..970e539 --- /dev/null +++ b/out/cljs/core.cljs @@ -0,0 +1,7754 @@ +; Copyright (c) Rich Hickey. All rights reserved. +; The use and distribution terms for this software are covered by the +; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +; which can be found in the file epl-v10.html at the root of this distribution. +; By using this software in any fashion, you are agreeing to be bound by +; the terms of this license. +; You must not remove this notice, or any other, from this software. + +(ns cljs.core + (:require [goog.string :as gstring] + [goog.string.StringBuffer :as gstringbuf] + [goog.object :as gobject] + [goog.array :as garray])) + +;; next line is auto-generated by the build-script - Do not edit! +(def *clojurescript-version* "0.0-2173") + +(def *unchecked-if* false) + +(def + ^{:doc "Each runtime environment provides a different way to print output. + Whatever function *print-fn* is bound to will be passed any + Strings which should be printed." :dynamic true} + *print-fn* + (fn [_] + (throw (js/Error. "No *print-fn* fn set for evaluation environment")))) + +(defn set-print-fn! + "Set *print-fn* to f." + [f] (set! *print-fn* f)) + +(def ^:dynamic *flush-on-newline* true) +(def ^:dynamic *print-newline* true) +(def ^:dynamic *print-readably* true) +(def ^:dynamic *print-meta* false) +(def ^:dynamic *print-dup* false) +(def ^:dynamic *print-length* nil) +(def ^:dynamic *print-level* nil) + +(defn- pr-opts [] + {:flush-on-newline *flush-on-newline* + :readably *print-readably* + :meta *print-meta* + :dup *print-dup* + :print-length *print-length*}) + +(declare into-array) + +(defn enable-console-print! + "Set *print-fn* to console.log" + [] + (set! *print-newline* false) + (set! *print-fn* + (fn [& args] + (.apply js/console.log js/console (into-array args))))) + +(def + ^{:doc "bound in a repl thread to the most recent value printed"} + *1) + +(def + ^{:doc "bound in a repl thread to the second most recent value printed"} + *2) + +(def + ^{:doc "bound in a repl thread to the third most recent value printed"} + *3) + +(defn truth_ + "Internal - do not use!" + [x] + (cljs.core/truth_ x)) + +(def not-native nil) + +(declare instance? Keyword) + +(defn ^boolean identical? + "Tests if 2 arguments are the same object" + [x y] + (cljs.core/identical? x y)) + +(defn ^boolean nil? + "Returns true if x is nil, false otherwise." + [x] + (coercive-= x nil)) + +(defn ^boolean array? [x] + (cljs.core/array? x)) + +(defn ^boolean number? [n] + (cljs.core/number? n)) + +(defn ^boolean not + "Returns true if x is logical false, false otherwise." + [x] (if x false true)) + +(defn ^boolean object? [x] + (if-not (nil? x) + (identical? (.-constructor x) js/Object) + false)) + +(defn ^boolean string? [x] + (goog/isString x)) + +(set! *unchecked-if* true) +(defn ^boolean native-satisfies? + "Internal - do not use!" + [p x] + (let [x (if (nil? x) nil x)] + (cond + (aget p (goog.typeOf x)) true + (aget p "_") true + :else false))) +(set! *unchecked-if* false) + +(defn is_proto_ + [x] + (identical? (.-prototype (.-constructor x)) x)) + +(def + ^{:doc "When compiled for a command-line target, whatever + function *main-fn* is set to will be called with the command-line + argv as arguments"} + *main-cli-fn* nil) + +(defn type [x] + (when-not (nil? x) + (.-constructor x))) + +(defn missing-protocol [proto obj] + (let [ty (type obj) + ty (if (and ty (.-cljs$lang$type ty)) + (.-cljs$lang$ctorStr ty) + (goog/typeOf obj))] + (js/Error. + (.join (array "No protocol method " proto + " defined for type " ty ": " obj) "")))) + +(defn type->str [ty] + (if-let [s (.-cljs$lang$ctorStr ty)] + s + (str ty))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; arrays ;;;;;;;;;;;;;;;; + +(defn ^array make-array + ([size] + (js/Array. size)) + ([type size] + (make-array size))) + +(defn aclone + "Returns a javascript array, cloned from the passed in array" + [arr] + (let [len (alength arr) + new-arr (make-array len)] + (dotimes [i len] + (aset new-arr i (aget arr i))) + new-arr)) + +(defn ^array array + "Creates a new javascript array. +@param {...*} var_args" ;;array is a special case, don't emulate this doc string + [var-args] ;; [& items] + (.call (.-slice (.-prototype js/Array)) (cljs.core/js-arguments))) + +(declare apply) + +(defn aget + "Returns the value at the index." + ([array i] + (cljs.core/aget array i)) + ([array i & idxs] + (apply aget (aget array i) idxs))) + +(defn aset + "Sets the value at the index." + ([array i val] + (cljs.core/aset array i val)) + ([array idx idx2 & idxv] + (apply aset (aget array idx) idx2 idxv))) + +(defn ^number alength + "Returns the length of the array. Works on arrays of all types." + [array] + (cljs.core/alength array)) + +(declare reduce) + +(defn ^array into-array + ([aseq] + (into-array nil aseq)) + ([type aseq] + (reduce (fn [a x] (.push a x) a) (array) aseq))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;; core protocols ;;;;;;;;;;;;; + +(defprotocol Fn + "Marker protocol") + +(defprotocol IFn + (-invoke + [this] + [this a] + [this a b] + [this a b c] + [this a b c d] + [this a b c d e] + [this a b c d e f] + [this a b c d e f g] + [this a b c d e f g h] + [this a b c d e f g h i] + [this a b c d e f g h i j] + [this a b c d e f g h i j k] + [this a b c d e f g h i j k l] + [this a b c d e f g h i j k l m] + [this a b c d e f g h i j k l m n] + [this a b c d e f g h i j k l m n o] + [this a b c d e f g h i j k l m n o p] + [this a b c d e f g h i j k l m n o p q] + [this a b c d e f g h i j k l m n o p q s] + [this a b c d e f g h i j k l m n o p q s t] + [this a b c d e f g h i j k l m n o p q s t rest])) + +(defprotocol ICloneable + (^clj -clone [value])) + +(defprotocol ICounted + (^number -count [coll] "constant time count")) + +(defprotocol IEmptyableCollection + (-empty [coll])) + +(defprotocol ICollection + (^clj -conj [coll o])) + +#_(defprotocol IOrdinal + (-index [coll])) + +(defprotocol IIndexed + (-nth [coll n] [coll n not-found])) + +(defprotocol ASeq) + +(defprotocol ISeq + (-first [coll]) + (^clj -rest [coll])) + +(defprotocol INext + (^clj-or-nil -next [coll])) + +(defprotocol ILookup + (-lookup [o k] [o k not-found])) + +(defprotocol IAssociative + (^boolean -contains-key? [coll k]) + #_(-entry-at [coll k]) + (^clj -assoc [coll k v])) + +(defprotocol IMap + #_(-assoc-ex [coll k v]) + (^clj -dissoc [coll k])) + +(defprotocol IMapEntry + (-key [coll]) + (-val [coll])) + +(defprotocol ISet + (^clj -disjoin [coll v])) + +(defprotocol IStack + (-peek [coll]) + (^clj -pop [coll])) + +(defprotocol IVector + (^clj -assoc-n [coll n val])) + +(defprotocol IDeref + (-deref [o])) + +(defprotocol IDerefWithTimeout + (-deref-with-timeout [o msec timeout-val])) + +(defprotocol IMeta + (^clj-or-nil -meta [o])) + +(defprotocol IWithMeta + (^clj -with-meta [o meta])) + +(defprotocol IReduce + (-reduce [coll f] [coll f start])) + +(defprotocol IKVReduce + (-kv-reduce [coll f init])) + +(defprotocol IEquiv + (^boolean -equiv [o other])) + +(defprotocol IHash + (-hash [o])) + +(defprotocol ISeqable + (^clj-or-nil -seq [o])) + +(defprotocol ISequential + "Marker interface indicating a persistent collection of sequential items") + +(defprotocol IList + "Marker interface indicating a persistent list") + +(defprotocol IRecord + "Marker interface indicating a record object") + +(defprotocol IReversible + (^clj -rseq [coll])) + +(defprotocol ISorted + (^clj -sorted-seq [coll ascending?]) + (^clj -sorted-seq-from [coll k ascending?]) + (-entry-key [coll entry]) + (-comparator [coll])) + +(defprotocol IWriter + (-write [writer s]) + (-flush [writer])) + +(defprotocol IPrintWithWriter + "The old IPrintable protocol's implementation consisted of building a giant + list of strings to concatenate. This involved lots of concat calls, + intermediate vectors, and lazy-seqs, and was very slow in some older JS + engines. IPrintWithWriter implements printing via the IWriter protocol, so it + be implemented efficiently in terms of e.g. a StringBuffer append." + (-pr-writer [o writer opts])) + +(defprotocol IPending + (^boolean -realized? [d])) + +(defprotocol IWatchable + (-notify-watches [this oldval newval]) + (-add-watch [this key f]) + (-remove-watch [this key])) + +(defprotocol IEditableCollection + (^clj -as-transient [coll])) + +(defprotocol ITransientCollection + (^clj -conj! [tcoll val]) + (^clj -persistent! [tcoll])) + +(defprotocol ITransientAssociative + (^clj -assoc! [tcoll key val])) + +(defprotocol ITransientMap + (^clj -dissoc! [tcoll key])) + +(defprotocol ITransientVector + (^clj -assoc-n! [tcoll n val]) + (^clj -pop! [tcoll])) + +(defprotocol ITransientSet + (^clj -disjoin! [tcoll v])) + +(defprotocol IComparable + (^number -compare [x y])) + +(defprotocol IChunk + (-drop-first [coll])) + +(defprotocol IChunkedSeq + (-chunked-first [coll]) + (-chunked-rest [coll])) + +(defprotocol IChunkedNext + (-chunked-next [coll])) + +(defprotocol INamed + (^string -name [x]) + (^string -namespace [x])) + +;; Printing support + +(deftype StringBufferWriter [sb] + IWriter + (-write [_ s] (.append sb s)) + (-flush [_] nil)) + +(defn pr-str* + "Support so that collections can implement toString without + loading all the printing machinery." + [^not-native obj] + (let [sb (gstring/StringBuffer.) + writer (StringBufferWriter. sb)] + (-pr-writer obj writer (pr-opts)) + (-flush writer) + (str sb))) + +;;;;;;;;;;;;;;;;;;; symbols ;;;;;;;;;;;;;;; + +(declare list hash-combine hash Symbol = compare) + +(defn ^boolean instance? [t o] + (cljs.core/instance? t o)) + +(defn ^boolean symbol? [x] + (instance? Symbol x)) + +(defn- hash-symbol [sym] + (hash-combine (hash (.-ns sym)) (hash (.-name sym)))) + +(defn- compare-symbols [a b] + (cond + (= a b) 0 + (and (not (.-ns a)) (.-ns b)) -1 + (.-ns a) (if-not (.-ns b) + 1 + (let [nsc (compare (.-ns a) (.-ns b))] + (if (zero? nsc) + (compare (.-name a) (.-name b)) + nsc))) + :default (compare (.-name a) (.-name b)))) + +(deftype Symbol [ns name str ^:mutable _hash _meta] + Object + (toString [_] str) + IEquiv + (-equiv [_ other] + (if (instance? Symbol other) + (identical? str (.-str other)) + false)) + IFn + (-invoke [sym coll] + (-lookup coll sym nil)) + (-invoke [sym coll not-found] + (-lookup coll sym not-found)) + IMeta + (-meta [_] _meta) + IWithMeta + (-with-meta [_ new-meta] (Symbol. ns name str _hash new-meta)) + IHash + (-hash [sym] + (caching-hash sym hash-symbol _hash)) + INamed + (-name [_] name) + (-namespace [_] ns) + IPrintWithWriter + (-pr-writer [o writer _] (-write writer str))) + +(defn symbol + ([name] + (if (symbol? name) + name + (symbol nil name))) + ([ns name] + (let [sym-str (if-not (nil? ns) + (str ns "/" name) + name)] + (Symbol. ns name sym-str nil nil)))) + +;;;;;;;;;;;;;;;;;;; fundamentals ;;;;;;;;;;;;;;; + +(declare array-seq prim-seq IndexedSeq) + +(defn clone [value] + (-clone value)) + +(defn cloneable? [value] + (satisfies? ICloneable value)) + +(defn ^seq seq + "Returns a seq on the collection. If the collection is + empty, returns nil. (seq nil) returns nil. seq also works on + Strings." + [coll] + (when-not (nil? coll) + (cond + (implements? ISeqable coll) + (-seq ^not-native coll) + + (array? coll) + (when-not (zero? (alength coll)) + (IndexedSeq. coll 0)) + + (string? coll) + (when-not (zero? (alength coll)) + (IndexedSeq. coll 0)) + + (native-satisfies? ISeqable coll) + (-seq coll) + + :else (throw (js/Error. (str coll "is not ISeqable")))))) + +(defn first + "Returns the first item in the collection. Calls seq on its + argument. If coll is nil, returns nil." + [coll] + (when-not (nil? coll) + (if (implements? ISeq coll) + (-first ^not-native coll) + (let [s (seq coll)] + (when-not (nil? s) + (-first s)))))) + +(defn ^seq rest + "Returns a possibly empty seq of the items after the first. Calls seq on its + argument." + [coll] + (if-not (nil? coll) + (if (implements? ISeq coll) + (-rest ^not-native coll) + (let [s (seq coll)] + (if s + (-rest ^not-native s) + ()))) + ())) + +(defn ^seq next + "Returns a seq of the items after the first. Calls seq on its + argument. If there are no more items, returns nil" + [coll] + (when-not (nil? coll) + (if (implements? INext coll) + (-next ^not-native coll) + (seq (rest coll))))) + +(defn ^boolean = + "Equality. Returns true if x equals y, false if not. Compares + numbers and collections in a type-independent manner. Clojure's immutable data + structures define -equiv (and thus =) as a value, not an identity, + comparison." + ([x] true) + ([x y] + (if (nil? x) + (nil? y) + (or (identical? x y) + ^boolean (-equiv x y)))) + ([x y & more] + (if (= x y) + (if (next more) + (recur y (first more) (next more)) + (= y (first more))) + false))) + +;;;;;;;;;;;;;;;;;;; protocols on primitives ;;;;;;;; +(declare hash-map list equiv-sequential) + +(extend-type nil + ICounted + (-count [_] 0)) + +;; TODO: we should remove this and handle date equality checking +;; by some other means, probably by adding a new primitive type +;; case to the hash table lookup - David + +(extend-type js/Date + IEquiv + (-equiv [o other] + (and (instance? js/Date other) + (identical? (.toString o) (.toString other))))) + +(extend-type number + IEquiv + (-equiv [x o] (identical? x o))) + +(declare with-meta) + +(extend-type function + Fn + IMeta + (-meta [_] nil)) + +(extend-type default + IHash + (-hash [o] + (goog/getUid o))) + +;;this is primitive because & emits call to array-seq +(defn inc + "Returns a number one greater than num." + [x] (cljs.core/+ x 1)) + +(declare deref) + +(deftype Reduced [val] + IDeref + (-deref [o] val)) + +(defn reduced + "Wraps x in a way such that a reduce will terminate with the value x" + [x] + (Reduced. x)) + +(defn ^boolean reduced? + "Returns true if x is the result of a call to reduced" + [r] + (instance? Reduced r)) + +(defn- ci-reduce + "Accepts any collection which satisfies the ICount and IIndexed protocols and +reduces them without incurring seq initialization" + ([cicoll f] + (let [cnt (-count cicoll)] + (if (zero? cnt) + (f) + (loop [val (-nth cicoll 0), n 1] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + ([cicoll f val] + (let [cnt (-count cicoll)] + (loop [val val, n 0] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val)))) + ([cicoll f val idx] + (let [cnt (-count cicoll)] + (loop [val val, n idx] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + +(defn- array-reduce + ([arr f] + (let [cnt (alength arr)] + (if (zero? (alength arr)) + (f) + (loop [val (aget arr 0), n 1] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + ([arr f val] + (let [cnt (alength arr)] + (loop [val val, n 0] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val)))) + ([arr f val idx] + (let [cnt (alength arr)] + (loop [val val, n idx] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + +(declare hash-coll cons RSeq) + +(defn ^boolean counted? + "Returns true if coll implements count in constant time" + [x] (satisfies? ICounted x)) + +(defn ^boolean indexed? + "Returns true if coll implements nth in constant time" + [x] (satisfies? IIndexed x)) + +(deftype IndexedSeq [arr i] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (IndexedSeq. arr i)) + + ISeqable + (-seq [this] this) + + ASeq + ISeq + (-first [_] (aget arr i)) + (-rest [_] (if (< (inc i) (alength arr)) + (IndexedSeq. arr (inc i)) + (list))) + + INext + (-next [_] (if (< (inc i) (alength arr)) + (IndexedSeq. arr (inc i)) + nil)) + + ICounted + (-count [_] (- (alength arr) i)) + + IIndexed + (-nth [coll n] + (let [i (+ n i)] + (when (< i (alength arr)) + (aget arr i)))) + (-nth [coll n not-found] + (let [i (+ n i)] + (if (< i (alength arr)) + (aget arr i) + not-found))) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] cljs.core.List.EMPTY) + + IReduce + (-reduce [coll f] + (array-reduce arr f (aget arr i) (inc i))) + (-reduce [coll f start] + (array-reduce arr f start i)) + + IHash + (-hash [coll] (hash-coll coll)) + + IReversible + (-rseq [coll] + (let [c (-count coll)] + (if (pos? c) + (RSeq. coll (dec c) nil))))) + +(defn prim-seq + ([prim] + (prim-seq prim 0)) + ([prim i] + (when (< i (alength prim)) + (IndexedSeq. prim i)))) + +(defn array-seq + ([array] + (prim-seq array 0)) + ([array i] + (prim-seq array i))) + +(declare with-meta seq-reduce) + +(deftype RSeq [ci i meta] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (RSeq. ci i meta)) + + IMeta + (-meta [coll] meta) + IWithMeta + (-with-meta [coll new-meta] + (RSeq. ci i new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ISeq + (-first [coll] + (-nth ci i)) + (-rest [coll] + (if (pos? i) + (RSeq. ci (dec i) nil))) + + ICounted + (-count [coll] (inc i)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + IReduce + (-reduce [col f] (seq-reduce f col)) + (-reduce [col f start] (seq-reduce f start col))) + +(defn second + "Same as (first (next x))" + [coll] + (first (next coll))) + +(defn ffirst + "Same as (first (first x))" + [coll] + (first (first coll))) + +(defn nfirst + "Same as (next (first x))" + [coll] + (next (first coll))) + +(defn fnext + "Same as (first (next x))" + [coll] + (first (next coll))) + +(defn nnext + "Same as (next (next x))" + [coll] + (next (next coll))) + +(defn last + "Return the last item in coll, in linear time" + [s] + (let [sn (next s)] + (if-not (nil? sn) + (recur sn) + (first s)))) + +(extend-type default + IEquiv + (-equiv [x o] (identical? x o))) + +(defn conj + "conj[oin]. Returns a new collection with the xs + 'added'. (conj nil item) returns (item). The 'addition' may + happen at different 'places' depending on the concrete type." + ([coll x] + (if-not (nil? coll) + (-conj coll x) + (list x))) + ([coll x & xs] + (if xs + (recur (conj coll x) (first xs) (next xs)) + (conj coll x)))) + +(defn empty + "Returns an empty collection of the same category as coll, or nil" + [coll] + (when-not (nil? coll) + (-empty coll))) + +(defn- accumulating-seq-count [coll] + (loop [s (seq coll) acc 0] + (if (counted? s) ; assumes nil is counted, which it currently is + (+ acc (-count s)) + (recur (next s) (inc acc))))) + +(defn count + "Returns the number of items in the collection. (count nil) returns + 0. Also works on strings, arrays, and Maps" + [coll] + (if-not (nil? coll) + (cond + (implements? ICounted coll) + (-count ^not-native coll) + + (array? coll) + (alength coll) + + (string? coll) + (alength coll) + + (native-satisfies? ICounted coll) + (-count coll) + + :else (accumulating-seq-count coll)) + 0)) + +(defn- linear-traversal-nth + ([coll n] + (cond + (nil? coll) (throw (js/Error. "Index out of bounds")) + (zero? n) (if (seq coll) + (first coll) + (throw (js/Error. "Index out of bounds"))) + (indexed? coll) (-nth coll n) + (seq coll) (recur (next coll) (dec n)) + :else (throw (js/Error. "Index out of bounds")))) + ([coll n not-found] + (cond + (nil? coll) not-found + (zero? n) (if (seq coll) + (first coll) + not-found) + (indexed? coll) (-nth coll n not-found) + (seq coll) (recur (next coll) (dec n) not-found) + :else not-found))) + +(defn nth + "Returns the value at the index. get returns nil if index out of + bounds, nth throws an exception unless not-found is supplied. nth + also works for strings, arrays, regex Matchers and Lists, and, + in O(n) time, for sequences." + ([coll n] + (when-not (nil? coll) + (cond + (implements? IIndexed coll) + (-nth ^not-native coll n) + + (array? coll) + (when (< n (.-length coll)) + (aget coll n)) + + (string? coll) + (when (< n (.-length coll)) + (aget coll n)) + + (native-satisfies? IIndexed coll) + (-nth coll n) + + :else + (if (satisfies? ISeq coll) + (linear-traversal-nth coll n) + (throw + (js/Error. + (str "nth not supported on this type " + (type->str (type coll))))))))) + ([coll n not-found] + (if-not (nil? coll) + (cond + (implements? IIndexed coll) + (-nth ^not-native coll n not-found) + + (array? coll) + (if (< n (.-length coll)) + (aget coll n) + not-found) + + (string? coll) + (if (< n (.-length coll)) + (aget coll n) + not-found) + + (native-satisfies? IIndexed coll) + (-nth coll n) + + :else + (if (satisfies? ISeq coll) + (linear-traversal-nth coll n not-found) + (throw + (js/Error. + (str "nth not supported on this type " + (type->str (type coll))))))) + not-found))) + +(defn get + "Returns the value mapped to key, not-found or nil if key not present." + ([o k] + (when-not (nil? o) + (cond + (implements? ILookup o) + (-lookup ^not-native o k) + + (array? o) + (when (< k (.-length o)) + (aget o k)) + + (string? o) + (when (< k (.-length o)) + (aget o k)) + + (native-satisfies? ILookup o) + (-lookup o k) + + :else nil))) + ([o k not-found] + (if-not (nil? o) + (cond + (implements? ILookup o) + (-lookup ^not-native o k not-found) + + (array? o) + (if (< k (.-length o)) + (aget o k) + not-found) + + (string? o) + (if (< k (.-length o)) + (aget o k) + not-found) + + (native-satisfies? ILookup o) + (-lookup o k not-found) + + :else not-found) + not-found))) + +(defn assoc + "assoc[iate]. When applied to a map, returns a new map of the + same (hashed/sorted) type, that contains the mapping of key(s) to + val(s). When applied to a vector, returns a new vector that + contains val at index." + ([coll k v] + (if-not (nil? coll) + (-assoc coll k v) + (hash-map k v))) + ([coll k v & kvs] + (let [ret (assoc coll k v)] + (if kvs + (recur ret (first kvs) (second kvs) (nnext kvs)) + ret)))) + +(defn dissoc + "dissoc[iate]. Returns a new map of the same (hashed/sorted) type, + that does not contain a mapping for key(s)." + ([coll] coll) + ([coll k] + (when-not (nil? coll) + (-dissoc coll k))) + ([coll k & ks] + (when-not (nil? coll) + (let [ret (dissoc coll k)] + (if ks + (recur ret (first ks) (next ks)) + ret))))) + +(defn ^boolean fn? [f] + (or ^boolean (goog/isFunction f) (satisfies? Fn f))) + +(defn with-meta + "Returns an object of the same type and value as obj, with + map m as its metadata." + [o meta] + (if (and (fn? o) (not (satisfies? IWithMeta o))) + (with-meta + (reify + Fn + IFn + (-invoke [_ & args] + (apply o args))) + meta) + (when-not (nil? o) + (-with-meta o meta)))) + +(defn meta + "Returns the metadata of obj, returns nil if there is no metadata." + [o] + (when (and (not (nil? o)) + (satisfies? IMeta o)) + (-meta o))) + +(defn peek + "For a list or queue, same as first, for a vector, same as, but much + more efficient than, last. If the collection is empty, returns nil." + [coll] + (when-not (nil? coll) + (-peek coll))) + +(defn pop + "For a list or queue, returns a new list/queue without the first + item, for a vector, returns a new vector without the last item. + Note - not the same as next/butlast." + [coll] + (when-not (nil? coll) + (-pop coll))) + +(defn disj + "disj[oin]. Returns a new set of the same (hashed/sorted) type, that + does not contain key(s)." + ([coll] coll) + ([coll k] + (when-not (nil? coll) + (-disjoin coll k))) + ([coll k & ks] + (when-not (nil? coll) + (let [ret (disj coll k)] + (if ks + (recur ret (first ks) (next ks)) + ret))))) + +;; Simple caching of string hashcode +(def string-hash-cache (js-obj)) +(def string-hash-cache-count 0) + +(defn add-to-string-hash-cache [k] + (let [h (goog.string/hashCode k)] + (aset string-hash-cache k h) + (set! string-hash-cache-count (inc string-hash-cache-count)) + h)) + +(defn check-string-hash-cache [k] + (when (> string-hash-cache-count 255) + (set! string-hash-cache (js-obj)) + (set! string-hash-cache-count 0)) + (let [h (aget string-hash-cache k)] + (if (number? h) + h + (add-to-string-hash-cache k)))) + +(defn hash [o] + (cond + (implements? IHash o) + (-hash ^not-native o) + + (number? o) + (js-mod (.floor js/Math o) 2147483647) + + (true? o) 1 + + (false? o) 0 + + (string? o) + (check-string-hash-cache o) + + (nil? o) 0 + + :else + (-hash o))) + +(defn ^boolean empty? + "Returns true if coll has no items - same as (not (seq coll)). + Please use the idiom (seq x) rather than (not (empty? x))" + [coll] (or (nil? coll) + (not (seq coll)))) + +(defn ^boolean coll? + "Returns true if x satisfies ICollection" + [x] + (if (nil? x) + false + (satisfies? ICollection x))) + +(defn ^boolean set? + "Returns true if x satisfies ISet" + [x] + (if (nil? x) + false + (satisfies? ISet x))) + +(defn ^boolean associative? + "Returns true if coll implements Associative" + [x] (satisfies? IAssociative x)) + +(defn ^boolean sequential? + "Returns true if coll satisfies ISequential" + [x] (satisfies? ISequential x)) + +(defn ^boolean sorted? + "Returns true if coll satisfies ISorted" + [x] (satisfies? ISorted x)) + +(defn ^boolean reduceable? + "Returns true if coll satisfies IReduce" + [x] (satisfies? IReduce x)) + +(defn ^boolean map? + "Return true if x satisfies IMap" + [x] + (if (nil? x) + false + (satisfies? IMap x))) + +(defn ^boolean vector? + "Return true if x satisfies IVector" + [x] (satisfies? IVector x)) + +(declare ChunkedCons ChunkedSeq) + +(defn ^boolean chunked-seq? + [x] (implements? IChunkedSeq x)) + +;;;;;;;;;;;;;;;;;;;; js primitives ;;;;;;;;;;;; +(defn js-obj + ([] + (cljs.core/js-obj)) + ([& keyvals] + (apply gobject/create keyvals))) + +(defn js-keys [obj] + (let [keys (array)] + (goog.object/forEach obj (fn [val key obj] (.push keys key))) + keys)) + +(defn js-delete [obj key] + (cljs.core/js-delete obj key)) + +(defn- array-copy + ([from i to j len] + (loop [i i j j len len] + (if (zero? len) + to + (do (aset to j (aget from i)) + (recur (inc i) (inc j) (dec len))))))) + +(defn- array-copy-downward + ([from i to j len] + (loop [i (+ i (dec len)) j (+ j (dec len)) len len] + (if (zero? len) + to + (do (aset to j (aget from i)) + (recur (dec i) (dec j) (dec len))))))) + +;;;;;;;;;;;;;;;; preds ;;;;;;;;;;;;;;;;;; + +(def ^:private lookup-sentinel (js-obj)) + +(defn ^boolean false? + "Returns true if x is the value false, false otherwise." + [x] (cljs.core/false? x)) + +(defn ^boolean true? + "Returns true if x is the value true, false otherwise." + [x] (cljs.core/true? x)) + +(defn ^boolean undefined? [x] + (cljs.core/undefined? x)) + +(defn ^boolean seq? + "Return true if s satisfies ISeq" + [s] + (if (nil? s) + false + (satisfies? ISeq s))) + +(defn ^boolean seqable? + "Return true if s satisfies ISeqable" + [s] + (satisfies? ISeqable s)) + +(defn ^boolean boolean [x] + (if x true false)) + +(defn ^boolean ifn? [f] + (or (fn? f) (satisfies? IFn f))) + +(defn ^boolean integer? + "Returns true if n is an integer." + [n] + (and (number? n) + (not ^boolean (js/isNaN n)) + (not (identical? n js/Infinity)) + (== (js/parseFloat n) (js/parseInt n 10)))) + +(defn ^boolean contains? + "Returns true if key is present in the given collection, otherwise + returns false. Note that for numerically indexed collections like + vectors and arrays, this tests if the numeric key is within the + range of indexes. 'contains?' operates constant or logarithmic time; + it will not perform a linear search for a value. See also 'some'." + [coll v] + (if (identical? (get coll v lookup-sentinel) lookup-sentinel) + false + true)) + +(defn find + "Returns the map entry for key, or nil if key not present." + [coll k] + (when (and (not (nil? coll)) + (associative? coll) + (contains? coll k)) + [k (get coll k)])) + +(defn ^boolean distinct? + "Returns true if no two of the arguments are =" + ([x] true) + ([x y] (not (= x y))) + ([x y & more] + (if (not (= x y)) + (loop [s #{x y} xs more] + (let [x (first xs) + etc (next xs)] + (if xs + (if (contains? s x) + false + (recur (conj s x) etc)) + true))) + false))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Seq fns ;;;;;;;;;;;;;;;; + +(defn ^seq sequence + "Coerces coll to a (possibly empty) sequence, if it is not already + one. Will not force a lazy seq. (sequence nil) yields ()" + [coll] + (if (seq? coll) + coll + (or (seq coll) ()))) + +(defn ^number compare + "Comparator. Returns a negative number, zero, or a positive number + when x is logically 'less than', 'equal to', or 'greater than' + y. Uses IComparable if available and google.array.defaultCompare for objects + of the same type and special-cases nil to be less than any other object." + [x y] + (cond + (identical? x y) 0 + + (nil? x) -1 + + (nil? y) 1 + + (identical? (type x) (type y)) + (if (implements? IComparable x) + (-compare ^not-native x y) + (garray/defaultCompare x y)) + + :else + (throw (js/Error. "compare on non-nil objects of different types")))) + +(defn ^:private compare-indexed + "Compare indexed collection." + ([xs ys] + (let [xl (count xs) + yl (count ys)] + (cond + (< xl yl) -1 + (> xl yl) 1 + :else (compare-indexed xs ys xl 0)))) + ([xs ys len n] + (let [d (compare (nth xs n) (nth ys n))] + (if (and (zero? d) (< (+ n 1) len)) + (recur xs ys len (inc n)) + d)))) + +(defn ^:private fn->comparator + "Given a fn that might be boolean valued or a comparator, + return a fn that is a comparator." + [f] + (if (= f compare) + compare + (fn [x y] + (let [r (f x y)] + (if (number? r) + r + (if r + -1 + (if (f y x) 1 0))))))) + +(declare to-array) + +(defn sort + "Returns a sorted sequence of the items in coll. Comp can be + boolean-valued comparison funcion, or a -/0/+ valued comparator. + Comp defaults to compare." + ([coll] + (sort compare coll)) + ([comp coll] + (if (seq coll) + (let [a (to-array coll)] + ;; matching Clojure's stable sort, though docs don't promise it + (garray/stableSort a (fn->comparator comp)) + (seq a)) + ()))) + +(defn sort-by + "Returns a sorted sequence of the items in coll, where the sort + order is determined by comparing (keyfn item). Comp can be + boolean-valued comparison funcion, or a -/0/+ valued comparator. + Comp defaults to compare." + ([keyfn coll] + (sort-by keyfn compare coll)) + ([keyfn comp coll] + (sort (fn [x y] ((fn->comparator comp) (keyfn x) (keyfn y))) coll))) + +; simple reduce based on seqs, used as default +(defn- seq-reduce + ([f coll] + (if-let [s (seq coll)] + (reduce f (first s) (next s)) + (f))) + ([f val coll] + (loop [val val, coll (seq coll)] + (if coll + (let [nval (f val (first coll))] + (if (reduced? nval) + @nval + (recur nval (next coll)))) + val)))) + +(declare vec) + +(defn shuffle + "Return a random permutation of coll" + [coll] + (let [a (to-array coll)] + (garray/shuffle a) + (vec a))) + +(defn reduce + "f should be a function of 2 arguments. If val is not supplied, + returns the result of applying f to the first 2 items in coll, then + applying f to that result and the 3rd item, etc. If coll contains no + items, f must accept no arguments as well, and reduce returns the + result of calling f with no arguments. If coll has only 1 item, it + is returned and f is not called. If val is supplied, returns the + result of applying f to val and the first item in coll, then + applying f to that result and the 2nd item, etc. If coll contains no + items, returns val and f is not called." + ([f coll] + (cond + (implements? IReduce coll) + (-reduce ^not-native coll f) + + (array? coll) + (array-reduce coll f) + + (string? coll) + (array-reduce coll f) + + (native-satisfies? IReduce coll) + (-reduce coll f) + + :else + (seq-reduce f coll))) + ([f val coll] + (cond + (implements? IReduce coll) + (-reduce ^not-native coll f val) + + (array? coll) + (array-reduce coll f val) + + (string? coll) + (array-reduce coll f val) + + (native-satisfies? IReduce coll) + (-reduce coll f val) + + :else + (seq-reduce f val coll)))) + +(defn reduce-kv + "Reduces an associative collection. f should be a function of 3 + arguments. Returns the result of applying f to init, the first key + and the first value in coll, then applying f to that result and the + 2nd key and value, etc. If coll contains no entries, returns init + and f is not called. Note that reduce-kv is supported on vectors, + where the keys will be the ordinals." + ([f init coll] + (if-not (nil? coll) + (-kv-reduce coll f init) + init))) + +;;; Math - variadic forms will not work until the following implemented: +;;; first, next, reduce + +(defn ^number + + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/+ x y)) + ([x y & more] + (reduce + (cljs.core/+ x y) more))) + +(defn ^number - + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/- x)) + ([x y] (cljs.core/- x y)) + ([x y & more] (reduce - (cljs.core/- x y) more))) + +(defn ^number * + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/* x y)) + ([x y & more] (reduce * (cljs.core/* x y) more))) + +(declare divide) + +(defn ^number / + "If no denominators are supplied, returns 1/numerator, + else returns numerator divided by all of the denominators." + ([x] (/ 1 x)) + ([x y] (cljs.core/divide x y)) ;; FIXME: waiting on cljs.core// + ([x y & more] (reduce / (/ x y) more))) + +(defn ^boolean < + "Returns non-nil if nums are in monotonically increasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/< x y)) + ([x y & more] + (if (cljs.core/< x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/< y (first more))) + false))) + +(defn ^boolean <= + "Returns non-nil if nums are in monotonically non-decreasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/<= x y)) + ([x y & more] + (if (cljs.core/<= x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/<= y (first more))) + false))) + +(defn ^boolean > + "Returns non-nil if nums are in monotonically decreasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/> x y)) + ([x y & more] + (if (cljs.core/> x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/> y (first more))) + false))) + +(defn ^boolean >= + "Returns non-nil if nums are in monotonically non-increasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/>= x y)) + ([x y & more] + (if (cljs.core/>= x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/>= y (first more))) + false))) + +(defn dec + "Returns a number one less than num." + [x] (- x 1)) + +(defn ^number max + "Returns the greatest of the nums." + ([x] x) + ([x y] (cljs.core/max x y)) + ([x y & more] + (reduce max (cljs.core/max x y) more))) + +(defn ^number min + "Returns the least of the nums." + ([x] x) + ([x y] (cljs.core/min x y)) + ([x y & more] + (reduce min (cljs.core/min x y) more))) + +(defn ^number byte [x] x) + +(defn char + "Coerce to char" + [x] + (cond + (number? x) (.fromCharCode js/String x) + (and (string? x) (== (.-length x) 1)) x + :else (throw (js/Error. "Argument to char must be a character or number")))) + +(defn ^number short [x] x) +(defn ^number float [x] x) +(defn ^number double [x] x) + +(defn ^number unchecked-byte [x] x) +(defn ^number unchecked-char [x] x) +(defn ^number unchecked-short [x] x) +(defn ^number unchecked-float [x] x) +(defn ^number unchecked-double [x] x) + +(defn ^number unchecked-add + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/unchecked-add x y)) + ([x y & more] (reduce unchecked-add (cljs.core/unchecked-add x y) more))) + +(defn ^number unchecked-add-int + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/unchecked-add-int x y)) + ([x y & more] (reduce unchecked-add-int (cljs.core/unchecked-add-int x y) more))) + +(defn unchecked-dec [x] + (cljs.core/unchecked-dec x)) + +(defn unchecked-dec-int [x] + (cljs.core/unchecked-dec-int x)) + +(defn ^number unchecked-divide-int + "If no denominators are supplied, returns 1/numerator, + else returns numerator divided by all of the denominators." + ([x] (unchecked-divide-int 1 x)) + ([x y] (cljs.core/divide x y)) ;; FIXME: waiting on cljs.core// + ([x y & more] (reduce unchecked-divide-int (unchecked-divide-int x y) more))) + +(defn unchecked-inc [x] + (cljs.core/unchecked-inc x)) + +(defn unchecked-inc-int [x] + (cljs.core/unchecked-inc-int x)) + +(defn ^number unchecked-multiply + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/unchecked-multiply x y)) + ([x y & more] (reduce unchecked-multiply (cljs.core/unchecked-multiply x y) more))) + +(defn ^number unchecked-multiply-int + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/unchecked-multiply-int x y)) + ([x y & more] (reduce unchecked-multiply-int (cljs.core/unchecked-multiply-int x y) more))) + +(defn unchecked-negate [x] + (cljs.core/unchecked-negate x)) + +(defn unchecked-negate-int [x] + (cljs.core/unchecked-negate-int x)) + +(declare mod) + +(defn unchecked-remainder-int [x n] + (cljs.core/unchecked-remainder-int x n)) + +(defn ^number unchecked-substract + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/unchecked-subtract x)) + ([x y] (cljs.core/unchecked-subtract x y)) + ([x y & more] (reduce unchecked-substract (cljs.core/unchecked-subtract x y) more))) + +(defn ^number unchecked-substract-int + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/unchecked-subtract-int x)) + ([x y] (cljs.core/unchecked-subtract-int x y)) + ([x y & more] (reduce unchecked-substract-int (cljs.core/unchecked-subtract-int x y) more))) + +(defn- ^number fix [q] + (if (>= q 0) + (Math/floor q) + (Math/ceil q))) + +(defn int + "Coerce to int by stripping decimal places." + [x] + (bit-or x 0)) + +(defn unchecked-int + "Coerce to int by stripping decimal places." + [x] + (fix x)) + +(defn long + "Coerce to long by stripping decimal places. Identical to `int'." + [x] + (fix x)) + +(defn unchecked-long + "Coerce to long by stripping decimal places. Identical to `int'." + [x] + (fix x)) + +(defn booleans [x] x) +(defn bytes [x] x) +(defn chars [x] x) +(defn shorts [x] x) +(defn ints [x] x) +(defn floats [x] x) +(defn doubles [x] x) +(defn longs [x] x) + +(defn js-mod + "Modulus of num and div with original javascript behavior. i.e. bug for negative numbers" + [n d] + (cljs.core/js-mod n d)) + +(defn mod + "Modulus of num and div. Truncates toward negative infinity." + [n d] + (js-mod (+ (js-mod n d) d) d)) + +(defn quot + "quot[ient] of dividing numerator by denominator." + [n d] + (let [rem (js-mod n d)] + (fix (/ (- n rem) d)))) + +(defn rem + "remainder of dividing numerator by denominator." + [n d] + (let [q (quot n d)] + (- n (* d q)))) + +(defn ^number rand + "Returns a random floating point number between 0 (inclusive) and n (default 1) (exclusive)." + ([] (Math/random)) + ([n] (* n (rand)))) + +(defn rand-int + "Returns a random integer between 0 (inclusive) and n (exclusive)." + [n] (fix (rand n))) + +(defn bit-xor + "Bitwise exclusive or" + [x y] (cljs.core/bit-xor x y)) + +(defn bit-and + "Bitwise and" + [x y] (cljs.core/bit-and x y)) + +(defn bit-or + "Bitwise or" + [x y] (cljs.core/bit-or x y)) + +(defn bit-and-not + "Bitwise and" + [x y] (cljs.core/bit-and-not x y)) + +(defn bit-clear + "Clear bit at index n" + [x n] + (cljs.core/bit-clear x n)) + +(defn bit-flip + "Flip bit at index n" + [x n] + (cljs.core/bit-flip x n)) + +(defn bit-not + "Bitwise complement" + [x] (cljs.core/bit-not x)) + +(defn bit-set + "Set bit at index n" + [x n] + (cljs.core/bit-set x n)) + +(defn bit-test + "Test bit at index n" + [x n] + (cljs.core/bit-test x n)) + +(defn bit-shift-left + "Bitwise shift left" + [x n] (cljs.core/bit-shift-left x n)) + +(defn bit-shift-right + "Bitwise shift right" + [x n] (cljs.core/bit-shift-right x n)) + +(defn bit-shift-right-zero-fill + "DEPRECATED: Bitwise shift right with zero fill" + [x n] (cljs.core/bit-shift-right-zero-fill x n)) + +(defn unsigned-bit-shift-right + "Bitwise shift right with zero fill" + [x n] (cljs.core/unsigned-bit-shift-right x n)) + +(defn bit-count + "Counts the number of bits set in n" + [v] + (let [v (- v (bit-and (bit-shift-right v 1) 0x55555555)) + v (+ (bit-and v 0x33333333) (bit-and (bit-shift-right v 2) 0x33333333))] + (bit-shift-right (* (bit-and (+ v (bit-shift-right v 4)) 0xF0F0F0F) 0x1010101) 24))) + +(defn ^boolean == + "Returns non-nil if nums all have the equivalent + value, otherwise false. Behavior on non nums is + undefined." + ([x] true) + ([x y] (-equiv x y)) + ([x y & more] + (if (== x y) + (if (next more) + (recur y (first more) (next more)) + (== y (first more))) + false))) + +(defn ^boolean pos? + "Returns true if num is greater than zero, else false" + [n] (cljs.core/pos? n)) + +(defn ^boolean zero? [n] + (cljs.core/zero? n)) + +(defn ^boolean neg? + "Returns true if num is less than zero, else false" + [x] (cljs.core/neg? x)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; protocols for host types ;;;;;; + +(defn nthnext + "Returns the nth next of coll, (seq coll) when n is 0." + [coll n] + (loop [n n xs (seq coll)] + (if (and xs (pos? n)) + (recur (dec n) (next xs)) + xs))) + +;;;;;;;;;;;;;;;;;;;;;;;;;; basics ;;;;;;;;;;;;;;;;;; + +(defn str + "With no args, returns the empty string. With one arg x, returns + x.toString(). (str nil) returns the empty string. With more than + one arg, returns the concatenation of the str values of the args." + ([] "") + ([x] (if (nil? x) + "" + (.toString x))) + ([x & ys] + (loop [sb (gstring/StringBuffer. (str x)) more ys] + (if more + (recur (. sb (append (str (first more)))) (next more)) + (.toString sb))))) + +(defn subs + "Returns the substring of s beginning at start inclusive, and ending + at end (defaults to length of string), exclusive." + ([s start] (.substring s start)) + ([s start end] (.substring s start end))) + +(declare map name) + +(defn- equiv-sequential + "Assumes x is sequential. Returns true if x equals y, otherwise + returns false." + [x y] + (boolean + (when (sequential? y) + (loop [xs (seq x) ys (seq y)] + (cond (nil? xs) (nil? ys) + (nil? ys) false + (= (first xs) (first ys)) (recur (next xs) (next ys)) + :else false))))) + +(defn hash-combine [seed hash] + ; a la boost + (bit-xor seed (+ hash 0x9e3779b9 + (bit-shift-left seed 6) + (bit-shift-right seed 2)))) + +(defn- hash-coll [coll] + (if (seq coll) + (loop [res (hash (first coll)) s (next coll)] + (if (nil? s) + res + (recur (hash-combine res (hash (first s))) (next s)))) + 0)) + +(declare key val) + +(defn- hash-imap [m] + ;; a la clojure.lang.APersistentMap + (loop [h 0 s (seq m)] + (if s + (let [e (first s)] + (recur (js-mod (+ h (bit-xor (hash (key e)) (hash (val e)))) + 4503599627370496) + (next s))) + h))) + +(defn- hash-iset [s] + ;; a la clojure.lang.APersistentSet + (loop [h 0 s (seq s)] + (if s + (let [e (first s)] + (recur (js-mod (+ h (hash e)) 4503599627370496) + (next s))) + h))) + +(declare name chunk-first chunk-rest) + +(defn- extend-object! + "Takes a JavaScript object and a map of names to functions and + attaches said functions as methods on the object. Any references to + JavaScript's implict this (via the this-as macro) will resolve to the + object that the function is attached." + [obj fn-map] + (doseq [[key-name f] fn-map] + (let [str-name (name key-name)] + (aset obj str-name f))) + obj) + +;;;;;;;;;;;;;;;; cons ;;;;;;;;;;;;;;;; +(deftype List [meta first rest count ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IList + + ICloneable + (-clone [_] (List. meta first rest count __hash)) + + IWithMeta + (-with-meta [coll meta] (List. meta first rest count __hash)) + + IMeta + (-meta [coll] meta) + + ASeq + ISeq + (-first [coll] first) + (-rest [coll] + (if (== count 1) + () + rest)) + + INext + (-next [coll] + (if (== count 1) + nil + rest)) + + IStack + (-peek [coll] first) + (-pop [coll] (-rest coll)) + + ICollection + (-conj [coll o] (List. meta o coll (inc count) nil)) + + IEmptyableCollection + (-empty [coll] cljs.core.List.EMPTY) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] coll) + + ICounted + (-count [coll] count) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(deftype EmptyList [meta] + Object + (toString [coll] + (pr-str* coll)) + + IList + + ICloneable + (-clone [_] (EmptyList. meta)) + + IWithMeta + (-with-meta [coll meta] (EmptyList. meta)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] nil) + (-rest [coll] ()) + + INext + (-next [coll] nil) + + IStack + (-peek [coll] nil) + (-pop [coll] (throw (js/Error. "Can't pop empty list"))) + + ICollection + (-conj [coll o] (List. meta o nil 1 nil)) + + IEmptyableCollection + (-empty [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] 0) + + ISeqable + (-seq [coll] nil) + + ICounted + (-count [coll] 0) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(set! cljs.core.List.EMPTY (EmptyList. nil)) + +(defn ^boolean reversible? [coll] + (satisfies? IReversible coll)) + +(defn ^seq rseq [coll] + (-rseq coll)) + +(defn reverse + "Returns a seq of the items in coll in reverse order. Not lazy." + [coll] + (if (reversible? coll) + (rseq coll) + (reduce conj () coll))) + +(defn list [& xs] + (let [arr (if (and (instance? IndexedSeq xs) (zero? (.-i xs))) + (.-arr xs) + (let [arr (array)] + (loop [^not-native xs xs] + (if-not (nil? xs) + (do + (.push arr (-first xs)) + (recur (-next xs))) + arr))))] + (loop [i (alength arr) ^not-native r ()] + (if (> i 0) + (recur (dec i) (-conj r (aget arr (dec i)))) + r)))) + +(deftype Cons [meta first rest ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IList + + ICloneable + (-clone [_] (Cons. meta first rest __hash)) + + IWithMeta + (-with-meta [coll meta] (Cons. meta first rest __hash)) + + IMeta + (-meta [coll] meta) + + ASeq + ISeq + (-first [coll] first) + (-rest [coll] (if (nil? rest) () rest)) + + INext + (-next [coll] + (if (nil? rest) nil (seq rest))) + + ICollection + (-conj [coll o] (Cons. nil o coll __hash)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] coll) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn cons + "Returns a new seq where x is the first element and seq is the rest." + [x coll] + (if (or (nil? coll) + (implements? ISeq coll)) + (Cons. nil x coll nil) + (Cons. nil x (seq coll) nil))) + +(defn ^boolean list? [x] + (satisfies? IList x)) + +(deftype Keyword [ns name fqn ^:mutable _hash] + Object + (toString [_] (str ":" fqn)) + + IEquiv + (-equiv [_ other] + (if (instance? Keyword other) + (identical? fqn (.-fqn other)) + false)) + IFn + (-invoke [kw coll] + (get coll kw)) + (-invoke [kw coll not-found] + (get coll kw not-found)) + + IHash + (-hash [_] + ; This was checking if _hash == -1, should it stay that way? + (if (nil? _hash) + (do + (set! _hash (+ (hash-combine (hash ns) (hash name)) + 0x9e3779b9)) + _hash) + _hash)) + + INamed + (-name [_] name) + (-namespace [_] ns) + + IPrintWithWriter + (-pr-writer [o writer _] (-write writer (str ":" fqn)))) + +(defn ^boolean keyword? [x] + (instance? Keyword x)) + +(defn ^boolean keyword-identical? [x y] + (if (identical? x y) + true + (if (and (keyword? x) + (keyword? y)) + (identical? (.-fqn x) (.-fqn y)) + false))) + +(defn namespace + "Returns the namespace String of a symbol or keyword, or nil if not present." + [x] + (if (implements? INamed x) + (-namespace ^not-native x) + (throw (js/Error. (str "Doesn't support namespace: " x))))) + +(defn keyword + "Returns a Keyword with the given namespace and name. Do not use : + in the keyword strings, it will be added automatically." + ([name] (cond + (keyword? name) name + (symbol? name) (Keyword. + (cljs.core/namespace name) + (cljs.core/name name) (.-str name) nil) + (string? name) (let [parts (.split name "/")] + (if (== (alength parts) 2) + (Keyword. (aget parts 0) (aget parts 1) name nil) + (Keyword. nil (aget parts 0) name nil))))) + ([ns name] (Keyword. ns name (str (when ns (str ns "/")) name) nil))) + + +(deftype LazySeq [meta ^:mutable fn ^:mutable s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + (sval [coll] + (if (nil? fn) + s + (do + (set! s (fn)) + (set! fn nil) + s))) + + IWithMeta + (-with-meta [coll meta] (LazySeq. meta fn s __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] + (-seq coll) + (when-not (nil? s) + (first s))) + (-rest [coll] + (-seq coll) + (if-not (nil? s) + (rest s) + ())) + + INext + (-next [coll] + (-seq coll) + (when-not (nil? s) + (next s))) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (.sval coll) + (when-not (nil? s) + (loop [ls s] + (if (instance? LazySeq ls) + (recur (.sval ls)) + (do (set! s ls) + (seq s)))))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(declare ArrayChunk) + +(deftype ChunkBuffer [^:mutable buf ^:mutable end] + Object + (add [_ o] + (aset buf end o) + (set! end (inc end))) + + (chunk [_ o] + (let [ret (ArrayChunk. buf 0 end)] + (set! buf nil) + ret)) + + ICounted + (-count [_] end)) + +(defn chunk-buffer [capacity] + (ChunkBuffer. (make-array capacity) 0)) + +(deftype ArrayChunk [arr off end] + ICounted + (-count [_] (- end off)) + + IIndexed + (-nth [coll i] + (aget arr (+ off i))) + (-nth [coll i not-found] + (if (and (>= i 0) (< i (- end off))) + (aget arr (+ off i)) + not-found)) + + IChunk + (-drop-first [coll] + (if (== off end) + (throw (js/Error. "-drop-first of empty chunk")) + (ArrayChunk. arr (inc off) end))) + + IReduce + (-reduce [coll f] + (array-reduce arr f (aget arr off) (inc off))) + (-reduce [coll f start] + (array-reduce arr f start off))) + +(defn array-chunk + ([arr] + (ArrayChunk. arr 0 (alength arr))) + ([arr off] + (ArrayChunk. arr off (alength arr))) + ([arr off end] + (ArrayChunk. arr off end))) + +(deftype ChunkedCons [chunk more meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll m] + (ChunkedCons. chunk more m __hash)) + + IMeta + (-meta [coll] meta) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ISeqable + (-seq [coll] coll) + + ASeq + ISeq + (-first [coll] (-nth chunk 0)) + (-rest [coll] + (if (> (-count chunk) 1) + (ChunkedCons. (-drop-first chunk) more meta nil) + (if (nil? more) + () + more))) + + INext + (-next [coll] + (if (> (-count chunk) 1) + (ChunkedCons. (-drop-first chunk) more meta nil) + (let [more (-seq more)] + (when-not (nil? more) + more)))) + + IChunkedSeq + (-chunked-first [coll] chunk) + (-chunked-rest [coll] + (if (nil? more) + () + more)) + + IChunkedNext + (-chunked-next [coll] + (if (nil? more) + nil + more)) + + ICollection + (-conj [this o] + (cons o this)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash))) + +(defn chunk-cons [chunk rest] + (if (zero? (-count chunk)) + rest + (ChunkedCons. chunk rest nil nil))) + +(defn chunk-append [b x] + (.add b x)) + +(defn chunk [b] + (.chunk b)) + +(defn chunk-first [s] + (-chunked-first s)) + +(defn chunk-rest [s] + (-chunked-rest s)) + +(defn chunk-next [s] + (if (implements? IChunkedNext s) + (-chunked-next s) + (seq (-chunked-rest s)))) + +;;;;;;;;;;;;;;;; + +(defn to-array + "Naive impl of to-array as a start." + [s] + (let [ary (array)] + (loop [s s] + (if (seq s) + (do (. ary push (first s)) + (recur (next s))) + ary)))) + +(defn to-array-2d + "Returns a (potentially-ragged) 2-dimensional array + containing the contents of coll." + [coll] + (let [ret (make-array (count coll))] + (loop [i 0 xs (seq coll)] + (when xs + (aset ret i (to-array (first xs))) + (recur (inc i) (next xs)))) + ret)) + +(defn int-array + ([size-or-seq] + (if (number? size-or-seq) + (int-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn long-array + ([size-or-seq] + (if (number? size-or-seq) + (long-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn double-array + ([size-or-seq] + (if (number? size-or-seq) + (double-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn object-array + ([size-or-seq] + (if (number? size-or-seq) + (object-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn- bounded-count [s n] + (if (counted? s) + (count s) + (loop [s s i n sum 0] + (if (and (pos? i) (seq s)) + (recur (next s) (dec i) (inc sum)) + sum)))) + +(defn spread + [arglist] + (cond + (nil? arglist) nil + (nil? (next arglist)) (seq (first arglist)) + :else (cons (first arglist) + (spread (next arglist))))) + +(defn concat + "Returns a lazy seq representing the concatenation of the elements in the supplied colls." + ([] (lazy-seq nil)) + ([x] (lazy-seq x)) + ([x y] + (lazy-seq + (let [s (seq x)] + (if s + (if (chunked-seq? s) + (chunk-cons (chunk-first s) (concat (chunk-rest s) y)) + (cons (first s) (concat (rest s) y))) + y)))) + ([x y & zs] + (let [cat (fn cat [xys zs] + (lazy-seq + (let [xys (seq xys)] + (if xys + (if (chunked-seq? xys) + (chunk-cons (chunk-first xys) + (cat (chunk-rest xys) zs)) + (cons (first xys) (cat (rest xys) zs))) + (when zs + (cat (first zs) (next zs)))))))] + (cat (concat x y) zs)))) + +(defn list* + "Creates a new list containing the items prepended to the rest, the + last of which will be treated as a sequence." + ([args] (seq args)) + ([a args] (cons a args)) + ([a b args] (cons a (cons b args))) + ([a b c args] (cons a (cons b (cons c args)))) + ([a b c d & more] + (cons a (cons b (cons c (cons d (spread more))))))) + + +;;; Transients + +(defn transient + "Returns a new, transient version of the collection, in constant time." + [coll] + (-as-transient coll)) + +(defn persistent! + "Returns a new, persistent version of the transient collection, in + constant time. The transient collection cannot be used after this + call, any such use will throw an exception." + [tcoll] + (-persistent! tcoll)) + +(defn conj! + "Adds x to the transient collection, and return coll. The 'addition' + may happen at different 'places' depending on the concrete type." + ([tcoll val] + (-conj! tcoll val)) + ([tcoll val & vals] + (let [ntcoll (-conj! tcoll val)] + (if vals + (recur ntcoll (first vals) (next vals)) + ntcoll)))) + +(defn assoc! + "When applied to a transient map, adds mapping of key(s) to + val(s). When applied to a transient vector, sets the val at index. + Note - index must be <= (count vector). Returns coll." + ([tcoll key val] + (-assoc! tcoll key val)) + ([tcoll key val & kvs] + (let [ntcoll (-assoc! tcoll key val)] + (if kvs + (recur ntcoll (first kvs) (second kvs) (nnext kvs)) + ntcoll)))) + +(defn dissoc! + "Returns a transient map that doesn't contain a mapping for key(s)." + ([tcoll key] + (-dissoc! tcoll key)) + ([tcoll key & ks] + (let [ntcoll (-dissoc! tcoll key)] + (if ks + (recur ntcoll (first ks) (next ks)) + ntcoll)))) + +(defn pop! + "Removes the last item from a transient vector. If + the collection is empty, throws an exception. Returns coll" + [tcoll] + (-pop! tcoll)) + +(defn disj! + "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that + does not contain key(s)." + ([tcoll val] + (-disjoin! tcoll val)) + ([tcoll val & vals] + (let [ntcoll (-disjoin! tcoll val)] + (if vals + (recur ntcoll (first vals) (next vals)) + ntcoll)))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; apply ;;;;;;;;;;;;;;;; + +;; see core.clj +(gen-apply-to) + +(set! *unchecked-if* true) +(defn apply + "Applies fn f to the argument list formed by prepending intervening arguments to args. + First cut. Not lazy. Needs to use emitted toApply." + ([f args] + (let [fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count args (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc args) + (.cljs$lang$applyTo f args))) + (.apply f f (to-array args))))) + ([f x args] + (let [arglist (list* x args) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist))))) + ([f x y args] + (let [arglist (list* x y args) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist))))) + ([f x y z args] + (let [arglist (list* x y z args) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist))))) + ([f a b c d & args] + (let [arglist (cons a (cons b (cons c (cons d (spread args))))) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist)))))) +(set! *unchecked-if* false) + +(defn vary-meta + "Returns an object of the same type and value as obj, with + (apply f (meta obj) args) as its metadata." + ([obj f] + (with-meta obj (f (meta obj)))) + ([obj f a] + (with-meta obj (f (meta obj) a))) + ([obj f a b] + (with-meta obj (f (meta obj) a b))) + ([obj f a b c] + (with-meta obj (f (meta obj) a b c))) + ([obj f a b c d] + (with-meta obj (f (meta obj) a b c d))) + ([obj f a b c d & args] + (with-meta obj (apply f (meta obj) a b c d args)))) + +(defn ^boolean not= + "Same as (not (= obj1 obj2))" + ([x] false) + ([x y] (not (= x y))) + ([x y & more] + (not (apply = x y more)))) + +(defn not-empty + "If coll is empty, returns nil, else coll" + [coll] (when (seq coll) coll)) + +(defn ^boolean every? + "Returns true if (pred x) is logical true for every x in coll, else + false." + [pred coll] + (cond + (nil? (seq coll)) true + (pred (first coll)) (recur pred (next coll)) + :else false)) + +(defn ^boolean not-every? + "Returns false if (pred x) is logical true for every x in + coll, else true." + [pred coll] (not (every? pred coll))) + +(defn some + "Returns the first logical true value of (pred x) for any x in coll, + else nil. One common idiom is to use a set as pred, for example + this will return :fred if :fred is in the sequence, otherwise nil: + (some #{:fred} coll)" + [pred coll] + (when (seq coll) + (or (pred (first coll)) (recur pred (next coll))))) + +(defn ^boolean not-any? + "Returns false if (pred x) is logical true for any x in coll, + else true." + [pred coll] (not (some pred coll))) + +(defn ^boolean even? + "Returns true if n is even, throws an exception if n is not an integer" + [n] (if (integer? n) + (zero? (bit-and n 1)) + (throw (js/Error. (str "Argument must be an integer: " n))))) + +(defn ^boolean odd? + "Returns true if n is odd, throws an exception if n is not an integer" + [n] (not (even? n))) + +(defn identity [x] x) + +(defn ^boolean complement + "Takes a fn f and returns a fn that takes the same arguments as f, + has the same effects, if any, and returns the opposite truth value." + [f] + (fn + ([] (not (f))) + ([x] (not (f x))) + ([x y] (not (f x y))) + ([x y & zs] (not (apply f x y zs))))) + +(defn constantly + "Returns a function that takes any number of arguments and returns x." + [x] (fn [& args] x)) + +(defn comp + "Takes a set of functions and returns a fn that is the composition + of those fns. The returned fn takes a variable number of args, + applies the rightmost of fns to the args, the next + fn (right-to-left) to the result, etc." + ([] identity) + ([f] f) + ([f g] + (fn + ([] (f (g))) + ([x] (f (g x))) + ([x y] (f (g x y))) + ([x y z] (f (g x y z))) + ([x y z & args] (f (apply g x y z args))))) + ([f g h] + (fn + ([] (f (g (h)))) + ([x] (f (g (h x)))) + ([x y] (f (g (h x y)))) + ([x y z] (f (g (h x y z)))) + ([x y z & args] (f (g (apply h x y z args)))))) + ([f1 f2 f3 & fs] + (let [fs (reverse (list* f1 f2 f3 fs))] + (fn [& args] + (loop [ret (apply (first fs) args) fs (next fs)] + (if fs + (recur ((first fs) ret) (next fs)) + ret)))))) + +(defn partial + "Takes a function f and fewer than the normal arguments to f, and + returns a fn that takes a variable number of additional args. When + called, the returned function calls f with args + additional args." + ([f] f) + ([f arg1] + (fn [& args] (apply f arg1 args))) + ([f arg1 arg2] + (fn [& args] (apply f arg1 arg2 args))) + ([f arg1 arg2 arg3] + (fn [& args] (apply f arg1 arg2 arg3 args))) + ([f arg1 arg2 arg3 & more] + (fn [& args] (apply f arg1 arg2 arg3 (concat more args))))) + +(defn fnil + "Takes a function f, and returns a function that calls f, replacing + a nil first argument to f with the supplied value x. Higher arity + versions can replace arguments in the second and third + positions (y, z). Note that the function f can take any number of + arguments, not just the one(s) being nil-patched." + ([f x] + (fn + ([a] (f (if (nil? a) x a))) + ([a b] (f (if (nil? a) x a) b)) + ([a b c] (f (if (nil? a) x a) b c)) + ([a b c & ds] (apply f (if (nil? a) x a) b c ds)))) + ([f x y] + (fn + ([a b] (f (if (nil? a) x a) (if (nil? b) y b))) + ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) c)) + ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) c ds)))) + ([f x y z] + (fn + ([a b] (f (if (nil? a) x a) (if (nil? b) y b))) + ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c))) + ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) ds))))) + +(defn map-indexed + "Returns a lazy sequence consisting of the result of applying f to 0 + and the first item of coll, followed by applying f to 1 and the second + item in coll, etc, until coll is exhausted. Thus function f should + accept 2 arguments, index and item." + [f coll] + (letfn [(mapi [idx coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (chunk-append b (f (+ idx i) (-nth c i)))) + (chunk-cons (chunk b) (mapi (+ idx size) (chunk-rest s)))) + (cons (f idx (first s)) (mapi (inc idx) (rest s)))))))] + (mapi 0 coll))) + +(defn keep + "Returns a lazy sequence of the non-nil results of (f item). Note, + this means false return values will be included. f must be free of + side-effects." + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (let [x (f (-nth c i))] + (when-not (nil? x) + (chunk-append b x)))) + (chunk-cons (chunk b) (keep f (chunk-rest s)))) + (let [x (f (first s))] + (if (nil? x) + (keep f (rest s)) + (cons x (keep f (rest s)))))))))) + +(defn keep-indexed + "Returns a lazy sequence of the non-nil results of (f index item). Note, + this means false return values will be included. f must be free of + side-effects." + ([f coll] + (letfn [(keepi [idx coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (let [x (f (+ idx i) (-nth c i))] + (when-not (nil? x) + (chunk-append b x)))) + (chunk-cons (chunk b) (keepi (+ idx size) (chunk-rest s)))) + (let [x (f idx (first s))] + (if (nil? x) + (keepi (inc idx) (rest s)) + (cons x (keepi (inc idx) (rest s)))))))))] + (keepi 0 coll)))) + +(defn every-pred + "Takes a set of predicates and returns a function f that returns true if all of its + composing predicates return a logical true value against all of its arguments, else it returns + false. Note that f is short-circuiting in that it will stop execution on the first + argument that triggers a logical false result against the original predicates." + ([p] + (fn ep1 + ([] true) + ([x] (boolean (p x))) + ([x y] (boolean (and (p x) (p y)))) + ([x y z] (boolean (and (p x) (p y) (p z)))) + ([x y z & args] (boolean (and (ep1 x y z) + (every? p args)))))) + ([p1 p2] + (fn ep2 + ([] true) + ([x] (boolean (and (p1 x) (p2 x)))) + ([x y] (boolean (and (p1 x) (p1 y) (p2 x) (p2 y)))) + ([x y z] (boolean (and (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z)))) + ([x y z & args] (boolean (and (ep2 x y z) + (every? #(and (p1 %) (p2 %)) args)))))) + ([p1 p2 p3] + (fn ep3 + ([] true) + ([x] (boolean (and (p1 x) (p2 x) (p3 x)))) + ([x y] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y)))) + ([x y z] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y) (p1 z) (p2 z) (p3 z)))) + ([x y z & args] (boolean (and (ep3 x y z) + (every? #(and (p1 %) (p2 %) (p3 %)) args)))))) + ([p1 p2 p3 & ps] + (let [ps (list* p1 p2 p3 ps)] + (fn epn + ([] true) + ([x] (every? #(% x) ps)) + ([x y] (every? #(and (% x) (% y)) ps)) + ([x y z] (every? #(and (% x) (% y) (% z)) ps)) + ([x y z & args] (boolean (and (epn x y z) + (every? #(every? % args) ps)))))))) + +(defn some-fn + "Takes a set of predicates and returns a function f that returns the first logical true value + returned by one of its composing predicates against any of its arguments, else it returns + logical false. Note that f is short-circuiting in that it will stop execution on the first + argument that triggers a logical true result against the original predicates." + ([p] + (fn sp1 + ([] nil) + ([x] (p x)) + ([x y] (or (p x) (p y))) + ([x y z] (or (p x) (p y) (p z))) + ([x y z & args] (or (sp1 x y z) + (some p args))))) + ([p1 p2] + (fn sp2 + ([] nil) + ([x] (or (p1 x) (p2 x))) + ([x y] (or (p1 x) (p1 y) (p2 x) (p2 y))) + ([x y z] (or (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z))) + ([x y z & args] (or (sp2 x y z) + (some #(or (p1 %) (p2 %)) args))))) + ([p1 p2 p3] + (fn sp3 + ([] nil) + ([x] (or (p1 x) (p2 x) (p3 x))) + ([x y] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y))) + ([x y z] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y) (p1 z) (p2 z) (p3 z))) + ([x y z & args] (or (sp3 x y z) + (some #(or (p1 %) (p2 %) (p3 %)) args))))) + ([p1 p2 p3 & ps] + (let [ps (list* p1 p2 p3 ps)] + (fn spn + ([] nil) + ([x] (some #(% x) ps)) + ([x y] (some #(or (% x) (% y)) ps)) + ([x y z] (some #(or (% x) (% y) (% z)) ps)) + ([x y z & args] (or (spn x y z) + (some #(some % args) ps))))))) + +(defn map + "Returns a lazy sequence consisting of the result of applying f to the + set of first items of each coll, followed by applying f to the set + of second items in each coll, until any one of the colls is + exhausted. Any remaining items in other colls are ignored. Function + f should accept number-of-colls arguments." + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (chunk-append b (f (-nth c i)))) + (chunk-cons (chunk b) (map f (chunk-rest s)))) + (cons (f (first s)) (map f (rest s))))))) + ([f c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (f (first s1) (first s2)) + (map f (rest s1) (rest s2))))))) + ([f c1 c2 c3] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2) s3 (seq c3)] + (when (and s1 s2 s3) + (cons (f (first s1) (first s2) (first s3)) + (map f (rest s1) (rest s2) (rest s3))))))) + ([f c1 c2 c3 & colls] + (let [step (fn step [cs] + (lazy-seq + (let [ss (map seq cs)] + (when (every? identity ss) + (cons (map first ss) (step (map rest ss)))))))] + (map #(apply f %) (step (conj colls c3 c2 c1)))))) + +(defn take + "Returns a lazy sequence of the first n items in coll, or all items if + there are fewer than n." + [n coll] + (lazy-seq + (when (pos? n) + (when-let [s (seq coll)] + (cons (first s) (take (dec n) (rest s))))))) + +(defn drop + "Returns a lazy sequence of all but the first n items in coll." + [n coll] + (let [step (fn [n coll] + (let [s (seq coll)] + (if (and (pos? n) s) + (recur (dec n) (rest s)) + s)))] + (lazy-seq (step n coll)))) + +(defn drop-last + "Return a lazy sequence of all but the last n (default 1) items in coll" + ([s] (drop-last 1 s)) + ([n s] (map (fn [x _] x) s (drop n s)))) + +(defn take-last + "Returns a seq of the last n items in coll. Depending on the type + of coll may be no better than linear time. For vectors, see also subvec." + [n coll] + (loop [s (seq coll), lead (seq (drop n coll))] + (if lead + (recur (next s) (next lead)) + s))) + +(defn drop-while + "Returns a lazy sequence of the items in coll starting from the first + item for which (pred item) returns nil." + [pred coll] + (let [step (fn [pred coll] + (let [s (seq coll)] + (if (and s (pred (first s))) + (recur pred (rest s)) + s)))] + (lazy-seq (step pred coll)))) + +(defn cycle + "Returns a lazy (infinite!) sequence of repetitions of the items in coll." + [coll] (lazy-seq + (when-let [s (seq coll)] + (concat s (cycle s))))) + +(defn split-at + "Returns a vector of [(take n coll) (drop n coll)]" + [n coll] + [(take n coll) (drop n coll)]) + +(defn repeat + "Returns a lazy (infinite!, or length n if supplied) sequence of xs." + ([x] (lazy-seq (cons x (repeat x)))) + ([n x] (take n (repeat x)))) + +(defn replicate + "Returns a lazy seq of n xs." + [n x] (take n (repeat x))) + +(defn repeatedly + "Takes a function of no args, presumably with side effects, and + returns an infinite (or length n if supplied) lazy sequence of calls + to it" + ([f] (lazy-seq (cons (f) (repeatedly f)))) + ([n f] (take n (repeatedly f)))) + +(defn iterate + "Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects" + {:added "1.0"} + [f x] (cons x (lazy-seq (iterate f (f x))))) + +(defn interleave + "Returns a lazy seq of the first item in each coll, then the second etc." + ([c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (first s1) (cons (first s2) + (interleave (rest s1) (rest s2)))))))) + ([c1 c2 & colls] + (lazy-seq + (let [ss (map seq (conj colls c2 c1))] + (when (every? identity ss) + (concat (map first ss) (apply interleave (map rest ss)))))))) + +(defn interpose + "Returns a lazy seq of the elements of coll separated by sep" + [sep coll] (drop 1 (interleave (repeat sep) coll))) + + + +(defn- flatten1 + "Take a collection of collections, and return a lazy seq + of items from the inner collection" + [colls] + (let [cat (fn cat [coll colls] + (lazy-seq + (if-let [coll (seq coll)] + (cons (first coll) (cat (rest coll) colls)) + (when (seq colls) + (cat (first colls) (rest colls))))))] + (cat nil colls))) + +(defn mapcat + "Returns the result of applying concat to the result of applying map + to f and colls. Thus function f should return a collection." + ([f coll] + (flatten1 (map f coll))) + ([f coll & colls] + (flatten1 (apply map f coll colls)))) + +(defn filter + "Returns a lazy sequence of the items in coll for which + (pred item) returns true. pred must be free of side-effects." + ([pred coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (when (pred (-nth c i)) + (chunk-append b (-nth c i)))) + (chunk-cons (chunk b) (filter pred (chunk-rest s)))) + (let [f (first s) r (rest s)] + (if (pred f) + (cons f (filter pred r)) + (filter pred r)))))))) + +(defn remove + "Returns a lazy sequence of the items in coll for which + (pred item) returns false. pred must be free of side-effects." + [pred coll] + (filter (complement pred) coll)) + +(defn tree-seq + "Returns a lazy sequence of the nodes in a tree, via a depth-first walk. + branch? must be a fn of one arg that returns true if passed a node + that can have children (but may not). children must be a fn of one + arg that returns a sequence of the children. Will only be called on + nodes for which branch? returns true. Root is the root node of the + tree." + [branch? children root] + (let [walk (fn walk [node] + (lazy-seq + (cons node + (when (branch? node) + (mapcat walk (children node))))))] + (walk root))) + +(defn flatten + "Takes any nested combination of sequential things (lists, vectors, + etc.) and returns their contents as a single, flat sequence. + (flatten nil) returns nil." + [x] + (filter #(not (sequential? %)) + (rest (tree-seq sequential? seq x)))) + +(defn into + "Returns a new coll consisting of to-coll with all of the items of + from-coll conjoined." + [to from] + (if-not (nil? to) + (if (implements? IEditableCollection to) + (persistent! (reduce -conj! (transient to) from)) + (reduce -conj to from)) + (reduce conj () from))) + +(defn mapv + "Returns a vector consisting of the result of applying f to the + set of first items of each coll, followed by applying f to the set + of second items in each coll, until any one of the colls is + exhausted. Any remaining items in other colls are ignored. Function + f should accept number-of-colls arguments." + ([f coll] + (-> (reduce (fn [v o] (conj! v (f o))) (transient []) coll) + persistent!)) + ([f c1 c2] + (into [] (map f c1 c2))) + ([f c1 c2 c3] + (into [] (map f c1 c2 c3))) + ([f c1 c2 c3 & colls] + (into [] (apply map f c1 c2 c3 colls)))) + +(defn filterv + "Returns a vector of the items in coll for which + (pred item) returns true. pred must be free of side-effects." + [pred coll] + (-> (reduce (fn [v o] (if (pred o) (conj! v o) v)) + (transient []) + coll) + persistent!)) + +(defn partition + "Returns a lazy sequence of lists of n items each, at offsets step + apart. If step is not supplied, defaults to n, i.e. the partitions + do not overlap. If a pad collection is supplied, use its elements as + necessary to complete last partition upto n items. In case there are + not enough padding elements, return a partition with less than n items." + ([n coll] + (partition n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (when (== n (count p)) + (cons p (partition n step (drop step s)))))))) + ([n step pad coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (if (== n (count p)) + (cons p (partition n step pad (drop step s))) + (list (take n (concat p pad))))))))) + +(defn get-in + "Returns the value in a nested associative structure, + where ks is a sequence of keys. Returns nil if the key is not present, + or the not-found value if supplied." + {:added "1.2" + :static true} + ([m ks] + (get-in m ks nil)) + ([m ks not-found] + (loop [sentinel lookup-sentinel + m m + ks (seq ks)] + (if ks + (if (not (satisfies? ILookup m)) + not-found + (let [m (get m (first ks) sentinel)] + (if (identical? sentinel m) + not-found + (recur sentinel m (next ks))))) + m)))) + +(defn assoc-in + "Associates a value in a nested associative structure, where ks is a + sequence of keys and v is the new value and returns a new nested structure. + If any levels do not exist, hash-maps will be created." + [m [k & ks] v] + (if ks + (assoc m k (assoc-in (get m k) ks v)) + (assoc m k v))) + +(defn update-in + "'Updates' a value in a nested associative structure, where ks is a + sequence of keys and f is a function that will take the old value + and any supplied args and return the new value, and returns a new + nested structure. If any levels do not exist, hash-maps will be + created." + ([m [k & ks] f] + (if ks + (assoc m k (update-in (get m k) ks f)) + (assoc m k (f (get m k))))) + ([m [k & ks] f a] + (if ks + (assoc m k (update-in (get m k) ks f a)) + (assoc m k (f (get m k) a)))) + ([m [k & ks] f a b] + (if ks + (assoc m k (update-in (get m k) ks f a b)) + (assoc m k (f (get m k) a b)))) + ([m [k & ks] f a b c] + (if ks + (assoc m k (update-in (get m k) ks f a b c)) + (assoc m k (f (get m k) a b c)))) + ([m [k & ks] f a b c & args] + (if ks + (assoc m k (apply update-in (get m k) ks f a b c args)) + (assoc m k (apply f (get m k) a b c args))))) + +;;; PersistentVector + +(deftype VectorNode [edit arr]) + +(defn- pv-fresh-node [edit] + (VectorNode. edit (make-array 32))) + +(defn- pv-aget [node idx] + (aget (.-arr node) idx)) + +(defn- pv-aset [node idx val] + (aset (.-arr node) idx val)) + +(defn- pv-clone-node [node] + (VectorNode. (.-edit node) (aclone (.-arr node)))) + +(defn- tail-off [pv] + (let [cnt (.-cnt pv)] + (if (< cnt 32) + 0 + (bit-shift-left (bit-shift-right-zero-fill (dec cnt) 5) 5)))) + +(defn- new-path [edit level node] + (loop [ll level + ret node] + (if (zero? ll) + ret + (let [embed ret + r (pv-fresh-node edit) + _ (pv-aset r 0 embed)] + (recur (- ll 5) r))))) + +(defn- push-tail [pv level parent tailnode] + (let [ret (pv-clone-node parent) + subidx (bit-and (bit-shift-right-zero-fill (dec (.-cnt pv)) level) 0x01f)] + (if (== 5 level) + (do + (pv-aset ret subidx tailnode) + ret) + (let [child (pv-aget parent subidx)] + (if-not (nil? child) + (let [node-to-insert (push-tail pv (- level 5) child tailnode)] + (pv-aset ret subidx node-to-insert) + ret) + (let [node-to-insert (new-path nil (- level 5) tailnode)] + (pv-aset ret subidx node-to-insert) + ret)))))) + +(defn- vector-index-out-of-bounds [i cnt] + (throw (js/Error. (str "No item " i " in vector of length " cnt)))) + +(defn- array-for [pv i] + (if (and (<= 0 i) (< i (.-cnt pv))) + (if (>= i (tail-off pv)) + (.-tail pv) + (loop [node (.-root pv) + level (.-shift pv)] + (if (pos? level) + (recur (pv-aget node (bit-and (bit-shift-right-zero-fill i level) 0x01f)) + (- level 5)) + (.-arr node)))) + (vector-index-out-of-bounds i (.-cnt pv)))) + +(defn- do-assoc [pv level node i val] + (let [ret (pv-clone-node node)] + (if (zero? level) + (do + (pv-aset ret (bit-and i 0x01f) val) + ret) + (let [subidx (bit-and (bit-shift-right-zero-fill i level) 0x01f)] + (pv-aset ret subidx (do-assoc pv (- level 5) (pv-aget node subidx) i val)) + ret)))) + +(defn- pop-tail [pv level node] + (let [subidx (bit-and (bit-shift-right-zero-fill (- (.-cnt pv) 2) level) 0x01f)] + (cond + (> level 5) (let [new-child (pop-tail pv (- level 5) (pv-aget node subidx))] + (if (and (nil? new-child) (zero? subidx)) + nil + (let [ret (pv-clone-node node)] + (pv-aset ret subidx new-child) + ret))) + (zero? subidx) nil + :else (let [ret (pv-clone-node node)] + (pv-aset ret subidx nil) + ret)))) + +(declare tv-editable-root tv-editable-tail TransientVector deref + pr-sequential-writer pr-writer chunked-seq) + +(deftype PersistentVector [meta cnt shift root tail ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentVector. meta cnt shift root tail __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentVector. meta cnt shift root tail __hash)) + + IMeta + (-meta [coll] meta) + + IStack + (-peek [coll] + (when (> cnt 0) + (-nth coll (dec cnt)))) + (-pop [coll] + (cond + (zero? cnt) (throw (js/Error. "Can't pop empty vector")) + (== 1 cnt) (-with-meta cljs.core.PersistentVector.EMPTY meta) + (< 1 (- cnt (tail-off coll))) + (PersistentVector. meta (dec cnt) shift root (.slice tail 0 -1) nil) + :else (let [new-tail (array-for coll (- cnt 2)) + nr (pop-tail coll shift root) + new-root (if (nil? nr) cljs.core.PersistentVector.EMPTY_NODE nr) + cnt-1 (dec cnt)] + (if (and (< 5 shift) (nil? (pv-aget new-root 1))) + (PersistentVector. meta cnt-1 (- shift 5) (pv-aget new-root 0) new-tail nil) + (PersistentVector. meta cnt-1 shift new-root new-tail nil))))) + + ICollection + (-conj [coll o] + (if (< (- cnt (tail-off coll)) 32) + (let [len (alength tail) + new-tail (make-array (inc len))] + (dotimes [i len] + (aset new-tail i (aget tail i))) + (aset new-tail len o) + (PersistentVector. meta (inc cnt) shift root new-tail nil)) + (let [root-overflow? (> (bit-shift-right-zero-fill cnt 5) (bit-shift-left 1 shift)) + new-shift (if root-overflow? (+ shift 5) shift) + new-root (if root-overflow? + (let [n-r (pv-fresh-node nil)] + (pv-aset n-r 0 root) + (pv-aset n-r 1 (new-path nil shift (VectorNode. nil tail))) + n-r) + (push-tail coll shift root (VectorNode. nil tail)))] + (PersistentVector. meta (inc cnt) new-shift new-root (array o) nil)))) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentVector.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (cond + (zero? cnt) nil + (< cnt 32) (array-seq tail) + :else (chunked-seq coll 0 0))) + + ICounted + (-count [coll] cnt) + + IIndexed + (-nth [coll n] + (aget (array-for coll n) (bit-and n 0x01f))) + (-nth [coll n not-found] + (if (and (<= 0 n) (< n cnt)) + (-nth coll n) + not-found)) + + ILookup + (-lookup [coll k] (-nth coll k nil)) + (-lookup [coll k not-found] (-nth coll k not-found)) + + IMapEntry + (-key [coll] + (-nth coll 0)) + (-val [coll] + (-nth coll 1)) + + IAssociative + (-assoc [coll k v] + (if (number? k) + (-assoc-n coll k v) + (throw (js/Error. "Vector's key for assoc must be a number.")))) + + IVector + (-assoc-n [coll n val] + (cond + (and (<= 0 n) (< n cnt)) + (if (<= (tail-off coll) n) + (let [new-tail (aclone tail)] + (aset new-tail (bit-and n 0x01f) val) + (PersistentVector. meta cnt shift root new-tail nil)) + (PersistentVector. meta cnt shift (do-assoc coll shift root n val) tail nil)) + (== n cnt) (-conj coll val) + :else (throw (js/Error. (str "Index " n " out of bounds [0," cnt "]"))))) + + IReduce + (-reduce [v f] + (ci-reduce v f)) + (-reduce [v f start] + (ci-reduce v f start)) + + IKVReduce + (-kv-reduce [v f init] + (let [step-init (array 0 init)] ; [step 0 init init] + (loop [i 0] + (if (< i cnt) + (let [arr (array-for v i) + len (alength arr)] + (let [init (loop [j 0 init (aget step-init 1)] + (if (< j len) + (let [init (f init (+ j i) (aget arr j))] + (if (reduced? init) + init + (recur (inc j) init))) + (do (aset step-init 0 len) + (aset step-init 1 init) + init)))] + (if (reduced? init) + @init + (recur (+ i (aget step-init 0)))))) + (aget step-init 1))))) + + IFn + (-invoke [coll k] + (-nth coll k)) + (-invoke [coll k not-found] + (-nth coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientVector. cnt shift (tv-editable-root root) (tv-editable-tail tail))) + + IReversible + (-rseq [coll] + (if (pos? cnt) + (RSeq. coll (dec cnt) nil)))) + +(set! cljs.core.PersistentVector.EMPTY_NODE (VectorNode. nil (make-array 32))) + +(set! cljs.core.PersistentVector.EMPTY + (PersistentVector. nil 0 5 cljs.core.PersistentVector.EMPTY_NODE (array) 0)) + +(set! cljs.core.PersistentVector.fromArray + (fn [xs ^boolean no-clone] + (let [l (alength xs) + xs (if no-clone xs (aclone xs))] + (if (< l 32) + (PersistentVector. nil l 5 cljs.core.PersistentVector.EMPTY_NODE xs nil) + (let [node (.slice xs 0 32) + v (PersistentVector. nil 32 5 cljs.core.PersistentVector.EMPTY_NODE node nil)] + (loop [i 32 out (-as-transient v)] + (if (< i l) + (recur (inc i) (conj! out (aget xs i))) + (persistent! out)))))))) + +(defn vec [coll] + (-persistent! + (reduce -conj! + (-as-transient cljs.core.PersistentVector.EMPTY) + coll))) + +(defn vector [& args] + (if (and (instance? IndexedSeq args) (zero? (.-i args))) + (cljs.core.PersistentVector.fromArray (.-arr args) true) + (vec args))) + +(declare subvec) + +(deftype ChunkedSeq [vec node i off meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll m] + (chunked-seq vec node i off m)) + (-meta [coll] meta) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ASeq + ISeq + (-first [coll] + (aget node off)) + (-rest [coll] + (if (< (inc off) (alength node)) + (let [s (chunked-seq vec node i (inc off))] + (if (nil? s) + () + s)) + (-chunked-rest coll))) + + INext + (-next [coll] + (if (< (inc off) (alength node)) + (let [s (chunked-seq vec node i (inc off))] + (if (nil? s) + nil + s)) + (-chunked-next coll))) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] + (with-meta cljs.core.PersistentVector.EMPTY meta)) + + IChunkedSeq + (-chunked-first [coll] + (array-chunk node off)) + (-chunked-rest [coll] + (let [l (alength node) + s (when (< (+ i l) (-count vec)) + (chunked-seq vec (+ i l) 0))] + (if (nil? s) + () + s))) + + IChunkedNext + (-chunked-next [coll] + (let [l (alength node) + s (when (< (+ i l) (-count vec)) + (chunked-seq vec (+ i l) 0))] + (if (nil? s) + nil + s))) + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IReduce + (-reduce [coll f] + (ci-reduce (subvec vec (+ i off) (count vec)) f)) + + (-reduce [coll f start] + (ci-reduce (subvec vec (+ i off) (count vec)) f start))) + +(defn chunked-seq + ([vec i off] (ChunkedSeq. vec (array-for vec i) i off nil nil)) + ([vec node i off] (ChunkedSeq. vec node i off nil nil)) + ([vec node i off meta] + (ChunkedSeq. vec node i off meta nil))) + +(declare build-subvec) + +(deftype Subvec [meta v start end ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (Subvec. meta v start end __hash)) + + IWithMeta + (-with-meta [coll meta] (build-subvec meta v start end __hash)) + + IMeta + (-meta [coll] meta) + + IStack + (-peek [coll] + (-nth v (dec end))) + (-pop [coll] + (if (== start end) + (throw (js/Error. "Can't pop empty vector")) + (build-subvec meta v start (dec end) nil))) + + ICollection + (-conj [coll o] + (build-subvec meta (-assoc-n v end o) start (inc end) nil)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentVector.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (let [subvec-seq (fn subvec-seq [i] + (when-not (== i end) + (cons (-nth v i) + (lazy-seq + (subvec-seq (inc i))))))] + (subvec-seq start))) + + IReversible + (-rseq [coll] + (if-not (== start end) + (RSeq. coll (dec (- end start)) nil))) + + ICounted + (-count [coll] (- end start)) + + IIndexed + (-nth [coll n] + (if (or (neg? n) (<= end (+ start n))) + (vector-index-out-of-bounds n (- end start)) + (-nth v (+ start n)))) + (-nth [coll n not-found] + (if (or (neg? n) (<= end (+ start n))) + not-found + (-nth v (+ start n) not-found))) + + ILookup + (-lookup [coll k] (-nth coll k nil)) + (-lookup [coll k not-found] (-nth coll k not-found)) + + IAssociative + (-assoc [coll key val] + (if (number? key) + (-assoc-n coll key val) + (throw (js/Error. "Subvec's key for assoc must be a number.")))) + + IVector + (-assoc-n [coll n val] + (let [v-pos (+ start n)] + (build-subvec meta (assoc v v-pos val) start (max end (inc v-pos)) nil))) + + IReduce + (-reduce [coll f] + (ci-reduce coll f)) + (-reduce [coll f start] + (ci-reduce coll f start)) + + IFn + (-invoke [coll k] + (-nth coll k)) + (-invoke [coll k not-found] + (-nth coll k not-found))) + +(defn- build-subvec [meta v start end __hash] + (if (instance? Subvec v) + (recur meta (.-v v) (+ (.-start v) start) (+ (.-start v) end) __hash) + (let [c (count v)] + (when (or (neg? start) + (neg? end) + (> start c) + (> end c)) + (throw (js/Error. "Index out of bounds"))) + (Subvec. meta v start end __hash)))) + +(defn subvec + "Returns a persistent vector of the items in vector from + start (inclusive) to end (exclusive). If end is not supplied, + defaults to (count vector). This operation is O(1) and very fast, as + the resulting vector shares structure with the original and no + trimming is done." + ([v start] + (subvec v start (count v))) + ([v start end] + (build-subvec nil v start end nil))) + +(defn- tv-ensure-editable [edit node] + (if (identical? edit (.-edit node)) + node + (VectorNode. edit (aclone (.-arr node))))) + +(defn- tv-editable-root [node] + (VectorNode. (js-obj) (aclone (.-arr node)))) + +(defn- tv-editable-tail [tl] + (let [ret (make-array 32)] + (array-copy tl 0 ret 0 (alength tl)) + ret)) + +(defn- tv-push-tail [tv level parent tail-node] + (let [ret (tv-ensure-editable (.. tv -root -edit) parent) + subidx (bit-and (bit-shift-right-zero-fill (dec (.-cnt tv)) level) 0x01f)] + (pv-aset ret subidx + (if (== level 5) + tail-node + (let [child (pv-aget ret subidx)] + (if-not (nil? child) + (tv-push-tail tv (- level 5) child tail-node) + (new-path (.. tv -root -edit) (- level 5) tail-node))))) + ret)) + +(defn- tv-pop-tail [tv level node] + (let [node (tv-ensure-editable (.. tv -root -edit) node) + subidx (bit-and (bit-shift-right-zero-fill (- (.-cnt tv) 2) level) 0x01f)] + (cond + (> level 5) (let [new-child (tv-pop-tail + tv (- level 5) (pv-aget node subidx))] + (if (and (nil? new-child) (zero? subidx)) + nil + (do (pv-aset node subidx new-child) + node))) + (zero? subidx) nil + :else (do (pv-aset node subidx nil) + node)))) + +(defn- editable-array-for [tv i] + (if (and (<= 0 i) (< i (.-cnt tv))) + (if (>= i (tail-off tv)) + (.-tail tv) + (let [root (.-root tv)] + (loop [node root + level (.-shift tv)] + (if (pos? level) + (recur (tv-ensure-editable + (.-edit root) + (pv-aget node + (bit-and (bit-shift-right-zero-fill i level) + 0x01f))) + (- level 5)) + (.-arr node))))) + (throw (js/Error. + (str "No item " i " in transient vector of length " (.-cnt tv)))))) + +(deftype TransientVector [^:mutable cnt + ^:mutable shift + ^:mutable root + ^:mutable tail] + ITransientCollection + (-conj! [tcoll o] + (if ^boolean (.-edit root) + (if (< (- cnt (tail-off tcoll)) 32) + (do (aset tail (bit-and cnt 0x01f) o) + (set! cnt (inc cnt)) + tcoll) + (let [tail-node (VectorNode. (.-edit root) tail) + new-tail (make-array 32)] + (aset new-tail 0 o) + (set! tail new-tail) + (if (> (bit-shift-right-zero-fill cnt 5) + (bit-shift-left 1 shift)) + (let [new-root-array (make-array 32) + new-shift (+ shift 5)] + (aset new-root-array 0 root) + (aset new-root-array 1 (new-path (.-edit root) shift tail-node)) + (set! root (VectorNode. (.-edit root) new-root-array)) + (set! shift new-shift) + (set! cnt (inc cnt)) + tcoll) + (let [new-root (tv-push-tail tcoll shift root tail-node)] + (set! root new-root) + (set! cnt (inc cnt)) + tcoll)))) + (throw (js/Error. "conj! after persistent!")))) + + (-persistent! [tcoll] + (if ^boolean (.-edit root) + (do (set! (.-edit root) nil) + (let [len (- cnt (tail-off tcoll)) + trimmed-tail (make-array len)] + (array-copy tail 0 trimmed-tail 0 len) + (PersistentVector. nil cnt shift root trimmed-tail nil))) + (throw (js/Error. "persistent! called twice")))) + + ITransientAssociative + (-assoc! [tcoll key val] (-assoc-n! tcoll key val)) + + ITransientVector + (-assoc-n! [tcoll n val] + (if ^boolean (.-edit root) + (cond + (and (<= 0 n) (< n cnt)) + (if (<= (tail-off tcoll) n) + (do (aset tail (bit-and n 0x01f) val) + tcoll) + (let [new-root + ((fn go [level node] + (let [node (tv-ensure-editable (.-edit root) node)] + (if (zero? level) + (do (pv-aset node (bit-and n 0x01f) val) + node) + (let [subidx (bit-and (bit-shift-right-zero-fill n level) + 0x01f)] + (pv-aset node subidx + (go (- level 5) (pv-aget node subidx))) + node)))) + shift root)] + (set! root new-root) + tcoll)) + (== n cnt) (-conj! tcoll val) + :else + (throw + (js/Error. + (str "Index " n " out of bounds for TransientVector of length" cnt)))) + (throw (js/Error. "assoc! after persistent!")))) + + (-pop! [tcoll] + (if ^boolean (.-edit root) + (cond + (zero? cnt) (throw (js/Error. "Can't pop empty vector")) + (== 1 cnt) (do (set! cnt 0) tcoll) + (pos? (bit-and (dec cnt) 0x01f)) (do (set! cnt (dec cnt)) tcoll) + :else + (let [new-tail (editable-array-for tcoll (- cnt 2)) + new-root (let [nr (tv-pop-tail tcoll shift root)] + (if-not (nil? nr) + nr + (VectorNode. (.-edit root) (make-array 32))))] + (if (and (< 5 shift) (nil? (pv-aget new-root 1))) + (let [new-root (tv-ensure-editable (.-edit root) (pv-aget new-root 0))] + (set! root new-root) + (set! shift (- shift 5)) + (set! cnt (dec cnt)) + (set! tail new-tail) + tcoll) + (do (set! root new-root) + (set! cnt (dec cnt)) + (set! tail new-tail) + tcoll)))) + (throw (js/Error. "pop! after persistent!")))) + + ICounted + (-count [coll] + (if ^boolean (.-edit root) + cnt + (throw (js/Error. "count after persistent!")))) + + IIndexed + (-nth [coll n] + (if ^boolean (.-edit root) + (aget (array-for coll n) (bit-and n 0x01f)) + (throw (js/Error. "nth after persistent!")))) + + (-nth [coll n not-found] + (if (and (<= 0 n) (< n cnt)) + (-nth coll n) + not-found)) + + ILookup + (-lookup [coll k] (-nth coll k nil)) + + (-lookup [coll k not-found] (-nth coll k not-found)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found))) + +;;; PersistentQueue ;;; + +(deftype PersistentQueueSeq [meta front rear ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll meta] (PersistentQueueSeq. meta front rear __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] (first front)) + (-rest [coll] + (if-let [f1 (next front)] + (PersistentQueueSeq. meta f1 rear nil) + (if (nil? rear) + (-empty coll) + (PersistentQueueSeq. meta rear nil nil)))) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] coll)) + +(deftype PersistentQueue [meta count front rear ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [coll] (PersistentQueue. meta count front rear __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentQueue. meta count front rear __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] (first front)) + (-rest [coll] (rest (seq coll))) + + IStack + (-peek [coll] (first front)) + (-pop [coll] + (if front + (if-let [f1 (next front)] + (PersistentQueue. meta (dec count) f1 rear nil) + (PersistentQueue. meta (dec count) (seq rear) [] nil)) + coll)) + + ICollection + (-conj [coll o] + (if front + (PersistentQueue. meta (inc count) front (conj (or rear []) o) nil) + (PersistentQueue. meta (inc count) (conj front o) [] nil))) + + IEmptyableCollection + (-empty [coll] cljs.core.PersistentQueue.EMPTY) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (let [rear (seq rear)] + (if (or front rear) + (PersistentQueueSeq. nil front (seq rear) nil)))) + + ICounted + (-count [coll] count)) + +(set! cljs.core.PersistentQueue.EMPTY (PersistentQueue. nil 0 nil [] 0)) + +(deftype NeverEquiv [] + IEquiv + (-equiv [o other] false)) + +(def ^:private never-equiv (NeverEquiv.)) + +(defn- equiv-map + "Assumes y is a map. Returns true if x equals y, otherwise returns + false." + [x y] + (boolean + (when (map? y) + ; assume all maps are counted + (when (== (count x) (count y)) + (every? identity + (map (fn [xkv] (= (get y (first xkv) never-equiv) + (second xkv))) + x)))))) + + +(defn- scan-array [incr k array] + (let [len (alength array)] + (loop [i 0] + (when (< i len) + (if (identical? k (aget array i)) + i + (recur (+ i incr))))))) + +; The keys field is an array of all keys of this map, in no particular +; order. Any string, keyword, or symbol key is used as a property name +; to store the value in strobj. If a key is assoc'ed when that same +; key already exists in strobj, the old value is overwritten. If a +; non-string key is assoc'ed, return a HashMap object instead. + +(defn- obj-map-compare-keys [a b] + (let [a (hash a) + b (hash b)] + (cond + (< a b) -1 + (> a b) 1 + :else 0))) + +(defn- obj-map->hash-map [m k v] + (let [ks (.-keys m) + len (alength ks) + so (.-strobj m) + mm (meta m)] + (loop [i 0 + out (transient cljs.core.PersistentHashMap.EMPTY)] + (if (< i len) + (let [k (aget ks i)] + (recur (inc i) (assoc! out k (aget so k)))) + (with-meta (persistent! (assoc! out k v)) mm))))) + +;;; ObjMap - DEPRECATED + +(defn- obj-clone [obj ks] + (let [new-obj (js-obj) + l (alength ks)] + (loop [i 0] + (when (< i l) + (let [k (aget ks i)] + (aset new-obj k (aget obj k)) + (recur (inc i))))) + new-obj)) + +(deftype ObjMap [meta keys strobj update-count ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll meta] (ObjMap. meta keys strobj update-count __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj + coll + entry))) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.ObjMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ISeqable + (-seq [coll] + (when (pos? (alength keys)) + (map #(vector % (aget strobj %)) + (.sort keys obj-map-compare-keys)))) + + ICounted + (-count [coll] (alength keys)) + + ILookup + (-lookup [coll k] (-lookup coll k nil)) + (-lookup [coll k not-found] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (aget strobj k) + not-found)) + + IAssociative + (-assoc [coll k v] + (if ^boolean (goog/isString k) + (if (or (> update-count cljs.core.ObjMap.HASHMAP_THRESHOLD) + (>= (alength keys) cljs.core.ObjMap.HASHMAP_THRESHOLD)) + (obj-map->hash-map coll k v) + (if-not (nil? (scan-array 1 k keys)) + (let [new-strobj (obj-clone strobj keys)] + (aset new-strobj k v) + (ObjMap. meta keys new-strobj (inc update-count) nil)) ; overwrite + (let [new-strobj (obj-clone strobj keys) ; append + new-keys (aclone keys)] + (aset new-strobj k v) + (.push new-keys k) + (ObjMap. meta new-keys new-strobj (inc update-count) nil)))) + ;; non-string key. game over. + (obj-map->hash-map coll k v))) + (-contains-key? [coll k] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + true + false)) + + IKVReduce + (-kv-reduce [coll f init] + (let [len (alength keys)] + (loop [keys (.sort keys obj-map-compare-keys) + init init] + (if (seq keys) + (let [k (first keys) + init (f init k (aget strobj k))] + (if (reduced? init) + @init + (recur (rest keys) init))) + init)))) + + IMap + (-dissoc [coll k] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (let [new-keys (aclone keys) + new-strobj (obj-clone strobj keys)] + (.splice new-keys (scan-array 1 k new-keys) 1) + (js-delete new-strobj k) + (ObjMap. meta new-keys new-strobj (inc update-count) nil)) + coll)) ; key not found, return coll unchanged + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (transient (into (hash-map) coll)))) + +(set! cljs.core.ObjMap.EMPTY (ObjMap. nil (array) (js-obj) 0 0)) + +(set! cljs.core.ObjMap.HASHMAP_THRESHOLD 8) + +(set! cljs.core.ObjMap.fromObject (fn [ks obj] (ObjMap. nil ks obj 0 nil))) + +;;; PersistentArrayMap + +(defn- array-map-index-of-nil? [arr m k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (nil? (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-keyword? [arr m k] + (let [len (alength arr) + kstr (.-fqn k)] + (loop [i 0] + (cond + (<= len i) -1 + (let [k' (aget arr i)] + (and (keyword? k') + (identical? kstr (.-fqn k')))) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-symbol? [arr m k] + (let [len (alength arr) + kstr (.-str k)] + (loop [i 0] + (cond + (<= len i) -1 + (let [k' (aget arr i)] + (and (symbol? k') + (identical? kstr (.-str k')))) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-identical? [arr m k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (identical? k (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-equiv? [arr m k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (= k (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of [m k] + (let [arr (.-arr m)] + (cond + (keyword? k) (array-map-index-of-keyword? arr m k) + + (or ^boolean (goog/isString k) (number? k)) + (array-map-index-of-identical? arr m k) + + (symbol? k) (array-map-index-of-symbol? arr m k) + + (nil? k) + (array-map-index-of-nil? arr m k) + + :else (array-map-index-of-equiv? arr m k)))) + +(defn- array-map-extend-kv [m k v] + (let [arr (.-arr m) + l (alength arr) + narr (make-array (+ l 2))] + (loop [i 0] + (when (< i l) + (aset narr i (aget arr i)) + (recur (inc i)))) + (aset narr l k) + (aset narr (inc l) v) + narr)) + +(declare TransientArrayMap) + +(deftype PersistentArrayMapSeq [arr i _meta] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] + (PersistentArrayMapSeq. arr i new-meta)) + + ICounted + (-count [coll] + (/ (- (alength arr) i) 2)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY _meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + ISeq + (-first [coll] + [(aget arr i) (aget arr (inc i))]) + + (-rest [coll] + (if (< i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr (+ i 2) _meta) + ())) + + INext + (-next [coll] + (when (< i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr (+ i 2) _meta))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn persistent-array-map-seq [arr i _meta] + (when (<= i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr i _meta))) + +(deftype PersistentArrayMap [meta cnt arr ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentArrayMap. meta cnt arr __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentArrayMap. meta cnt arr __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj coll entry))) + + IEmptyableCollection + (-empty [coll] (-with-meta cljs.core.PersistentArrayMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ISeqable + (-seq [coll] + (persistent-array-map-seq arr 0 nil)) + + ICounted + (-count [coll] cnt) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (let [idx (array-map-index-of coll k)] + (if (== idx -1) + not-found + (aget arr (inc idx))))) + + IAssociative + (-assoc [coll k v] + (let [idx (array-map-index-of coll k)] + (cond + (== idx -1) + (if (< cnt cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) + (let [arr (array-map-extend-kv coll k v)] + (PersistentArrayMap. meta (inc cnt) arr nil)) + (-> (into cljs.core.PersistentHashMap.EMPTY coll) + (-assoc k v) + (-with-meta meta))) + + (identical? v (aget arr (inc idx))) + coll + + :else + (let [arr (doto (aclone arr) + (aset (inc idx) v))] + (PersistentArrayMap. meta cnt arr nil))))) + + (-contains-key? [coll k] + (not (== (array-map-index-of coll k) -1))) + + IMap + (-dissoc [coll k] + (let [idx (array-map-index-of coll k)] + (if (>= idx 0) + (let [len (alength arr) + new-len (- len 2)] + (if (zero? new-len) + (-empty coll) + (let [new-arr (make-array new-len)] + (loop [s 0 d 0] + (cond + (>= s len) (PersistentArrayMap. meta (dec cnt) new-arr nil) + (= k (aget arr s)) (recur (+ s 2) d) + :else (do (aset new-arr d (aget arr s)) + (aset new-arr (inc d) (aget arr (inc s))) + (recur (+ s 2) (+ d 2)))))))) + coll))) + + IKVReduce + (-kv-reduce [coll f init] + (let [len (alength arr)] + (loop [i 0 init init] + (if (< i len) + (let [init (f init (aget arr i) (aget arr (inc i)))] + (if (reduced? init) + @init + (recur (+ i 2) init))) + init)))) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientArrayMap. (js-obj) (alength arr) (aclone arr)))) + +(set! cljs.core.PersistentArrayMap.EMPTY (PersistentArrayMap. nil 0 (array) nil)) + +(set! cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD 8) + +(set! cljs.core.PersistentArrayMap.fromArray + (fn [arr ^boolean no-clone ^boolean no-check] + (let [arr (if no-clone arr (aclone arr))] + (if no-check + (let [cnt (/ (alength arr) 2)] + (PersistentArrayMap. nil cnt arr nil)) + (let [len (alength arr)] + (loop [i 0 + ret (transient cljs.core.PersistentArrayMap.EMPTY)] + (if (< i len) + (recur (+ i 2) + (-assoc! ret (aget arr i) (aget arr (inc i)))) + (-persistent! ret)))))))) + +(declare array->transient-hash-map) + +(deftype TransientArrayMap [^:mutable editable? + ^:mutable len + arr] + ICounted + (-count [tcoll] + (if editable? + (quot len 2) + (throw (js/Error. "count after persistent!")))) + + ILookup + (-lookup [tcoll k] + (-lookup tcoll k nil)) + + (-lookup [tcoll k not-found] + (if editable? + (let [idx (array-map-index-of tcoll k)] + (if (== idx -1) + not-found + (aget arr (inc idx)))) + (throw (js/Error. "lookup after persistent!")))) + + ITransientCollection + (-conj! [tcoll o] + (if editable? + (if (satisfies? IMapEntry o) + (-assoc! tcoll (key o) (val o)) + (loop [es (seq o) tcoll tcoll] + (if-let [e (first es)] + (recur (next es) + (-assoc! tcoll (key e) (val e))) + tcoll))) + (throw (js/Error. "conj! after persistent!")))) + + (-persistent! [tcoll] + (if editable? + (do (set! editable? false) + (PersistentArrayMap. nil (quot len 2) arr nil)) + (throw (js/Error. "persistent! called twice")))) + + ITransientAssociative + (-assoc! [tcoll key val] + (if editable? + (let [idx (array-map-index-of tcoll key)] + (if (== idx -1) + (if (<= (+ len 2) (* 2 cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)) + (do (set! len (+ len 2)) + (.push arr key) + (.push arr val) + tcoll) + (assoc! (array->transient-hash-map len arr) key val)) + (if (identical? val (aget arr (inc idx))) + tcoll + (do (aset arr (inc idx) val) + tcoll)))) + (throw (js/Error. "assoc! after persistent!")))) + + ITransientMap + (-dissoc! [tcoll key] + (if editable? + (let [idx (array-map-index-of tcoll key)] + (when (>= idx 0) + (aset arr idx (aget arr (- len 2))) + (aset arr (inc idx) (aget arr (dec len))) + (doto arr .pop .pop) + (set! len (- len 2))) + tcoll) + (throw (js/Error. "dissoc! after persistent!"))))) + +(declare TransientHashMap PersistentHashMap) + +(defn- array->transient-hash-map [len arr] + (loop [out (transient cljs.core.PersistentHashMap.EMPTY) + i 0] + (if (< i len) + (recur (assoc! out (aget arr i) (aget arr (inc i))) (+ i 2)) + out))) + +;;; PersistentHashMap + +(deftype Box [^:mutable val]) + +(declare create-inode-seq create-array-node-seq reset! create-node atom deref) + +(defn ^boolean key-test [key other] + (cond + (identical? key other) true + (keyword-identical? key other) true + :else (= key other))) + +(defn- mask [hash shift] + (bit-and (bit-shift-right-zero-fill hash shift) 0x01f)) + +(defn- clone-and-set + ([arr i a] + (doto (aclone arr) + (aset i a))) + ([arr i a j b] + (doto (aclone arr) + (aset i a) + (aset j b)))) + +(defn- remove-pair [arr i] + (let [new-arr (make-array (- (alength arr) 2))] + (array-copy arr 0 new-arr 0 (* 2 i)) + (array-copy arr (* 2 (inc i)) new-arr (* 2 i) (- (alength new-arr) (* 2 i))) + new-arr)) + +(defn- bitmap-indexed-node-index [bitmap bit] + (bit-count (bit-and bitmap (dec bit)))) + +(defn- bitpos [hash shift] + (bit-shift-left 1 (mask hash shift))) + +(defn- edit-and-set + ([inode edit i a] + (let [editable (.ensure-editable inode edit)] + (aset (.-arr editable) i a) + editable)) + ([inode edit i a j b] + (let [editable (.ensure-editable inode edit)] + (aset (.-arr editable) i a) + (aset (.-arr editable) j b) + editable))) + +(defn- inode-kv-reduce [arr f init] + (let [len (alength arr)] + (loop [i 0 init init] + (if (< i len) + (let [init (let [k (aget arr i)] + (if-not (nil? k) + (f init k (aget arr (inc i))) + (let [node (aget arr (inc i))] + (if-not (nil? node) + (.kv-reduce node f init) + init))))] + (if (reduced? init) + @init + (recur (+ i 2) init))) + init)))) + +(declare ArrayNode) + +(deftype BitmapIndexedNode [edit ^:mutable bitmap ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (let [bit (bitpos hash shift) + idx (bitmap-indexed-node-index bitmap bit)] + (if (zero? (bit-and bitmap bit)) + (let [n (bit-count bitmap)] + (if (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash shift)] + (aset nodes jdx (.inode-assoc cljs.core.BitmapIndexedNode.EMPTY (+ shift 5) hash key val added-leaf?)) + (loop [i 0 j 0] + (if (< i 32) + (if (zero? (bit-and (bit-shift-right-zero-fill bitmap i) 1)) + (recur (inc i) j) + (do (aset nodes i + (if-not (nil? (aget arr j)) + (.inode-assoc cljs.core.BitmapIndexedNode.EMPTY + (+ shift 5) (cljs.core/hash (aget arr j)) (aget arr j) (aget arr (inc j)) added-leaf?) + (aget arr (inc j)))) + (recur (inc i) (+ j 2)))))) + (ArrayNode. nil (inc n) nodes)) + (let [new-arr (make-array (* 2 (inc n)))] + (array-copy arr 0 new-arr 0 (* 2 idx)) + (aset new-arr (* 2 idx) key) + (aset new-arr (inc (* 2 idx)) val) + (array-copy arr (* 2 idx) new-arr (* 2 (inc idx)) (* 2 (- n idx))) + (set! (.-val added-leaf?) true) + (BitmapIndexedNode. nil (bit-or bitmap bit) new-arr)))) + (let [key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-assoc val-or-node (+ shift 5) hash key val added-leaf?)] + (if (identical? n val-or-node) + inode + (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) n)))) + + (key-test key key-or-nil) + (if (identical? val val-or-node) + inode + (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) val))) + + :else + (do (set! (.-val added-leaf?) true) + (BitmapIndexedNode. nil bitmap + (clone-and-set arr (* 2 idx) nil (inc (* 2 idx)) + (create-node (+ shift 5) key-or-nil val-or-node hash key val))))))))) + + (inode-without [inode shift hash key] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + inode + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-without val-or-node (+ shift 5) hash key)] + (cond (identical? n val-or-node) inode + (not (nil? n)) (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) n)) + (== bitmap bit) nil + :else (BitmapIndexedNode. nil (bit-xor bitmap bit) (remove-pair arr idx)))) + (key-test key key-or-nil) + (BitmapIndexedNode. nil (bit-xor bitmap bit) (remove-pair arr idx)) + :else inode))))) + + (inode-lookup [inode shift hash key not-found] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + not-found + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) (.inode-lookup val-or-node (+ shift 5) hash key not-found) + (key-test key key-or-nil) val-or-node + :else not-found))))) + + (inode-find [inode shift hash key not-found] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + not-found + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) (.inode-find val-or-node (+ shift 5) hash key not-found) + (key-test key key-or-nil) [key-or-nil val-or-node] + :else not-found))))) + + (inode-seq [inode] + (create-inode-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (let [n (bit-count bitmap) + new-arr (make-array (if (neg? n) 4 (* 2 (inc n))))] + (array-copy arr 0 new-arr 0 (* 2 n)) + (BitmapIndexedNode. e bitmap new-arr)))) + + (edit-and-remove-pair [inode e bit i] + (if (== bitmap bit) + nil + (let [editable (.ensure-editable inode e) + earr (.-arr editable) + len (alength earr)] + (set! (.-bitmap editable) (bit-xor bit (.-bitmap editable))) + (array-copy earr (* 2 (inc i)) + earr (* 2 i) + (- len (* 2 (inc i)))) + (aset earr (- len 2) nil) + (aset earr (dec len) nil) + editable))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (let [bit (bitpos hash shift) + idx (bitmap-indexed-node-index bitmap bit)] + (if (zero? (bit-and bitmap bit)) + (let [n (bit-count bitmap)] + (cond + (< (* 2 n) (alength arr)) + (let [editable (.ensure-editable inode edit) + earr (.-arr editable)] + (set! (.-val added-leaf?) true) + (array-copy-downward earr (* 2 idx) + earr (* 2 (inc idx)) + (* 2 (- n idx))) + (aset earr (* 2 idx) key) + (aset earr (inc (* 2 idx)) val) + (set! (.-bitmap editable) (bit-or (.-bitmap editable) bit)) + editable) + + (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash shift)] + (aset nodes jdx (.inode-assoc! cljs.core.BitmapIndexedNode.EMPTY edit (+ shift 5) hash key val added-leaf?)) + (loop [i 0 j 0] + (if (< i 32) + (if (zero? (bit-and (bit-shift-right-zero-fill bitmap i) 1)) + (recur (inc i) j) + (do (aset nodes i + (if-not (nil? (aget arr j)) + (.inode-assoc! cljs.core.BitmapIndexedNode.EMPTY + edit (+ shift 5) (cljs.core/hash (aget arr j)) (aget arr j) (aget arr (inc j)) added-leaf?) + (aget arr (inc j)))) + (recur (inc i) (+ j 2)))))) + (ArrayNode. edit (inc n) nodes)) + + :else + (let [new-arr (make-array (* 2 (+ n 4)))] + (array-copy arr 0 new-arr 0 (* 2 idx)) + (aset new-arr (* 2 idx) key) + (aset new-arr (inc (* 2 idx)) val) + (array-copy arr (* 2 idx) new-arr (* 2 (inc idx)) (* 2 (- n idx))) + (set! (.-val added-leaf?) true) + (let [editable (.ensure-editable inode edit)] + (set! (.-arr editable) new-arr) + (set! (.-bitmap editable) (bit-or (.-bitmap editable) bit)) + editable)))) + (let [key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-assoc! val-or-node edit (+ shift 5) hash key val added-leaf?)] + (if (identical? n val-or-node) + inode + (edit-and-set inode edit (inc (* 2 idx)) n))) + + (key-test key key-or-nil) + (if (identical? val val-or-node) + inode + (edit-and-set inode edit (inc (* 2 idx)) val)) + + :else + (do (set! (.-val added-leaf?) true) + (edit-and-set inode edit (* 2 idx) nil (inc (* 2 idx)) + (create-node edit (+ shift 5) key-or-nil val-or-node hash key val)))))))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + inode + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-without! val-or-node edit (+ shift 5) hash key removed-leaf?)] + (cond (identical? n val-or-node) inode + (not (nil? n)) (edit-and-set inode edit (inc (* 2 idx)) n) + (== bitmap bit) nil + :else (.edit-and-remove-pair inode edit bit idx))) + (key-test key key-or-nil) + (do (aset removed-leaf? 0 true) + (.edit-and-remove-pair inode edit bit idx)) + :else inode))))) + + (kv-reduce [inode f init] + (inode-kv-reduce arr f init))) + +(set! cljs.core.BitmapIndexedNode.EMPTY (BitmapIndexedNode. nil 0 (make-array 0))) + +(defn- pack-array-node [array-node edit idx] + (let [arr (.-arr array-node) + len (* 2 (dec (.-cnt array-node))) + new-arr (make-array len)] + (loop [i 0 j 1 bitmap 0] + (if (< i len) + (if (and (not (== i idx)) + (not (nil? (aget arr i)))) + (do (aset new-arr j (aget arr i)) + (recur (inc i) (+ j 2) (bit-or bitmap (bit-shift-left 1 i)))) + (recur (inc i) j bitmap)) + (BitmapIndexedNode. edit bitmap new-arr))))) + +(deftype ArrayNode [edit ^:mutable cnt ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + (ArrayNode. nil (inc cnt) (clone-and-set arr idx (.inode-assoc cljs.core.BitmapIndexedNode.EMPTY (+ shift 5) hash key val added-leaf?))) + (let [n (.inode-assoc node (+ shift 5) hash key val added-leaf?)] + (if (identical? n node) + inode + (ArrayNode. nil cnt (clone-and-set arr idx n))))))) + + (inode-without [inode shift hash key] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (let [n (.inode-without node (+ shift 5) hash key)] + (cond + (identical? n node) + inode + + (nil? n) + (if (<= cnt 8) + (pack-array-node inode nil idx) + (ArrayNode. nil (dec cnt) (clone-and-set arr idx n))) + + :else + (ArrayNode. nil cnt (clone-and-set arr idx n)))) + inode))) + + (inode-lookup [inode shift hash key not-found] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (.inode-lookup node (+ shift 5) hash key not-found) + not-found))) + + (inode-find [inode shift hash key not-found] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (.inode-find node (+ shift 5) hash key not-found) + not-found))) + + (inode-seq [inode] + (create-array-node-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (ArrayNode. e cnt (aclone arr)))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + (let [editable (edit-and-set inode edit idx (.inode-assoc! cljs.core.BitmapIndexedNode.EMPTY edit (+ shift 5) hash key val added-leaf?))] + (set! (.-cnt editable) (inc (.-cnt editable))) + editable) + (let [n (.inode-assoc! node edit (+ shift 5) hash key val added-leaf?)] + (if (identical? n node) + inode + (edit-and-set inode edit idx n)))))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + inode + (let [n (.inode-without! node edit (+ shift 5) hash key removed-leaf?)] + (cond + (identical? n node) + inode + + (nil? n) + (if (<= cnt 8) + (pack-array-node inode edit idx) + (let [editable (edit-and-set inode edit idx n)] + (set! (.-cnt editable) (dec (.-cnt editable))) + editable)) + + :else + (edit-and-set inode edit idx n)))))) + + (kv-reduce [inode f init] + (let [len (alength arr)] ; actually 32 + (loop [i 0 init init] + (if (< i len) + (let [node (aget arr i)] + (if-not (nil? node) + (let [init (.kv-reduce node f init)] + (if (reduced? init) + @init + (recur (inc i) init))) + (recur (inc i) init))) + init))))) + +(defn- hash-collision-node-find-index [arr cnt key] + (let [lim (* 2 cnt)] + (loop [i 0] + (if (< i lim) + (if (key-test key (aget arr i)) + i + (recur (+ i 2))) + -1)))) + +(deftype HashCollisionNode [edit + ^:mutable collision-hash + ^:mutable cnt + ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (if (== hash collision-hash) + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + (let [len (* 2 cnt) + new-arr (make-array (+ len 2))] + (array-copy arr 0 new-arr 0 len) + (aset new-arr len key) + (aset new-arr (inc len) val) + (set! (.-val added-leaf?) true) + (HashCollisionNode. nil collision-hash (inc cnt) new-arr)) + (if (= (aget arr idx) val) + inode + (HashCollisionNode. nil collision-hash cnt (clone-and-set arr (inc idx) val))))) + (.inode-assoc (BitmapIndexedNode. nil (bitpos collision-hash shift) (array nil inode)) + shift hash key val added-leaf?))) + + (inode-without [inode shift hash key] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (== idx -1) inode + (== cnt 1) nil + :else (HashCollisionNode. nil collision-hash (dec cnt) (remove-pair arr (quot idx 2)))))) + + (inode-lookup [inode shift hash key not-found] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (< idx 0) not-found + (key-test key (aget arr idx)) (aget arr (inc idx)) + :else not-found))) + + (inode-find [inode shift hash key not-found] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (< idx 0) not-found + (key-test key (aget arr idx)) [(aget arr idx) (aget arr (inc idx))] + :else not-found))) + + (inode-seq [inode] + (create-inode-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (let [new-arr (make-array (* 2 (inc cnt)))] + (array-copy arr 0 new-arr 0 (* 2 cnt)) + (HashCollisionNode. e collision-hash cnt new-arr)))) + + (ensure-editable-array [inode e count array] + (if (identical? e edit) + (do (set! arr array) + (set! cnt count) + inode) + (HashCollisionNode. edit collision-hash count array))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (if (== hash collision-hash) + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + (if (> (alength arr) (* 2 cnt)) + (let [editable (edit-and-set inode edit (* 2 cnt) key (inc (* 2 cnt)) val)] + (set! (.-val added-leaf?) true) + (set! (.-cnt editable) (inc (.-cnt editable))) + editable) + (let [len (alength arr) + new-arr (make-array (+ len 2))] + (array-copy arr 0 new-arr 0 len) + (aset new-arr len key) + (aset new-arr (inc len) val) + (set! (.-val added-leaf?) true) + (.ensure-editable-array inode edit (inc cnt) new-arr))) + (if (identical? (aget arr (inc idx)) val) + inode + (edit-and-set inode edit (inc idx) val)))) + (.inode-assoc! (BitmapIndexedNode. edit (bitpos collision-hash shift) (array nil inode nil nil)) + edit shift hash key val added-leaf?))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + inode + (do (aset removed-leaf? 0 true) + (if (== cnt 1) + nil + (let [editable (.ensure-editable inode edit) + earr (.-arr editable)] + (aset earr idx (aget earr (- (* 2 cnt) 2))) + (aset earr (inc idx) (aget earr (dec (* 2 cnt)))) + (aset earr (dec (* 2 cnt)) nil) + (aset earr (- (* 2 cnt) 2) nil) + (set! (.-cnt editable) (dec (.-cnt editable))) + editable)))))) + + (kv-reduce [inode f init] + (inode-kv-reduce arr f init))) + +(defn- create-node + ([shift key1 val1 key2hash key2 val2] + (let [key1hash (hash key1)] + (if (== key1hash key2hash) + (HashCollisionNode. nil key1hash 2 (array key1 val1 key2 val2)) + (let [added-leaf? (Box. false)] + (-> cljs.core.BitmapIndexedNode.EMPTY + (.inode-assoc shift key1hash key1 val1 added-leaf?) + (.inode-assoc shift key2hash key2 val2 added-leaf?)))))) + ([edit shift key1 val1 key2hash key2 val2] + (let [key1hash (hash key1)] + (if (== key1hash key2hash) + (HashCollisionNode. nil key1hash 2 (array key1 val1 key2 val2)) + (let [added-leaf? (Box. false)] + (-> cljs.core.BitmapIndexedNode.EMPTY + (.inode-assoc! edit shift key1hash key1 val1 added-leaf?) + (.inode-assoc! edit shift key2hash key2 val2 added-leaf?))))))) + +(deftype NodeSeq [meta nodes i s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] (NodeSeq. meta nodes i s __hash)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + ISeq + (-first [coll] + (if (nil? s) + [(aget nodes i) (aget nodes (inc i))] + (first s))) + + (-rest [coll] + (if (nil? s) + (create-inode-seq nodes (+ i 2) nil) + (create-inode-seq nodes i (next s)))) + + ISeqable + (-seq [this] this) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn- create-inode-seq + ([nodes] + (create-inode-seq nodes 0 nil)) + ([nodes i s] + (if (nil? s) + (let [len (alength nodes)] + (loop [j i] + (if (< j len) + (if-not (nil? (aget nodes j)) + (NodeSeq. nil nodes j nil nil) + (if-let [node (aget nodes (inc j))] + (if-let [node-seq (.inode-seq node)] + (NodeSeq. nil nodes (+ j 2) node-seq nil) + (recur (+ j 2))) + (recur (+ j 2))))))) + (NodeSeq. nil nodes i s nil)))) + +(deftype ArrayNodeSeq [meta nodes i s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] (ArrayNodeSeq. meta nodes i s __hash)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + ISeq + (-first [coll] (first s)) + (-rest [coll] (create-array-node-seq nil nodes i (next s))) + + ISeqable + (-seq [this] this) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn- create-array-node-seq + ([nodes] (create-array-node-seq nil nodes 0 nil)) + ([meta nodes i s] + (if (nil? s) + (let [len (alength nodes)] + (loop [j i] + (if (< j len) + (if-let [nj (aget nodes j)] + (if-let [ns (.inode-seq nj)] + (ArrayNodeSeq. meta nodes (inc j) ns nil) + (recur (inc j))) + (recur (inc j)))))) + (ArrayNodeSeq. meta nodes i s nil)))) + +(declare TransientHashMap) + +(deftype PersistentHashMap [meta cnt root ^boolean has-nil? nil-val ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentHashMap. meta cnt root has-nil? nil-val __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentHashMap. meta cnt root has-nil? nil-val __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj coll entry))) + + IEmptyableCollection + (-empty [coll] (-with-meta cljs.core.PersistentHashMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ISeqable + (-seq [coll] + (when (pos? cnt) + (let [s (if-not (nil? root) (.inode-seq root))] + (if has-nil? + (cons [nil nil-val] s) + s)))) + + ICounted + (-count [coll] cnt) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (cond (nil? k) (if has-nil? + nil-val + not-found) + (nil? root) not-found + :else (.inode-lookup root 0 (hash k) k not-found))) + + IAssociative + (-assoc [coll k v] + (if (nil? k) + (if (and has-nil? (identical? v nil-val)) + coll + (PersistentHashMap. meta (if has-nil? cnt (inc cnt)) root true v nil)) + (let [added-leaf? (Box. false) + new-root (-> (if (nil? root) + cljs.core.BitmapIndexedNode.EMPTY + root) + (.inode-assoc 0 (hash k) k v added-leaf?))] + (if (identical? new-root root) + coll + (PersistentHashMap. meta (if ^boolean (.-val added-leaf?) (inc cnt) cnt) new-root has-nil? nil-val nil))))) + + (-contains-key? [coll k] + (cond (nil? k) has-nil? + (nil? root) false + :else (not (identical? (.inode-lookup root 0 (hash k) k lookup-sentinel) + lookup-sentinel)))) + + IMap + (-dissoc [coll k] + (cond (nil? k) (if has-nil? + (PersistentHashMap. meta (dec cnt) root false nil nil) + coll) + (nil? root) coll + :else + (let [new-root (.inode-without root 0 (hash k) k)] + (if (identical? new-root root) + coll + (PersistentHashMap. meta (dec cnt) new-root has-nil? nil-val nil))))) + + IKVReduce + (-kv-reduce [coll f init] + (let [init (if has-nil? (f init nil nil-val) init)] + (cond + (reduced? init) @init + (not (nil? root)) (.kv-reduce root f init) + :else init))) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientHashMap. (js-obj) root cnt has-nil? nil-val))) + +(set! cljs.core.PersistentHashMap.EMPTY (PersistentHashMap. nil 0 nil false nil 0)) + +(set! cljs.core.PersistentHashMap.fromArrays + (fn [ks vs] + (let [len (alength ks)] + (loop [i 0 ^not-native out (transient cljs.core.PersistentHashMap.EMPTY)] + (if (< i len) + (recur (inc i) (-assoc! out (aget ks i) (aget vs i))) + (persistent! out)))))) + +(deftype TransientHashMap [^:mutable ^boolean edit + ^:mutable root + ^:mutable count + ^:mutable ^boolean has-nil? + ^:mutable nil-val] + Object + (conj! [tcoll o] + (if edit + (if (satisfies? IMapEntry o) + (.assoc! tcoll (key o) (val o)) + (loop [es (seq o) tcoll tcoll] + (if-let [e (first es)] + (recur (next es) + (.assoc! tcoll (key e) (val e))) + tcoll))) + (throw (js/Error. "conj! after persistent")))) + + (assoc! [tcoll k v] + (if edit + (if (nil? k) + (do (if (identical? nil-val v) + nil + (set! nil-val v)) + (if has-nil? + nil + (do (set! count (inc count)) + (set! has-nil? true))) + tcoll) + (let [added-leaf? (Box. false) + node (-> (if (nil? root) + cljs.core.BitmapIndexedNode.EMPTY + root) + (.inode-assoc! edit 0 (hash k) k v added-leaf?))] + (if (identical? node root) + nil + (set! root node)) + (if ^boolean (.-val added-leaf?) + (set! count (inc count))) + tcoll)) + (throw (js/Error. "assoc! after persistent!")))) + + (without! [tcoll k] + (if edit + (if (nil? k) + (if has-nil? + (do (set! has-nil? false) + (set! nil-val nil) + (set! count (dec count)) + tcoll) + tcoll) + (if (nil? root) + tcoll + (let [removed-leaf? (Box. false) + node (.inode-without! root edit 0 (hash k) k removed-leaf?)] + (if (identical? node root) + nil + (set! root node)) + (if (aget removed-leaf? 0) + (set! count (dec count))) + tcoll))) + (throw (js/Error. "dissoc! after persistent!")))) + + (persistent! [tcoll] + (if edit + (do (set! edit nil) + (PersistentHashMap. nil count root has-nil? nil-val nil)) + (throw (js/Error. "persistent! called twice")))) + + ICounted + (-count [coll] + (if edit + count + (throw (js/Error. "count after persistent!")))) + + ILookup + (-lookup [tcoll k] + (if (nil? k) + (if has-nil? + nil-val) + (if (nil? root) + nil + (.inode-lookup root 0 (hash k) k)))) + + (-lookup [tcoll k not-found] + (if (nil? k) + (if has-nil? + nil-val + not-found) + (if (nil? root) + not-found + (.inode-lookup root 0 (hash k) k not-found)))) + + ITransientCollection + (-conj! [tcoll val] (.conj! tcoll val)) + + (-persistent! [tcoll] (.persistent! tcoll)) + + ITransientAssociative + (-assoc! [tcoll key val] (.assoc! tcoll key val)) + + ITransientMap + (-dissoc! [tcoll key] (.without! tcoll key))) + +;;; PersistentTreeMap + +(defn- tree-map-seq-push [node stack ^boolean ascending?] + (loop [t node stack stack] + (if-not (nil? t) + (recur (if ascending? (.-left t) (.-right t)) + (conj stack t)) + stack))) + +(deftype PersistentTreeMapSeq [meta stack ^boolean ascending? cnt ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ISeqable + (-seq [this] this) + + ISequential + ISeq + (-first [this] (peek stack)) + (-rest [this] + (let [t (first stack) + next-stack (tree-map-seq-push (if ascending? (.-right t) (.-left t)) + (next stack) + ascending?)] + (if-not (nil? next-stack) + (PersistentTreeMapSeq. nil next-stack ascending? (dec cnt) nil) + ()))) + + ICounted + (-count [coll] + (if (neg? cnt) + (inc (count (next coll))) + cnt)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] + (PersistentTreeMapSeq. meta stack ascending? cnt __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn- create-tree-map-seq [tree ascending? cnt] + (PersistentTreeMapSeq. nil (tree-map-seq-push tree nil ascending?) ascending? cnt nil)) + +(declare RedNode BlackNode) + +(defn- balance-left [key val ins right] + (if (instance? RedNode ins) + (cond + (instance? RedNode (.-left ins)) + (RedNode. (.-key ins) (.-val ins) + (.blacken (.-left ins)) + (BlackNode. key val (.-right ins) right nil) + nil) + + (instance? RedNode (.-right ins)) + (RedNode. (.. ins -right -key) (.. ins -right -val) + (BlackNode. (.-key ins) (.-val ins) + (.-left ins) + (.. ins -right -left) + nil) + (BlackNode. key val + (.. ins -right -right) + right + nil) + nil) + + :else + (BlackNode. key val ins right nil)) + (BlackNode. key val ins right nil))) + +(defn- balance-right [key val left ins] + (if (instance? RedNode ins) + (cond + (instance? RedNode (.-right ins)) + (RedNode. (.-key ins) (.-val ins) + (BlackNode. key val left (.-left ins) nil) + (.blacken (.-right ins)) + nil) + + (instance? RedNode (.-left ins)) + (RedNode. (.. ins -left -key) (.. ins -left -val) + (BlackNode. key val left (.. ins -left -left) nil) + (BlackNode. (.-key ins) (.-val ins) + (.. ins -left -right) + (.-right ins) + nil) + nil) + + :else + (BlackNode. key val left ins nil)) + (BlackNode. key val left ins nil))) + +(defn- balance-left-del [key val del right] + (cond + (instance? RedNode del) + (RedNode. key val (.blacken del) right nil) + + (instance? BlackNode right) + (balance-right key val del (.redden right)) + + (and (instance? RedNode right) (instance? BlackNode (.-left right))) + (RedNode. (.. right -left -key) (.. right -left -val) + (BlackNode. key val del (.. right -left -left) nil) + (balance-right (.-key right) (.-val right) + (.. right -left -right) + (.redden (.-right right))) + nil) + + :else + (throw (js/Error. "red-black tree invariant violation")))) + +(defn- balance-right-del [key val left del] + (cond + (instance? RedNode del) + (RedNode. key val left (.blacken del) nil) + + (instance? BlackNode left) + (balance-left key val (.redden left) del) + + (and (instance? RedNode left) (instance? BlackNode (.-right left))) + (RedNode. (.. left -right -key) (.. left -right -val) + (balance-left (.-key left) (.-val left) + (.redden (.-left left)) + (.. left -right -left)) + (BlackNode. key val (.. left -right -right) del nil) + nil) + + :else + (throw (js/Error. "red-black tree invariant violation")))) + +(defn- tree-map-kv-reduce [node f init] + (let [init (if-not (nil? (.-left node)) + (tree-map-kv-reduce (.-left node) f init) + init)] + (if (reduced? init) + @init + (let [init (f init (.-key node) (.-val node))] + (if (reduced? init) + @init + (let [init (if-not (nil? (.-right node)) + (tree-map-kv-reduce (.-right node) f init) + init)] + (if (reduced? init) + @init + init))))))) + +(deftype BlackNode [key val left right ^:mutable __hash] + Object + (add-left [node ins] + (.balance-left ins node)) + + (add-right [node ins] + (.balance-right ins node)) + + (remove-left [node del] + (balance-left-del key val del right)) + + (remove-right [node del] + (balance-right-del key val left del)) + + (blacken [node] node) + + (redden [node] (RedNode. key val left right nil)) + + (balance-left [node parent] + (BlackNode. (.-key parent) (.-val parent) node (.-right parent) nil)) + + (balance-right [node parent] + (BlackNode. (.-key parent) (.-val parent) (.-left parent) node nil)) + + (replace [node key val left right] + (BlackNode. key val left right nil)) + + (kv-reduce [node f init] + (tree-map-kv-reduce node f init)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] []) + + ISequential + ISeqable + (-seq [node] (list key val)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else nil)) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-lookup node k)) + + (-invoke [node k not-found] + (-lookup node k not-found))) + +(deftype RedNode [key val left right ^:mutable __hash] + Object + (add-left [node ins] + (RedNode. key val ins right nil)) + + (add-right [node ins] + (RedNode. key val left ins nil)) + + (remove-left [node del] + (RedNode. key val del right nil)) + + (remove-right [node del] + (RedNode. key val left del nil)) + + (blacken [node] + (BlackNode. key val left right nil)) + + (redden [node] + (throw (js/Error. "red-black tree invariant violation"))) + + (balance-left [node parent] + (cond + (instance? RedNode left) + (RedNode. key val + (.blacken left) + (BlackNode. (.-key parent) (.-val parent) right (.-right parent) nil) + nil) + + (instance? RedNode right) + (RedNode. (.-key right) (.-val right) + (BlackNode. key val left (.-left right) nil) + (BlackNode. (.-key parent) (.-val parent) + (.-right right) + (.-right parent) + nil) + nil) + + :else + (BlackNode. (.-key parent) (.-val parent) node (.-right parent) nil))) + + (balance-right [node parent] + (cond + (instance? RedNode right) + (RedNode. key val + (BlackNode. (.-key parent) (.-val parent) + (.-left parent) + left + nil) + (.blacken right) + nil) + + (instance? RedNode left) + (RedNode. (.-key left) (.-val left) + (BlackNode. (.-key parent) (.-val parent) + (.-left parent) + (.-left left) + nil) + (BlackNode. key val (.-right left) right nil) + nil) + + :else + (BlackNode. (.-key parent) (.-val parent) (.-left parent) node nil))) + + (replace [node key val left right] + (RedNode. key val left right nil)) + + (kv-reduce [node f init] + (tree-map-kv-reduce node f init)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] []) + + ISequential + ISeqable + (-seq [node] (list key val)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else nil)) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-lookup node k)) + + (-invoke [node k not-found] + (-lookup node k not-found))) + +(defn- tree-map-add [comp tree k v found] + (if (nil? tree) + (RedNode. k v nil nil nil) + (let [c (comp k (.-key tree))] + (cond + (zero? c) + (do (aset found 0 tree) + nil) + + (neg? c) + (let [ins (tree-map-add comp (.-left tree) k v found)] + (if-not (nil? ins) + (.add-left tree ins))) + + :else + (let [ins (tree-map-add comp (.-right tree) k v found)] + (if-not (nil? ins) + (.add-right tree ins))))))) + +(defn- tree-map-append [left right] + (cond + (nil? left) + right + + (nil? right) + left + + (instance? RedNode left) + (if (instance? RedNode right) + (let [app (tree-map-append (.-right left) (.-left right))] + (if (instance? RedNode app) + (RedNode. (.-key app) (.-val app) + (RedNode. (.-key left) (.-val left) + (.-left left) + (.-left app) + nil) + (RedNode. (.-key right) (.-val right) + (.-right app) + (.-right right) + nil) + nil) + (RedNode. (.-key left) (.-val left) + (.-left left) + (RedNode. (.-key right) (.-val right) app (.-right right) nil) + nil))) + (RedNode. (.-key left) (.-val left) + (.-left left) + (tree-map-append (.-right left) right) + nil)) + + (instance? RedNode right) + (RedNode. (.-key right) (.-val right) + (tree-map-append left (.-left right)) + (.-right right) + nil) + + :else + (let [app (tree-map-append (.-right left) (.-left right))] + (if (instance? RedNode app) + (RedNode. (.-key app) (.-val app) + (BlackNode. (.-key left) (.-val left) + (.-left left) + (.-left app) + nil) + (BlackNode. (.-key right) (.-val right) + (.-right app) + (.-right right) + nil) + nil) + (balance-left-del (.-key left) (.-val left) + (.-left left) + (BlackNode. (.-key right) (.-val right) + app + (.-right right) + nil)))))) + +(defn- tree-map-remove [comp tree k found] + (if-not (nil? tree) + (let [c (comp k (.-key tree))] + (cond + (zero? c) + (do (aset found 0 tree) + (tree-map-append (.-left tree) (.-right tree))) + + (neg? c) + (let [del (tree-map-remove comp (.-left tree) k found)] + (if (or (not (nil? del)) (not (nil? (aget found 0)))) + (if (instance? BlackNode (.-left tree)) + (balance-left-del (.-key tree) (.-val tree) del (.-right tree)) + (RedNode. (.-key tree) (.-val tree) del (.-right tree) nil)))) + + :else + (let [del (tree-map-remove comp (.-right tree) k found)] + (if (or (not (nil? del)) (not (nil? (aget found 0)))) + (if (instance? BlackNode (.-right tree)) + (balance-right-del (.-key tree) (.-val tree) (.-left tree) del) + (RedNode. (.-key tree) (.-val tree) (.-left tree) del nil)))))))) + +(defn- tree-map-replace [comp tree k v] + (let [tk (.-key tree) + c (comp k tk)] + (cond (zero? c) (.replace tree tk v (.-left tree) (.-right tree)) + (neg? c) (.replace tree tk (.-val tree) (tree-map-replace comp (.-left tree) k v) (.-right tree)) + :else (.replace tree tk (.-val tree) (.-left tree) (tree-map-replace comp (.-right tree) k v))))) + +(declare key) + +(deftype PersistentTreeMap [comp tree cnt meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + (entry-at [coll k] + (loop [t tree] + (if-not (nil? t) + (let [c (comp k (.-key t))] + (cond (zero? c) t + (neg? c) (recur (.-left t)) + :else (recur (.-right t))))))) + + ICloneable + (-clone [_] (PersistentTreeMap. comp tree cnt meta __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentTreeMap. comp tree cnt meta __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj + coll + entry))) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentTreeMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ICounted + (-count [coll] cnt) + + IKVReduce + (-kv-reduce [coll f init] + (if-not (nil? tree) + (tree-map-kv-reduce tree f init) + init)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + ISeqable + (-seq [coll] + (if (pos? cnt) + (create-tree-map-seq tree true cnt))) + + IReversible + (-rseq [coll] + (if (pos? cnt) + (create-tree-map-seq tree false cnt))) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (let [n (.entry-at coll k)] + (if-not (nil? n) + (.-val n) + not-found))) + + IAssociative + (-assoc [coll k v] + (let [found (array nil) + t (tree-map-add comp tree k v found)] + (if (nil? t) + (let [found-node (nth found 0)] + (if (= v (.-val found-node)) + coll + (PersistentTreeMap. comp (tree-map-replace comp tree k v) cnt meta nil))) + (PersistentTreeMap. comp (.blacken t) (inc cnt) meta nil)))) + + (-contains-key? [coll k] + (not (nil? (.entry-at coll k)))) + + IMap + (-dissoc [coll k] + (let [found (array nil) + t (tree-map-remove comp tree k found)] + (if (nil? t) + (if (nil? (nth found 0)) + coll + (PersistentTreeMap. comp nil 0 meta nil)) + (PersistentTreeMap. comp (.blacken t) (dec cnt) meta nil)))) + + ISorted + (-sorted-seq [coll ascending?] + (if (pos? cnt) + (create-tree-map-seq tree ascending? cnt))) + + (-sorted-seq-from [coll k ascending?] + (if (pos? cnt) + (loop [stack nil t tree] + (if-not (nil? t) + (let [c (comp k (.-key t))] + (cond + (zero? c) (PersistentTreeMapSeq. nil (conj stack t) ascending? -1 nil) + ascending? (if (neg? c) + (recur (conj stack t) (.-left t)) + (recur stack (.-right t))) + :else (if (pos? c) + (recur (conj stack t) (.-right t)) + (recur stack (.-left t))))) + (when-not (nil? stack) + (PersistentTreeMapSeq. nil stack ascending? -1 nil)))))) + + (-entry-key [coll entry] (key entry)) + + (-comparator [coll] comp)) + +(set! cljs.core.PersistentTreeMap.EMPTY (PersistentTreeMap. compare nil 0 nil 0)) + +(defn hash-map + "keyval => key val + Returns a new hash map with supplied mappings." + [& keyvals] + (loop [in (seq keyvals), out (transient cljs.core.PersistentHashMap.EMPTY)] + (if in + (recur (nnext in) (assoc! out (first in) (second in))) + (persistent! out)))) + +(defn array-map + "keyval => key val + Returns a new array map with supplied mappings." + [& keyvals] + (PersistentArrayMap. nil (quot (count keyvals) 2) (apply array keyvals) nil)) + +(defn obj-map + "keyval => key val + Returns a new object map with supplied mappings." + [& keyvals] + (let [ks (array) + obj (js-obj)] + (loop [kvs (seq keyvals)] + (if kvs + (do (.push ks (first kvs)) + (aset obj (first kvs) (second kvs)) + (recur (nnext kvs))) + (cljs.core.ObjMap.fromObject ks obj))))) + +(defn sorted-map + "keyval => key val + Returns a new sorted map with supplied mappings." + ([& keyvals] + (loop [in (seq keyvals) out cljs.core.PersistentTreeMap.EMPTY] + (if in + (recur (nnext in) (assoc out (first in) (second in))) + out)))) + +(defn sorted-map-by + "keyval => key val + Returns a new sorted map with supplied mappings, using the supplied comparator." + ([comparator & keyvals] + (loop [in (seq keyvals) + out (cljs.core.PersistentTreeMap. (fn->comparator comparator) nil 0 nil 0)] + (if in + (recur (nnext in) (assoc out (first in) (second in))) + out)))) + +(deftype KeySeq [^not-native mseq _meta] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] (KeySeq. mseq new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY _meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + ISeq + (-first [coll] + (let [^not-native me (-first mseq)] + (-key me))) + + (-rest [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (if-not (nil? nseq) + (KeySeq. nseq _meta) + ()))) + + INext + (-next [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (when-not (nil? nseq) + (KeySeq. nseq _meta)))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn keys + "Returns a sequence of the map's keys." + [hash-map] + (when-let [mseq (seq hash-map)] + (KeySeq. mseq nil))) + +(defn key + "Returns the key of the map entry." + [map-entry] + (-key map-entry)) + +(deftype ValSeq [^not-native mseq _meta] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] (ValSeq. mseq new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY _meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + ISeq + (-first [coll] + (let [^not-native me (-first mseq)] + (-val me))) + + (-rest [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (if-not (nil? nseq) + (ValSeq. nseq _meta) + ()))) + + INext + (-next [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (when-not (nil? nseq) + (ValSeq. nseq _meta)))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn vals + "Returns a sequence of the map's values." + [hash-map] + (when-let [mseq (seq hash-map)] + (ValSeq. mseq nil))) + +(defn val + "Returns the value in the map entry." + [map-entry] + (-val map-entry)) + +(defn merge + "Returns a map that consists of the rest of the maps conj-ed onto + the first. If a key occurs in more than one map, the mapping from + the latter (left-to-right) will be the mapping in the result." + [& maps] + (when (some identity maps) + (reduce #(conj (or %1 {}) %2) maps))) + +(defn merge-with + "Returns a map that consists of the rest of the maps conj-ed onto + the first. If a key occurs in more than one map, the mapping(s) + from the latter (left-to-right) will be combined with the mapping in + the result by calling (f val-in-result val-in-latter)." + [f & maps] + (when (some identity maps) + (let [merge-entry (fn [m e] + (let [k (first e) v (second e)] + (if (contains? m k) + (assoc m k (f (get m k) v)) + (assoc m k v)))) + merge2 (fn [m1 m2] + (reduce merge-entry (or m1 {}) (seq m2)))] + (reduce merge2 maps)))) + +(defn select-keys + "Returns a map containing only those entries in map whose key is in keys" + [map keyseq] + (loop [ret {} keys (seq keyseq)] + (if keys + (let [key (first keys) + entry (get map key ::not-found)] + (recur + (if (not= entry ::not-found) + (assoc ret key entry) + ret) + (next keys))) + ret))) + +;;; PersistentHashSet + +(declare TransientHashSet) + +(deftype PersistentHashSet [meta hash-map ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentHashSet. meta hash-map __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentHashSet. meta hash-map __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll o] + (PersistentHashSet. meta (assoc hash-map o nil) nil)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentHashSet.EMPTY meta)) + + IEquiv + (-equiv [coll other] + (and + (set? other) + (== (count coll) (count other)) + (every? #(contains? coll %) + other))) + + IHash + (-hash [coll] (caching-hash coll hash-iset __hash)) + + ISeqable + (-seq [coll] (keys hash-map)) + + ICounted + (-count [coll] (-count hash-map)) + + ILookup + (-lookup [coll v] + (-lookup coll v nil)) + (-lookup [coll v not-found] + (if (-contains-key? hash-map v) + v + not-found)) + + ISet + (-disjoin [coll v] + (PersistentHashSet. meta (-dissoc hash-map v) nil)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] (TransientHashSet. (-as-transient hash-map)))) + +(set! cljs.core.PersistentHashSet.EMPTY + (PersistentHashSet. nil cljs.core.PersistentArrayMap.EMPTY 0)) + +(set! cljs.core.PersistentHashSet.fromArray + (fn [items ^boolean no-clone] + (let [len (alength items)] + (if (<= len cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) + (let [arr (if no-clone items (aclone items))] + (loop [i 0 + out (transient cljs.core.PersistentArrayMap.EMPTY)] + (if (< i len) + (recur (inc i) (-assoc! out (aget items i) nil)) + (cljs.core.PersistentHashSet. nil (-persistent! out) nil)))) + (loop [i 0 + out (transient cljs.core.PersistentHashSet.EMPTY)] + (if (< i len) + (recur (inc i) (-conj! out (aget items i))) + (-persistent! out))))))) + +(deftype TransientHashSet [^:mutable transient-map] + ITransientCollection + (-conj! [tcoll o] + (set! transient-map (assoc! transient-map o nil)) + tcoll) + + (-persistent! [tcoll] + (PersistentHashSet. nil (persistent! transient-map) nil)) + + ITransientSet + (-disjoin! [tcoll v] + (set! transient-map (dissoc! transient-map v)) + tcoll) + + ICounted + (-count [tcoll] (count transient-map)) + + ILookup + (-lookup [tcoll v] + (-lookup tcoll v nil)) + + (-lookup [tcoll v not-found] + (if (identical? (-lookup transient-map v lookup-sentinel) lookup-sentinel) + not-found + v)) + + IFn + (-invoke [tcoll k] + (if (identical? (-lookup transient-map k lookup-sentinel) lookup-sentinel) + nil + k)) + + (-invoke [tcoll k not-found] + (if (identical? (-lookup transient-map k lookup-sentinel) lookup-sentinel) + not-found + k))) + +(deftype PersistentTreeSet [meta tree-map ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentTreeSet. meta tree-map __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentTreeSet. meta tree-map __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll o] + (PersistentTreeSet. meta (assoc tree-map o nil) nil)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentTreeSet.EMPTY meta)) + + IEquiv + (-equiv [coll other] + (and + (set? other) + (== (count coll) (count other)) + (every? #(contains? coll %) + other))) + + IHash + (-hash [coll] (caching-hash coll hash-iset __hash)) + + ISeqable + (-seq [coll] (keys tree-map)) + + ISorted + (-sorted-seq [coll ascending?] + (map key (-sorted-seq tree-map ascending?))) + + (-sorted-seq-from [coll k ascending?] + (map key (-sorted-seq-from tree-map k ascending?))) + + (-entry-key [coll entry] entry) + + (-comparator [coll] (-comparator tree-map)) + + IReversible + (-rseq [coll] + (if (pos? (count tree-map)) + (map key (rseq tree-map)))) + + ICounted + (-count [coll] (count tree-map)) + + ILookup + (-lookup [coll v] + (-lookup coll v nil)) + (-lookup [coll v not-found] + (let [n (.entry-at tree-map v)] + (if-not (nil? n) + (.-key n) + not-found))) + + ISet + (-disjoin [coll v] + (PersistentTreeSet. meta (dissoc tree-map v) nil)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found))) + +(set! cljs.core.PersistentTreeSet.EMPTY + (PersistentTreeSet. nil cljs.core.PersistentTreeMap.EMPTY 0)) + +(defn set-from-indexed-seq [iseq] + (let [arr (.-arr iseq) + ret (areduce arr i ^not-native res (-as-transient #{}) + (-conj! res (aget arr i)))] + (-persistent! ^not-native ret))) + +(defn set + "Returns a set of the distinct elements of coll." + [coll] + (let [^not-native in (seq coll)] + (cond + (nil? in) #{} + + (and (instance? IndexedSeq in) (zero? (.-i in))) + (set-from-indexed-seq in) + + :else + (loop [in in + ^not-native out (-as-transient #{})] + (if-not (nil? in) + (recur (-next in) (-conj! out (-first in))) + (-persistent! out)))))) + +(defn hash-set + ([] #{}) + ([& keys] (set keys))) + +(defn sorted-set + "Returns a new sorted set with supplied keys." + ([& keys] + (reduce -conj cljs.core.PersistentTreeSet.EMPTY keys))) + +(defn sorted-set-by + "Returns a new sorted set with supplied keys, using the supplied comparator." + ([comparator & keys] + (reduce -conj + (cljs.core.PersistentTreeSet. nil (sorted-map-by comparator) 0) + keys))) + +(defn replace + "Given a map of replacement pairs and a vector/collection, returns a + vector/seq with any elements = a key in smap replaced with the + corresponding val in smap" + [smap coll] + (if (vector? coll) + (let [n (count coll)] + (reduce (fn [v i] + (if-let [e (find smap (nth v i))] + (assoc v i (second e)) + v)) + coll (take n (iterate inc 0)))) + (map #(if-let [e (find smap %)] (second e) %) coll))) + +(defn distinct + "Returns a lazy sequence of the elements of coll with duplicates removed" + [coll] + (let [step (fn step [xs seen] + (lazy-seq + ((fn [[f :as xs] seen] + (when-let [s (seq xs)] + (if (contains? seen f) + (recur (rest s) seen) + (cons f (step (rest s) (conj seen f)))))) + xs seen)))] + (step coll #{}))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defn butlast [s] + (loop [ret [] s s] + (if (next s) + (recur (conj ret (first s)) (next s)) + (seq ret)))) + +(defn name + "Returns the name String of a string, symbol or keyword." + [x] + (if (implements? INamed x) + (-name ^not-native x) + (if (string? x) + x + (throw (js/Error. (str "Doesn't support name: " x)))))) + +(defn zipmap + "Returns a map with the keys mapped to the corresponding vals." + [keys vals] + (loop [map (transient {}) + ks (seq keys) + vs (seq vals)] + (if (and ks vs) + (recur (assoc! map (first ks) (first vs)) + (next ks) + (next vs)) + (persistent! map)))) + +(defn max-key + "Returns the x for which (k x), a number, is greatest." + ([k x] x) + ([k x y] (if (> (k x) (k y)) x y)) + ([k x y & more] + (reduce #(max-key k %1 %2) (max-key k x y) more))) + +(defn min-key + "Returns the x for which (k x), a number, is least." + ([k x] x) + ([k x y] (if (< (k x) (k y)) x y)) + ([k x y & more] + (reduce #(min-key k %1 %2) (min-key k x y) more))) + +(defn partition-all + "Returns a lazy sequence of lists like partition, but may include + partitions with fewer than n items at the end." + ([n coll] + (partition-all n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (cons (take n s) (partition-all n step (drop step s))))))) + +(defn take-while + "Returns a lazy sequence of successive items from coll while + (pred item) returns true. pred must be free of side-effects." + [pred coll] + (lazy-seq + (when-let [s (seq coll)] + (when (pred (first s)) + (cons (first s) (take-while pred (rest s))))))) + +(defn mk-bound-fn + [sc test key] + (fn [e] + (let [comp (-comparator sc)] + (test (comp (-entry-key sc e) key) 0)))) + +(defn subseq + "sc must be a sorted collection, test(s) one of <, <=, > or + >=. Returns a seq of those entries with keys ek for + which (test (.. sc comparator (compare ek key)) 0) is true" + ([sc test key] + (let [include (mk-bound-fn sc test key)] + (if (#{> >=} test) + (when-let [[e :as s] (-sorted-seq-from sc key true)] + (if (include e) s (next s))) + (take-while include (-sorted-seq sc true))))) + ([sc start-test start-key end-test end-key] + (when-let [[e :as s] (-sorted-seq-from sc start-key true)] + (take-while (mk-bound-fn sc end-test end-key) + (if ((mk-bound-fn sc start-test start-key) e) s (next s)))))) + +(defn rsubseq + "sc must be a sorted collection, test(s) one of <, <=, > or + >=. Returns a reverse seq of those entries with keys ek for + which (test (.. sc comparator (compare ek key)) 0) is true" + ([sc test key] + (let [include (mk-bound-fn sc test key)] + (if (#{< <=} test) + (when-let [[e :as s] (-sorted-seq-from sc key false)] + (if (include e) s (next s))) + (take-while include (-sorted-seq sc false))))) + ([sc start-test start-key end-test end-key] + (when-let [[e :as s] (-sorted-seq-from sc end-key false)] + (take-while (mk-bound-fn sc start-test start-key) + (if ((mk-bound-fn sc end-test end-key) e) s (next s)))))) + +(deftype Range [meta start end step ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (Range. meta start end step __hash)) + + IWithMeta + (-with-meta [rng meta] (Range. meta start end step __hash)) + + IMeta + (-meta [rng] meta) + + ISeqable + (-seq [rng] + (if (pos? step) + (when (< start end) + rng) + (when (> start end) + rng))) + + ISeq + (-first [rng] + (when-not (nil? (-seq rng)) start)) + (-rest [rng] + (if-not (nil? (-seq rng)) + (Range. meta (+ start step) end step nil) + ())) + + INext + (-next [rng] + (if (pos? step) + (when (< (+ start step) end) + (Range. meta (+ start step) end step nil)) + (when (> (+ start step) end) + (Range. meta (+ start step) end step nil)))) + + ICollection + (-conj [rng o] (cons o rng)) + + IEmptyableCollection + (-empty [rng] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [rng other] (equiv-sequential rng other)) + + IHash + (-hash [rng] (caching-hash rng hash-coll __hash)) + + ICounted + (-count [rng] + (if-not (-seq rng) + 0 + (js/Math.ceil (/ (- end start) step)))) + + IIndexed + (-nth [rng n] + (if (< n (-count rng)) + (+ start (* n step)) + (if (and (> start end) (zero? step)) + start + (throw (js/Error. "Index out of bounds"))))) + (-nth [rng n not-found] + (if (< n (-count rng)) + (+ start (* n step)) + (if (and (> start end) (zero? step)) + start + not-found))) + + IReduce + (-reduce [rng f] (ci-reduce rng f)) + (-reduce [rng f s] (ci-reduce rng f s))) + +(defn range + "Returns a lazy seq of nums from start (inclusive) to end + (exclusive), by step, where start defaults to 0, step to 1, + and end to infinity." + ([] (range 0 js/Number.MAX_VALUE 1)) + ([end] (range 0 end 1)) + ([start end] (range start end 1)) + ([start end step] (Range. nil start end step nil))) + +(defn take-nth + "Returns a lazy seq of every nth item in coll." + [n coll] + (lazy-seq + (when-let [s (seq coll)] + (cons (first s) (take-nth n (drop n s)))))) + +(defn split-with + "Returns a vector of [(take-while pred coll) (drop-while pred coll)]" + [pred coll] + [(take-while pred coll) (drop-while pred coll)]) + +(defn partition-by + "Applies f to each value in coll, splitting it each time f returns + a new value. Returns a lazy seq of partitions." + [f coll] + (lazy-seq + (when-let [s (seq coll)] + (let [fst (first s) + fv (f fst) + run (cons fst (take-while #(= fv (f %)) (next s)))] + (cons run (partition-by f (seq (drop (count run) s)))))))) + +(defn frequencies + "Returns a map from distinct items in coll to the number of times + they appear." + [coll] + (persistent! + (reduce (fn [counts x] + (assoc! counts x (inc (get counts x 0)))) + (transient {}) coll))) + +(defn reductions + "Returns a lazy seq of the intermediate values of the reduction (as + per reduce) of coll by f, starting with init." + ([f coll] + (lazy-seq + (if-let [s (seq coll)] + (reductions f (first s) (rest s)) + (list (f))))) + ([f init coll] + (cons init + (lazy-seq + (when-let [s (seq coll)] + (reductions f (f init (first s)) (rest s))))))) + +(defn juxt + "Takes a set of functions and returns a fn that is the juxtaposition + of those fns. The returned fn takes a variable number of args, and + returns a vector containing the result of applying each fn to the + args (left-to-right). + ((juxt a b c) x) => [(a x) (b x) (c x)]" + ([f] + (fn + ([] (vector (f))) + ([x] (vector (f x))) + ([x y] (vector (f x y))) + ([x y z] (vector (f x y z))) + ([x y z & args] (vector (apply f x y z args))))) + ([f g] + (fn + ([] (vector (f) (g))) + ([x] (vector (f x) (g x))) + ([x y] (vector (f x y) (g x y))) + ([x y z] (vector (f x y z) (g x y z))) + ([x y z & args] (vector (apply f x y z args) (apply g x y z args))))) + ([f g h] + (fn + ([] (vector (f) (g) (h))) + ([x] (vector (f x) (g x) (h x))) + ([x y] (vector (f x y) (g x y) (h x y))) + ([x y z] (vector (f x y z) (g x y z) (h x y z))) + ([x y z & args] (vector (apply f x y z args) (apply g x y z args) (apply h x y z args))))) + ([f g h & fs] + (let [fs (list* f g h fs)] + (fn + ([] (reduce #(conj %1 (%2)) [] fs)) + ([x] (reduce #(conj %1 (%2 x)) [] fs)) + ([x y] (reduce #(conj %1 (%2 x y)) [] fs)) + ([x y z] (reduce #(conj %1 (%2 x y z)) [] fs)) + ([x y z & args] (reduce #(conj %1 (apply %2 x y z args)) [] fs)))))) + +(defn dorun + "When lazy sequences are produced via functions that have side + effects, any effects other than those needed to produce the first + element in the seq do not occur until the seq is consumed. dorun can + be used to force any effects. Walks through the successive nexts of + the seq, does not retain the head and returns nil." + ([coll] + (when (seq coll) + (recur (next coll)))) + ([n coll] + (when (and (seq coll) (pos? n)) + (recur (dec n) (next coll))))) + +(defn doall + "When lazy sequences are produced via functions that have side + effects, any effects other than those needed to produce the first + element in the seq do not occur until the seq is consumed. doall can + be used to force any effects. Walks through the successive nexts of + the seq, retains the head and returns it, thus causing the entire + seq to reside in memory at one time." + ([coll] + (dorun coll) + coll) + ([n coll] + (dorun n coll) + coll)) + +;;;;;;;;;;;;;;;;;;;;;;;;; Regular Expressions ;;;;;;;;;; + +(defn regexp? [o] + (instance? js/RegExp o)) + +(defn re-matches + "Returns the result of (re-find re s) if re fully matches s." + [re s] + (let [matches (.exec re s)] + (when (= (first matches) s) + (if (== (count matches) 1) + (first matches) + (vec matches))))) + +(defn re-find + "Returns the first regex match, if any, of s to re, using + re.exec(s). Returns a vector, containing first the matching + substring, then any capturing groups if the regular expression contains + capturing groups." + [re s] + (let [matches (.exec re s)] + (when-not (nil? matches) + (if (== (count matches) 1) + (first matches) + (vec matches))))) + +(defn re-seq + "Returns a lazy sequence of successive matches of re in s." + [re s] + (let [match-data (re-find re s) + match-idx (.search s re) + match-str (if (coll? match-data) (first match-data) match-data) + post-match (subs s (+ match-idx (count match-str)))] + (when match-data (lazy-seq (cons match-data (when (seq post-match) (re-seq re post-match))))))) + +(defn re-pattern + "Returns an instance of RegExp which has compiled the provided string." + [s] + (let [[_ flags pattern] (re-find #"^(?:\(\?([idmsux]*)\))?(.*)" s)] + (js/RegExp. pattern flags))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Printing ;;;;;;;;;;;;;;;; + +(defn pr-sequential-writer [writer print-one begin sep end opts coll] + (binding [*print-level* (when-not (nil? *print-level*) (dec *print-level*))] + (if (and (not (nil? *print-level*)) (neg? *print-level*)) + (-write writer "#") + (do + (-write writer begin) + (when (seq coll) + (print-one (first coll) writer opts)) + (loop [coll (next coll) n (:print-length opts)] + (when (and coll (or (nil? n) (not (zero? n)))) + (-write writer sep) + (print-one (first coll) writer opts) + (recur (next coll) (dec n)))) + (when (:print-length opts) + (-write writer sep) + (print-one "..." writer opts)) + (-write writer end))))) + +(defn write-all [writer & ss] + (doseq [s ss] + (-write writer s))) + +(defn string-print [x] + (*print-fn* x) + nil) + +(defn flush [] ;stub + nil) + +(def ^:private char-escapes + (js-obj + "\"" "\\\"" + "\\" "\\\\" + "\b" "\\b" + "\f" "\\f" + "\n" "\\n" + "\r" "\\r" + "\t" "\\t")) + +(defn ^:private quote-string + [s] + (str \" + (.replace s (js/RegExp "[\\\\\"\b\f\n\r\t]" "g") + (fn [match] (aget char-escapes match))) + \")) + +(declare print-map) + +(defn- pr-writer + "Prefer this to pr-seq, because it makes the printing function + configurable, allowing efficient implementations such as appending + to a StringBuffer." + [obj writer opts] + (cond + (nil? obj) (-write writer "nil") + (undefined? obj) (-write writer "#") + :else (do + (when (and (get opts :meta) + (satisfies? IMeta obj) + (meta obj)) + (-write writer "^") + (pr-writer (meta obj) writer opts) + (-write writer " ")) + (cond + (nil? obj) (-write writer "nil") + + ;; handle CLJS ctors + ^boolean (.-cljs$lang$type obj) + (.cljs$lang$ctorPrWriter obj obj writer opts) + + ; Use the new, more efficient, IPrintWithWriter interface when possible. + (implements? IPrintWithWriter obj) + (-pr-writer ^not-native obj writer opts) + + (or (identical? (type obj) js/Boolean) (number? obj)) + (-write writer (str obj)) + + (object? obj) + (do + (-write writer "#js ") + (print-map + (map (fn [k] [(keyword k) (aget obj k)]) (js-keys obj)) + pr-writer writer opts)) + + (array? obj) + (pr-sequential-writer writer pr-writer "#js [" " " "]" opts obj) + + ^boolean (goog/isString obj) + (if (:readably opts) + (-write writer (quote-string obj)) + (-write writer obj)) + + (fn? obj) + (write-all writer "#<" (str obj) ">") + + (instance? js/Date obj) + (let [normalize (fn [n len] + (loop [ns (str n)] + (if (< (count ns) len) + (recur (str "0" ns)) + ns)))] + (write-all writer + "#inst \"" + (str (.getUTCFullYear obj)) "-" + (normalize (inc (.getUTCMonth obj)) 2) "-" + (normalize (.getUTCDate obj) 2) "T" + (normalize (.getUTCHours obj) 2) ":" + (normalize (.getUTCMinutes obj) 2) ":" + (normalize (.getUTCSeconds obj) 2) "." + (normalize (.getUTCMilliseconds obj) 3) "-" + "00:00\"")) + + (regexp? obj) (write-all writer "#\"" (.-source obj) "\"") + + (satisfies? IPrintWithWriter obj) + (-pr-writer obj writer opts) + + :else (write-all writer "#<" (str obj) ">"))))) + +(defn pr-seq-writer [objs writer opts] + (pr-writer (first objs) writer opts) + (doseq [obj (next objs)] + (-write writer " ") + (pr-writer obj writer opts))) + +(defn- pr-sb-with-opts [objs opts] + (let [sb (gstring/StringBuffer.) + writer (StringBufferWriter. sb)] + (pr-seq-writer objs writer opts) + (-flush writer) + sb)) + +(defn pr-str-with-opts + "Prints a sequence of objects to a string, observing all the + options given in opts" + [objs opts] + (if (empty? objs) + "" + (str (pr-sb-with-opts objs opts)))) + +(defn prn-str-with-opts + "Same as pr-str-with-opts followed by (newline)" + [objs opts] + (if (empty? objs) + "\n" + (let [sb (pr-sb-with-opts objs opts)] + (.append sb \newline) + (str sb)))) + +(defn- pr-with-opts + "Prints a sequence of objects using string-print, observing all + the options given in opts" + [objs opts] + (string-print (pr-str-with-opts objs opts))) + +(defn newline [opts] + (string-print "\n") + (when (get opts :flush-on-newline) + (flush))) + +(defn pr-str + "pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter." + [& objs] + (pr-str-with-opts objs (pr-opts))) + +(defn prn-str + "Same as pr-str followed by (newline)" + [& objs] + (prn-str-with-opts objs (pr-opts))) + +(defn pr + "Prints the object(s) using string-print. Prints the + object(s), separated by spaces if there is more than one. + By default, pr and prn print in a way that objects can be + read by the reader" + [& objs] + (pr-with-opts objs (pr-opts))) + +(def ^{:doc + "Prints the object(s) using string-print. + print and println produce output for human consumption."} + print + (fn cljs-core-print [& objs] + (pr-with-opts objs (assoc (pr-opts) :readably false)))) + +(defn print-str + "print to a string, returning it" + [& objs] + (pr-str-with-opts objs (assoc (pr-opts) :readably false))) + +(defn println + "Same as print followed by (newline)" + [& objs] + (pr-with-opts objs (assoc (pr-opts) :readably false)) + (when *print-newline* + (newline (pr-opts)))) + +(defn println-str + "println to a string, returning it" + [& objs] + (prn-str-with-opts objs (assoc (pr-opts) :readably false))) + +(defn prn + "Same as pr followed by (newline)." + [& objs] + (pr-with-opts objs (pr-opts)) + (when *print-newline* + (newline (pr-opts)))) + +(defn print-map [m print-one writer opts] + (pr-sequential-writer + writer + (fn [e w opts] + (do (print-one (key e) w opts) + (-write w \space) + (print-one (val e) w opts))) + "{" ", " "}" + opts (seq m))) + +(extend-protocol IPrintWithWriter + LazySeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + IndexedSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + RSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentQueue + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#queue [" " " "]" opts (seq coll))) + + PersistentTreeMapSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + NodeSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ArrayNodeSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + List + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Cons + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + EmptyList + (-pr-writer [coll writer opts] (-write writer "()")) + + PersistentVector + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + ChunkedCons + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ChunkedSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Subvec + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + BlackNode + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + RedNode + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + ObjMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + KeySeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ValSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentArrayMapSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentArrayMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentHashMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentTreeMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentHashSet + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#{" " " "}" opts coll)) + + PersistentTreeSet + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#{" " " "}" opts coll)) + + Range + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll))) + + +;; IComparable +(extend-protocol IComparable + Symbol + (-compare [x y] (compare-symbols x y)) + + Keyword + ; keyword happens to have the same fields as Symbol, so this just works + (-compare [x y] (compare-symbols x y)) + + Subvec + (-compare [x y] (compare-indexed x y)) + + PersistentVector + (-compare [x y] (compare-indexed x y))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Reference Types ;;;;;;;;;;;;;;;; + +(defprotocol IAtom) + +(defprotocol IReset + (-reset! [o new-value])) + +(defprotocol ISwap + (-swap! [o f] [o f a] [o f a b] [o f a b xs])) + +(deftype Atom [state meta validator watches] + IAtom + + IEquiv + (-equiv [o other] (identical? o other)) + + IDeref + (-deref [_] state) + + IMeta + (-meta [_] meta) + + IPrintWithWriter + (-pr-writer [a writer opts] + (-write writer "#")) + + IWatchable + (-notify-watches [this oldval newval] + (doseq [[key f] watches] + (f key this oldval newval))) + (-add-watch [this key f] + (set! (.-watches this) (assoc watches key f))) + (-remove-watch [this key] + (set! (.-watches this) (dissoc watches key))) + + IHash + (-hash [this] (goog/getUid this))) + +(defn atom + "Creates and returns an Atom with an initial value of x and zero or + more options (in any order): + + :meta metadata-map + + :validator validate-fn + + If metadata-map is supplied, it will be come the metadata on the + atom. validate-fn must be nil or a side-effect-free fn of one + argument, which will be passed the intended new state on any state + change. If the new state is unacceptable, the validate-fn should + return false or throw an Error. If either of these error conditions + occur, then the value of the atom will not change." + ([x] (Atom. x nil nil nil)) + ([x & {:keys [meta validator]}] (Atom. x meta validator nil))) + +(defn reset! + "Sets the value of atom to newval without regard for the + current value. Returns newval." + [a new-value] + (if (instance? Atom a) + (let [validate (.-validator a)] + (when-not (nil? validate) + (assert (validate new-value) "Validator rejected reference state")) + (let [old-value (.-state a)] + (set! (.-state a) new-value) + (when-not (nil? (.-watches a)) + (-notify-watches a old-value new-value)) + new-value)) + (-reset! a new-value))) + +;; generic to all refs +;; (but currently hard-coded to atom!) +(defn deref + [o] + (-deref o)) + +(defn swap! + "Atomically swaps the value of atom to be: + (apply f current-value-of-atom args). Note that f may be called + multiple times, and thus should be free of side effects. Returns + the value that was swapped in." + ([a f] + (if (instance? Atom a) + (reset! a (f (.-state a))) + (-swap! a f))) + ([a f x] + (if (instance? Atom a) + (reset! a (f (.-state a) x)) + (-swap! a f x))) + ([a f x y] + (if (instance? Atom a) + (reset! a (f (.-state a) x y)) + (-swap! a f x y))) + ([a f x y & more] + (if (instance? Atom a) + (reset! a (apply f (.-state a) x y more)) + (-swap! a f x y more)))) + +(defn compare-and-set! + "Atomically sets the value of atom to newval if and only if the + current value of the atom is identical to oldval. Returns true if + set happened, else false." + [a oldval newval] + (if (= (.-state a) oldval) + (do (reset! a newval) true) + false)) + +(defn set-validator! + "Sets the validator-fn for an atom. validator-fn must be nil or a + side-effect-free fn of one argument, which will be passed the intended + new state on any state change. If the new state is unacceptable, the + validator-fn should return false or throw an Error. If the current state + is not acceptable to the new validator, an Error will be thrown and the + validator will not be changed." + [iref val] + (set! (.-validator iref) val)) + +(defn get-validator + "Gets the validator-fn for a var/ref/agent/atom." + [iref] + (.-validator iref)) + +(defn alter-meta! + "Atomically sets the metadata for a namespace/var/ref/agent/atom to be: + + (apply f its-current-meta args) + + f must be free of side-effects" + [iref f & args] + (set! (.-meta iref) (apply f (.-meta iref) args))) + +(defn reset-meta! + "Atomically resets the metadata for an atom" + [iref m] + (set! (.-meta iref) m)) + +(defn add-watch + "Alpha - subject to change. + + Adds a watch function to an atom reference. The watch fn must be a + fn of 4 args: a key, the reference, its old-state, its + new-state. Whenever the reference's state might have been changed, + any registered watches will have their functions called. The watch + fn will be called synchronously. Note that an atom's state + may have changed again prior to the fn call, so use old/new-state + rather than derefing the reference. Keys must be unique per + reference, and can be used to remove the watch with remove-watch, + but are otherwise considered opaque by the watch mechanism. Bear in + mind that regardless of the result or action of the watch fns the + atom's value will change. Example: + + (def a (atom 0)) + (add-watch a :inc (fn [k r o n] (assert (== 0 n)))) + (swap! a inc) + ;; Assertion Error + (deref a) + ;=> 1" + [iref key f] + (-add-watch iref key f)) + +(defn remove-watch + "Alpha - subject to change. + + Removes a watch (set by add-watch) from a reference" + [iref key] + (-remove-watch iref key)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; gensym ;;;;;;;;;;;;;;;; +;; Internal - do not use! +(def gensym_counter nil) + +(defn gensym + "Returns a new symbol with a unique name. If a prefix string is + supplied, the name is prefix# where # is some unique number. If + prefix is not supplied, the prefix is 'G__'." + ([] (gensym "G__")) + ([prefix-string] + (when (nil? gensym_counter) + (set! gensym_counter (atom 0))) + (symbol (str prefix-string (swap! gensym_counter inc))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Fixtures ;;;;;;;;;;;;;;;; + +(def fixture1 1) +(def fixture2 2) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Delay ;;;;;;;;;;;;;;;;;;;; + +(deftype Delay [state f] + IDeref + (-deref [_] + (:value (swap! state (fn [{:keys [done] :as curr-state}] + (if done + curr-state, + {:done true :value (f)}))))) + + IPending + (-realized? [d] + (:done @state))) + +(defn ^boolean delay? + "returns true if x is a Delay created with delay" + [x] (instance? cljs.core.Delay x)) + +(defn force + "If x is a Delay, returns the (possibly cached) value of its expression, else returns x" + [x] + (if (delay? x) + (deref x) + x)) + +(defn ^boolean realized? + "Returns true if a value has been produced for a promise, delay, future or lazy sequence." + [d] + (-realized? d)) + +(defprotocol IEncodeJS + (-clj->js [x] "Recursively transforms clj values to JavaScript") + (-key->js [x] "Transforms map keys to valid JavaScript keys. Arbitrary keys are + encoded to their string representation via (pr-str x)")) + +(declare clj->js) + +(defn key->js [k] + (if (satisfies? IEncodeJS k) + (-clj->js k) + (if (or (string? k) + (number? k) + (keyword? k) + (symbol? k)) + (clj->js k) + (pr-str k)))) + +(defn clj->js + "Recursively transforms ClojureScript values to JavaScript. +sets/vectors/lists become Arrays, Keywords and Symbol become Strings, +Maps become Objects. Arbitrary keys are encoded to by key->js." + [x] + (when-not (nil? x) + (if (satisfies? IEncodeJS x) + (-clj->js x) + (cond + (keyword? x) (name x) + (symbol? x) (str x) + (map? x) (let [m (js-obj)] + (doseq [[k v] x] + (aset m (key->js k) (clj->js v))) + m) + (coll? x) (let [arr (array)] + (doseq [x (map clj->js x)] + (.push arr x)) + arr) + :else x)))) + +(defprotocol IEncodeClojure + (-js->clj [x options] "Transforms JavaScript values to Clojure")) + +(defn js->clj + "Recursively transforms JavaScript arrays into ClojureScript + vectors, and JavaScript objects into ClojureScript maps. With + option ':keywordize-keys true' will convert object fields from + strings to keywords." + ([x] (js->clj x {:keywordize-keys false})) + ([x & opts] + (cond + (satisfies? IEncodeClojure x) + (-js->clj x (apply array-map opts)) + + (seq opts) + (let [{:keys [keywordize-keys]} opts + keyfn (if keywordize-keys keyword str) + f (fn thisfn [x] + (cond + (seq? x) + (doall (map thisfn x)) + + (coll? x) + (into (empty x) (map thisfn x)) + + (array? x) + (vec (map thisfn x)) + + (identical? (type x) js/Object) + (into {} (for [k (js-keys x)] + [(keyfn k) (thisfn (aget x k))])) + + :else x))] + (f x))))) + +(defn memoize + "Returns a memoized version of a referentially transparent function. The + memoized version of the function keeps a cache of the mapping from arguments + to results and, when calls with the same arguments are repeated often, has + higher performance at the expense of higher memory use." + [f] + (let [mem (atom {})] + (fn [& args] + (if-let [v (get @mem args)] + v + (let [ret (apply f args)] + (swap! mem assoc args ret) + ret))))) + +(defn trampoline + "trampoline can be used to convert algorithms requiring mutual + recursion without stack consumption. Calls f with supplied args, if + any. If f returns a fn, calls that fn with no arguments, and + continues to repeat, until the return value is not a fn, then + returns that non-fn value. Note that if you want to return a fn as a + final value, you must wrap it in some data structure and unpack it + after trampoline returns." + ([f] + (let [ret (f)] + (if (fn? ret) + (recur ret) + ret))) + ([f & args] + (trampoline #(apply f args)))) + +(defn rand + "Returns a random floating point number between 0 (inclusive) and + n (default 1) (exclusive)." + ([] (rand 1)) + ([n] (* (Math/random) n))) + +(defn rand-int + "Returns a random integer between 0 (inclusive) and n (exclusive)." + [n] (Math/floor (* (Math/random) n))) + +(defn rand-nth + "Return a random element of the (sequential) collection. Will have + the same performance characteristics as nth for the given + collection." + [coll] + (nth coll (rand-int (count coll)))) + +(defn group-by + "Returns a map of the elements of coll keyed by the result of + f on each element. The value at each key will be a vector of the + corresponding elements, in the order they appeared in coll." + [f coll] + (reduce + (fn [ret x] + (let [k (f x)] + (assoc ret k (conj (get ret k []) x)))) + {} coll)) + +(defn make-hierarchy + "Creates a hierarchy object for use with derive, isa? etc." + [] {:parents {} :descendants {} :ancestors {}}) + +(def ^:private -global-hierarchy nil) + +(defn- get-global-hierarchy [] + (when (nil? -global-hierarchy) + (set! -global-hierarchy (atom (make-hierarchy)))) + -global-hierarchy) + +(defn- swap-global-hierarchy! [f & args] + (apply swap! (get-global-hierarchy) f args)) + +(defn ^boolean isa? + "Returns true if (= child parent), or child is directly or indirectly derived from + parent, either via a JavaScript type inheritance relationship or a + relationship established via derive. h must be a hierarchy obtained + from make-hierarchy, if not supplied defaults to the global + hierarchy" + ([child parent] (isa? @(get-global-hierarchy) child parent)) + ([h child parent] + (or (= child parent) + ;; (and (class? parent) (class? child) + ;; (. ^Class parent isAssignableFrom child)) + (contains? ((:ancestors h) child) parent) + ;;(and (class? child) (some #(contains? ((:ancestors h) %) parent) (supers child))) + (and (vector? parent) (vector? child) + (== (count parent) (count child)) + (loop [ret true i 0] + (if (or (not ret) (== i (count parent))) + ret + (recur (isa? h (child i) (parent i)) (inc i)))))))) + +(defn parents + "Returns the immediate parents of tag, either via a JavaScript type + inheritance relationship or a relationship established via derive. h + must be a hierarchy obtained from make-hierarchy, if not supplied + defaults to the global hierarchy" + ([tag] (parents @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:parents h) tag)))) + +(defn ancestors + "Returns the immediate and indirect parents of tag, either via a JavaScript type + inheritance relationship or a relationship established via derive. h + must be a hierarchy obtained from make-hierarchy, if not supplied + defaults to the global hierarchy" + ([tag] (ancestors @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:ancestors h) tag)))) + +(defn descendants + "Returns the immediate and indirect children of tag, through a + relationship established via derive. h must be a hierarchy obtained + from make-hierarchy, if not supplied defaults to the global + hierarchy. Note: does not work on JavaScript type inheritance + relationships." + ([tag] (descendants @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:descendants h) tag)))) + +(defn derive + "Establishes a parent/child relationship between parent and + tag. Parent must be a namespace-qualified symbol or keyword and + child can be either a namespace-qualified symbol or keyword or a + class. h must be a hierarchy obtained from make-hierarchy, if not + supplied defaults to, and modifies, the global hierarchy." + ([tag parent] + (assert (namespace parent)) + ;; (assert (or (class? tag) (and (instance? cljs.core.Named tag) (namespace tag)))) + (swap-global-hierarchy! derive tag parent) nil) + ([h tag parent] + (assert (not= tag parent)) + ;; (assert (or (class? tag) (instance? clojure.lang.Named tag))) + ;; (assert (instance? clojure.lang.INamed tag)) + ;; (assert (instance? clojure.lang.INamed parent)) + (let [tp (:parents h) + td (:descendants h) + ta (:ancestors h) + tf (fn [m source sources target targets] + (reduce (fn [ret k] + (assoc ret k + (reduce conj (get targets k #{}) (cons target (targets target))))) + m (cons source (sources source))))] + (or + (when-not (contains? (tp tag) parent) + (when (contains? (ta tag) parent) + (throw (js/Error. (str tag "already has" parent "as ancestor")))) + (when (contains? (ta parent) tag) + (throw (js/Error. (str "Cyclic derivation:" parent "has" tag "as ancestor")))) + {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent)) + :ancestors (tf (:ancestors h) tag td parent ta) + :descendants (tf (:descendants h) parent ta tag td)}) + h)))) + +(defn underive + "Removes a parent/child relationship between parent and + tag. h must be a hierarchy obtained from make-hierarchy, if not + supplied defaults to, and modifies, the global hierarchy." + ([tag parent] + (swap-global-hierarchy! underive tag parent) + nil) + ([h tag parent] + (let [parentMap (:parents h) + childsParents (if (parentMap tag) + (disj (parentMap tag) parent) #{}) + newParents (if (not-empty childsParents) + (assoc parentMap tag childsParents) + (dissoc parentMap tag)) + deriv-seq (flatten (map #(cons (first %) (interpose (first %) (second %))) + (seq newParents)))] + (if (contains? (parentMap tag) parent) + (reduce #(apply derive %1 %2) (make-hierarchy) + (partition 2 deriv-seq)) + h)))) + +(defn- reset-cache + [method-cache method-table cached-hierarchy hierarchy] + (swap! method-cache (fn [_] (deref method-table))) + (swap! cached-hierarchy (fn [_] (deref hierarchy)))) + +(defn- prefers* + [x y prefer-table] + (let [xprefs (@prefer-table x)] + (or + (when (and xprefs (xprefs y)) + true) + (loop [ps (parents y)] + (when (pos? (count ps)) + (when (prefers* x (first ps) prefer-table) + true) + (recur (rest ps)))) + (loop [ps (parents x)] + (when (pos? (count ps)) + (when (prefers* (first ps) y prefer-table) + true) + (recur (rest ps)))) + false))) + +(defn- dominates + [x y prefer-table] + (or (prefers* x y prefer-table) (isa? x y))) + +(defn- find-and-cache-best-method + [name dispatch-val hierarchy method-table prefer-table method-cache cached-hierarchy] + (let [best-entry (reduce (fn [be [k _ :as e]] + (if (isa? @hierarchy dispatch-val k) + (let [be2 (if (or (nil? be) (dominates k (first be) prefer-table)) + e + be)] + (when-not (dominates (first be2) k prefer-table) + (throw (js/Error. + (str "Multiple methods in multimethod '" name + "' match dispatch value: " dispatch-val " -> " k + " and " (first be2) ", and neither is preferred")))) + be2) + be)) + nil @method-table)] + (when best-entry + (if (= @cached-hierarchy @hierarchy) + (do + (swap! method-cache assoc dispatch-val (second best-entry)) + (second best-entry)) + (do + (reset-cache method-cache method-table cached-hierarchy hierarchy) + (find-and-cache-best-method name dispatch-val hierarchy method-table prefer-table + method-cache cached-hierarchy)))))) + +(defprotocol IMultiFn + (-reset [mf]) + (-add-method [mf dispatch-val method]) + (-remove-method [mf dispatch-val]) + (-prefer-method [mf dispatch-val dispatch-val-y]) + (-get-method [mf dispatch-val]) + (-methods [mf]) + (-prefers [mf]) + (-dispatch [mf args])) + +(defn- do-dispatch + [mf name dispatch-fn args] + (let [dispatch-val (apply dispatch-fn args) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw (js/Error. (str "No method in multimethod '" name "' for dispatch value: " dispatch-val)))) + (apply target-fn args))) + +(deftype MultiFn [name dispatch-fn default-dispatch-val hierarchy + method-table prefer-table method-cache cached-hierarchy] + IMultiFn + (-reset [mf] + (swap! method-table (fn [mf] {})) + (swap! method-cache (fn [mf] {})) + (swap! prefer-table (fn [mf] {})) + (swap! cached-hierarchy (fn [mf] nil)) + mf) + + (-add-method [mf dispatch-val method] + (swap! method-table assoc dispatch-val method) + (reset-cache method-cache method-table cached-hierarchy hierarchy) + mf) + + (-remove-method [mf dispatch-val] + (swap! method-table dissoc dispatch-val) + (reset-cache method-cache method-table cached-hierarchy hierarchy) + mf) + + (-get-method [mf dispatch-val] + (when-not (= @cached-hierarchy @hierarchy) + (reset-cache method-cache method-table cached-hierarchy hierarchy)) + (if-let [target-fn (@method-cache dispatch-val)] + target-fn + (if-let [target-fn (find-and-cache-best-method name dispatch-val hierarchy method-table + prefer-table method-cache cached-hierarchy)] + target-fn + (@method-table default-dispatch-val)))) + + (-prefer-method [mf dispatch-val-x dispatch-val-y] + (when (prefers* dispatch-val-x dispatch-val-y prefer-table) + (throw (js/Error. (str "Preference conflict in multimethod '" name "': " dispatch-val-y + " is already preferred to " dispatch-val-x)))) + (swap! prefer-table + (fn [old] + (assoc old dispatch-val-x + (conj (get old dispatch-val-x #{}) + dispatch-val-y)))) + (reset-cache method-cache method-table cached-hierarchy hierarchy)) + + (-methods [mf] @method-table) + (-prefers [mf] @prefer-table) + + (-dispatch [mf args] (do-dispatch mf name dispatch-fn args)) + + IHash + (-hash [this] (goog/getUid this))) + +(set! cljs.core.MultiFn.prototype.call + (fn [_ & args] + (this-as self + (-dispatch self args)))) + +(set! cljs.core.MultiFn.prototype.apply + (fn [_ args] + (this-as self + (-dispatch self args)))) + +(defn remove-all-methods + "Removes all of the methods of multimethod." + [multifn] + (-reset multifn)) + +(defn remove-method + "Removes the method of multimethod associated with dispatch-value." + [multifn dispatch-val] + (-remove-method multifn dispatch-val)) + +(defn prefer-method + "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y + when there is a conflict" + [multifn dispatch-val-x dispatch-val-y] + (-prefer-method multifn dispatch-val-x dispatch-val-y)) + +(defn methods + "Given a multimethod, returns a map of dispatch values -> dispatch fns" + [multifn] (-methods multifn)) + +(defn get-method + "Given a multimethod and a dispatch value, returns the dispatch fn + that would apply to that value, or nil if none apply and no default" + [multifn dispatch-val] (-get-method multifn dispatch-val)) + +(defn prefers + "Given a multimethod, returns a map of preferred value -> set of other values" + [multifn] (-prefers multifn)) + +;; UUID + +(deftype UUID [uuid] + IEquiv + (-equiv [_ other] + (and (instance? UUID other) (identical? uuid (.-uuid other)))) + + IPrintWithWriter + (-pr-writer [_ writer _] + (-write writer (str "#uuid \"" uuid "\""))) + + IHash + (-hash [this] + (goog.string/hashCode (pr-str this)))) + +;;; ExceptionInfo + +(deftype ExceptionInfo [message data cause]) + +;;; ExceptionInfo is a special case, do not emulate this +(set! cljs.core.ExceptionInfo.prototype (js/Error.)) +(set! (.-constructor cljs.core.ExceptionInfo.prototype) ExceptionInfo) + +(defn ex-info + "Alpha - subject to change. + Create an instance of ExceptionInfo, an Error type that carries a + map of additional data." + ([msg map] + (ExceptionInfo. msg map nil)) + ([msg map cause] + (ExceptionInfo. msg map cause))) + +(defn ex-data + "Alpha - subject to change. + Returns exception data (a map) if ex is an ExceptionInfo. + Otherwise returns nil." + [ex] + (when (instance? ExceptionInfo ex) + (.-data ex))) + +(defn ex-message + "Alpha - subject to change. + Returns the message attached to the given Error / ExceptionInfo object. + For non-Errors returns nil." + [ex] + (when (instance? js/Error ex) + (.-message ex))) + +(defn ex-cause + "Alpha - subject to change. + Returns exception cause (an Error / ExceptionInfo) if ex is an + ExceptionInfo. + Otherwise returns nil." + [ex] + (when (instance? ExceptionInfo ex) + (.-cause ex))) + +(defn comparator + "Returns an JavaScript compatible comparator based upon pred." + [pred] + (fn [x y] + (cond (pred x y) -1 (pred y x) 1 :else 0))) + +(defn ^boolean special-symbol? [x] + (contains? + '#{if def fn* do let* loop* letfn* throw try + recur new set! ns deftype* defrecord* . js* & quote} + x)) diff --git a/out/cljs/core.js b/out/cljs/core.js new file mode 100644 index 0000000..0b6722c --- /dev/null +++ b/out/cljs/core.js @@ -0,0 +1,18804 @@ +// Compiled by ClojureScript 0.0-2173 +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_clojurescript_version_STAR_ = "0.0-2173"; +cljs.core._STAR_unchecked_if_STAR_ = false; +/** +* Each runtime environment provides a different way to print output. +* Whatever function *print-fn* is bound to will be passed any +* Strings which should be printed. +*/ +cljs.core._STAR_print_fn_STAR_ = (function _STAR_print_fn_STAR_(_){throw (new Error("No *print-fn* fn set for evaluation environment")); +}); +/** +* Set *print-fn* to f. +*/ +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); +}); +/** +* Set *print-fn* to console.log +*/ +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__4918__delegate = function (args){return console.log.apply(console,cljs.core.into_array.call(null,args)); +}; +var G__4918 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__4918__delegate.call(this,args);}; +G__4918.cljs$lang$maxFixedArity = 0; +G__4918.cljs$lang$applyTo = (function (arglist__4919){ +var args = cljs.core.seq(arglist__4919); +return G__4918__delegate(args); +}); +G__4918.cljs$core$IFn$_invoke$arity$variadic = G__4918__delegate; +return G__4918; +})() +; +}); +/** +* Internal - do not use! +*/ +cljs.core.truth_ = (function truth_(x){return (x != null && x !== false); +}); +cljs.core.not_native = null; +/** +* Tests if 2 arguments are the same object +*/ +cljs.core.identical_QMARK_ = (function identical_QMARK_(x,y){return (x === y); +}); +/** +* Returns true if x is nil, false otherwise. +*/ +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'; +}); +/** +* Returns true if x is logical false, false otherwise. +*/ +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); +}); +/** +* Internal - do not use! +*/ +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); +}); +/** +* When compiled for a command-line target, whatever +* function *main-fn* is set to will be called with the command-line +* argv as arguments +*/ +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__3528__auto__ = ty;if(cljs.core.truth_(and__3528__auto__)) +{return ty.cljs$lang$type; +} else +{return and__3528__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; +})() +; +/** +* Returns a javascript array, cloned from the passed in array +*/ +cljs.core.aclone = (function aclone(arr){var len = arr.length;var new_arr = (new Array(len));var n__4388__auto___4920 = len;var i_4921 = 0;while(true){ +if((i_4921 < n__4388__auto___4920)) +{(new_arr[i_4921] = (arr[i_4921])); +{ +var G__4922 = (i_4921 + 1); +i_4921 = G__4922; +continue; +} +} else +{} +break; +} +return new_arr; +}); +/** +* Creates a new javascript array. +* @param {...*} var_args +*/ +cljs.core.array = (function array(var_args){return Array.prototype.slice.call(arguments); +}); +/** +* Returns the value at the index. +* @param {...*} var_args +*/ +cljs.core.aget = (function() { +var aget = null; +var aget__2 = (function (array,i){return (array[i]); +}); +var aget__3 = (function() { +var G__4923__delegate = function (array,i,idxs){return cljs.core.apply.call(null,aget,aget.call(null,array,i),idxs); +}; +var G__4923 = 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__4923__delegate.call(this,array,i,idxs);}; +G__4923.cljs$lang$maxFixedArity = 2; +G__4923.cljs$lang$applyTo = (function (arglist__4924){ +var array = cljs.core.first(arglist__4924); +arglist__4924 = cljs.core.next(arglist__4924); +var i = cljs.core.first(arglist__4924); +var idxs = cljs.core.rest(arglist__4924); +return G__4923__delegate(array,i,idxs); +}); +G__4923.cljs$core$IFn$_invoke$arity$variadic = G__4923__delegate; +return G__4923; +})() +; +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; +})() +; +/** +* Sets the value at the index. +* @param {...*} var_args +*/ +cljs.core.aset = (function() { +var aset = null; +var aset__3 = (function (array,i,val){return (array[i] = val); +}); +var aset__4 = (function() { +var G__4925__delegate = function (array,idx,idx2,idxv){return cljs.core.apply.call(null,aset,(array[idx]),idx2,idxv); +}; +var G__4925 = 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__4925__delegate.call(this,array,idx,idx2,idxv);}; +G__4925.cljs$lang$maxFixedArity = 3; +G__4925.cljs$lang$applyTo = (function (arglist__4926){ +var array = cljs.core.first(arglist__4926); +arglist__4926 = cljs.core.next(arglist__4926); +var idx = cljs.core.first(arglist__4926); +arglist__4926 = cljs.core.next(arglist__4926); +var idx2 = cljs.core.first(arglist__4926); +var idxv = cljs.core.rest(arglist__4926); +return G__4925__delegate(array,idx,idx2,idxv); +}); +G__4925.cljs$core$IFn$_invoke$arity$variadic = G__4925__delegate; +return G__4925; +})() +; +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; +})() +; +/** +* Returns the length of the array. Works on arrays of all types. +*/ +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 obj4928 = {};return obj4928; +})(); +cljs.core.IFn = (function (){var obj4930 = {};return obj4930; +})(); +cljs.core._invoke = (function() { +var _invoke = null; +var _invoke__1 = (function (this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$2(this$,a); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$3(this$,a,b); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$4(this$,a,b,c); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$5; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$6; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$7; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$8; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$9; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$10; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$11; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$12; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$13; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$14; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$15; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$16; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$17; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$18; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$19; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$20; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$21; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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.ICloneable = (function (){var obj4932 = {};return obj4932; +})(); +cljs.core._clone = (function _clone(value){if((function (){var and__3528__auto__ = value;if(and__3528__auto__) +{return value.cljs$core$ICloneable$_clone$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return value.cljs$core$ICloneable$_clone$arity$1(value); +} else +{var x__4167__auto__ = (((value == null))?null:value);return (function (){var or__3540__auto__ = (cljs.core._clone[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._clone["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICloneable.-clone",value); +} +} +})().call(null,value); +} +}); +cljs.core.ICounted = (function (){var obj4934 = {};return obj4934; +})(); +cljs.core._count = (function _count(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ICounted$_count$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ICounted$_count$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._count[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._count["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICounted.-count",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IEmptyableCollection = (function (){var obj4936 = {};return obj4936; +})(); +cljs.core._empty = (function _empty(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IEmptyableCollection$_empty$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._empty[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._empty["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEmptyableCollection.-empty",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ICollection = (function (){var obj4938 = {};return obj4938; +})(); +cljs.core._conj = (function _conj(coll,o){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ICollection$_conj$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ICollection$_conj$arity$2(coll,o); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._conj[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._conj["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICollection.-conj",coll); +} +} +})().call(null,coll,o); +} +}); +cljs.core.IIndexed = (function (){var obj4940 = {};return obj4940; +})(); +cljs.core._nth = (function() { +var _nth = null; +var _nth__2 = (function (coll,n){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IIndexed$_nth$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IIndexed$_nth$arity$2(coll,n); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._nth[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._nth["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IIndexed$_nth$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IIndexed$_nth$arity$3(coll,n,not_found); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._nth[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._nth["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj4942 = {};return obj4942; +})(); +cljs.core.ISeq = (function (){var obj4944 = {};return obj4944; +})(); +cljs.core._first = (function _first(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISeq$_first$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISeq$_first$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._first[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._first["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISeq$_rest$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISeq$_rest$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._rest[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._rest["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISeq.-rest",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.INext = (function (){var obj4946 = {};return obj4946; +})(); +cljs.core._next = (function _next(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$INext$_next$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$INext$_next$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._next[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._next["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"INext.-next",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ILookup = (function (){var obj4948 = {};return obj4948; +})(); +cljs.core._lookup = (function() { +var _lookup = null; +var _lookup__2 = (function (o,k){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ILookup$_lookup$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ILookup$_lookup$arity$2(o,k); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._lookup[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._lookup["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ILookup$_lookup$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ILookup$_lookup$arity$3(o,k,not_found); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._lookup[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._lookup["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj4950 = {};return obj4950; +})(); +cljs.core._contains_key_QMARK_ = (function _contains_key_QMARK_(coll,k){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll,k); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._contains_key_QMARK_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._contains_key_QMARK_["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IAssociative$_assoc$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IAssociative$_assoc$arity$3(coll,k,v); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._assoc[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IAssociative.-assoc",coll); +} +} +})().call(null,coll,k,v); +} +}); +cljs.core.IMap = (function (){var obj4952 = {};return obj4952; +})(); +cljs.core._dissoc = (function _dissoc(coll,k){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IMap$_dissoc$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IMap$_dissoc$arity$2(coll,k); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._dissoc[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._dissoc["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IMap.-dissoc",coll); +} +} +})().call(null,coll,k); +} +}); +cljs.core.IMapEntry = (function (){var obj4954 = {};return obj4954; +})(); +cljs.core._key = (function _key(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IMapEntry$_key$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IMapEntry$_key$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._key[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._key["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IMapEntry$_val$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IMapEntry$_val$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._val[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._val["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IMapEntry.-val",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ISet = (function (){var obj4956 = {};return obj4956; +})(); +cljs.core._disjoin = (function _disjoin(coll,v){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISet$_disjoin$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISet$_disjoin$arity$2(coll,v); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._disjoin[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._disjoin["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISet.-disjoin",coll); +} +} +})().call(null,coll,v); +} +}); +cljs.core.IStack = (function (){var obj4958 = {};return obj4958; +})(); +cljs.core._peek = (function _peek(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IStack$_peek$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IStack$_peek$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._peek[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._peek["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IStack$_pop$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IStack$_pop$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._pop[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._pop["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IStack.-pop",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IVector = (function (){var obj4960 = {};return obj4960; +})(); +cljs.core._assoc_n = (function _assoc_n(coll,n,val){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IVector$_assoc_n$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IVector$_assoc_n$arity$3(coll,n,val); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._assoc_n[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc_n["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IVector.-assoc-n",coll); +} +} +})().call(null,coll,n,val); +} +}); +cljs.core.IDeref = (function (){var obj4962 = {};return obj4962; +})(); +cljs.core._deref = (function _deref(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IDeref$_deref$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IDeref$_deref$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._deref[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._deref["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IDeref.-deref",o); +} +} +})().call(null,o); +} +}); +cljs.core.IDerefWithTimeout = (function (){var obj4964 = {};return obj4964; +})(); +cljs.core._deref_with_timeout = (function _deref_with_timeout(o,msec,timeout_val){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o,msec,timeout_val); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._deref_with_timeout[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._deref_with_timeout["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj4966 = {};return obj4966; +})(); +cljs.core._meta = (function _meta(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IMeta$_meta$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IMeta$_meta$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._meta[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._meta["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IMeta.-meta",o); +} +} +})().call(null,o); +} +}); +cljs.core.IWithMeta = (function (){var obj4968 = {};return obj4968; +})(); +cljs.core._with_meta = (function _with_meta(o,meta){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IWithMeta$_with_meta$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IWithMeta$_with_meta$arity$2(o,meta); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._with_meta[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._with_meta["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IWithMeta.-with-meta",o); +} +} +})().call(null,o,meta); +} +}); +cljs.core.IReduce = (function (){var obj4970 = {};return obj4970; +})(); +cljs.core._reduce = (function() { +var _reduce = null; +var _reduce__2 = (function (coll,f){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IReduce$_reduce$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IReduce$_reduce$arity$2(coll,f); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._reduce[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reduce["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IReduce$_reduce$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IReduce$_reduce$arity$3(coll,f,start); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._reduce[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reduce["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj4972 = {};return obj4972; +})(); +cljs.core._kv_reduce = (function _kv_reduce(coll,f,init){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IKVReduce$_kv_reduce$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll,f,init); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._kv_reduce[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._kv_reduce["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IKVReduce.-kv-reduce",coll); +} +} +})().call(null,coll,f,init); +} +}); +cljs.core.IEquiv = (function (){var obj4974 = {};return obj4974; +})(); +cljs.core._equiv = (function _equiv(o,other){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IEquiv$_equiv$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IEquiv$_equiv$arity$2(o,other); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._equiv[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._equiv["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEquiv.-equiv",o); +} +} +})().call(null,o,other); +} +}); +cljs.core.IHash = (function (){var obj4976 = {};return obj4976; +})(); +cljs.core._hash = (function _hash(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IHash$_hash$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IHash$_hash$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._hash[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._hash["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IHash.-hash",o); +} +} +})().call(null,o); +} +}); +cljs.core.ISeqable = (function (){var obj4978 = {};return obj4978; +})(); +cljs.core._seq = (function _seq(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISeqable$_seq$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISeqable$_seq$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._seq[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._seq["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISeqable.-seq",o); +} +} +})().call(null,o); +} +}); +cljs.core.ISequential = (function (){var obj4980 = {};return obj4980; +})(); +cljs.core.IList = (function (){var obj4982 = {};return obj4982; +})(); +cljs.core.IRecord = (function (){var obj4984 = {};return obj4984; +})(); +cljs.core.IReversible = (function (){var obj4986 = {};return obj4986; +})(); +cljs.core._rseq = (function _rseq(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IReversible$_rseq$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IReversible$_rseq$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._rseq[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._rseq["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IReversible.-rseq",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ISorted = (function (){var obj4988 = {};return obj4988; +})(); +cljs.core._sorted_seq = (function _sorted_seq(coll,ascending_QMARK_){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_sorted_seq$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll,ascending_QMARK_); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._sorted_seq[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._sorted_seq["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_sorted_seq_from$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll,k,ascending_QMARK_); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._sorted_seq_from[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._sorted_seq_from["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_entry_key$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_entry_key$arity$2(coll,entry); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._entry_key[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._entry_key["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_comparator$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_comparator$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._comparator[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._comparator["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISorted.-comparator",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IWriter = (function (){var obj4990 = {};return obj4990; +})(); +cljs.core._write = (function _write(writer,s){if((function (){var and__3528__auto__ = writer;if(and__3528__auto__) +{return writer.cljs$core$IWriter$_write$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return writer.cljs$core$IWriter$_write$arity$2(writer,s); +} else +{var x__4167__auto__ = (((writer == null))?null:writer);return (function (){var or__3540__auto__ = (cljs.core._write[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._write["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = writer;if(and__3528__auto__) +{return writer.cljs$core$IWriter$_flush$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return writer.cljs$core$IWriter$_flush$arity$1(writer); +} else +{var x__4167__auto__ = (((writer == null))?null:writer);return (function (){var or__3540__auto__ = (cljs.core._flush[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._flush["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IWriter.-flush",writer); +} +} +})().call(null,writer); +} +}); +cljs.core.IPrintWithWriter = (function (){var obj4992 = {};return obj4992; +})(); +cljs.core._pr_writer = (function _pr_writer(o,writer,opts){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o,writer,opts); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._pr_writer[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._pr_writer["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IPrintWithWriter.-pr-writer",o); +} +} +})().call(null,o,writer,opts); +} +}); +cljs.core.IPending = (function (){var obj4994 = {};return obj4994; +})(); +cljs.core._realized_QMARK_ = (function _realized_QMARK_(d){if((function (){var and__3528__auto__ = d;if(and__3528__auto__) +{return d.cljs$core$IPending$_realized_QMARK_$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return d.cljs$core$IPending$_realized_QMARK_$arity$1(d); +} else +{var x__4167__auto__ = (((d == null))?null:d);return (function (){var or__3540__auto__ = (cljs.core._realized_QMARK_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._realized_QMARK_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IPending.-realized?",d); +} +} +})().call(null,d); +} +}); +cljs.core.IWatchable = (function (){var obj4996 = {};return obj4996; +})(); +cljs.core._notify_watches = (function _notify_watches(this$,oldval,newval){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IWatchable$_notify_watches$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$,oldval,newval); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._notify_watches[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._notify_watches["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IWatchable$_add_watch$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IWatchable$_add_watch$arity$3(this$,key,f); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._add_watch[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._add_watch["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IWatchable$_remove_watch$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$,key); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._remove_watch[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._remove_watch["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IWatchable.-remove-watch",this$); +} +} +})().call(null,this$,key); +} +}); +cljs.core.IEditableCollection = (function (){var obj4998 = {};return obj4998; +})(); +cljs.core._as_transient = (function _as_transient(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IEditableCollection$_as_transient$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._as_transient[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._as_transient["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEditableCollection.-as-transient",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ITransientCollection = (function (){var obj5000 = {};return obj5000; +})(); +cljs.core._conj_BANG_ = (function _conj_BANG_(tcoll,val){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll,val); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._conj_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._conj_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._persistent_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._persistent_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientCollection.-persistent!",tcoll); +} +} +})().call(null,tcoll); +} +}); +cljs.core.ITransientAssociative = (function (){var obj5002 = {};return obj5002; +})(); +cljs.core._assoc_BANG_ = (function _assoc_BANG_(tcoll,key,val){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll,key,val); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._assoc_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientAssociative.-assoc!",tcoll); +} +} +})().call(null,tcoll,key,val); +} +}); +cljs.core.ITransientMap = (function (){var obj5004 = {};return obj5004; +})(); +cljs.core._dissoc_BANG_ = (function _dissoc_BANG_(tcoll,key){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll,key); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._dissoc_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._dissoc_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientMap.-dissoc!",tcoll); +} +} +})().call(null,tcoll,key); +} +}); +cljs.core.ITransientVector = (function (){var obj5006 = {};return obj5006; +})(); +cljs.core._assoc_n_BANG_ = (function _assoc_n_BANG_(tcoll,n,val){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll,n,val); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._assoc_n_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc_n_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._pop_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._pop_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientVector.-pop!",tcoll); +} +} +})().call(null,tcoll); +} +}); +cljs.core.ITransientSet = (function (){var obj5008 = {};return obj5008; +})(); +cljs.core._disjoin_BANG_ = (function _disjoin_BANG_(tcoll,v){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll,v); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._disjoin_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._disjoin_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientSet.-disjoin!",tcoll); +} +} +})().call(null,tcoll,v); +} +}); +cljs.core.IComparable = (function (){var obj5010 = {};return obj5010; +})(); +cljs.core._compare = (function _compare(x,y){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IComparable$_compare$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IComparable$_compare$arity$2(x,y); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._compare[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._compare["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IComparable.-compare",x); +} +} +})().call(null,x,y); +} +}); +cljs.core.IChunk = (function (){var obj5012 = {};return obj5012; +})(); +cljs.core._drop_first = (function _drop_first(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunk$_drop_first$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunk$_drop_first$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._drop_first[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._drop_first["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IChunk.-drop-first",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IChunkedSeq = (function (){var obj5014 = {};return obj5014; +})(); +cljs.core._chunked_first = (function _chunked_first(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._chunked_first[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._chunked_first["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._chunked_rest[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._chunked_rest["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IChunkedSeq.-chunked-rest",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IChunkedNext = (function (){var obj5016 = {};return obj5016; +})(); +cljs.core._chunked_next = (function _chunked_next(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunkedNext$_chunked_next$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._chunked_next[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._chunked_next["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IChunkedNext.-chunked-next",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.INamed = (function (){var obj5018 = {};return obj5018; +})(); +cljs.core._name = (function _name(x){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$INamed$_name$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$INamed$_name$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._name[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._name["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$INamed$_namespace$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$INamed$_namespace$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._namespace[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._namespace["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"INamed.-namespace",x); +} +} +})().call(null,x); +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); +/** +* Support so that collections can implement toString without +* loading all the printing machinery. +*/ +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__3528__auto__ = cljs.core.not.call(null,a.ns);if(and__3528__auto__) +{return b.ns; +} else +{return and__3528__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; +} +} +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__._hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_symbol.call(null,sym__$1);self__._hash = h__3951__auto____$1; +return h__3951__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__5020 = null; +var G__5020__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__5020__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__5020 = function(self__,coll,not_found){ +switch(arguments.length){ +case 2: +return G__5020__2.call(this,self__,coll); +case 3: +return G__5020__3.call(this,self__,coll,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5020; +})() +; +cljs.core.Symbol.prototype.apply = (function (self__,args5019){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5019))); +}); +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.clone = (function clone(value){return cljs.core._clone.call(null,value); +}); +cljs.core.cloneable_QMARK_ = (function cloneable_QMARK_(value){var G__5022 = value;if(G__5022) +{var bit__4190__auto__ = (G__5022.cljs$lang$protocol_mask$partition1$ & 8192);if((bit__4190__auto__) || (G__5022.cljs$core$ICloneable$)) +{return true; +} else +{if((!G__5022.cljs$lang$protocol_mask$partition1$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICloneable,G__5022); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICloneable,G__5022); +} +}); +/** +* Returns a seq on the collection. If the collection is +* empty, returns nil. (seq nil) returns nil. seq also works on +* Strings. +*/ +cljs.core.seq = (function seq(coll){if((coll == null)) +{return null; +} else +{if((function (){var G__5024 = coll;if(G__5024) +{var bit__4183__auto__ = (G__5024.cljs$lang$protocol_mask$partition0$ & 8388608);if((bit__4183__auto__) || (G__5024.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; +} +} +} +} +} +} +}); +/** +* Returns the first item in the collection. Calls seq on its +* argument. If coll is nil, returns nil. +*/ +cljs.core.first = (function first(coll){if((coll == null)) +{return null; +} else +{if((function (){var G__5026 = coll;if(G__5026) +{var bit__4183__auto__ = (G__5026.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4183__auto__) || (G__5026.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); +} +} +} +}); +/** +* Returns a possibly empty seq of the items after the first. Calls seq on its +* argument. +*/ +cljs.core.rest = (function rest(coll){if(!((coll == null))) +{if((function (){var G__5028 = coll;if(G__5028) +{var bit__4183__auto__ = (G__5028.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4183__auto__) || (G__5028.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; +} +}); +/** +* Returns a seq of the items after the first. Calls seq on its +* argument. If there are no more items, returns nil +*/ +cljs.core.next = (function next(coll){if((coll == null)) +{return null; +} else +{if((function (){var G__5030 = coll;if(G__5030) +{var bit__4183__auto__ = (G__5030.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4183__auto__) || (G__5030.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)); +} +} +}); +/** +* Equality. Returns true if x equals y, false if not. Compares +* numbers and collections in a type-independent manner. Clojure's immutable data +* structures define -equiv (and thus =) as a value, not an identity, +* comparison. +* @param {...*} var_args +*/ +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__5031__delegate = function (x,y,more){while(true){ +if(_EQ_.call(null,x,y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__5032 = y; +var G__5033 = cljs.core.first.call(null,more); +var G__5034 = cljs.core.next.call(null,more); +x = G__5032; +y = G__5033; +more = G__5034; +continue; +} +} else +{return _EQ_.call(null,y,cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__5031 = 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__5031__delegate.call(this,x,y,more);}; +G__5031.cljs$lang$maxFixedArity = 2; +G__5031.cljs$lang$applyTo = (function (arglist__5035){ +var x = cljs.core.first(arglist__5035); +arglist__5035 = cljs.core.next(arglist__5035); +var y = cljs.core.first(arglist__5035); +var more = cljs.core.rest(arglist__5035); +return G__5031__delegate(x,y,more); +}); +G__5031.cljs$core$IFn$_invoke$arity$variadic = G__5031__delegate; +return G__5031; +})() +; +_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); +})); +/** +* Returns a number one greater than num. +*/ +cljs.core.inc = (function inc(x){return (x + 1); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); +/** +* Wraps x in a way such that a reduce will terminate with the value x +*/ +cljs.core.reduced = (function reduced(x){return (new cljs.core.Reduced(x)); +}); +/** +* Returns true if x is the result of a call to reduced +*/ +cljs.core.reduced_QMARK_ = (function reduced_QMARK_(r){return (r instanceof cljs.core.Reduced); +}); +/** +* Accepts any collection which satisfies the ICount and IIndexed protocols and +* reduces them without incurring seq initialization +*/ +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__5036 = nval; +var G__5037 = (n + 1); +val = G__5036; +n = G__5037; +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__5038 = nval; +var G__5039 = (n + 1); +val__$1 = G__5038; +n = G__5039; +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__5040 = nval; +var G__5041 = (n + 1); +val__$1 = G__5040; +n = G__5041; +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__5042 = nval; +var G__5043 = (n + 1); +val = G__5042; +n = G__5043; +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__5044 = nval; +var G__5045 = (n + 1); +val__$1 = G__5044; +n = G__5045; +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__5046 = nval; +var G__5047 = (n + 1); +val__$1 = G__5046; +n = G__5047; +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; +})() +; +/** +* Returns true if coll implements count in constant time +*/ +cljs.core.counted_QMARK_ = (function counted_QMARK_(x){var G__5049 = x;if(G__5049) +{var bit__4190__auto__ = (G__5049.cljs$lang$protocol_mask$partition0$ & 2);if((bit__4190__auto__) || (G__5049.cljs$core$ICounted$)) +{return true; +} else +{if((!G__5049.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICounted,G__5049); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICounted,G__5049); +} +}); +/** +* Returns true if coll implements nth in constant time +*/ +cljs.core.indexed_QMARK_ = (function indexed_QMARK_(x){var G__5051 = x;if(G__5051) +{var bit__4190__auto__ = (G__5051.cljs$lang$protocol_mask$partition0$ & 16);if((bit__4190__auto__) || (G__5051.cljs$core$IIndexed$)) +{return true; +} else +{if((!G__5051.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IIndexed,G__5051); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IIndexed,G__5051); +} +}); + +/** +* @constructor +*/ +cljs.core.IndexedSeq = (function (arr,i){ +this.arr = arr; +this.i = i; +this.cljs$lang$protocol_mask$partition0$ = 166199550; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.IndexedSeq.cljs$lang$type = true; +cljs.core.IndexedSeq.cljs$lang$ctorStr = "cljs.core/IndexedSeq"; +cljs.core.IndexedSeq.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.IndexedSeq(self__.arr,self__.i)); +}); +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; +})() +; + +/** +* @constructor +*/ +cljs.core.RSeq = (function (ci,i,meta){ +this.ci = ci; +this.i = i; +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 32374862; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.RSeq.cljs$lang$type = true; +cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq"; +cljs.core.RSeq.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.RSeq(self__.ci,self__.i,self__.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)); +}); +/** +* Same as (first (next x)) +*/ +cljs.core.second = (function second(coll){return cljs.core.first.call(null,cljs.core.next.call(null,coll)); +}); +/** +* Same as (first (first x)) +*/ +cljs.core.ffirst = (function ffirst(coll){return cljs.core.first.call(null,cljs.core.first.call(null,coll)); +}); +/** +* Same as (next (first x)) +*/ +cljs.core.nfirst = (function nfirst(coll){return cljs.core.next.call(null,cljs.core.first.call(null,coll)); +}); +/** +* Same as (first (next x)) +*/ +cljs.core.fnext = (function fnext(coll){return cljs.core.first.call(null,cljs.core.next.call(null,coll)); +}); +/** +* Same as (next (next x)) +*/ +cljs.core.nnext = (function nnext(coll){return cljs.core.next.call(null,cljs.core.next.call(null,coll)); +}); +/** +* Return the last item in coll, in linear time +*/ +cljs.core.last = (function last(s){while(true){ +var sn = cljs.core.next.call(null,s);if(!((sn == null))) +{{ +var G__5052 = sn; +s = G__5052; +continue; +} +} else +{return cljs.core.first.call(null,s); +} +break; +} +}); +(cljs.core.IEquiv["_"] = true); +(cljs.core._equiv["_"] = (function (x,o){return (x === o); +})); +/** +* conj[oin]. Returns a new collection with the xs +* 'added'. (conj nil item) returns (item). The 'addition' may +* happen at different 'places' depending on the concrete type. +* @param {...*} var_args +*/ +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__5053__delegate = function (coll,x,xs){while(true){ +if(cljs.core.truth_(xs)) +{{ +var G__5054 = conj.call(null,coll,x); +var G__5055 = cljs.core.first.call(null,xs); +var G__5056 = cljs.core.next.call(null,xs); +coll = G__5054; +x = G__5055; +xs = G__5056; +continue; +} +} else +{return conj.call(null,coll,x); +} +break; +} +}; +var G__5053 = 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__5053__delegate.call(this,coll,x,xs);}; +G__5053.cljs$lang$maxFixedArity = 2; +G__5053.cljs$lang$applyTo = (function (arglist__5057){ +var coll = cljs.core.first(arglist__5057); +arglist__5057 = cljs.core.next(arglist__5057); +var x = cljs.core.first(arglist__5057); +var xs = cljs.core.rest(arglist__5057); +return G__5053__delegate(coll,x,xs); +}); +G__5053.cljs$core$IFn$_invoke$arity$variadic = G__5053__delegate; +return G__5053; +})() +; +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; +})() +; +/** +* Returns an empty collection of the same category as coll, or nil +*/ +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__5058 = cljs.core.next.call(null,s); +var G__5059 = (acc + 1); +s = G__5058; +acc = G__5059; +continue; +} +} +break; +} +}); +/** +* Returns the number of items in the collection. (count nil) returns +* 0. Also works on strings, arrays, and Maps +*/ +cljs.core.count = (function count(coll){if(!((coll == null))) +{if((function (){var G__5061 = coll;if(G__5061) +{var bit__4183__auto__ = (G__5061.cljs$lang$protocol_mask$partition0$ & 2);if((bit__4183__auto__) || (G__5061.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__5062 = cljs.core.next.call(null,coll); +var G__5063 = (n - 1); +coll = G__5062; +n = G__5063; +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__5064 = cljs.core.next.call(null,coll); +var G__5065 = (n - 1); +var G__5066 = not_found; +coll = G__5064; +n = G__5065; +not_found = G__5066; +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; +})() +; +/** +* Returns the value at the index. get returns nil if index out of +* bounds, nth throws an exception unless not-found is supplied. nth +* also works for strings, arrays, regex Matchers and Lists, and, +* in O(n) time, for sequences. +*/ +cljs.core.nth = (function() { +var nth = null; +var nth__2 = (function (coll,n){if((coll == null)) +{return null; +} else +{if((function (){var G__5071 = coll;if(G__5071) +{var bit__4183__auto__ = (G__5071.cljs$lang$protocol_mask$partition0$ & 16);if((bit__4183__auto__) || (G__5071.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__5072 = coll;if(G__5072) +{var bit__4190__auto__ = (G__5072.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4190__auto__) || (G__5072.cljs$core$ISeq$)) +{return true; +} else +{if((!G__5072.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__5072); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__5072); +} +})()) +{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__5073 = coll;if(G__5073) +{var bit__4183__auto__ = (G__5073.cljs$lang$protocol_mask$partition0$ & 16);if((bit__4183__auto__) || (G__5073.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__5074 = coll;if(G__5074) +{var bit__4190__auto__ = (G__5074.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4190__auto__) || (G__5074.cljs$core$ISeq$)) +{return true; +} else +{if((!G__5074.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__5074); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__5074); +} +})()) +{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; +})() +; +/** +* Returns the value mapped to key, not-found or nil if key not present. +*/ +cljs.core.get = (function() { +var get = null; +var get__2 = (function (o,k){if((o == null)) +{return null; +} else +{if((function (){var G__5077 = o;if(G__5077) +{var bit__4183__auto__ = (G__5077.cljs$lang$protocol_mask$partition0$ & 256);if((bit__4183__auto__) || (G__5077.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__5078 = o;if(G__5078) +{var bit__4183__auto__ = (G__5078.cljs$lang$protocol_mask$partition0$ & 256);if((bit__4183__auto__) || (G__5078.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; +})() +; +/** +* assoc[iate]. When applied to a map, returns a new map of the +* same (hashed/sorted) type, that contains the mapping of key(s) to +* val(s). When applied to a vector, returns a new vector that +* contains val at index. +* @param {...*} var_args +*/ +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__5079__delegate = function (coll,k,v,kvs){while(true){ +var ret = assoc.call(null,coll,k,v);if(cljs.core.truth_(kvs)) +{{ +var G__5080 = ret; +var G__5081 = cljs.core.first.call(null,kvs); +var G__5082 = cljs.core.second.call(null,kvs); +var G__5083 = cljs.core.nnext.call(null,kvs); +coll = G__5080; +k = G__5081; +v = G__5082; +kvs = G__5083; +continue; +} +} else +{return ret; +} +break; +} +}; +var G__5079 = 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__5079__delegate.call(this,coll,k,v,kvs);}; +G__5079.cljs$lang$maxFixedArity = 3; +G__5079.cljs$lang$applyTo = (function (arglist__5084){ +var coll = cljs.core.first(arglist__5084); +arglist__5084 = cljs.core.next(arglist__5084); +var k = cljs.core.first(arglist__5084); +arglist__5084 = cljs.core.next(arglist__5084); +var v = cljs.core.first(arglist__5084); +var kvs = cljs.core.rest(arglist__5084); +return G__5079__delegate(coll,k,v,kvs); +}); +G__5079.cljs$core$IFn$_invoke$arity$variadic = G__5079__delegate; +return G__5079; +})() +; +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; +})() +; +/** +* dissoc[iate]. Returns a new map of the same (hashed/sorted) type, +* that does not contain a mapping for key(s). +* @param {...*} var_args +*/ +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__5085__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__5086 = ret; +var G__5087 = cljs.core.first.call(null,ks); +var G__5088 = cljs.core.next.call(null,ks); +coll = G__5086; +k = G__5087; +ks = G__5088; +continue; +} +} else +{return ret; +} +} +break; +} +}; +var G__5085 = 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__5085__delegate.call(this,coll,k,ks);}; +G__5085.cljs$lang$maxFixedArity = 2; +G__5085.cljs$lang$applyTo = (function (arglist__5089){ +var coll = cljs.core.first(arglist__5089); +arglist__5089 = cljs.core.next(arglist__5089); +var k = cljs.core.first(arglist__5089); +var ks = cljs.core.rest(arglist__5089); +return G__5085__delegate(coll,k,ks); +}); +G__5085.cljs$core$IFn$_invoke$arity$variadic = G__5085__delegate; +return G__5085; +})() +; +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__3540__auto__ = goog.isFunction(f);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var G__5093 = f;if(G__5093) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto____$1 = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return G__5093.cljs$core$Fn$; +} +})())) +{return true; +} else +{if((!G__5093.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.Fn,G__5093); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.Fn,G__5093); +} +} +}); +/** +* Returns an object of the same type and value as obj, with +* map m as its metadata. +*/ +cljs.core.with_meta = (function with_meta(o,meta){if((cljs.core.fn_QMARK_.call(null,o)) && (!((function (){var G__5101 = o;if(G__5101) +{var bit__4190__auto__ = (G__5101.cljs$lang$protocol_mask$partition0$ & 262144);if((bit__4190__auto__) || (G__5101.cljs$core$IWithMeta$)) +{return true; +} else +{if((!G__5101.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IWithMeta,G__5101); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IWithMeta,G__5101); +} +})()))) +{return with_meta.call(null,(function (){if(typeof cljs.core.t5102 !== 'undefined') +{} else +{ +/** +* @constructor +*/ +cljs.core.t5102 = (function (meta,o,with_meta,meta5103){ +this.meta = meta; +this.o = o; +this.with_meta = with_meta; +this.meta5103 = meta5103; +this.cljs$lang$protocol_mask$partition1$ = 0; +this.cljs$lang$protocol_mask$partition0$ = 393217; +}) +cljs.core.t5102.cljs$lang$type = true; +cljs.core.t5102.cljs$lang$ctorStr = "cljs.core/t5102"; +cljs.core.t5102.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__auto__,"cljs.core/t5102"); +}); +cljs.core.t5102.prototype.call = (function() { +var G__5106__delegate = function (self__,args){var self____$1 = this;var _ = self____$1;return cljs.core.apply.call(null,self__.o,args); +}; +var G__5106 = 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__5106__delegate.call(this,self__,args);}; +G__5106.cljs$lang$maxFixedArity = 1; +G__5106.cljs$lang$applyTo = (function (arglist__5107){ +var self__ = cljs.core.first(arglist__5107); +var args = cljs.core.rest(arglist__5107); +return G__5106__delegate(self__,args); +}); +G__5106.cljs$core$IFn$_invoke$arity$variadic = G__5106__delegate; +return G__5106; +})() +; +cljs.core.t5102.prototype.apply = (function (self__,args5105){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5105))); +}); +cljs.core.t5102.prototype.cljs$core$IFn$_invoke$arity$2 = (function() { +var G__5108__delegate = function (args){var _ = this;return cljs.core.apply.call(null,self__.o,args); +}; +var G__5108 = 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__5108__delegate.call(this,args);}; +G__5108.cljs$lang$maxFixedArity = 0; +G__5108.cljs$lang$applyTo = (function (arglist__5109){ +var args = cljs.core.seq(arglist__5109); +return G__5108__delegate(args); +}); +G__5108.cljs$core$IFn$_invoke$arity$variadic = G__5108__delegate; +return G__5108; +})() +; +cljs.core.t5102.prototype.cljs$core$Fn$ = true; +cljs.core.t5102.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_5104){var self__ = this; +var _5104__$1 = this;return self__.meta5103; +}); +cljs.core.t5102.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (_5104,meta5103__$1){var self__ = this; +var _5104__$1 = this;return (new cljs.core.t5102(self__.meta,self__.o,self__.with_meta,meta5103__$1)); +}); +cljs.core.__GT_t5102 = (function __GT_t5102(meta__$1,o__$1,with_meta__$1,meta5103){return (new cljs.core.t5102(meta__$1,o__$1,with_meta__$1,meta5103)); +}); +} +return (new cljs.core.t5102(meta,o,with_meta,null)); +})(),meta); +} else +{if((o == null)) +{return null; +} else +{return cljs.core._with_meta.call(null,o,meta); +} +} +}); +/** +* Returns the metadata of obj, returns nil if there is no metadata. +*/ +cljs.core.meta = (function meta(o){if((function (){var and__3528__auto__ = !((o == null));if(and__3528__auto__) +{var G__5113 = o;if(G__5113) +{var bit__4190__auto__ = (G__5113.cljs$lang$protocol_mask$partition0$ & 131072);if((bit__4190__auto__) || (G__5113.cljs$core$IMeta$)) +{return true; +} else +{if((!G__5113.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__5113); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__5113); +} +} else +{return and__3528__auto__; +} +})()) +{return cljs.core._meta.call(null,o); +} else +{return null; +} +}); +/** +* For a list or queue, same as first, for a vector, same as, but much +* more efficient than, last. If the collection is empty, returns nil. +*/ +cljs.core.peek = (function peek(coll){if((coll == null)) +{return null; +} else +{return cljs.core._peek.call(null,coll); +} +}); +/** +* For a list or queue, returns a new list/queue without the first +* item, for a vector, returns a new vector without the last item. +* Note - not the same as next/butlast. +*/ +cljs.core.pop = (function pop(coll){if((coll == null)) +{return null; +} else +{return cljs.core._pop.call(null,coll); +} +}); +/** +* disj[oin]. Returns a new set of the same (hashed/sorted) type, that +* does not contain key(s). +* @param {...*} var_args +*/ +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__5114__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__5115 = ret; +var G__5116 = cljs.core.first.call(null,ks); +var G__5117 = cljs.core.next.call(null,ks); +coll = G__5115; +k = G__5116; +ks = G__5117; +continue; +} +} else +{return ret; +} +} +break; +} +}; +var G__5114 = 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__5114__delegate.call(this,coll,k,ks);}; +G__5114.cljs$lang$maxFixedArity = 2; +G__5114.cljs$lang$applyTo = (function (arglist__5118){ +var coll = cljs.core.first(arglist__5118); +arglist__5118 = cljs.core.next(arglist__5118); +var k = cljs.core.first(arglist__5118); +var ks = cljs.core.rest(arglist__5118); +return G__5114__delegate(coll,k,ks); +}); +G__5114.cljs$core$IFn$_invoke$arity$variadic = G__5114__delegate; +return G__5114; +})() +; +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 obj5120 = {};return obj5120; +})(); +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 obj5124 = {};return obj5124; +})(); +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__5126 = o;if(G__5126) +{var bit__4183__auto__ = (G__5126.cljs$lang$protocol_mask$partition0$ & 4194304);if((bit__4183__auto__) || (G__5126.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; +} +} +} +} +} +} +} +}); +/** +* Returns true if coll has no items - same as (not (seq coll)). +* Please use the idiom (seq x) rather than (not (empty? x)) +*/ +cljs.core.empty_QMARK_ = (function empty_QMARK_(coll){return ((coll == null)) || (cljs.core.not.call(null,cljs.core.seq.call(null,coll))); +}); +/** +* Returns true if x satisfies ICollection +*/ +cljs.core.coll_QMARK_ = (function coll_QMARK_(x){if((x == null)) +{return false; +} else +{var G__5128 = x;if(G__5128) +{var bit__4190__auto__ = (G__5128.cljs$lang$protocol_mask$partition0$ & 8);if((bit__4190__auto__) || (G__5128.cljs$core$ICollection$)) +{return true; +} else +{if((!G__5128.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICollection,G__5128); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICollection,G__5128); +} +} +}); +/** +* Returns true if x satisfies ISet +*/ +cljs.core.set_QMARK_ = (function set_QMARK_(x){if((x == null)) +{return false; +} else +{var G__5130 = x;if(G__5130) +{var bit__4190__auto__ = (G__5130.cljs$lang$protocol_mask$partition0$ & 4096);if((bit__4190__auto__) || (G__5130.cljs$core$ISet$)) +{return true; +} else +{if((!G__5130.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISet,G__5130); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISet,G__5130); +} +} +}); +/** +* Returns true if coll implements Associative +*/ +cljs.core.associative_QMARK_ = (function associative_QMARK_(x){var G__5132 = x;if(G__5132) +{var bit__4190__auto__ = (G__5132.cljs$lang$protocol_mask$partition0$ & 512);if((bit__4190__auto__) || (G__5132.cljs$core$IAssociative$)) +{return true; +} else +{if((!G__5132.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IAssociative,G__5132); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IAssociative,G__5132); +} +}); +/** +* Returns true if coll satisfies ISequential +*/ +cljs.core.sequential_QMARK_ = (function sequential_QMARK_(x){var G__5134 = x;if(G__5134) +{var bit__4190__auto__ = (G__5134.cljs$lang$protocol_mask$partition0$ & 16777216);if((bit__4190__auto__) || (G__5134.cljs$core$ISequential$)) +{return true; +} else +{if((!G__5134.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISequential,G__5134); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISequential,G__5134); +} +}); +/** +* Returns true if coll satisfies ISorted +*/ +cljs.core.sorted_QMARK_ = (function sorted_QMARK_(x){var G__5136 = x;if(G__5136) +{var bit__4190__auto__ = (G__5136.cljs$lang$protocol_mask$partition0$ & 268435456);if((bit__4190__auto__) || (G__5136.cljs$core$ISorted$)) +{return true; +} else +{if((!G__5136.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISorted,G__5136); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISorted,G__5136); +} +}); +/** +* Returns true if coll satisfies IReduce +*/ +cljs.core.reduceable_QMARK_ = (function reduceable_QMARK_(x){var G__5138 = x;if(G__5138) +{var bit__4190__auto__ = (G__5138.cljs$lang$protocol_mask$partition0$ & 524288);if((bit__4190__auto__) || (G__5138.cljs$core$IReduce$)) +{return true; +} else +{if((!G__5138.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReduce,G__5138); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReduce,G__5138); +} +}); +/** +* Return true if x satisfies IMap +*/ +cljs.core.map_QMARK_ = (function map_QMARK_(x){if((x == null)) +{return false; +} else +{var G__5140 = x;if(G__5140) +{var bit__4190__auto__ = (G__5140.cljs$lang$protocol_mask$partition0$ & 1024);if((bit__4190__auto__) || (G__5140.cljs$core$IMap$)) +{return true; +} else +{if((!G__5140.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMap,G__5140); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMap,G__5140); +} +} +}); +/** +* Return true if x satisfies IVector +*/ +cljs.core.vector_QMARK_ = (function vector_QMARK_(x){var G__5142 = x;if(G__5142) +{var bit__4190__auto__ = (G__5142.cljs$lang$protocol_mask$partition0$ & 16384);if((bit__4190__auto__) || (G__5142.cljs$core$IVector$)) +{return true; +} else +{if((!G__5142.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IVector,G__5142); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IVector,G__5142); +} +}); +cljs.core.chunked_seq_QMARK_ = (function chunked_seq_QMARK_(x){var G__5144 = x;if(G__5144) +{var bit__4183__auto__ = (G__5144.cljs$lang$protocol_mask$partition1$ & 512);if((bit__4183__auto__) || (G__5144.cljs$core$IChunkedSeq$)) +{return true; +} else +{return false; +} +} else +{return false; +} +}); +/** +* @param {...*} var_args +*/ +cljs.core.js_obj = (function() { +var js_obj = null; +var js_obj__0 = (function (){var obj5148 = {};return obj5148; +}); +var js_obj__1 = (function() { +var G__5149__delegate = function (keyvals){return cljs.core.apply.call(null,goog.object.create,keyvals); +}; +var G__5149 = function (var_args){ +var keyvals = null;if (arguments.length > 0) { + keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5149__delegate.call(this,keyvals);}; +G__5149.cljs$lang$maxFixedArity = 0; +G__5149.cljs$lang$applyTo = (function (arglist__5150){ +var keyvals = cljs.core.seq(arglist__5150); +return G__5149__delegate(keyvals); +}); +G__5149.cljs$core$IFn$_invoke$arity$variadic = G__5149__delegate; +return G__5149; +})() +; +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__5151 = (i__$1 + 1); +var G__5152 = (j__$1 + 1); +var G__5153 = (len__$1 - 1); +i__$1 = G__5151; +j__$1 = G__5152; +len__$1 = G__5153; +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__5154 = (i__$1 - 1); +var G__5155 = (j__$1 - 1); +var G__5156 = (len__$1 - 1); +i__$1 = G__5154; +j__$1 = G__5155; +len__$1 = G__5156; +continue; +} +} +break; +} +}); +cljs.core.lookup_sentinel = (function (){var obj5158 = {};return obj5158; +})(); +/** +* Returns true if x is the value false, false otherwise. +*/ +cljs.core.false_QMARK_ = (function false_QMARK_(x){return x === false; +}); +/** +* Returns true if x is the value true, false otherwise. +*/ +cljs.core.true_QMARK_ = (function true_QMARK_(x){return x === true; +}); +cljs.core.undefined_QMARK_ = (function undefined_QMARK_(x){return (void 0 === x); +}); +/** +* Return true if s satisfies ISeq +*/ +cljs.core.seq_QMARK_ = (function seq_QMARK_(s){if((s == null)) +{return false; +} else +{var G__5160 = s;if(G__5160) +{var bit__4190__auto__ = (G__5160.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4190__auto__) || (G__5160.cljs$core$ISeq$)) +{return true; +} else +{if((!G__5160.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__5160); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__5160); +} +} +}); +/** +* Return true if s satisfies ISeqable +*/ +cljs.core.seqable_QMARK_ = (function seqable_QMARK_(s){var G__5162 = s;if(G__5162) +{var bit__4190__auto__ = (G__5162.cljs$lang$protocol_mask$partition0$ & 8388608);if((bit__4190__auto__) || (G__5162.cljs$core$ISeqable$)) +{return true; +} else +{if((!G__5162.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeqable,G__5162); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeqable,G__5162); +} +}); +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__3540__auto__ = cljs.core.fn_QMARK_.call(null,f);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var G__5166 = f;if(G__5166) +{var bit__4190__auto__ = (G__5166.cljs$lang$protocol_mask$partition0$ & 1);if((bit__4190__auto__) || (G__5166.cljs$core$IFn$)) +{return true; +} else +{if((!G__5166.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IFn,G__5166); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IFn,G__5166); +} +} +}); +/** +* Returns true if n is an integer. +*/ +cljs.core.integer_QMARK_ = (function integer_QMARK_(n){return (typeof n === 'number') && (!(isNaN(n))) && (!((n === Infinity))) && ((parseFloat(n) === parseInt(n,10))); +}); +/** +* Returns true if key is present in the given collection, otherwise +* returns false. Note that for numerically indexed collections like +* vectors and arrays, this tests if the numeric key is within the +* range of indexes. 'contains?' operates constant or logarithmic time; +* it will not perform a linear search for a value. See also 'some'. +*/ +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; +} +}); +/** +* Returns the map entry for key, or nil if key not present. +*/ +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; +} +}); +/** +* Returns true if no two of the arguments are = +* @param {...*} var_args +*/ +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__5167__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__5168 = cljs.core.conj.call(null,s,x__$1); +var G__5169 = etc; +s = G__5168; +xs = G__5169; +continue; +} +} +} else +{return true; +} +break; +} +} else +{return false; +} +}; +var G__5167 = 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__5167__delegate.call(this,x,y,more);}; +G__5167.cljs$lang$maxFixedArity = 2; +G__5167.cljs$lang$applyTo = (function (arglist__5170){ +var x = cljs.core.first(arglist__5170); +arglist__5170 = cljs.core.next(arglist__5170); +var y = cljs.core.first(arglist__5170); +var more = cljs.core.rest(arglist__5170); +return G__5167__delegate(x,y,more); +}); +G__5167.cljs$core$IFn$_invoke$arity$variadic = G__5167__delegate; +return G__5167; +})() +; +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_; +})() +; +/** +* Coerces coll to a (possibly empty) sequence, if it is not already +* one. Will not force a lazy seq. (sequence nil) yields () +*/ +cljs.core.sequence = (function sequence(coll){if(cljs.core.seq_QMARK_.call(null,coll)) +{return coll; +} else +{var or__3540__auto__ = cljs.core.seq.call(null,coll);if(or__3540__auto__) +{return or__3540__auto__; +} else +{return cljs.core.List.EMPTY; +} +} +}); +/** +* Comparator. Returns a negative number, zero, or a positive number +* when x is logically 'less than', 'equal to', or 'greater than' +* y. Uses IComparable if available and google.array.defaultCompare for objects +* of the same type and special-cases nil to be less than any other object. +*/ +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__5172 = x;if(G__5172) +{var bit__4183__auto__ = (G__5172.cljs$lang$protocol_mask$partition1$ & 2048);if((bit__4183__auto__) || (G__5172.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; +} +} +} +} +} +}); +/** +* Compare indexed collection. +*/ +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__5173 = xs; +var G__5174 = ys; +var G__5175 = len; +var G__5176 = (n + 1); +xs = G__5173; +ys = G__5174; +len = G__5175; +n = G__5176; +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; +})() +; +/** +* Given a fn that might be boolean valued or a comparator, +* return a fn that is a comparator. +*/ +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; +} +} +} +}); +} +}); +/** +* Returns a sorted sequence of the items in coll. Comp can be +* boolean-valued comparison funcion, or a -/0/+ valued comparator. +* Comp defaults to compare. +*/ +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; +})() +; +/** +* Returns a sorted sequence of the items in coll, where the sort +* order is determined by comparing (keyfn item). Comp can be +* boolean-valued comparison funcion, or a -/0/+ valued comparator. +* Comp defaults to compare. +*/ +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__5177 = nval; +var G__5178 = cljs.core.next.call(null,coll__$1); +val__$1 = G__5177; +coll__$1 = G__5178; +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; +})() +; +/** +* Return a random permutation of coll +*/ +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); +}); +/** +* f should be a function of 2 arguments. If val is not supplied, +* returns the result of applying f to the first 2 items in coll, then +* applying f to that result and the 3rd item, etc. If coll contains no +* items, f must accept no arguments as well, and reduce returns the +* result of calling f with no arguments. If coll has only 1 item, it +* is returned and f is not called. If val is supplied, returns the +* result of applying f to val and the first item in coll, then +* applying f to that result and the 2nd item, etc. If coll contains no +* items, returns val and f is not called. +*/ +cljs.core.reduce = (function() { +var reduce = null; +var reduce__2 = (function (f,coll){if((function (){var G__5181 = coll;if(G__5181) +{var bit__4183__auto__ = (G__5181.cljs$lang$protocol_mask$partition0$ & 524288);if((bit__4183__auto__) || (G__5181.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__5182 = coll;if(G__5182) +{var bit__4183__auto__ = (G__5182.cljs$lang$protocol_mask$partition0$ & 524288);if((bit__4183__auto__) || (G__5182.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; +})() +; +/** +* Reduces an associative collection. f should be a function of 3 +* arguments. Returns the result of applying f to init, the first key +* and the first value in coll, then applying f to that result and the +* 2nd key and value, etc. If coll contains no entries, returns init +* and f is not called. Note that reduce-kv is supported on vectors, +* where the keys will be the ordinals. +*/ +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; +} +}); +/** +* Returns the sum of nums. (+) returns 0. +* @param {...*} var_args +*/ +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__5183__delegate = function (x,y,more){return cljs.core.reduce.call(null,_PLUS_,(x + y),more); +}; +var G__5183 = 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__5183__delegate.call(this,x,y,more);}; +G__5183.cljs$lang$maxFixedArity = 2; +G__5183.cljs$lang$applyTo = (function (arglist__5184){ +var x = cljs.core.first(arglist__5184); +arglist__5184 = cljs.core.next(arglist__5184); +var y = cljs.core.first(arglist__5184); +var more = cljs.core.rest(arglist__5184); +return G__5183__delegate(x,y,more); +}); +G__5183.cljs$core$IFn$_invoke$arity$variadic = G__5183__delegate; +return G__5183; +})() +; +_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_; +})() +; +/** +* If no ys are supplied, returns the negation of x, else subtracts +* the ys from x and returns the result. +* @param {...*} var_args +*/ +cljs.core._ = (function() { +var _ = null; +var ___1 = (function (x){return (- x); +}); +var ___2 = (function (x,y){return (x - y); +}); +var ___3 = (function() { +var G__5185__delegate = function (x,y,more){return cljs.core.reduce.call(null,_,(x - y),more); +}; +var G__5185 = 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__5185__delegate.call(this,x,y,more);}; +G__5185.cljs$lang$maxFixedArity = 2; +G__5185.cljs$lang$applyTo = (function (arglist__5186){ +var x = cljs.core.first(arglist__5186); +arglist__5186 = cljs.core.next(arglist__5186); +var y = cljs.core.first(arglist__5186); +var more = cljs.core.rest(arglist__5186); +return G__5185__delegate(x,y,more); +}); +G__5185.cljs$core$IFn$_invoke$arity$variadic = G__5185__delegate; +return G__5185; +})() +; +_ = 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 _; +})() +; +/** +* Returns the product of nums. (*) returns 1. +* @param {...*} var_args +*/ +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__5187__delegate = function (x,y,more){return cljs.core.reduce.call(null,_STAR_,(x * y),more); +}; +var G__5187 = 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__5187__delegate.call(this,x,y,more);}; +G__5187.cljs$lang$maxFixedArity = 2; +G__5187.cljs$lang$applyTo = (function (arglist__5188){ +var x = cljs.core.first(arglist__5188); +arglist__5188 = cljs.core.next(arglist__5188); +var y = cljs.core.first(arglist__5188); +var more = cljs.core.rest(arglist__5188); +return G__5187__delegate(x,y,more); +}); +G__5187.cljs$core$IFn$_invoke$arity$variadic = G__5187__delegate; +return G__5187; +})() +; +_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_; +})() +; +/** +* If no denominators are supplied, returns 1/numerator, +* else returns numerator divided by all of the denominators. +* @param {...*} var_args +*/ +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__5189__delegate = function (x,y,more){return cljs.core.reduce.call(null,_SLASH_,_SLASH_.call(null,x,y),more); +}; +var G__5189 = 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__5189__delegate.call(this,x,y,more);}; +G__5189.cljs$lang$maxFixedArity = 2; +G__5189.cljs$lang$applyTo = (function (arglist__5190){ +var x = cljs.core.first(arglist__5190); +arglist__5190 = cljs.core.next(arglist__5190); +var y = cljs.core.first(arglist__5190); +var more = cljs.core.rest(arglist__5190); +return G__5189__delegate(x,y,more); +}); +G__5189.cljs$core$IFn$_invoke$arity$variadic = G__5189__delegate; +return G__5189; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically increasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__5191__delegate = function (x,y,more){while(true){ +if((x < y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__5192 = y; +var G__5193 = cljs.core.first.call(null,more); +var G__5194 = cljs.core.next.call(null,more); +x = G__5192; +y = G__5193; +more = G__5194; +continue; +} +} else +{return (y < cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__5191 = 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__5191__delegate.call(this,x,y,more);}; +G__5191.cljs$lang$maxFixedArity = 2; +G__5191.cljs$lang$applyTo = (function (arglist__5195){ +var x = cljs.core.first(arglist__5195); +arglist__5195 = cljs.core.next(arglist__5195); +var y = cljs.core.first(arglist__5195); +var more = cljs.core.rest(arglist__5195); +return G__5191__delegate(x,y,more); +}); +G__5191.cljs$core$IFn$_invoke$arity$variadic = G__5191__delegate; +return G__5191; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically non-decreasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__5196__delegate = function (x,y,more){while(true){ +if((x <= y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__5197 = y; +var G__5198 = cljs.core.first.call(null,more); +var G__5199 = cljs.core.next.call(null,more); +x = G__5197; +y = G__5198; +more = G__5199; +continue; +} +} else +{return (y <= cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__5196 = 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__5196__delegate.call(this,x,y,more);}; +G__5196.cljs$lang$maxFixedArity = 2; +G__5196.cljs$lang$applyTo = (function (arglist__5200){ +var x = cljs.core.first(arglist__5200); +arglist__5200 = cljs.core.next(arglist__5200); +var y = cljs.core.first(arglist__5200); +var more = cljs.core.rest(arglist__5200); +return G__5196__delegate(x,y,more); +}); +G__5196.cljs$core$IFn$_invoke$arity$variadic = G__5196__delegate; +return G__5196; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically decreasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__5201__delegate = function (x,y,more){while(true){ +if((x > y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__5202 = y; +var G__5203 = cljs.core.first.call(null,more); +var G__5204 = cljs.core.next.call(null,more); +x = G__5202; +y = G__5203; +more = G__5204; +continue; +} +} else +{return (y > cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__5201 = 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__5201__delegate.call(this,x,y,more);}; +G__5201.cljs$lang$maxFixedArity = 2; +G__5201.cljs$lang$applyTo = (function (arglist__5205){ +var x = cljs.core.first(arglist__5205); +arglist__5205 = cljs.core.next(arglist__5205); +var y = cljs.core.first(arglist__5205); +var more = cljs.core.rest(arglist__5205); +return G__5201__delegate(x,y,more); +}); +G__5201.cljs$core$IFn$_invoke$arity$variadic = G__5201__delegate; +return G__5201; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically non-increasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__5206__delegate = function (x,y,more){while(true){ +if((x >= y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__5207 = y; +var G__5208 = cljs.core.first.call(null,more); +var G__5209 = cljs.core.next.call(null,more); +x = G__5207; +y = G__5208; +more = G__5209; +continue; +} +} else +{return (y >= cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__5206 = 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__5206__delegate.call(this,x,y,more);}; +G__5206.cljs$lang$maxFixedArity = 2; +G__5206.cljs$lang$applyTo = (function (arglist__5210){ +var x = cljs.core.first(arglist__5210); +arglist__5210 = cljs.core.next(arglist__5210); +var y = cljs.core.first(arglist__5210); +var more = cljs.core.rest(arglist__5210); +return G__5206__delegate(x,y,more); +}); +G__5206.cljs$core$IFn$_invoke$arity$variadic = G__5206__delegate; +return G__5206; +})() +; +_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_; +})() +; +/** +* Returns a number one less than num. +*/ +cljs.core.dec = (function dec(x){return (x - 1); +}); +/** +* Returns the greatest of the nums. +* @param {...*} var_args +*/ +cljs.core.max = (function() { +var max = null; +var max__1 = (function (x){return x; +}); +var max__2 = (function (x,y){var x__3847__auto__ = x;var y__3848__auto__ = y;return ((x__3847__auto__ > y__3848__auto__) ? x__3847__auto__ : y__3848__auto__); +}); +var max__3 = (function() { +var G__5211__delegate = function (x,y,more){return cljs.core.reduce.call(null,max,(function (){var x__3847__auto__ = x;var y__3848__auto__ = y;return ((x__3847__auto__ > y__3848__auto__) ? x__3847__auto__ : y__3848__auto__); +})(),more); +}; +var G__5211 = 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__5211__delegate.call(this,x,y,more);}; +G__5211.cljs$lang$maxFixedArity = 2; +G__5211.cljs$lang$applyTo = (function (arglist__5212){ +var x = cljs.core.first(arglist__5212); +arglist__5212 = cljs.core.next(arglist__5212); +var y = cljs.core.first(arglist__5212); +var more = cljs.core.rest(arglist__5212); +return G__5211__delegate(x,y,more); +}); +G__5211.cljs$core$IFn$_invoke$arity$variadic = G__5211__delegate; +return G__5211; +})() +; +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; +})() +; +/** +* Returns the least of the nums. +* @param {...*} var_args +*/ +cljs.core.min = (function() { +var min = null; +var min__1 = (function (x){return x; +}); +var min__2 = (function (x,y){var x__3854__auto__ = x;var y__3855__auto__ = y;return ((x__3854__auto__ < y__3855__auto__) ? x__3854__auto__ : y__3855__auto__); +}); +var min__3 = (function() { +var G__5213__delegate = function (x,y,more){return cljs.core.reduce.call(null,min,(function (){var x__3854__auto__ = x;var y__3855__auto__ = y;return ((x__3854__auto__ < y__3855__auto__) ? x__3854__auto__ : y__3855__auto__); +})(),more); +}; +var G__5213 = 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__5213__delegate.call(this,x,y,more);}; +G__5213.cljs$lang$maxFixedArity = 2; +G__5213.cljs$lang$applyTo = (function (arglist__5214){ +var x = cljs.core.first(arglist__5214); +arglist__5214 = cljs.core.next(arglist__5214); +var y = cljs.core.first(arglist__5214); +var more = cljs.core.rest(arglist__5214); +return G__5213__delegate(x,y,more); +}); +G__5213.cljs$core$IFn$_invoke$arity$variadic = G__5213__delegate; +return G__5213; +})() +; +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; +}); +/** +* Coerce to char +*/ +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; +}); +/** +* Returns the sum of nums. (+) returns 0. +* @param {...*} var_args +*/ +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__5215__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_add,(x + y),more); +}; +var G__5215 = 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__5215__delegate.call(this,x,y,more);}; +G__5215.cljs$lang$maxFixedArity = 2; +G__5215.cljs$lang$applyTo = (function (arglist__5216){ +var x = cljs.core.first(arglist__5216); +arglist__5216 = cljs.core.next(arglist__5216); +var y = cljs.core.first(arglist__5216); +var more = cljs.core.rest(arglist__5216); +return G__5215__delegate(x,y,more); +}); +G__5215.cljs$core$IFn$_invoke$arity$variadic = G__5215__delegate; +return G__5215; +})() +; +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; +})() +; +/** +* Returns the sum of nums. (+) returns 0. +* @param {...*} var_args +*/ +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__5217__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_add_int,(x + y),more); +}; +var G__5217 = 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__5217__delegate.call(this,x,y,more);}; +G__5217.cljs$lang$maxFixedArity = 2; +G__5217.cljs$lang$applyTo = (function (arglist__5218){ +var x = cljs.core.first(arglist__5218); +arglist__5218 = cljs.core.next(arglist__5218); +var y = cljs.core.first(arglist__5218); +var more = cljs.core.rest(arglist__5218); +return G__5217__delegate(x,y,more); +}); +G__5217.cljs$core$IFn$_invoke$arity$variadic = G__5217__delegate; +return G__5217; +})() +; +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); +}); +/** +* If no denominators are supplied, returns 1/numerator, +* else returns numerator divided by all of the denominators. +* @param {...*} var_args +*/ +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__5219__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_divide_int,unchecked_divide_int.call(null,x,y),more); +}; +var G__5219 = 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__5219__delegate.call(this,x,y,more);}; +G__5219.cljs$lang$maxFixedArity = 2; +G__5219.cljs$lang$applyTo = (function (arglist__5220){ +var x = cljs.core.first(arglist__5220); +arglist__5220 = cljs.core.next(arglist__5220); +var y = cljs.core.first(arglist__5220); +var more = cljs.core.rest(arglist__5220); +return G__5219__delegate(x,y,more); +}); +G__5219.cljs$core$IFn$_invoke$arity$variadic = G__5219__delegate; +return G__5219; +})() +; +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); +}); +/** +* Returns the product of nums. (*) returns 1. +* @param {...*} var_args +*/ +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__5221__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_multiply,(x * y),more); +}; +var G__5221 = 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__5221__delegate.call(this,x,y,more);}; +G__5221.cljs$lang$maxFixedArity = 2; +G__5221.cljs$lang$applyTo = (function (arglist__5222){ +var x = cljs.core.first(arglist__5222); +arglist__5222 = cljs.core.next(arglist__5222); +var y = cljs.core.first(arglist__5222); +var more = cljs.core.rest(arglist__5222); +return G__5221__delegate(x,y,more); +}); +G__5221.cljs$core$IFn$_invoke$arity$variadic = G__5221__delegate; +return G__5221; +})() +; +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; +})() +; +/** +* Returns the product of nums. (*) returns 1. +* @param {...*} var_args +*/ +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__5223__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_multiply_int,(x * y),more); +}; +var G__5223 = 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__5223__delegate.call(this,x,y,more);}; +G__5223.cljs$lang$maxFixedArity = 2; +G__5223.cljs$lang$applyTo = (function (arglist__5224){ +var x = cljs.core.first(arglist__5224); +arglist__5224 = cljs.core.next(arglist__5224); +var y = cljs.core.first(arglist__5224); +var more = cljs.core.rest(arglist__5224); +return G__5223__delegate(x,y,more); +}); +G__5223.cljs$core$IFn$_invoke$arity$variadic = G__5223__delegate; +return G__5223; +})() +; +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); +}); +/** +* If no ys are supplied, returns the negation of x, else subtracts +* the ys from x and returns the result. +* @param {...*} var_args +*/ +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__5225__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_substract,(x - y),more); +}; +var G__5225 = 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__5225__delegate.call(this,x,y,more);}; +G__5225.cljs$lang$maxFixedArity = 2; +G__5225.cljs$lang$applyTo = (function (arglist__5226){ +var x = cljs.core.first(arglist__5226); +arglist__5226 = cljs.core.next(arglist__5226); +var y = cljs.core.first(arglist__5226); +var more = cljs.core.rest(arglist__5226); +return G__5225__delegate(x,y,more); +}); +G__5225.cljs$core$IFn$_invoke$arity$variadic = G__5225__delegate; +return G__5225; +})() +; +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; +})() +; +/** +* If no ys are supplied, returns the negation of x, else subtracts +* the ys from x and returns the result. +* @param {...*} var_args +*/ +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__5227__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_substract_int,(x - y),more); +}; +var G__5227 = 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__5227__delegate.call(this,x,y,more);}; +G__5227.cljs$lang$maxFixedArity = 2; +G__5227.cljs$lang$applyTo = (function (arglist__5228){ +var x = cljs.core.first(arglist__5228); +arglist__5228 = cljs.core.next(arglist__5228); +var y = cljs.core.first(arglist__5228); +var more = cljs.core.rest(arglist__5228); +return G__5227__delegate(x,y,more); +}); +G__5227.cljs$core$IFn$_invoke$arity$variadic = G__5227__delegate; +return G__5227; +})() +; +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); +} +}); +/** +* Coerce to int by stripping decimal places. +*/ +cljs.core.int$ = (function int$(x){return (x | 0); +}); +/** +* Coerce to int by stripping decimal places. +*/ +cljs.core.unchecked_int = (function unchecked_int(x){return cljs.core.fix.call(null,x); +}); +/** +* Coerce to long by stripping decimal places. Identical to `int'. +*/ +cljs.core.long$ = (function long$(x){return cljs.core.fix.call(null,x); +}); +/** +* Coerce to long by stripping decimal places. Identical to `int'. +*/ +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; +}); +/** +* Modulus of num and div with original javascript behavior. i.e. bug for negative numbers +*/ +cljs.core.js_mod = (function js_mod(n,d){return (n % d); +}); +/** +* Modulus of num and div. Truncates toward negative infinity. +*/ +cljs.core.mod = (function mod(n,d){return (((n % d) + d) % d); +}); +/** +* quot[ient] of dividing numerator by denominator. +*/ +cljs.core.quot = (function quot(n,d){var rem = (n % d);return cljs.core.fix.call(null,((n - rem) / d)); +}); +/** +* remainder of dividing numerator by denominator. +*/ +cljs.core.rem = (function rem(n,d){var q = cljs.core.quot.call(null,n,d);return (n - (d * q)); +}); +/** +* Returns a random floating point number between 0 (inclusive) and n (default 1) (exclusive). +*/ +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; +})() +; +/** +* Returns a random integer between 0 (inclusive) and n (exclusive). +*/ +cljs.core.rand_int = (function rand_int(n){return cljs.core.fix.call(null,cljs.core.rand.call(null,n)); +}); +/** +* Bitwise exclusive or +*/ +cljs.core.bit_xor = (function bit_xor(x,y){return (x ^ y); +}); +/** +* Bitwise and +*/ +cljs.core.bit_and = (function bit_and(x,y){return (x & y); +}); +/** +* Bitwise or +*/ +cljs.core.bit_or = (function bit_or(x,y){return (x | y); +}); +/** +* Bitwise and +*/ +cljs.core.bit_and_not = (function bit_and_not(x,y){return (x & ~y); +}); +/** +* Clear bit at index n +*/ +cljs.core.bit_clear = (function bit_clear(x,n){return (x & ~(1 << n)); +}); +/** +* Flip bit at index n +*/ +cljs.core.bit_flip = (function bit_flip(x,n){return (x ^ (1 << n)); +}); +/** +* Bitwise complement +*/ +cljs.core.bit_not = (function bit_not(x){return (~ x); +}); +/** +* Set bit at index n +*/ +cljs.core.bit_set = (function bit_set(x,n){return (x | (1 << n)); +}); +/** +* Test bit at index n +*/ +cljs.core.bit_test = (function bit_test(x,n){return ((x & (1 << n)) != 0); +}); +/** +* Bitwise shift left +*/ +cljs.core.bit_shift_left = (function bit_shift_left(x,n){return (x << n); +}); +/** +* Bitwise shift right +*/ +cljs.core.bit_shift_right = (function bit_shift_right(x,n){return (x >> n); +}); +/** +* DEPRECATED: Bitwise shift right with zero fill +*/ +cljs.core.bit_shift_right_zero_fill = (function bit_shift_right_zero_fill(x,n){return (x >>> n); +}); +/** +* Bitwise shift right with zero fill +*/ +cljs.core.unsigned_bit_shift_right = (function unsigned_bit_shift_right(x,n){return (x >>> n); +}); +/** +* Counts the number of bits set in 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); +}); +/** +* Returns non-nil if nums all have the equivalent +* value, otherwise false. Behavior on non nums is +* undefined. +* @param {...*} var_args +*/ +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__5229__delegate = function (x,y,more){while(true){ +if(_EQ__EQ_.call(null,x,y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__5230 = y; +var G__5231 = cljs.core.first.call(null,more); +var G__5232 = cljs.core.next.call(null,more); +x = G__5230; +y = G__5231; +more = G__5232; +continue; +} +} else +{return _EQ__EQ_.call(null,y,cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__5229 = 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__5229__delegate.call(this,x,y,more);}; +G__5229.cljs$lang$maxFixedArity = 2; +G__5229.cljs$lang$applyTo = (function (arglist__5233){ +var x = cljs.core.first(arglist__5233); +arglist__5233 = cljs.core.next(arglist__5233); +var y = cljs.core.first(arglist__5233); +var more = cljs.core.rest(arglist__5233); +return G__5229__delegate(x,y,more); +}); +G__5229.cljs$core$IFn$_invoke$arity$variadic = G__5229__delegate; +return G__5229; +})() +; +_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_; +})() +; +/** +* Returns true if num is greater than zero, else false +*/ +cljs.core.pos_QMARK_ = (function pos_QMARK_(n){return (n > 0); +}); +cljs.core.zero_QMARK_ = (function zero_QMARK_(n){return (n === 0); +}); +/** +* Returns true if num is less than zero, else false +*/ +cljs.core.neg_QMARK_ = (function neg_QMARK_(x){return (x < 0); +}); +/** +* Returns the nth next of coll, (seq coll) when n is 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__5234 = (n__$1 - 1); +var G__5235 = cljs.core.next.call(null,xs); +n__$1 = G__5234; +xs = G__5235; +continue; +} +} else +{return xs; +} +break; +} +}); +/** +* With no args, returns the empty string. With one arg x, returns +* x.toString(). (str nil) returns the empty string. With more than +* one arg, returns the concatenation of the str values of the args. +* @param {...*} var_args +*/ +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__5236__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__5237 = sb.append(str.call(null,cljs.core.first.call(null,more))); +var G__5238 = cljs.core.next.call(null,more); +sb = G__5237; +more = G__5238; +continue; +} +} else +{return sb.toString(); +} +break; +} +}; +var G__5236 = 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__5236__delegate.call(this,x,ys);}; +G__5236.cljs$lang$maxFixedArity = 1; +G__5236.cljs$lang$applyTo = (function (arglist__5239){ +var x = cljs.core.first(arglist__5239); +var ys = cljs.core.rest(arglist__5239); +return G__5236__delegate(x,ys); +}); +G__5236.cljs$core$IFn$_invoke$arity$variadic = G__5236__delegate; +return G__5236; +})() +; +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; +})() +; +/** +* Returns the substring of s beginning at start inclusive, and ending +* at end (defaults to length of string), exclusive. +*/ +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; +})() +; +/** +* Assumes x is sequential. Returns true if x equals y, otherwise +* returns false. +*/ +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__5240 = cljs.core.next.call(null,xs); +var G__5241 = cljs.core.next.call(null,ys); +xs = G__5240; +ys = G__5241; +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__5242 = cljs.core.hash_combine.call(null,res,cljs.core.hash.call(null,cljs.core.first.call(null,s))); +var G__5243 = cljs.core.next.call(null,s); +res = G__5242; +s = G__5243; +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__5244 = ((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__5245 = cljs.core.next.call(null,s); +h = G__5244; +s = G__5245; +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__5246 = ((h + cljs.core.hash.call(null,e)) % 4503599627370496); +var G__5247 = cljs.core.next.call(null,s__$1); +h = G__5246; +s__$1 = G__5247; +continue; +} +} else +{return h; +} +break; +} +}); +/** +* Takes a JavaScript object and a map of names to functions and +* attaches said functions as methods on the object. Any references to +* JavaScript's implict this (via the this-as macro) will resolve to the +* object that the function is attached. +*/ +cljs.core.extend_object_BANG_ = (function extend_object_BANG_(obj,fn_map){var seq__5254_5260 = cljs.core.seq.call(null,fn_map);var chunk__5255_5261 = null;var count__5256_5262 = 0;var i__5257_5263 = 0;while(true){ +if((i__5257_5263 < count__5256_5262)) +{var vec__5258_5264 = cljs.core._nth.call(null,chunk__5255_5261,i__5257_5263);var key_name_5265 = cljs.core.nth.call(null,vec__5258_5264,0,null);var f_5266 = cljs.core.nth.call(null,vec__5258_5264,1,null);var str_name_5267 = cljs.core.name.call(null,key_name_5265);(obj[str_name_5267] = f_5266); +{ +var G__5268 = seq__5254_5260; +var G__5269 = chunk__5255_5261; +var G__5270 = count__5256_5262; +var G__5271 = (i__5257_5263 + 1); +seq__5254_5260 = G__5268; +chunk__5255_5261 = G__5269; +count__5256_5262 = G__5270; +i__5257_5263 = G__5271; +continue; +} +} else +{var temp__4092__auto___5272 = cljs.core.seq.call(null,seq__5254_5260);if(temp__4092__auto___5272) +{var seq__5254_5273__$1 = temp__4092__auto___5272;if(cljs.core.chunked_seq_QMARK_.call(null,seq__5254_5273__$1)) +{var c__4288__auto___5274 = cljs.core.chunk_first.call(null,seq__5254_5273__$1);{ +var G__5275 = cljs.core.chunk_rest.call(null,seq__5254_5273__$1); +var G__5276 = c__4288__auto___5274; +var G__5277 = cljs.core.count.call(null,c__4288__auto___5274); +var G__5278 = 0; +seq__5254_5260 = G__5275; +chunk__5255_5261 = G__5276; +count__5256_5262 = G__5277; +i__5257_5263 = G__5278; +continue; +} +} else +{var vec__5259_5279 = cljs.core.first.call(null,seq__5254_5273__$1);var key_name_5280 = cljs.core.nth.call(null,vec__5259_5279,0,null);var f_5281 = cljs.core.nth.call(null,vec__5259_5279,1,null);var str_name_5282 = cljs.core.name.call(null,key_name_5280);(obj[str_name_5282] = f_5281); +{ +var G__5283 = cljs.core.next.call(null,seq__5254_5273__$1); +var G__5284 = null; +var G__5285 = 0; +var G__5286 = 0; +seq__5254_5260 = G__5283; +chunk__5255_5261 = G__5284; +count__5256_5262 = G__5285; +i__5257_5263 = G__5286; +continue; +} +} +} else +{} +} +break; +} +return obj; +}); + +/** +* @constructor +*/ +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$partition0$ = 65937646; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.List.cljs$lang$type = true; +cljs.core.List.cljs$lang$ctorStr = "cljs.core/List"; +cljs.core.List.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.List(self__.meta,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)); +}); + +/** +* @constructor +*/ +cljs.core.EmptyList = (function (meta){ +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 65937614; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.EmptyList.cljs$lang$type = true; +cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList"; +cljs.core.EmptyList.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.EmptyList(self__.meta)); +}); +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__5288 = coll;if(G__5288) +{var bit__4190__auto__ = (G__5288.cljs$lang$protocol_mask$partition0$ & 134217728);if((bit__4190__auto__) || (G__5288.cljs$core$IReversible$)) +{return true; +} else +{if((!G__5288.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReversible,G__5288); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReversible,G__5288); +} +}); +cljs.core.rseq = (function rseq(coll){return cljs.core._rseq.call(null,coll); +}); +/** +* Returns a seq of the items in coll in reverse order. Not lazy. +*/ +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); +} +}); +/** +* @param {...*} var_args +*/ +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__5289 = cljs.core._next.call(null,xs__$1); +xs__$1 = G__5289; +continue; +} +} else +{return arr; +} +break; +} +})());var i = arr.length;var r = cljs.core.List.EMPTY;while(true){ +if((i > 0)) +{{ +var G__5290 = (i - 1); +var G__5291 = cljs.core._conj.call(null,r,(arr[(i - 1)])); +i = G__5290; +r = G__5291; +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__5292){ +var xs = cljs.core.seq(arglist__5292); +return list__delegate(xs); +}); +list.cljs$core$IFn$_invoke$arity$variadic = list__delegate; +return list; +})() +; + +/** +* @constructor +*/ +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$partition0$ = 65929452; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.Cons.cljs$lang$type = true; +cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons"; +cljs.core.Cons.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.Cons(self__.meta,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)); +}); +/** +* Returns a new seq where x is the first element and seq is the rest. +*/ +cljs.core.cons = (function cons(x,coll){if((function (){var or__3540__auto__ = (coll == null);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var G__5296 = coll;if(G__5296) +{var bit__4183__auto__ = (G__5296.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4183__auto__) || (G__5296.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__5298 = x;if(G__5298) +{var bit__4190__auto__ = (G__5298.cljs$lang$protocol_mask$partition0$ & 33554432);if((bit__4190__auto__) || (G__5298.cljs$core$IList$)) +{return true; +} else +{if((!G__5298.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IList,G__5298); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IList,G__5298); +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5300 = null; +var G__5300__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__5300__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__5300 = function(self__,coll,not_found){ +switch(arguments.length){ +case 2: +return G__5300__2.call(this,self__,coll); +case 3: +return G__5300__3.call(this,self__,coll,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5300; +})() +; +cljs.core.Keyword.prototype.apply = (function (self__,args5299){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5299))); +}); +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; +} +} +}); +/** +* Returns the namespace String of a symbol or keyword, or nil if not present. +*/ +cljs.core.namespace = (function namespace(x){if((function (){var G__5302 = x;if(G__5302) +{var bit__4183__auto__ = (G__5302.cljs$lang$protocol_mask$partition1$ & 4096);if((bit__4183__auto__) || (G__5302.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(''))); +} +}); +/** +* Returns a Keyword with the given namespace and name. Do not use : +* in the keyword strings, it will be added automatically. +*/ +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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5303 = ls.sval(); +ls = G__5303; +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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5305 = s;if(G__5305) +{var bit__4183__auto__ = (G__5305.cljs$lang$protocol_mask$partition1$ & 1024);if((bit__4183__auto__) || (G__5305.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)); +} +}); +/** +* Naive impl of to-array as a start. +*/ +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__5306 = cljs.core.next.call(null,s__$1); +s__$1 = G__5306; +continue; +} +} else +{return ary; +} +break; +} +}); +/** +* Returns a (potentially-ragged) 2-dimensional array +* containing the contents of coll. +*/ +cljs.core.to_array_2d = (function to_array_2d(coll){var ret = (new Array(cljs.core.count.call(null,coll)));var i_5307 = 0;var xs_5308 = cljs.core.seq.call(null,coll);while(true){ +if(xs_5308) +{(ret[i_5307] = cljs.core.to_array.call(null,cljs.core.first.call(null,xs_5308))); +{ +var G__5309 = (i_5307 + 1); +var G__5310 = cljs.core.next.call(null,xs_5308); +i_5307 = G__5309; +xs_5308 = G__5310; +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__5311 = (i + 1); +var G__5312 = cljs.core.next.call(null,s__$1); +i = G__5311; +s__$1 = G__5312; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___5313 = size;var i_5314 = 0;while(true){ +if((i_5314 < n__4388__auto___5313)) +{(a[i_5314] = init_val_or_seq); +{ +var G__5315 = (i_5314 + 1); +i_5314 = G__5315; +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__5316 = (i + 1); +var G__5317 = cljs.core.next.call(null,s__$1); +i = G__5316; +s__$1 = G__5317; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___5318 = size;var i_5319 = 0;while(true){ +if((i_5319 < n__4388__auto___5318)) +{(a[i_5319] = init_val_or_seq); +{ +var G__5320 = (i_5319 + 1); +i_5319 = G__5320; +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__5321 = (i + 1); +var G__5322 = cljs.core.next.call(null,s__$1); +i = G__5321; +s__$1 = G__5322; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___5323 = size;var i_5324 = 0;while(true){ +if((i_5324 < n__4388__auto___5323)) +{(a[i_5324] = init_val_or_seq); +{ +var G__5325 = (i_5324 + 1); +i_5324 = G__5325; +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__5326 = (i + 1); +var G__5327 = cljs.core.next.call(null,s__$1); +i = G__5326; +s__$1 = G__5327; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___5328 = size;var i_5329 = 0;while(true){ +if((i_5329 < n__4388__auto___5328)) +{(a[i_5329] = init_val_or_seq); +{ +var G__5330 = (i_5329 + 1); +i_5329 = G__5330; +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__5331 = cljs.core.next.call(null,s__$1); +var G__5332 = (i - 1); +var G__5333 = (sum + 1); +s__$1 = G__5331; +i = G__5332; +sum = G__5333; +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; +} +} +} +}); +/** +* Returns a lazy seq representing the concatenation of the elements in the supplied colls. +* @param {...*} var_args +*/ +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__5334__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__5334 = 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__5334__delegate.call(this,x,y,zs);}; +G__5334.cljs$lang$maxFixedArity = 2; +G__5334.cljs$lang$applyTo = (function (arglist__5335){ +var x = cljs.core.first(arglist__5335); +arglist__5335 = cljs.core.next(arglist__5335); +var y = cljs.core.first(arglist__5335); +var zs = cljs.core.rest(arglist__5335); +return G__5334__delegate(x,y,zs); +}); +G__5334.cljs$core$IFn$_invoke$arity$variadic = G__5334__delegate; +return G__5334; +})() +; +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; +})() +; +/** +* Creates a new list containing the items prepended to the rest, the +* last of which will be treated as a sequence. +* @param {...*} var_args +*/ +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__5336__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__5336 = 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__5336__delegate.call(this,a,b,c,d,more);}; +G__5336.cljs$lang$maxFixedArity = 4; +G__5336.cljs$lang$applyTo = (function (arglist__5337){ +var a = cljs.core.first(arglist__5337); +arglist__5337 = cljs.core.next(arglist__5337); +var b = cljs.core.first(arglist__5337); +arglist__5337 = cljs.core.next(arglist__5337); +var c = cljs.core.first(arglist__5337); +arglist__5337 = cljs.core.next(arglist__5337); +var d = cljs.core.first(arglist__5337); +var more = cljs.core.rest(arglist__5337); +return G__5336__delegate(a,b,c,d,more); +}); +G__5336.cljs$core$IFn$_invoke$arity$variadic = G__5336__delegate; +return G__5336; +})() +; +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_; +})() +; +/** +* Returns a new, transient version of the collection, in constant time. +*/ +cljs.core.transient$ = (function transient$(coll){return cljs.core._as_transient.call(null,coll); +}); +/** +* Returns a new, persistent version of the transient collection, in +* constant time. The transient collection cannot be used after this +* call, any such use will throw an exception. +*/ +cljs.core.persistent_BANG_ = (function persistent_BANG_(tcoll){return cljs.core._persistent_BANG_.call(null,tcoll); +}); +/** +* Adds x to the transient collection, and return coll. The 'addition' +* may happen at different 'places' depending on the concrete type. +* @param {...*} var_args +*/ +cljs.core.conj_BANG_ = (function() { +var conj_BANG_ = null; +var conj_BANG___2 = (function (tcoll,val){return cljs.core._conj_BANG_.call(null,tcoll,val); +}); +var conj_BANG___3 = (function() { +var G__5338__delegate = function (tcoll,val,vals){while(true){ +var ntcoll = cljs.core._conj_BANG_.call(null,tcoll,val);if(cljs.core.truth_(vals)) +{{ +var G__5339 = ntcoll; +var G__5340 = cljs.core.first.call(null,vals); +var G__5341 = cljs.core.next.call(null,vals); +tcoll = G__5339; +val = G__5340; +vals = G__5341; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__5338 = function (tcoll,val,var_args){ +var vals = null;if (arguments.length > 2) { + vals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2),0);} +return G__5338__delegate.call(this,tcoll,val,vals);}; +G__5338.cljs$lang$maxFixedArity = 2; +G__5338.cljs$lang$applyTo = (function (arglist__5342){ +var tcoll = cljs.core.first(arglist__5342); +arglist__5342 = cljs.core.next(arglist__5342); +var val = cljs.core.first(arglist__5342); +var vals = cljs.core.rest(arglist__5342); +return G__5338__delegate(tcoll,val,vals); +}); +G__5338.cljs$core$IFn$_invoke$arity$variadic = G__5338__delegate; +return G__5338; +})() +; +conj_BANG_ = function(tcoll,val,var_args){ +var vals = var_args; +switch(arguments.length){ +case 2: +return conj_BANG___2.call(this,tcoll,val); +default: +return conj_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll,val, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +conj_BANG_.cljs$lang$maxFixedArity = 2; +conj_BANG_.cljs$lang$applyTo = conj_BANG___3.cljs$lang$applyTo; +conj_BANG_.cljs$core$IFn$_invoke$arity$2 = conj_BANG___2; +conj_BANG_.cljs$core$IFn$_invoke$arity$variadic = conj_BANG___3.cljs$core$IFn$_invoke$arity$variadic; +return conj_BANG_; +})() +; +/** +* When applied to a transient map, adds mapping of key(s) to +* val(s). When applied to a transient vector, sets the val at index. +* Note - index must be <= (count vector). Returns coll. +* @param {...*} var_args +*/ +cljs.core.assoc_BANG_ = (function() { +var assoc_BANG_ = null; +var assoc_BANG___3 = (function (tcoll,key,val){return cljs.core._assoc_BANG_.call(null,tcoll,key,val); +}); +var assoc_BANG___4 = (function() { +var G__5343__delegate = function (tcoll,key,val,kvs){while(true){ +var ntcoll = cljs.core._assoc_BANG_.call(null,tcoll,key,val);if(cljs.core.truth_(kvs)) +{{ +var G__5344 = ntcoll; +var G__5345 = cljs.core.first.call(null,kvs); +var G__5346 = cljs.core.second.call(null,kvs); +var G__5347 = cljs.core.nnext.call(null,kvs); +tcoll = G__5344; +key = G__5345; +val = G__5346; +kvs = G__5347; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__5343 = function (tcoll,key,val,var_args){ +var kvs = null;if (arguments.length > 3) { + kvs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3),0);} +return G__5343__delegate.call(this,tcoll,key,val,kvs);}; +G__5343.cljs$lang$maxFixedArity = 3; +G__5343.cljs$lang$applyTo = (function (arglist__5348){ +var tcoll = cljs.core.first(arglist__5348); +arglist__5348 = cljs.core.next(arglist__5348); +var key = cljs.core.first(arglist__5348); +arglist__5348 = cljs.core.next(arglist__5348); +var val = cljs.core.first(arglist__5348); +var kvs = cljs.core.rest(arglist__5348); +return G__5343__delegate(tcoll,key,val,kvs); +}); +G__5343.cljs$core$IFn$_invoke$arity$variadic = G__5343__delegate; +return G__5343; +})() +; +assoc_BANG_ = function(tcoll,key,val,var_args){ +var kvs = var_args; +switch(arguments.length){ +case 3: +return assoc_BANG___3.call(this,tcoll,key,val); +default: +return assoc_BANG___4.cljs$core$IFn$_invoke$arity$variadic(tcoll,key,val, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +assoc_BANG_.cljs$lang$maxFixedArity = 3; +assoc_BANG_.cljs$lang$applyTo = assoc_BANG___4.cljs$lang$applyTo; +assoc_BANG_.cljs$core$IFn$_invoke$arity$3 = assoc_BANG___3; +assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = assoc_BANG___4.cljs$core$IFn$_invoke$arity$variadic; +return assoc_BANG_; +})() +; +/** +* Returns a transient map that doesn't contain a mapping for key(s). +* @param {...*} var_args +*/ +cljs.core.dissoc_BANG_ = (function() { +var dissoc_BANG_ = null; +var dissoc_BANG___2 = (function (tcoll,key){return cljs.core._dissoc_BANG_.call(null,tcoll,key); +}); +var dissoc_BANG___3 = (function() { +var G__5349__delegate = function (tcoll,key,ks){while(true){ +var ntcoll = cljs.core._dissoc_BANG_.call(null,tcoll,key);if(cljs.core.truth_(ks)) +{{ +var G__5350 = ntcoll; +var G__5351 = cljs.core.first.call(null,ks); +var G__5352 = cljs.core.next.call(null,ks); +tcoll = G__5350; +key = G__5351; +ks = G__5352; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__5349 = function (tcoll,key,var_args){ +var ks = null;if (arguments.length > 2) { + ks = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2),0);} +return G__5349__delegate.call(this,tcoll,key,ks);}; +G__5349.cljs$lang$maxFixedArity = 2; +G__5349.cljs$lang$applyTo = (function (arglist__5353){ +var tcoll = cljs.core.first(arglist__5353); +arglist__5353 = cljs.core.next(arglist__5353); +var key = cljs.core.first(arglist__5353); +var ks = cljs.core.rest(arglist__5353); +return G__5349__delegate(tcoll,key,ks); +}); +G__5349.cljs$core$IFn$_invoke$arity$variadic = G__5349__delegate; +return G__5349; +})() +; +dissoc_BANG_ = function(tcoll,key,var_args){ +var ks = var_args; +switch(arguments.length){ +case 2: +return dissoc_BANG___2.call(this,tcoll,key); +default: +return dissoc_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll,key, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +dissoc_BANG_.cljs$lang$maxFixedArity = 2; +dissoc_BANG_.cljs$lang$applyTo = dissoc_BANG___3.cljs$lang$applyTo; +dissoc_BANG_.cljs$core$IFn$_invoke$arity$2 = dissoc_BANG___2; +dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = dissoc_BANG___3.cljs$core$IFn$_invoke$arity$variadic; +return dissoc_BANG_; +})() +; +/** +* Removes the last item from a transient vector. If +* the collection is empty, throws an exception. Returns coll +*/ +cljs.core.pop_BANG_ = (function pop_BANG_(tcoll){return cljs.core._pop_BANG_.call(null,tcoll); +}); +/** +* disj[oin]. Returns a transient set of the same (hashed/sorted) type, that +* does not contain key(s). +* @param {...*} var_args +*/ +cljs.core.disj_BANG_ = (function() { +var disj_BANG_ = null; +var disj_BANG___2 = (function (tcoll,val){return cljs.core._disjoin_BANG_.call(null,tcoll,val); +}); +var disj_BANG___3 = (function() { +var G__5354__delegate = function (tcoll,val,vals){while(true){ +var ntcoll = cljs.core._disjoin_BANG_.call(null,tcoll,val);if(cljs.core.truth_(vals)) +{{ +var G__5355 = ntcoll; +var G__5356 = cljs.core.first.call(null,vals); +var G__5357 = cljs.core.next.call(null,vals); +tcoll = G__5355; +val = G__5356; +vals = G__5357; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__5354 = function (tcoll,val,var_args){ +var vals = null;if (arguments.length > 2) { + vals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2),0);} +return G__5354__delegate.call(this,tcoll,val,vals);}; +G__5354.cljs$lang$maxFixedArity = 2; +G__5354.cljs$lang$applyTo = (function (arglist__5358){ +var tcoll = cljs.core.first(arglist__5358); +arglist__5358 = cljs.core.next(arglist__5358); +var val = cljs.core.first(arglist__5358); +var vals = cljs.core.rest(arglist__5358); +return G__5354__delegate(tcoll,val,vals); +}); +G__5354.cljs$core$IFn$_invoke$arity$variadic = G__5354__delegate; +return G__5354; +})() +; +disj_BANG_ = function(tcoll,val,var_args){ +var vals = var_args; +switch(arguments.length){ +case 2: +return disj_BANG___2.call(this,tcoll,val); +default: +return disj_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll,val, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +disj_BANG_.cljs$lang$maxFixedArity = 2; +disj_BANG_.cljs$lang$applyTo = disj_BANG___3.cljs$lang$applyTo; +disj_BANG_.cljs$core$IFn$_invoke$arity$2 = disj_BANG___2; +disj_BANG_.cljs$core$IFn$_invoke$arity$variadic = disj_BANG___3.cljs$core$IFn$_invoke$arity$variadic; +return disj_BANG_; +})() +; +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")); +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +}); +/** +* Applies fn f to the argument list formed by prepending intervening arguments to args. +* First cut. Not lazy. Needs to use emitted toApply. +* @param {...*} var_args +*/ +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__5359__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__5359 = 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__5359__delegate.call(this,f,a,b,c,d,args);}; +G__5359.cljs$lang$maxFixedArity = 5; +G__5359.cljs$lang$applyTo = (function (arglist__5360){ +var f = cljs.core.first(arglist__5360); +arglist__5360 = cljs.core.next(arglist__5360); +var a = cljs.core.first(arglist__5360); +arglist__5360 = cljs.core.next(arglist__5360); +var b = cljs.core.first(arglist__5360); +arglist__5360 = cljs.core.next(arglist__5360); +var c = cljs.core.first(arglist__5360); +arglist__5360 = cljs.core.next(arglist__5360); +var d = cljs.core.first(arglist__5360); +var args = cljs.core.rest(arglist__5360); +return G__5359__delegate(f,a,b,c,d,args); +}); +G__5359.cljs$core$IFn$_invoke$arity$variadic = G__5359__delegate; +return G__5359; +})() +; +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; +})() +; +/** +* Returns an object of the same type and value as obj, with +* (apply f (meta obj) args) as its metadata. +* @param {...*} var_args +*/ +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__5361__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__5361 = 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__5361__delegate.call(this,obj,f,a,b,c,d,args);}; +G__5361.cljs$lang$maxFixedArity = 6; +G__5361.cljs$lang$applyTo = (function (arglist__5362){ +var obj = cljs.core.first(arglist__5362); +arglist__5362 = cljs.core.next(arglist__5362); +var f = cljs.core.first(arglist__5362); +arglist__5362 = cljs.core.next(arglist__5362); +var a = cljs.core.first(arglist__5362); +arglist__5362 = cljs.core.next(arglist__5362); +var b = cljs.core.first(arglist__5362); +arglist__5362 = cljs.core.next(arglist__5362); +var c = cljs.core.first(arglist__5362); +arglist__5362 = cljs.core.next(arglist__5362); +var d = cljs.core.first(arglist__5362); +var args = cljs.core.rest(arglist__5362); +return G__5361__delegate(obj,f,a,b,c,d,args); +}); +G__5361.cljs$core$IFn$_invoke$arity$variadic = G__5361__delegate; +return G__5361; +})() +; +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; +})() +; +/** +* Same as (not (= obj1 obj2)) +* @param {...*} var_args +*/ +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__5363__delegate = function (x,y,more){return cljs.core.not.call(null,cljs.core.apply.call(null,cljs.core._EQ_,x,y,more)); +}; +var G__5363 = 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__5363__delegate.call(this,x,y,more);}; +G__5363.cljs$lang$maxFixedArity = 2; +G__5363.cljs$lang$applyTo = (function (arglist__5364){ +var x = cljs.core.first(arglist__5364); +arglist__5364 = cljs.core.next(arglist__5364); +var y = cljs.core.first(arglist__5364); +var more = cljs.core.rest(arglist__5364); +return G__5363__delegate(x,y,more); +}); +G__5363.cljs$core$IFn$_invoke$arity$variadic = G__5363__delegate; +return G__5363; +})() +; +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_; +})() +; +/** +* If coll is empty, returns nil, else coll +*/ +cljs.core.not_empty = (function not_empty(coll){if(cljs.core.seq.call(null,coll)) +{return coll; +} else +{return null; +} +}); +/** +* Returns true if (pred x) is logical true for every x in coll, else +* false. +*/ +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__5365 = pred; +var G__5366 = cljs.core.next.call(null,coll); +pred = G__5365; +coll = G__5366; +continue; +} +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{return false; +} else +{return null; +} +} +} +break; +} +}); +/** +* Returns false if (pred x) is logical true for every x in +* coll, else true. +*/ +cljs.core.not_every_QMARK_ = (function not_every_QMARK_(pred,coll){return !(cljs.core.every_QMARK_.call(null,pred,coll)); +}); +/** +* Returns the first logical true value of (pred x) for any x in coll, +* else nil. One common idiom is to use a set as pred, for example +* this will return :fred if :fred is in the sequence, otherwise nil: +* (some #{:fred} coll) +*/ +cljs.core.some = (function some(pred,coll){while(true){ +if(cljs.core.seq.call(null,coll)) +{var or__3540__auto__ = pred.call(null,cljs.core.first.call(null,coll));if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{{ +var G__5367 = pred; +var G__5368 = cljs.core.next.call(null,coll); +pred = G__5367; +coll = G__5368; +continue; +} +} +} else +{return null; +} +break; +} +}); +/** +* Returns false if (pred x) is logical true for any x in coll, +* else true. +*/ +cljs.core.not_any_QMARK_ = (function not_any_QMARK_(pred,coll){return cljs.core.not.call(null,cljs.core.some.call(null,pred,coll)); +}); +/** +* Returns true if n is even, throws an exception if n is not an integer +*/ +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(''))); +} +}); +/** +* Returns true if n is odd, throws an exception if n is not an integer +*/ +cljs.core.odd_QMARK_ = (function odd_QMARK_(n){return !(cljs.core.even_QMARK_.call(null,n)); +}); +cljs.core.identity = (function identity(x){return x; +}); +/** +* Takes a fn f and returns a fn that takes the same arguments as f, +* has the same effects, if any, and returns the opposite truth value. +*/ +cljs.core.complement = (function complement(f){return (function() { +var G__5369 = null; +var G__5369__0 = (function (){return cljs.core.not.call(null,f.call(null)); +}); +var G__5369__1 = (function (x){return cljs.core.not.call(null,f.call(null,x)); +}); +var G__5369__2 = (function (x,y){return cljs.core.not.call(null,f.call(null,x,y)); +}); +var G__5369__3 = (function() { +var G__5370__delegate = function (x,y,zs){return cljs.core.not.call(null,cljs.core.apply.call(null,f,x,y,zs)); +}; +var G__5370 = 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__5370__delegate.call(this,x,y,zs);}; +G__5370.cljs$lang$maxFixedArity = 2; +G__5370.cljs$lang$applyTo = (function (arglist__5371){ +var x = cljs.core.first(arglist__5371); +arglist__5371 = cljs.core.next(arglist__5371); +var y = cljs.core.first(arglist__5371); +var zs = cljs.core.rest(arglist__5371); +return G__5370__delegate(x,y,zs); +}); +G__5370.cljs$core$IFn$_invoke$arity$variadic = G__5370__delegate; +return G__5370; +})() +; +G__5369 = function(x,y,var_args){ +var zs = var_args; +switch(arguments.length){ +case 0: +return G__5369__0.call(this); +case 1: +return G__5369__1.call(this,x); +case 2: +return G__5369__2.call(this,x,y); +default: +return G__5369__3.cljs$core$IFn$_invoke$arity$variadic(x,y, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5369.cljs$lang$maxFixedArity = 2; +G__5369.cljs$lang$applyTo = G__5369__3.cljs$lang$applyTo; +return G__5369; +})() +}); +/** +* Returns a function that takes any number of arguments and returns x. +*/ +cljs.core.constantly = (function constantly(x){return (function() { +var G__5372__delegate = function (args){return x; +}; +var G__5372 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5372__delegate.call(this,args);}; +G__5372.cljs$lang$maxFixedArity = 0; +G__5372.cljs$lang$applyTo = (function (arglist__5373){ +var args = cljs.core.seq(arglist__5373); +return G__5372__delegate(args); +}); +G__5372.cljs$core$IFn$_invoke$arity$variadic = G__5372__delegate; +return G__5372; +})() +; +}); +/** +* Takes a set of functions and returns a fn that is the composition +* of those fns. The returned fn takes a variable number of args, +* applies the rightmost of fns to the args, the next +* fn (right-to-left) to the result, etc. +* @param {...*} var_args +*/ +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__5374 = null; +var G__5374__0 = (function (){return f.call(null,g.call(null)); +}); +var G__5374__1 = (function (x){return f.call(null,g.call(null,x)); +}); +var G__5374__2 = (function (x,y){return f.call(null,g.call(null,x,y)); +}); +var G__5374__3 = (function (x,y,z){return f.call(null,g.call(null,x,y,z)); +}); +var G__5374__4 = (function() { +var G__5375__delegate = function (x,y,z,args){return f.call(null,cljs.core.apply.call(null,g,x,y,z,args)); +}; +var G__5375 = 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__5375__delegate.call(this,x,y,z,args);}; +G__5375.cljs$lang$maxFixedArity = 3; +G__5375.cljs$lang$applyTo = (function (arglist__5376){ +var x = cljs.core.first(arglist__5376); +arglist__5376 = cljs.core.next(arglist__5376); +var y = cljs.core.first(arglist__5376); +arglist__5376 = cljs.core.next(arglist__5376); +var z = cljs.core.first(arglist__5376); +var args = cljs.core.rest(arglist__5376); +return G__5375__delegate(x,y,z,args); +}); +G__5375.cljs$core$IFn$_invoke$arity$variadic = G__5375__delegate; +return G__5375; +})() +; +G__5374 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__5374__0.call(this); +case 1: +return G__5374__1.call(this,x); +case 2: +return G__5374__2.call(this,x,y); +case 3: +return G__5374__3.call(this,x,y,z); +default: +return G__5374__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5374.cljs$lang$maxFixedArity = 3; +G__5374.cljs$lang$applyTo = G__5374__4.cljs$lang$applyTo; +return G__5374; +})() +}); +var comp__3 = (function (f,g,h){return (function() { +var G__5377 = null; +var G__5377__0 = (function (){return f.call(null,g.call(null,h.call(null))); +}); +var G__5377__1 = (function (x){return f.call(null,g.call(null,h.call(null,x))); +}); +var G__5377__2 = (function (x,y){return f.call(null,g.call(null,h.call(null,x,y))); +}); +var G__5377__3 = (function (x,y,z){return f.call(null,g.call(null,h.call(null,x,y,z))); +}); +var G__5377__4 = (function() { +var G__5378__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__5378 = 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__5378__delegate.call(this,x,y,z,args);}; +G__5378.cljs$lang$maxFixedArity = 3; +G__5378.cljs$lang$applyTo = (function (arglist__5379){ +var x = cljs.core.first(arglist__5379); +arglist__5379 = cljs.core.next(arglist__5379); +var y = cljs.core.first(arglist__5379); +arglist__5379 = cljs.core.next(arglist__5379); +var z = cljs.core.first(arglist__5379); +var args = cljs.core.rest(arglist__5379); +return G__5378__delegate(x,y,z,args); +}); +G__5378.cljs$core$IFn$_invoke$arity$variadic = G__5378__delegate; +return G__5378; +})() +; +G__5377 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__5377__0.call(this); +case 1: +return G__5377__1.call(this,x); +case 2: +return G__5377__2.call(this,x,y); +case 3: +return G__5377__3.call(this,x,y,z); +default: +return G__5377__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5377.cljs$lang$maxFixedArity = 3; +G__5377.cljs$lang$applyTo = G__5377__4.cljs$lang$applyTo; +return G__5377; +})() +}); +var comp__4 = (function() { +var G__5380__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__5381__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__5382 = cljs.core.first.call(null,fs__$2).call(null,ret); +var G__5383 = cljs.core.next.call(null,fs__$2); +ret = G__5382; +fs__$2 = G__5383; +continue; +} +} else +{return ret; +} +break; +} +}; +var G__5381 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5381__delegate.call(this,args);}; +G__5381.cljs$lang$maxFixedArity = 0; +G__5381.cljs$lang$applyTo = (function (arglist__5384){ +var args = cljs.core.seq(arglist__5384); +return G__5381__delegate(args); +}); +G__5381.cljs$core$IFn$_invoke$arity$variadic = G__5381__delegate; +return G__5381; +})() +; +}; +var G__5380 = 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__5380__delegate.call(this,f1,f2,f3,fs);}; +G__5380.cljs$lang$maxFixedArity = 3; +G__5380.cljs$lang$applyTo = (function (arglist__5385){ +var f1 = cljs.core.first(arglist__5385); +arglist__5385 = cljs.core.next(arglist__5385); +var f2 = cljs.core.first(arglist__5385); +arglist__5385 = cljs.core.next(arglist__5385); +var f3 = cljs.core.first(arglist__5385); +var fs = cljs.core.rest(arglist__5385); +return G__5380__delegate(f1,f2,f3,fs); +}); +G__5380.cljs$core$IFn$_invoke$arity$variadic = G__5380__delegate; +return G__5380; +})() +; +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; +})() +; +/** +* Takes a function f and fewer than the normal arguments to f, and +* returns a fn that takes a variable number of additional args. When +* called, the returned function calls f with args + additional args. +* @param {...*} var_args +*/ +cljs.core.partial = (function() { +var partial = null; +var partial__1 = (function (f){return f; +}); +var partial__2 = (function (f,arg1){return (function() { +var G__5386__delegate = function (args){return cljs.core.apply.call(null,f,arg1,args); +}; +var G__5386 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5386__delegate.call(this,args);}; +G__5386.cljs$lang$maxFixedArity = 0; +G__5386.cljs$lang$applyTo = (function (arglist__5387){ +var args = cljs.core.seq(arglist__5387); +return G__5386__delegate(args); +}); +G__5386.cljs$core$IFn$_invoke$arity$variadic = G__5386__delegate; +return G__5386; +})() +; +}); +var partial__3 = (function (f,arg1,arg2){return (function() { +var G__5388__delegate = function (args){return cljs.core.apply.call(null,f,arg1,arg2,args); +}; +var G__5388 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5388__delegate.call(this,args);}; +G__5388.cljs$lang$maxFixedArity = 0; +G__5388.cljs$lang$applyTo = (function (arglist__5389){ +var args = cljs.core.seq(arglist__5389); +return G__5388__delegate(args); +}); +G__5388.cljs$core$IFn$_invoke$arity$variadic = G__5388__delegate; +return G__5388; +})() +; +}); +var partial__4 = (function (f,arg1,arg2,arg3){return (function() { +var G__5390__delegate = function (args){return cljs.core.apply.call(null,f,arg1,arg2,arg3,args); +}; +var G__5390 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5390__delegate.call(this,args);}; +G__5390.cljs$lang$maxFixedArity = 0; +G__5390.cljs$lang$applyTo = (function (arglist__5391){ +var args = cljs.core.seq(arglist__5391); +return G__5390__delegate(args); +}); +G__5390.cljs$core$IFn$_invoke$arity$variadic = G__5390__delegate; +return G__5390; +})() +; +}); +var partial__5 = (function() { +var G__5392__delegate = function (f,arg1,arg2,arg3,more){return (function() { +var G__5393__delegate = function (args){return cljs.core.apply.call(null,f,arg1,arg2,arg3,cljs.core.concat.call(null,more,args)); +}; +var G__5393 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5393__delegate.call(this,args);}; +G__5393.cljs$lang$maxFixedArity = 0; +G__5393.cljs$lang$applyTo = (function (arglist__5394){ +var args = cljs.core.seq(arglist__5394); +return G__5393__delegate(args); +}); +G__5393.cljs$core$IFn$_invoke$arity$variadic = G__5393__delegate; +return G__5393; +})() +; +}; +var G__5392 = 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__5392__delegate.call(this,f,arg1,arg2,arg3,more);}; +G__5392.cljs$lang$maxFixedArity = 4; +G__5392.cljs$lang$applyTo = (function (arglist__5395){ +var f = cljs.core.first(arglist__5395); +arglist__5395 = cljs.core.next(arglist__5395); +var arg1 = cljs.core.first(arglist__5395); +arglist__5395 = cljs.core.next(arglist__5395); +var arg2 = cljs.core.first(arglist__5395); +arglist__5395 = cljs.core.next(arglist__5395); +var arg3 = cljs.core.first(arglist__5395); +var more = cljs.core.rest(arglist__5395); +return G__5392__delegate(f,arg1,arg2,arg3,more); +}); +G__5392.cljs$core$IFn$_invoke$arity$variadic = G__5392__delegate; +return G__5392; +})() +; +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; +})() +; +/** +* Takes a function f, and returns a function that calls f, replacing +* a nil first argument to f with the supplied value x. Higher arity +* versions can replace arguments in the second and third +* positions (y, z). Note that the function f can take any number of +* arguments, not just the one(s) being nil-patched. +*/ +cljs.core.fnil = (function() { +var fnil = null; +var fnil__2 = (function (f,x){return (function() { +var G__5396 = null; +var G__5396__1 = (function (a){return f.call(null,(((a == null))?x:a)); +}); +var G__5396__2 = (function (a,b){return f.call(null,(((a == null))?x:a),b); +}); +var G__5396__3 = (function (a,b,c){return f.call(null,(((a == null))?x:a),b,c); +}); +var G__5396__4 = (function() { +var G__5397__delegate = function (a,b,c,ds){return cljs.core.apply.call(null,f,(((a == null))?x:a),b,c,ds); +}; +var G__5397 = 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__5397__delegate.call(this,a,b,c,ds);}; +G__5397.cljs$lang$maxFixedArity = 3; +G__5397.cljs$lang$applyTo = (function (arglist__5398){ +var a = cljs.core.first(arglist__5398); +arglist__5398 = cljs.core.next(arglist__5398); +var b = cljs.core.first(arglist__5398); +arglist__5398 = cljs.core.next(arglist__5398); +var c = cljs.core.first(arglist__5398); +var ds = cljs.core.rest(arglist__5398); +return G__5397__delegate(a,b,c,ds); +}); +G__5397.cljs$core$IFn$_invoke$arity$variadic = G__5397__delegate; +return G__5397; +})() +; +G__5396 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 1: +return G__5396__1.call(this,a); +case 2: +return G__5396__2.call(this,a,b); +case 3: +return G__5396__3.call(this,a,b,c); +default: +return G__5396__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5396.cljs$lang$maxFixedArity = 3; +G__5396.cljs$lang$applyTo = G__5396__4.cljs$lang$applyTo; +return G__5396; +})() +}); +var fnil__3 = (function (f,x,y){return (function() { +var G__5399 = null; +var G__5399__2 = (function (a,b){return f.call(null,(((a == null))?x:a),(((b == null))?y:b)); +}); +var G__5399__3 = (function (a,b,c){return f.call(null,(((a == null))?x:a),(((b == null))?y:b),c); +}); +var G__5399__4 = (function() { +var G__5400__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__5400 = 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__5400__delegate.call(this,a,b,c,ds);}; +G__5400.cljs$lang$maxFixedArity = 3; +G__5400.cljs$lang$applyTo = (function (arglist__5401){ +var a = cljs.core.first(arglist__5401); +arglist__5401 = cljs.core.next(arglist__5401); +var b = cljs.core.first(arglist__5401); +arglist__5401 = cljs.core.next(arglist__5401); +var c = cljs.core.first(arglist__5401); +var ds = cljs.core.rest(arglist__5401); +return G__5400__delegate(a,b,c,ds); +}); +G__5400.cljs$core$IFn$_invoke$arity$variadic = G__5400__delegate; +return G__5400; +})() +; +G__5399 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 2: +return G__5399__2.call(this,a,b); +case 3: +return G__5399__3.call(this,a,b,c); +default: +return G__5399__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5399.cljs$lang$maxFixedArity = 3; +G__5399.cljs$lang$applyTo = G__5399__4.cljs$lang$applyTo; +return G__5399; +})() +}); +var fnil__4 = (function (f,x,y,z){return (function() { +var G__5402 = null; +var G__5402__2 = (function (a,b){return f.call(null,(((a == null))?x:a),(((b == null))?y:b)); +}); +var G__5402__3 = (function (a,b,c){return f.call(null,(((a == null))?x:a),(((b == null))?y:b),(((c == null))?z:c)); +}); +var G__5402__4 = (function() { +var G__5403__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__5403 = 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__5403__delegate.call(this,a,b,c,ds);}; +G__5403.cljs$lang$maxFixedArity = 3; +G__5403.cljs$lang$applyTo = (function (arglist__5404){ +var a = cljs.core.first(arglist__5404); +arglist__5404 = cljs.core.next(arglist__5404); +var b = cljs.core.first(arglist__5404); +arglist__5404 = cljs.core.next(arglist__5404); +var c = cljs.core.first(arglist__5404); +var ds = cljs.core.rest(arglist__5404); +return G__5403__delegate(a,b,c,ds); +}); +G__5403.cljs$core$IFn$_invoke$arity$variadic = G__5403__delegate; +return G__5403; +})() +; +G__5402 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 2: +return G__5402__2.call(this,a,b); +case 3: +return G__5402__3.call(this,a,b,c); +default: +return G__5402__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5402.cljs$lang$maxFixedArity = 3; +G__5402.cljs$lang$applyTo = G__5402__4.cljs$lang$applyTo; +return G__5402; +})() +}); +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; +})() +; +/** +* Returns a lazy sequence consisting of the result of applying f to 0 +* and the first item of coll, followed by applying f to 1 and the second +* item in coll, etc, until coll is exhausted. Thus function f should +* accept 2 arguments, index and item. +*/ +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__4388__auto___5405 = size;var i_5406 = 0;while(true){ +if((i_5406 < n__4388__auto___5405)) +{cljs.core.chunk_append.call(null,b,f.call(null,(idx + i_5406),cljs.core._nth.call(null,c,i_5406))); +{ +var G__5407 = (i_5406 + 1); +i_5406 = G__5407; +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); +}); +/** +* Returns a lazy sequence of the non-nil results of (f item). Note, +* this means false return values will be included. f must be free of +* side-effects. +*/ +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__4388__auto___5408 = size;var i_5409 = 0;while(true){ +if((i_5409 < n__4388__auto___5408)) +{var x_5410 = f.call(null,cljs.core._nth.call(null,c,i_5409));if((x_5410 == null)) +{} else +{cljs.core.chunk_append.call(null,b,x_5410); +} +{ +var G__5411 = (i_5409 + 1); +i_5409 = G__5411; +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)); +}); +/** +* Returns a lazy sequence of the non-nil results of (f index item). Note, +* this means false return values will be included. f must be free of +* side-effects. +*/ +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__4388__auto___5412 = size;var i_5413 = 0;while(true){ +if((i_5413 < n__4388__auto___5412)) +{var x_5414 = f.call(null,(idx + i_5413),cljs.core._nth.call(null,c,i_5413));if((x_5414 == null)) +{} else +{cljs.core.chunk_append.call(null,b,x_5414); +} +{ +var G__5415 = (i_5413 + 1); +i_5413 = G__5415; +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); +}); +/** +* Takes a set of predicates and returns a function f that returns true if all of its +* composing predicates return a logical true value against all of its arguments, else it returns +* false. Note that f is short-circuiting in that it will stop execution on the first +* argument that triggers a logical false result against the original predicates. +* @param {...*} var_args +*/ +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__3528__auto__ = p.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{return p.call(null,y); +} else +{return and__3528__auto__; +} +})()); +}); +var ep1__3 = (function (x,y,z){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{return p.call(null,z); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep1__4 = (function() { +var G__5422__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__5422 = 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__5422__delegate.call(this,x,y,z,args);}; +G__5422.cljs$lang$maxFixedArity = 3; +G__5422.cljs$lang$applyTo = (function (arglist__5423){ +var x = cljs.core.first(arglist__5423); +arglist__5423 = cljs.core.next(arglist__5423); +var y = cljs.core.first(arglist__5423); +arglist__5423 = cljs.core.next(arglist__5423); +var z = cljs.core.first(arglist__5423); +var args = cljs.core.rest(arglist__5423); +return G__5422__delegate(x,y,z,args); +}); +G__5422.cljs$core$IFn$_invoke$arity$variadic = G__5422__delegate; +return G__5422; +})() +; +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__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{return p2.call(null,x); +} else +{return and__3528__auto__; +} +})()); +}); +var ep2__2 = (function (x,y){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$2)) +{return p2.call(null,y); +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep2__3 = (function (x,y,z){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p1.call(null,z);if(cljs.core.truth_(and__3528__auto____$2)) +{var and__3528__auto____$3 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$3)) +{var and__3528__auto____$4 = p2.call(null,y);if(cljs.core.truth_(and__3528__auto____$4)) +{return p2.call(null,z); +} else +{return and__3528__auto____$4; +} +} else +{return and__3528__auto____$3; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep2__4 = (function() { +var G__5424__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__5416_SHARP_){var and__3528__auto__ = p1.call(null,p1__5416_SHARP_);if(cljs.core.truth_(and__3528__auto__)) +{return p2.call(null,p1__5416_SHARP_); +} else +{return and__3528__auto__; +} +}),args))); +}; +var G__5424 = 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__5424__delegate.call(this,x,y,z,args);}; +G__5424.cljs$lang$maxFixedArity = 3; +G__5424.cljs$lang$applyTo = (function (arglist__5425){ +var x = cljs.core.first(arglist__5425); +arglist__5425 = cljs.core.next(arglist__5425); +var y = cljs.core.first(arglist__5425); +arglist__5425 = cljs.core.next(arglist__5425); +var z = cljs.core.first(arglist__5425); +var args = cljs.core.rest(arglist__5425); +return G__5424__delegate(x,y,z,args); +}); +G__5424.cljs$core$IFn$_invoke$arity$variadic = G__5424__delegate; +return G__5424; +})() +; +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__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$1)) +{return p3.call(null,x); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep3__2 = (function (x,y){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p3.call(null,x);if(cljs.core.truth_(and__3528__auto____$2)) +{var and__3528__auto____$3 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$3)) +{var and__3528__auto____$4 = p2.call(null,y);if(cljs.core.truth_(and__3528__auto____$4)) +{return p3.call(null,y); +} else +{return and__3528__auto____$4; +} +} else +{return and__3528__auto____$3; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep3__3 = (function (x,y,z){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p3.call(null,x);if(cljs.core.truth_(and__3528__auto____$2)) +{var and__3528__auto____$3 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$3)) +{var and__3528__auto____$4 = p2.call(null,y);if(cljs.core.truth_(and__3528__auto____$4)) +{var and__3528__auto____$5 = p3.call(null,y);if(cljs.core.truth_(and__3528__auto____$5)) +{var and__3528__auto____$6 = p1.call(null,z);if(cljs.core.truth_(and__3528__auto____$6)) +{var and__3528__auto____$7 = p2.call(null,z);if(cljs.core.truth_(and__3528__auto____$7)) +{return p3.call(null,z); +} else +{return and__3528__auto____$7; +} +} else +{return and__3528__auto____$6; +} +} else +{return and__3528__auto____$5; +} +} else +{return and__3528__auto____$4; +} +} else +{return and__3528__auto____$3; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep3__4 = (function() { +var G__5426__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__5417_SHARP_){var and__3528__auto__ = p1.call(null,p1__5417_SHARP_);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,p1__5417_SHARP_);if(cljs.core.truth_(and__3528__auto____$1)) +{return p3.call(null,p1__5417_SHARP_); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +}),args))); +}; +var G__5426 = 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__5426__delegate.call(this,x,y,z,args);}; +G__5426.cljs$lang$maxFixedArity = 3; +G__5426.cljs$lang$applyTo = (function (arglist__5427){ +var x = cljs.core.first(arglist__5427); +arglist__5427 = cljs.core.next(arglist__5427); +var y = cljs.core.first(arglist__5427); +arglist__5427 = cljs.core.next(arglist__5427); +var z = cljs.core.first(arglist__5427); +var args = cljs.core.rest(arglist__5427); +return G__5426__delegate(x,y,z,args); +}); +G__5426.cljs$core$IFn$_invoke$arity$variadic = G__5426__delegate; +return G__5426; +})() +; +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__5428__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__5418_SHARP_){return p1__5418_SHARP_.call(null,x); +}),ps__$1); +}); +var epn__2 = (function (x,y){return cljs.core.every_QMARK_.call(null,(function (p1__5419_SHARP_){var and__3528__auto__ = p1__5419_SHARP_.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{return p1__5419_SHARP_.call(null,y); +} else +{return and__3528__auto__; +} +}),ps__$1); +}); +var epn__3 = (function (x,y,z){return cljs.core.every_QMARK_.call(null,(function (p1__5420_SHARP_){var and__3528__auto__ = p1__5420_SHARP_.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p1__5420_SHARP_.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{return p1__5420_SHARP_.call(null,z); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +}),ps__$1); +}); +var epn__4 = (function() { +var G__5429__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__5421_SHARP_){return cljs.core.every_QMARK_.call(null,p1__5421_SHARP_,args); +}),ps__$1))); +}; +var G__5429 = 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__5429__delegate.call(this,x,y,z,args);}; +G__5429.cljs$lang$maxFixedArity = 3; +G__5429.cljs$lang$applyTo = (function (arglist__5430){ +var x = cljs.core.first(arglist__5430); +arglist__5430 = cljs.core.next(arglist__5430); +var y = cljs.core.first(arglist__5430); +arglist__5430 = cljs.core.next(arglist__5430); +var z = cljs.core.first(arglist__5430); +var args = cljs.core.rest(arglist__5430); +return G__5429__delegate(x,y,z,args); +}); +G__5429.cljs$core$IFn$_invoke$arity$variadic = G__5429__delegate; +return G__5429; +})() +; +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__5428 = 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__5428__delegate.call(this,p1,p2,p3,ps);}; +G__5428.cljs$lang$maxFixedArity = 3; +G__5428.cljs$lang$applyTo = (function (arglist__5431){ +var p1 = cljs.core.first(arglist__5431); +arglist__5431 = cljs.core.next(arglist__5431); +var p2 = cljs.core.first(arglist__5431); +arglist__5431 = cljs.core.next(arglist__5431); +var p3 = cljs.core.first(arglist__5431); +var ps = cljs.core.rest(arglist__5431); +return G__5428__delegate(p1,p2,p3,ps); +}); +G__5428.cljs$core$IFn$_invoke$arity$variadic = G__5428__delegate; +return G__5428; +})() +; +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; +})() +; +/** +* Takes a set of predicates and returns a function f that returns the first logical true value +* returned by one of its composing predicates against any of its arguments, else it returns +* logical false. Note that f is short-circuiting in that it will stop execution on the first +* argument that triggers a logical true result against the original predicates. +* @param {...*} var_args +*/ +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__3540__auto__ = p.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return p.call(null,y); +} +}); +var sp1__3 = (function (x,y,z){var or__3540__auto__ = p.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p.call(null,z); +} +} +}); +var sp1__4 = (function() { +var G__5438__delegate = function (x,y,z,args){var or__3540__auto__ = sp1.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,p,args); +} +}; +var G__5438 = 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__5438__delegate.call(this,x,y,z,args);}; +G__5438.cljs$lang$maxFixedArity = 3; +G__5438.cljs$lang$applyTo = (function (arglist__5439){ +var x = cljs.core.first(arglist__5439); +arglist__5439 = cljs.core.next(arglist__5439); +var y = cljs.core.first(arglist__5439); +arglist__5439 = cljs.core.next(arglist__5439); +var z = cljs.core.first(arglist__5439); +var args = cljs.core.rest(arglist__5439); +return G__5438__delegate(x,y,z,args); +}); +G__5438.cljs$core$IFn$_invoke$arity$variadic = G__5438__delegate; +return G__5438; +})() +; +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__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return p2.call(null,x); +} +}); +var sp2__2 = (function (x,y){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{return p2.call(null,y); +} +} +} +}); +var sp2__3 = (function (x,y,z){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p1.call(null,z);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{var or__3540__auto____$3 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$3)) +{return or__3540__auto____$3; +} else +{var or__3540__auto____$4 = p2.call(null,y);if(cljs.core.truth_(or__3540__auto____$4)) +{return or__3540__auto____$4; +} else +{return p2.call(null,z); +} +} +} +} +} +}); +var sp2__4 = (function() { +var G__5440__delegate = function (x,y,z,args){var or__3540__auto__ = sp2.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,(function (p1__5432_SHARP_){var or__3540__auto____$1 = p1.call(null,p1__5432_SHARP_);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p2.call(null,p1__5432_SHARP_); +} +}),args); +} +}; +var G__5440 = 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__5440__delegate.call(this,x,y,z,args);}; +G__5440.cljs$lang$maxFixedArity = 3; +G__5440.cljs$lang$applyTo = (function (arglist__5441){ +var x = cljs.core.first(arglist__5441); +arglist__5441 = cljs.core.next(arglist__5441); +var y = cljs.core.first(arglist__5441); +arglist__5441 = cljs.core.next(arglist__5441); +var z = cljs.core.first(arglist__5441); +var args = cljs.core.rest(arglist__5441); +return G__5440__delegate(x,y,z,args); +}); +G__5440.cljs$core$IFn$_invoke$arity$variadic = G__5440__delegate; +return G__5440; +})() +; +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__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p3.call(null,x); +} +} +}); +var sp3__2 = (function (x,y){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p3.call(null,x);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{var or__3540__auto____$3 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$3)) +{return or__3540__auto____$3; +} else +{var or__3540__auto____$4 = p2.call(null,y);if(cljs.core.truth_(or__3540__auto____$4)) +{return or__3540__auto____$4; +} else +{return p3.call(null,y); +} +} +} +} +} +}); +var sp3__3 = (function (x,y,z){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p3.call(null,x);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{var or__3540__auto____$3 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$3)) +{return or__3540__auto____$3; +} else +{var or__3540__auto____$4 = p2.call(null,y);if(cljs.core.truth_(or__3540__auto____$4)) +{return or__3540__auto____$4; +} else +{var or__3540__auto____$5 = p3.call(null,y);if(cljs.core.truth_(or__3540__auto____$5)) +{return or__3540__auto____$5; +} else +{var or__3540__auto____$6 = p1.call(null,z);if(cljs.core.truth_(or__3540__auto____$6)) +{return or__3540__auto____$6; +} else +{var or__3540__auto____$7 = p2.call(null,z);if(cljs.core.truth_(or__3540__auto____$7)) +{return or__3540__auto____$7; +} else +{return p3.call(null,z); +} +} +} +} +} +} +} +} +}); +var sp3__4 = (function() { +var G__5442__delegate = function (x,y,z,args){var or__3540__auto__ = sp3.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,(function (p1__5433_SHARP_){var or__3540__auto____$1 = p1.call(null,p1__5433_SHARP_);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p2.call(null,p1__5433_SHARP_);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{return p3.call(null,p1__5433_SHARP_); +} +} +}),args); +} +}; +var G__5442 = 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__5442__delegate.call(this,x,y,z,args);}; +G__5442.cljs$lang$maxFixedArity = 3; +G__5442.cljs$lang$applyTo = (function (arglist__5443){ +var x = cljs.core.first(arglist__5443); +arglist__5443 = cljs.core.next(arglist__5443); +var y = cljs.core.first(arglist__5443); +arglist__5443 = cljs.core.next(arglist__5443); +var z = cljs.core.first(arglist__5443); +var args = cljs.core.rest(arglist__5443); +return G__5442__delegate(x,y,z,args); +}); +G__5442.cljs$core$IFn$_invoke$arity$variadic = G__5442__delegate; +return G__5442; +})() +; +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__5444__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__5434_SHARP_){return p1__5434_SHARP_.call(null,x); +}),ps__$1); +}); +var spn__2 = (function (x,y){return cljs.core.some.call(null,(function (p1__5435_SHARP_){var or__3540__auto__ = p1__5435_SHARP_.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return p1__5435_SHARP_.call(null,y); +} +}),ps__$1); +}); +var spn__3 = (function (x,y,z){return cljs.core.some.call(null,(function (p1__5436_SHARP_){var or__3540__auto__ = p1__5436_SHARP_.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p1__5436_SHARP_.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p1__5436_SHARP_.call(null,z); +} +} +}),ps__$1); +}); +var spn__4 = (function() { +var G__5445__delegate = function (x,y,z,args){var or__3540__auto__ = spn.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,(function (p1__5437_SHARP_){return cljs.core.some.call(null,p1__5437_SHARP_,args); +}),ps__$1); +} +}; +var G__5445 = 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__5445__delegate.call(this,x,y,z,args);}; +G__5445.cljs$lang$maxFixedArity = 3; +G__5445.cljs$lang$applyTo = (function (arglist__5446){ +var x = cljs.core.first(arglist__5446); +arglist__5446 = cljs.core.next(arglist__5446); +var y = cljs.core.first(arglist__5446); +arglist__5446 = cljs.core.next(arglist__5446); +var z = cljs.core.first(arglist__5446); +var args = cljs.core.rest(arglist__5446); +return G__5445__delegate(x,y,z,args); +}); +G__5445.cljs$core$IFn$_invoke$arity$variadic = G__5445__delegate; +return G__5445; +})() +; +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__5444 = 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__5444__delegate.call(this,p1,p2,p3,ps);}; +G__5444.cljs$lang$maxFixedArity = 3; +G__5444.cljs$lang$applyTo = (function (arglist__5447){ +var p1 = cljs.core.first(arglist__5447); +arglist__5447 = cljs.core.next(arglist__5447); +var p2 = cljs.core.first(arglist__5447); +arglist__5447 = cljs.core.next(arglist__5447); +var p3 = cljs.core.first(arglist__5447); +var ps = cljs.core.rest(arglist__5447); +return G__5444__delegate(p1,p2,p3,ps); +}); +G__5444.cljs$core$IFn$_invoke$arity$variadic = G__5444__delegate; +return G__5444; +})() +; +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; +})() +; +/** +* Returns a lazy sequence consisting of the result of applying f to the +* set of first items of each coll, followed by applying f to the set +* of second items in each coll, until any one of the colls is +* exhausted. Any remaining items in other colls are ignored. Function +* f should accept number-of-colls arguments. +* @param {...*} var_args +*/ +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__4388__auto___5449 = size;var i_5450 = 0;while(true){ +if((i_5450 < n__4388__auto___5449)) +{cljs.core.chunk_append.call(null,b,f.call(null,cljs.core._nth.call(null,c,i_5450))); +{ +var G__5451 = (i_5450 + 1); +i_5450 = G__5451; +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__5452__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__5448_SHARP_){return cljs.core.apply.call(null,f,p1__5448_SHARP_); +}),step.call(null,cljs.core.conj.call(null,colls,c3,c2,c1))); +}; +var G__5452 = 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__5452__delegate.call(this,f,c1,c2,c3,colls);}; +G__5452.cljs$lang$maxFixedArity = 4; +G__5452.cljs$lang$applyTo = (function (arglist__5453){ +var f = cljs.core.first(arglist__5453); +arglist__5453 = cljs.core.next(arglist__5453); +var c1 = cljs.core.first(arglist__5453); +arglist__5453 = cljs.core.next(arglist__5453); +var c2 = cljs.core.first(arglist__5453); +arglist__5453 = cljs.core.next(arglist__5453); +var c3 = cljs.core.first(arglist__5453); +var colls = cljs.core.rest(arglist__5453); +return G__5452__delegate(f,c1,c2,c3,colls); +}); +G__5452.cljs$core$IFn$_invoke$arity$variadic = G__5452__delegate; +return G__5452; +})() +; +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; +})() +; +/** +* Returns a lazy sequence of the first n items in coll, or all items if +* there are fewer than n. +*/ +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)); +}); +/** +* Returns a lazy sequence of all but the first n items in coll. +*/ +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__5454 = (n__$1 - 1); +var G__5455 = cljs.core.rest.call(null,s); +n__$1 = G__5454; +coll__$1 = G__5455; +continue; +} +} else +{return s; +} +break; +} +});return (new cljs.core.LazySeq(null,(function (){return step.call(null,n,coll); +}),null,null)); +}); +/** +* Return a lazy sequence of all but the last n (default 1) items in coll +*/ +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; +})() +; +/** +* Returns a seq of the last n items in coll. Depending on the type +* of coll may be no better than linear time. For vectors, see also subvec. +*/ +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__5456 = cljs.core.next.call(null,s); +var G__5457 = cljs.core.next.call(null,lead); +s = G__5456; +lead = G__5457; +continue; +} +} else +{return s; +} +break; +} +}); +/** +* Returns a lazy sequence of the items in coll starting from the first +* item for which (pred item) returns nil. +*/ +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__3528__auto__ = s;if(and__3528__auto__) +{return pred__$1.call(null,cljs.core.first.call(null,s)); +} else +{return and__3528__auto__; +} +})())) +{{ +var G__5458 = pred__$1; +var G__5459 = cljs.core.rest.call(null,s); +pred__$1 = G__5458; +coll__$1 = G__5459; +continue; +} +} else +{return s; +} +break; +} +});return (new cljs.core.LazySeq(null,(function (){return step.call(null,pred,coll); +}),null,null)); +}); +/** +* Returns a lazy (infinite!) sequence of repetitions of the items in coll. +*/ +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)); +}); +/** +* Returns a vector of [(take n coll) (drop n coll)] +*/ +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); +}); +/** +* Returns a lazy (infinite!, or length n if supplied) sequence of xs. +*/ +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; +})() +; +/** +* Returns a lazy seq of n xs. +*/ +cljs.core.replicate = (function replicate(n,x){return cljs.core.take.call(null,n,cljs.core.repeat.call(null,x)); +}); +/** +* Takes a function of no args, presumably with side effects, and +* returns an infinite (or length n if supplied) lazy sequence of calls +* to it +*/ +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; +})() +; +/** +* Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects +*/ +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))); +}); +/** +* Returns a lazy seq of the first item in each coll, then the second etc. +* @param {...*} var_args +*/ +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__5460__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__5460 = 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__5460__delegate.call(this,c1,c2,colls);}; +G__5460.cljs$lang$maxFixedArity = 2; +G__5460.cljs$lang$applyTo = (function (arglist__5461){ +var c1 = cljs.core.first(arglist__5461); +arglist__5461 = cljs.core.next(arglist__5461); +var c2 = cljs.core.first(arglist__5461); +var colls = cljs.core.rest(arglist__5461); +return G__5460__delegate(c1,c2,colls); +}); +G__5460.cljs$core$IFn$_invoke$arity$variadic = G__5460__delegate; +return G__5460; +})() +; +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; +})() +; +/** +* Returns a lazy seq of the elements of coll separated by sep +*/ +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)); +}); +/** +* Take a collection of collections, and return a lazy seq +* of items from the inner collection +*/ +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); +}); +/** +* Returns the result of applying concat to the result of applying map +* to f and colls. Thus function f should return a collection. +* @param {...*} var_args +*/ +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__5462__delegate = function (f,coll,colls){return cljs.core.flatten1.call(null,cljs.core.apply.call(null,cljs.core.map,f,coll,colls)); +}; +var G__5462 = 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__5462__delegate.call(this,f,coll,colls);}; +G__5462.cljs$lang$maxFixedArity = 2; +G__5462.cljs$lang$applyTo = (function (arglist__5463){ +var f = cljs.core.first(arglist__5463); +arglist__5463 = cljs.core.next(arglist__5463); +var coll = cljs.core.first(arglist__5463); +var colls = cljs.core.rest(arglist__5463); +return G__5462__delegate(f,coll,colls); +}); +G__5462.cljs$core$IFn$_invoke$arity$variadic = G__5462__delegate; +return G__5462; +})() +; +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; +})() +; +/** +* Returns a lazy sequence of the items in coll for which +* (pred item) returns true. pred must be free of side-effects. +*/ +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__4388__auto___5464 = size;var i_5465 = 0;while(true){ +if((i_5465 < n__4388__auto___5464)) +{if(cljs.core.truth_(pred.call(null,cljs.core._nth.call(null,c,i_5465)))) +{cljs.core.chunk_append.call(null,b,cljs.core._nth.call(null,c,i_5465)); +} else +{} +{ +var G__5466 = (i_5465 + 1); +i_5465 = G__5466; +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)); +}); +/** +* Returns a lazy sequence of the items in coll for which +* (pred item) returns false. pred must be free of side-effects. +*/ +cljs.core.remove = (function remove(pred,coll){return cljs.core.filter.call(null,cljs.core.complement.call(null,pred),coll); +}); +/** +* Returns a lazy sequence of the nodes in a tree, via a depth-first walk. +* branch? must be a fn of one arg that returns true if passed a node +* that can have children (but may not). children must be a fn of one +* arg that returns a sequence of the children. Will only be called on +* nodes for which branch? returns true. Root is the root node of the +* tree. +*/ +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); +}); +/** +* Takes any nested combination of sequential things (lists, vectors, +* etc.) and returns their contents as a single, flat sequence. +* (flatten nil) returns nil. +*/ +cljs.core.flatten = (function flatten(x){return cljs.core.filter.call(null,(function (p1__5467_SHARP_){return !(cljs.core.sequential_QMARK_.call(null,p1__5467_SHARP_)); +}),cljs.core.rest.call(null,cljs.core.tree_seq.call(null,cljs.core.sequential_QMARK_,cljs.core.seq,x))); +}); +/** +* Returns a new coll consisting of to-coll with all of the items of +* from-coll conjoined. +*/ +cljs.core.into = (function into(to,from){if(!((to == null))) +{if((function (){var G__5469 = to;if(G__5469) +{var bit__4183__auto__ = (G__5469.cljs$lang$protocol_mask$partition1$ & 4);if((bit__4183__auto__) || (G__5469.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); +} +}); +/** +* Returns a vector consisting of the result of applying f to the +* set of first items of each coll, followed by applying f to the set +* of second items in each coll, until any one of the colls is +* exhausted. Any remaining items in other colls are ignored. Function +* f should accept number-of-colls arguments. +* @param {...*} var_args +*/ +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__5470__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__5470 = 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__5470__delegate.call(this,f,c1,c2,c3,colls);}; +G__5470.cljs$lang$maxFixedArity = 4; +G__5470.cljs$lang$applyTo = (function (arglist__5471){ +var f = cljs.core.first(arglist__5471); +arglist__5471 = cljs.core.next(arglist__5471); +var c1 = cljs.core.first(arglist__5471); +arglist__5471 = cljs.core.next(arglist__5471); +var c2 = cljs.core.first(arglist__5471); +arglist__5471 = cljs.core.next(arglist__5471); +var c3 = cljs.core.first(arglist__5471); +var colls = cljs.core.rest(arglist__5471); +return G__5470__delegate(f,c1,c2,c3,colls); +}); +G__5470.cljs$core$IFn$_invoke$arity$variadic = G__5470__delegate; +return G__5470; +})() +; +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; +})() +; +/** +* Returns a vector of the items in coll for which +* (pred item) returns true. pred must be free of side-effects. +*/ +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)); +}); +/** +* Returns a lazy sequence of lists of n items each, at offsets step +* apart. If step is not supplied, defaults to n, i.e. the partitions +* do not overlap. If a pad collection is supplied, use its elements as +* necessary to complete last partition upto n items. In case there are +* not enough padding elements, return a partition with less than n items. +*/ +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; +})() +; +/** +* Returns the value in a nested associative structure, +* where ks is a sequence of keys. Returns nil if the key is not present, +* or the not-found value if supplied. +*/ +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__5473 = m__$1;if(G__5473) +{var bit__4190__auto__ = (G__5473.cljs$lang$protocol_mask$partition0$ & 256);if((bit__4190__auto__) || (G__5473.cljs$core$ILookup$)) +{return true; +} else +{if((!G__5473.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ILookup,G__5473); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ILookup,G__5473); +} +})())) +{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__5474 = sentinel; +var G__5475 = m__$2; +var G__5476 = cljs.core.next.call(null,ks__$1); +sentinel = G__5474; +m__$1 = G__5475; +ks__$1 = G__5476; +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; +})() +; +/** +* Associates a value in a nested associative structure, where ks is a +* sequence of keys and v is the new value and returns a new nested structure. +* If any levels do not exist, hash-maps will be created. +*/ +cljs.core.assoc_in = (function assoc_in(m,p__5477,v){var vec__5479 = p__5477;var k = cljs.core.nth.call(null,vec__5479,0,null);var ks = cljs.core.nthnext.call(null,vec__5479,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); +} +}); +/** +* 'Updates' a value in a nested associative structure, where ks is a +* sequence of keys and f is a function that will take the old value +* and any supplied args and return the new value, and returns a new +* nested structure. If any levels do not exist, hash-maps will be +* created. +* @param {...*} var_args +*/ +cljs.core.update_in = (function() { +var update_in = null; +var update_in__3 = (function (m,p__5480,f){var vec__5490 = p__5480;var k = cljs.core.nth.call(null,vec__5490,0,null);var ks = cljs.core.nthnext.call(null,vec__5490,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__5481,f,a){var vec__5491 = p__5481;var k = cljs.core.nth.call(null,vec__5491,0,null);var ks = cljs.core.nthnext.call(null,vec__5491,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__5482,f,a,b){var vec__5492 = p__5482;var k = cljs.core.nth.call(null,vec__5492,0,null);var ks = cljs.core.nthnext.call(null,vec__5492,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__5483,f,a,b,c){var vec__5493 = p__5483;var k = cljs.core.nth.call(null,vec__5493,0,null);var ks = cljs.core.nthnext.call(null,vec__5493,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__5495__delegate = function (m,p__5484,f,a,b,c,args){var vec__5494 = p__5484;var k = cljs.core.nth.call(null,vec__5494,0,null);var ks = cljs.core.nthnext.call(null,vec__5494,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__5495 = function (m,p__5484,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__5495__delegate.call(this,m,p__5484,f,a,b,c,args);}; +G__5495.cljs$lang$maxFixedArity = 6; +G__5495.cljs$lang$applyTo = (function (arglist__5496){ +var m = cljs.core.first(arglist__5496); +arglist__5496 = cljs.core.next(arglist__5496); +var p__5484 = cljs.core.first(arglist__5496); +arglist__5496 = cljs.core.next(arglist__5496); +var f = cljs.core.first(arglist__5496); +arglist__5496 = cljs.core.next(arglist__5496); +var a = cljs.core.first(arglist__5496); +arglist__5496 = cljs.core.next(arglist__5496); +var b = cljs.core.first(arglist__5496); +arglist__5496 = cljs.core.next(arglist__5496); +var c = cljs.core.first(arglist__5496); +var args = cljs.core.rest(arglist__5496); +return G__5495__delegate(m,p__5484,f,a,b,c,args); +}); +G__5495.cljs$core$IFn$_invoke$arity$variadic = G__5495__delegate; +return G__5495; +})() +; +update_in = function(m,p__5484,f,a,b,c,var_args){ +var args = var_args; +switch(arguments.length){ +case 3: +return update_in__3.call(this,m,p__5484,f); +case 4: +return update_in__4.call(this,m,p__5484,f,a); +case 5: +return update_in__5.call(this,m,p__5484,f,a,b); +case 6: +return update_in__6.call(this,m,p__5484,f,a,b,c); +default: +return update_in__7.cljs$core$IFn$_invoke$arity$variadic(m,p__5484,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; +})() +; + +/** +* @constructor +*/ +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__4110__auto__,writer__4111__auto__,opts__4112__auto__){return cljs.core._write.call(null,writer__4111__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__5497 = (ll - 5); +var G__5498 = r; +ll = G__5497; +ret = G__5498; +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__5499 = cljs.core.pv_aget.call(null,node,((i >>> level) & 31)); +var G__5500 = (level - 5); +node = G__5499; +level = G__5500; +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; +} +} +} +}); + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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(typeof k === 'number') +{return cljs.core._assoc_n.call(null,coll__$1,k,v); +} else +{throw (new Error("Vector's key for assoc must be a number.")); +} +}); +cljs.core.PersistentVector.prototype.call = (function() { +var G__5502 = null; +var G__5502__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__5502__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__5502 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5502__2.call(this,self__,k); +case 3: +return G__5502__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5502; +})() +; +cljs.core.PersistentVector.prototype.apply = (function (self__,args5501){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5501))); +}); +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__5503 = (j + 1); +var G__5504 = init__$2; +j = G__5503; +init__$1 = G__5504; +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__5505 = (i + (step_init[0])); +i = G__5505; +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__4388__auto___5506 = len;var i_5507 = 0;while(true){ +if((i_5507 < n__4388__auto___5506)) +{(new_tail[i_5507] = (self__.tail[i_5507])); +{ +var G__5508 = (i_5507 + 1); +i_5507 = G__5508; +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;if(((0 <= n)) && ((n < self__.cnt))) +{if((cljs.core.tail_off.call(null,coll__$1) <= n)) +{var new_tail = cljs.core.aclone.call(null,self__.tail);(new_tail[(n & 31)] = val); +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,n,val),self__.tail,null)); +} +} else +{if((n === self__.cnt)) +{return cljs.core._conj.call(null,coll__$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 [0,"),cljs.core.str(self__.cnt),cljs.core.str("]")].join(''))); +} else +{return null; +} +} +} +}); +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentVector(self__.meta,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__5509 = (i + 1); +var G__5510 = cljs.core.conj_BANG_.call(null,out,(xs__$1[i])); +i = G__5509; +out = G__5510; +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)); +}); +/** +* @param {...*} var_args +*/ +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__5511){ +var args = cljs.core.seq(arglist__5511); +return vector__delegate(args); +}); +vector.cljs$core$IFn$_invoke$arity$variadic = vector__delegate; +return vector; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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; +})() +; + +/** +* @constructor +*/ +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$partition0$ = 166617887; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.Subvec.cljs$lang$type = true; +cljs.core.Subvec.cljs$lang$ctorStr = "cljs.core/Subvec"; +cljs.core.Subvec.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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;if(typeof key === 'number') +{return cljs.core._assoc_n.call(null,coll__$1,key,val); +} else +{throw (new Error("Subvec's key for assoc must be a number.")); +} +}); +cljs.core.Subvec.prototype.call = (function() { +var G__5513 = null; +var G__5513__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__5513__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__5513 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5513__2.call(this,self__,k); +case 3: +return G__5513__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5513; +})() +; +cljs.core.Subvec.prototype.apply = (function (self__,args5512){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5512))); +}); +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.cljs$core$IReversible$_rseq$arity$1 = (function (coll){var self__ = this; +var coll__$1 = this;if(!((self__.start === self__.end))) +{return (new cljs.core.RSeq(coll__$1,((self__.end - self__.start) - 1),null)); +} else +{return 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;var v_pos = (self__.start + n);return cljs.core.build_subvec.call(null,self__.meta,cljs.core.assoc.call(null,self__.v,v_pos,val),self__.start,(function (){var x__3847__auto__ = self__.end;var y__3848__auto__ = (v_pos + 1);return ((x__3847__auto__ > y__3848__auto__) ? x__3847__auto__ : y__3848__auto__); +})(),null); +}); +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.Subvec(self__.meta,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__5514 = meta; +var G__5515 = v.v; +var G__5516 = (v.start + start); +var G__5517 = (v.start + end); +var G__5518 = __hash; +meta = G__5514; +v = G__5515; +start = G__5516; +end = G__5517; +__hash = G__5518; +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; +} +}); +/** +* Returns a persistent vector of the items in vector from +* start (inclusive) to end (exclusive). If end is not supplied, +* defaults to (count vector). This operation is O(1) and very fast, as +* the resulting vector shares structure with the original and no +* trimming is done. +*/ +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 obj5522 = {};return obj5522; +})(),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__5523 = cljs.core.tv_ensure_editable.call(null,root.edit,cljs.core.pv_aget.call(null,node,((i >>> level) & 31))); +var G__5524 = (level - 5); +node = G__5523; +level = G__5524; +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(''))); +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__auto__,"cljs.core/TransientVector"); +}); +cljs.core.TransientVector.prototype.call = (function() { +var G__5526 = null; +var G__5526__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__5526__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__5526 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5526__2.call(this,self__,k); +case 3: +return G__5526__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5526; +})() +; +cljs.core.TransientVector.prototype.apply = (function (self__,args5525){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5525))); +}); +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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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)); +}); + +/** +* @constructor +*/ +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$partition0$ = 31858766; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.PersistentQueue.cljs$lang$type = true; +cljs.core.PersistentQueue.cljs$lang$ctorStr = "cljs.core/PersistentQueue"; +cljs.core.PersistentQueue.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__3540__auto__ = self__.rear;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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__3540__auto__ = self__.front;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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$ICloneable$_clone$arity$1 = (function (coll){var self__ = this; +var coll__$1 = this;return (new cljs.core.PersistentQueue(self__.meta,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)); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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()); +/** +* Assumes y is a map. Returns true if x equals y, otherwise returns +* false. +*/ +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__5527 = (i + incr); +i = G__5527; +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__5528 = (i + 1); +var G__5529 = cljs.core.assoc_BANG_.call(null,out,k__$1,(so[k__$1])); +i = G__5528; +out = G__5529; +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 obj5533 = {};return obj5533; +})();var l = ks.length;var i_5534 = 0;while(true){ +if((i_5534 < l)) +{var k_5535 = (ks[i_5534]);(new_obj[k_5535] = (obj[k_5535])); +{ +var G__5536 = (i_5534 + 1); +i_5534 = G__5536; +continue; +} +} else +{} +break; +} +return new_obj; +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5539 = null; +var G__5539__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__5539__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__5539 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5539__2.call(this,self__,k); +case 3: +return G__5539__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5539; +})() +; +cljs.core.ObjMap.prototype.apply = (function (self__,args5538){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5538))); +}); +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__5540 = cljs.core.rest.call(null,keys__$1); +var G__5541 = init__$2; +keys__$1 = G__5540; +init__$1 = G__5541; +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__5537_SHARP_){return (new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[p1__5537_SHARP_,(self__.strobj[p1__5537_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 obj5543 = {};return obj5543; +})(),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__5544 = (i + 2); +i = G__5544; +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__5545 = (i + 2); +i = G__5545; +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__5546 = (i + 2); +i = G__5546; +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__5547 = (i + 2); +i = G__5547; +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__5548 = (i + 2); +i = G__5548; +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_5549 = 0;while(true){ +if((i_5549 < l)) +{(narr[i_5549] = (arr[i_5549])); +{ +var G__5550 = (i_5549 + 1); +i_5549 = G__5550; +continue; +} +} else +{} +break; +} +(narr[l] = k); +(narr[(l + 1)] = v); +return narr; +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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; +} +}); + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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 obj5553 = {};return obj5553; +})(),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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5554 = cljs.core.aclone.call(null,self__.arr);(G__5554[(idx + 1)] = v); +return G__5554; +})();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__5555 = null; +var G__5555__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__5555__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__5555 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5555__2.call(this,self__,k); +case 3: +return G__5555__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5555; +})() +; +cljs.core.PersistentArrayMap.prototype.apply = (function (self__,args5551){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5551))); +}); +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__5556 = (i + 2); +var G__5557 = init__$2; +i = G__5556; +init__$1 = G__5557; +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentArrayMap(self__.meta,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__5558 = (s + 2); +var G__5559 = d; +s = G__5558; +d = G__5559; +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__5560 = (s + 2); +var G__5561 = (d + 2); +s = G__5560; +d = G__5561; +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__5562 = (i + 2); +var G__5563 = cljs.core._assoc_BANG_.call(null,ret,(arr__$1[i]),(arr__$1[(i + 1)])); +i = G__5562; +ret = G__5563; +continue; +} +} else +{return cljs.core._persistent_BANG_.call(null,ret); +} +break; +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5564_5566 = self__.arr;G__5564_5566.pop(); +G__5564_5566.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__5565 = o;if(G__5565) +{var bit__4190__auto__ = (G__5565.cljs$lang$protocol_mask$partition0$ & 2048);if((bit__4190__auto__) || (G__5565.cljs$core$IMapEntry$)) +{return true; +} else +{if((!G__5565.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__5565); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__5565); +} +})()) +{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__5567 = cljs.core.next.call(null,es); +var G__5568 = cljs.core._assoc_BANG_.call(null,tcoll__$2,cljs.core.key.call(null,e),cljs.core.val.call(null,e)); +es = G__5567; +tcoll__$2 = G__5568; +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__5569 = cljs.core.assoc_BANG_.call(null,out,(arr[i]),(arr[(i + 1)])); +var G__5570 = (i + 2); +out = G__5569; +i = G__5570; +continue; +} +} else +{return out; +} +break; +} +}); + +/** +* @constructor +*/ +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__4110__auto__,writer__4111__auto__,opts__4112__auto__){return cljs.core._write.call(null,writer__4111__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__5573 = cljs.core.aclone.call(null,arr);(G__5573[i] = a); +return G__5573; +}); +var clone_and_set__5 = (function (arr,i,a,j,b){var G__5574 = cljs.core.aclone.call(null,arr);(G__5574[i] = a); +(G__5574[j] = b); +return G__5574; +}); +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) & 0x01f)); +}); +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__5575 = (i + 2); +var G__5576 = init__$2; +i = G__5575; +init__$1 = G__5576; +continue; +} +} +} else +{return init__$1; +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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) & 0x01f));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) & 0x01f);(nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + 5),hash,key,val,added_leaf_QMARK_)); +var i_5577 = 0;var j_5578 = 0;while(true){ +if((i_5577 < 32)) +{if((((self__.bitmap >>> i_5577) & 1) === 0)) +{{ +var G__5579 = (i_5577 + 1); +var G__5580 = j_5578; +i_5577 = G__5579; +j_5578 = G__5580; +continue; +} +} else +{(nodes[i_5577] = ((!(((self__.arr[j_5578]) == null)))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + 5),cljs.core.hash.call(null,(self__.arr[j_5578])),(self__.arr[j_5578]),(self__.arr[(j_5578 + 1)]),added_leaf_QMARK_):(self__.arr[(j_5578 + 1)]))); +{ +var G__5581 = (i_5577 + 1); +var G__5582 = (j_5578 + 2); +i_5577 = G__5581; +j_5578 = G__5582; +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) & 0x01f));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) & 0x01f));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) & 0x01f));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) & 0x01f));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) & 0x01f);(nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + 5),hash,key,val,added_leaf_QMARK_)); +var i_5583 = 0;var j_5584 = 0;while(true){ +if((i_5583 < 32)) +{if((((self__.bitmap >>> i_5583) & 1) === 0)) +{{ +var G__5585 = (i_5583 + 1); +var G__5586 = j_5584; +i_5583 = G__5585; +j_5584 = G__5586; +continue; +} +} else +{(nodes[i_5583] = ((!(((self__.arr[j_5584]) == null)))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + 5),cljs.core.hash.call(null,(self__.arr[j_5584])),(self__.arr[j_5584]),(self__.arr[(j_5584 + 1)]),added_leaf_QMARK_):(self__.arr[(j_5584 + 1)]))); +{ +var G__5587 = (i_5583 + 1); +var G__5588 = (j_5584 + 2); +i_5583 = G__5587; +j_5584 = G__5588; +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) & 0x01f));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__5589 = (i + 1); +var G__5590 = (j + 2); +var G__5591 = (bitmap | (1 << i)); +i = G__5589; +j = G__5590; +bitmap = G__5591; +continue; +} +} else +{{ +var G__5592 = (i + 1); +var G__5593 = j; +var G__5594 = bitmap; +i = G__5592; +j = G__5593; +bitmap = G__5594; +continue; +} +} +} else +{return (new cljs.core.BitmapIndexedNode(edit,bitmap,new_arr)); +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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) & 0x01f);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) & 0x01f);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__5595 = (i + 1); +var G__5596 = init__$2; +i = G__5595; +init__$1 = G__5596; +continue; +} +} +} else +{{ +var G__5597 = (i + 1); +var G__5598 = init__$1; +i = G__5597; +init__$1 = G__5598; +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) & 0x01f);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) & 0x01f);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) & 0x01f);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) & 0x01f);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__5599 = (i + 2); +i = G__5599; +continue; +} +} +} else +{return -1; +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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) & 0x01f)),[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) & 0x01f)),[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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5600 = (j + 2); +j = G__5600; +continue; +} +} +} else +{{ +var G__5601 = (j + 2); +j = G__5601; +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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5602 = (j + 1); +j = G__5602; +continue; +} +} +} else +{{ +var G__5603 = (j + 1); +j = G__5603; +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; +})() +; + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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 obj5606 = {};return obj5606; +})(),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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5607 = null; +var G__5607__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__5607__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__5607 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5607__2.call(this,self__,k); +case 3: +return G__5607__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5607; +})() +; +cljs.core.PersistentHashMap.prototype.apply = (function (self__,args5604){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5604))); +}); +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentHashMap(self__.meta,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__5608 = (i + 1); +var G__5609 = cljs.core._assoc_BANG_.call(null,out,(ks[i]),(vs[i])); +i = G__5608; +out = G__5609; +continue; +} +} else +{return cljs.core.persistent_BANG_.call(null,out); +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5610 = o;if(G__5610) +{var bit__4190__auto__ = (G__5610.cljs$lang$protocol_mask$partition0$ & 2048);if((bit__4190__auto__) || (G__5610.cljs$core$IMapEntry$)) +{return true; +} else +{if((!G__5610.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__5610); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__5610); +} +})()) +{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__5611 = cljs.core.next.call(null,es); +var G__5612 = tcoll__$1.assoc_BANG_(cljs.core.key.call(null,e),cljs.core.val.call(null,e)); +es = G__5611; +tcoll__$1 = G__5612; +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__5613 = ((ascending_QMARK_)?t.left:t.right); +var G__5614 = cljs.core.conj.call(null,stack__$1,t); +t = G__5613; +stack__$1 = G__5614; +continue; +} +} else +{return stack__$1; +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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; +} +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5616 = null; +var G__5616__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__5616__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__5616 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5616__2.call(this,self__,k); +case 3: +return G__5616__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5616; +})() +; +cljs.core.BlackNode.prototype.apply = (function (self__,args5615){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5615))); +}); +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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5618 = null; +var G__5618__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__5618__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__5618 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5618__2.call(this,self__,k); +case 3: +return G__5618__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5618; +})() +; +cljs.core.RedNode.prototype.apply = (function (self__,args5617){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5617))); +}); +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; +} +} +} +}); + +/** +* @constructor +*/ +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$partition0$ = 418776847; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.PersistentTreeMap.cljs$lang$type = true; +cljs.core.PersistentTreeMap.cljs$lang$ctorStr = "cljs.core/PersistentTreeMap"; +cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5620 = null; +var G__5620__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__5620__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__5620 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5620__2.call(this,self__,k); +case 3: +return G__5620__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5620; +})() +; +cljs.core.PersistentTreeMap.prototype.apply = (function (self__,args5619){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5619))); +}); +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.toString = (function (){var self__ = this; +var coll = this;return cljs.core.pr_str_STAR_.call(null,coll); +}); +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__5621 = t.left; +t = G__5621; +continue; +} +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{{ +var G__5622 = t.right; +t = G__5622; +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__5623 = cljs.core.conj.call(null,stack,t); +var G__5624 = t.left; +stack = G__5623; +t = G__5624; +continue; +} +} else +{{ +var G__5625 = stack; +var G__5626 = t.right; +stack = G__5625; +t = G__5626; +continue; +} +} +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{if((c > 0)) +{{ +var G__5627 = cljs.core.conj.call(null,stack,t); +var G__5628 = t.right; +stack = G__5627; +t = G__5628; +continue; +} +} else +{{ +var G__5629 = stack; +var G__5630 = t.left; +stack = G__5629; +t = G__5630; +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentTreeMap(self__.comp,self__.tree,self__.cnt,self__.meta,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)); +/** +* keyval => key val +* Returns a new hash map with supplied mappings. +* @param {...*} var_args +*/ +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__5631 = cljs.core.nnext.call(null,in$); +var G__5632 = cljs.core.assoc_BANG_.call(null,out,cljs.core.first.call(null,in$),cljs.core.second.call(null,in$)); +in$ = G__5631; +out = G__5632; +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__5633){ +var keyvals = cljs.core.seq(arglist__5633); +return hash_map__delegate(keyvals); +}); +hash_map.cljs$core$IFn$_invoke$arity$variadic = hash_map__delegate; +return hash_map; +})() +; +/** +* keyval => key val +* Returns a new array map with supplied mappings. +* @param {...*} var_args +*/ +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__5634){ +var keyvals = cljs.core.seq(arglist__5634); +return array_map__delegate(keyvals); +}); +array_map.cljs$core$IFn$_invoke$arity$variadic = array_map__delegate; +return array_map; +})() +; +/** +* keyval => key val +* Returns a new object map with supplied mappings. +* @param {...*} var_args +*/ +cljs.core.obj_map = (function() { +var obj_map__delegate = function (keyvals){var ks = [];var obj = (function (){var obj5638 = {};return obj5638; +})();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__5639 = cljs.core.nnext.call(null,kvs); +kvs = G__5639; +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__5640){ +var keyvals = cljs.core.seq(arglist__5640); +return obj_map__delegate(keyvals); +}); +obj_map.cljs$core$IFn$_invoke$arity$variadic = obj_map__delegate; +return obj_map; +})() +; +/** +* keyval => key val +* Returns a new sorted map with supplied mappings. +* @param {...*} var_args +*/ +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__5641 = cljs.core.nnext.call(null,in$); +var G__5642 = cljs.core.assoc.call(null,out,cljs.core.first.call(null,in$),cljs.core.second.call(null,in$)); +in$ = G__5641; +out = G__5642; +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__5643){ +var keyvals = cljs.core.seq(arglist__5643); +return sorted_map__delegate(keyvals); +}); +sorted_map.cljs$core$IFn$_invoke$arity$variadic = sorted_map__delegate; +return sorted_map; +})() +; +/** +* keyval => key val +* Returns a new sorted map with supplied mappings, using the supplied comparator. +* @param {...*} var_args +*/ +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__5644 = cljs.core.nnext.call(null,in$); +var G__5645 = cljs.core.assoc.call(null,out,cljs.core.first.call(null,in$),cljs.core.second.call(null,in$)); +in$ = G__5644; +out = G__5645; +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__5646){ +var comparator = cljs.core.first(arglist__5646); +var keyvals = cljs.core.rest(arglist__5646); +return sorted_map_by__delegate(comparator,keyvals); +}); +sorted_map_by.cljs$core$IFn$_invoke$arity$variadic = sorted_map_by__delegate; +return sorted_map_by; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5647 = self__.mseq;if(G__5647) +{var bit__4190__auto__ = (G__5647.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__5647.cljs$core$INext$)) +{return true; +} else +{if((!G__5647.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5647); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5647); +} +})())?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__5648 = self__.mseq;if(G__5648) +{var bit__4190__auto__ = (G__5648.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__5648.cljs$core$INext$)) +{return true; +} else +{if((!G__5648.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5648); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5648); +} +})())?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)); +}); +/** +* Returns a sequence of the map's keys. +*/ +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; +} +}); +/** +* Returns the key of the map entry. +*/ +cljs.core.key = (function key(map_entry){return cljs.core._key.call(null,map_entry); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5649 = self__.mseq;if(G__5649) +{var bit__4190__auto__ = (G__5649.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__5649.cljs$core$INext$)) +{return true; +} else +{if((!G__5649.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5649); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5649); +} +})())?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__5650 = self__.mseq;if(G__5650) +{var bit__4190__auto__ = (G__5650.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__5650.cljs$core$INext$)) +{return true; +} else +{if((!G__5650.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5650); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__5650); +} +})())?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)); +}); +/** +* Returns a sequence of the map's values. +*/ +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; +} +}); +/** +* Returns the value in the map entry. +*/ +cljs.core.val = (function val(map_entry){return cljs.core._val.call(null,map_entry); +}); +/** +* Returns a map that consists of the rest of the maps conj-ed onto +* the first. If a key occurs in more than one map, the mapping from +* the latter (left-to-right) will be the mapping in the result. +* @param {...*} var_args +*/ +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__5651_SHARP_,p2__5652_SHARP_){return cljs.core.conj.call(null,(function (){var or__3540__auto__ = p1__5651_SHARP_;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.PersistentArrayMap.EMPTY; +} +})(),p2__5652_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__5653){ +var maps = cljs.core.seq(arglist__5653); +return merge__delegate(maps); +}); +merge.cljs$core$IFn$_invoke$arity$variadic = merge__delegate; +return merge; +})() +; +/** +* Returns a map that consists of the rest of the maps conj-ed onto +* the first. If a key occurs in more than one map, the mapping(s) +* from the latter (left-to-right) will be combined with the mapping in +* the result by calling (f val-in-result val-in-latter). +* @param {...*} var_args +*/ +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__3540__auto__ = m1;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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__5654){ +var f = cljs.core.first(arglist__5654); +var maps = cljs.core.rest(arglist__5654); +return merge_with__delegate(f,maps); +}); +merge_with.cljs$core$IFn$_invoke$arity$variadic = merge_with__delegate; +return merge_with; +})() +; +/** +* Returns a map containing only those entries in map whose key is in keys +*/ +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__5655 = ((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__5656 = cljs.core.next.call(null,keys); +ret = G__5655; +keys = G__5656; +continue; +} +} else +{return ret; +} +break; +} +}); + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_iset.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5659 = null; +var G__5659__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__5659__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__5659 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5659__2.call(this,self__,k); +case 3: +return G__5659__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5659; +})() +; +cljs.core.PersistentHashSet.prototype.apply = (function (self__,args5658){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5658))); +}); +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__5657_SHARP_){return cljs.core.contains_QMARK_.call(null,coll__$1,p1__5657_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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentHashSet(self__.meta,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__5660 = (i + 1); +var G__5661 = cljs.core._assoc_BANG_.call(null,out,(items[i]),null); +i = G__5660; +out = G__5661; +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__5662 = (i + 1); +var G__5663 = cljs.core._conj_BANG_.call(null,out,(items[i])); +i = G__5662; +out = G__5663; +continue; +} +} else +{return cljs.core._persistent_BANG_.call(null,out); +} +break; +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__auto__,"cljs.core/TransientHashSet"); +}); +cljs.core.TransientHashSet.prototype.call = (function() { +var G__5665 = null; +var G__5665__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__5665__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__5665 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5665__2.call(this,self__,k); +case 3: +return G__5665__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5665; +})() +; +cljs.core.TransientHashSet.prototype.apply = (function (self__,args5664){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5664))); +}); +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)); +}); + +/** +* @constructor +*/ +cljs.core.PersistentTreeSet = (function (meta,tree_map,__hash){ +this.meta = meta; +this.tree_map = tree_map; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 417730831; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.PersistentTreeSet.cljs$lang$type = true; +cljs.core.PersistentTreeSet.cljs$lang$ctorStr = "cljs.core/PersistentTreeSet"; +cljs.core.PersistentTreeSet.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_iset.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__5668 = null; +var G__5668__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__5668__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__5668 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__5668__2.call(this,self__,k); +case 3: +return G__5668__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__5668; +})() +; +cljs.core.PersistentTreeSet.prototype.apply = (function (self__,args5667){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args5667))); +}); +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__5666_SHARP_){return cljs.core.contains_QMARK_.call(null,coll__$1,p1__5666_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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentTreeSet(self__.meta,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__4382__auto__ = arr;var i = 0;var res = cljs.core._as_transient.call(null,cljs.core.PersistentHashSet.EMPTY);while(true){ +if((i < a__4382__auto__.length)) +{{ +var G__5669 = (i + 1); +var G__5670 = cljs.core._conj_BANG_.call(null,res,(arr[i])); +i = G__5669; +res = G__5670; +continue; +} +} else +{return res; +} +break; +} +})();return cljs.core._persistent_BANG_.call(null,ret); +}); +/** +* Returns a set of the distinct elements of coll. +*/ +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__5671 = cljs.core._next.call(null,in$__$1); +var G__5672 = cljs.core._conj_BANG_.call(null,out,cljs.core._first.call(null,in$__$1)); +in$__$1 = G__5671; +out = G__5672; +continue; +} +} else +{return cljs.core._persistent_BANG_.call(null,out); +} +break; +} +} else +{return null; +} +} +} +}); +/** +* @param {...*} var_args +*/ +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__5673__delegate = function (keys){return cljs.core.set.call(null,keys); +}; +var G__5673 = function (var_args){ +var keys = null;if (arguments.length > 0) { + keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5673__delegate.call(this,keys);}; +G__5673.cljs$lang$maxFixedArity = 0; +G__5673.cljs$lang$applyTo = (function (arglist__5674){ +var keys = cljs.core.seq(arglist__5674); +return G__5673__delegate(keys); +}); +G__5673.cljs$core$IFn$_invoke$arity$variadic = G__5673__delegate; +return G__5673; +})() +; +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; +})() +; +/** +* Returns a new sorted set with supplied keys. +* @param {...*} var_args +*/ +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__5675){ +var keys = cljs.core.seq(arglist__5675); +return sorted_set__delegate(keys); +}); +sorted_set.cljs$core$IFn$_invoke$arity$variadic = sorted_set__delegate; +return sorted_set; +})() +; +/** +* Returns a new sorted set with supplied keys, using the supplied comparator. +* @param {...*} var_args +*/ +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__5676){ +var comparator = cljs.core.first(arglist__5676); +var keys = cljs.core.rest(arglist__5676); +return sorted_set_by__delegate(comparator,keys); +}); +sorted_set_by.cljs$core$IFn$_invoke$arity$variadic = sorted_set_by__delegate; +return sorted_set_by; +})() +; +/** +* Given a map of replacement pairs and a vector/collection, returns a +* vector/seq with any elements = a key in smap replaced with the +* corresponding val in smap +*/ +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__5677_SHARP_){var temp__4090__auto__ = cljs.core.find.call(null,smap,p1__5677_SHARP_);if(cljs.core.truth_(temp__4090__auto__)) +{var e = temp__4090__auto__;return cljs.core.second.call(null,e); +} else +{return p1__5677_SHARP_; +} +}),coll); +} +}); +/** +* Returns a lazy sequence of the elements of coll with duplicates removed +*/ +cljs.core.distinct = (function distinct(coll){var step = (function step(xs,seen){return (new cljs.core.LazySeq(null,(function (){return (function (p__5684,seen__$1){while(true){ +var vec__5685 = p__5684;var f = cljs.core.nth.call(null,vec__5685,0,null);var xs__$1 = vec__5685;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__5686 = cljs.core.rest.call(null,s); +var G__5687 = seen__$1; +p__5684 = G__5686; +seen__$1 = G__5687; +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__5688 = cljs.core.conj.call(null,ret,cljs.core.first.call(null,s__$1)); +var G__5689 = cljs.core.next.call(null,s__$1); +ret = G__5688; +s__$1 = G__5689; +continue; +} +} else +{return cljs.core.seq.call(null,ret); +} +break; +} +}); +/** +* Returns the name String of a string, symbol or keyword. +*/ +cljs.core.name = (function name(x){if((function (){var G__5691 = x;if(G__5691) +{var bit__4183__auto__ = (G__5691.cljs$lang$protocol_mask$partition1$ & 4096);if((bit__4183__auto__) || (G__5691.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(''))); +} +} +}); +/** +* Returns a map with the keys mapped to the corresponding vals. +*/ +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__5692 = cljs.core.assoc_BANG_.call(null,map,cljs.core.first.call(null,ks),cljs.core.first.call(null,vs)); +var G__5693 = cljs.core.next.call(null,ks); +var G__5694 = cljs.core.next.call(null,vs); +map = G__5692; +ks = G__5693; +vs = G__5694; +continue; +} +} else +{return cljs.core.persistent_BANG_.call(null,map); +} +break; +} +}); +/** +* Returns the x for which (k x), a number, is greatest. +* @param {...*} var_args +*/ +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__5697__delegate = function (k,x,y,more){return cljs.core.reduce.call(null,(function (p1__5695_SHARP_,p2__5696_SHARP_){return max_key.call(null,k,p1__5695_SHARP_,p2__5696_SHARP_); +}),max_key.call(null,k,x,y),more); +}; +var G__5697 = 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__5697__delegate.call(this,k,x,y,more);}; +G__5697.cljs$lang$maxFixedArity = 3; +G__5697.cljs$lang$applyTo = (function (arglist__5698){ +var k = cljs.core.first(arglist__5698); +arglist__5698 = cljs.core.next(arglist__5698); +var x = cljs.core.first(arglist__5698); +arglist__5698 = cljs.core.next(arglist__5698); +var y = cljs.core.first(arglist__5698); +var more = cljs.core.rest(arglist__5698); +return G__5697__delegate(k,x,y,more); +}); +G__5697.cljs$core$IFn$_invoke$arity$variadic = G__5697__delegate; +return G__5697; +})() +; +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; +})() +; +/** +* Returns the x for which (k x), a number, is least. +* @param {...*} var_args +*/ +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__5701__delegate = function (k,x,y,more){return cljs.core.reduce.call(null,(function (p1__5699_SHARP_,p2__5700_SHARP_){return min_key.call(null,k,p1__5699_SHARP_,p2__5700_SHARP_); +}),min_key.call(null,k,x,y),more); +}; +var G__5701 = 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__5701__delegate.call(this,k,x,y,more);}; +G__5701.cljs$lang$maxFixedArity = 3; +G__5701.cljs$lang$applyTo = (function (arglist__5702){ +var k = cljs.core.first(arglist__5702); +arglist__5702 = cljs.core.next(arglist__5702); +var x = cljs.core.first(arglist__5702); +arglist__5702 = cljs.core.next(arglist__5702); +var y = cljs.core.first(arglist__5702); +var more = cljs.core.rest(arglist__5702); +return G__5701__delegate(k,x,y,more); +}); +G__5701.cljs$core$IFn$_invoke$arity$variadic = G__5701__delegate; +return G__5701; +})() +; +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; +})() +; +/** +* Returns a lazy sequence of lists like partition, but may include +* partitions with fewer than n items at the end. +*/ +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; +})() +; +/** +* Returns a lazy sequence of successive items from coll while +* (pred item) returns true. pred must be free of side-effects. +*/ +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); +}); +}); +/** +* sc must be a sorted collection, test(s) one of <, <=, > or +* >=. Returns a seq of those entries with keys ek for +* which (test (.. sc comparator (compare ek key)) 0) is true +*/ +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__5705 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__5705,0,null);var s = vec__5705;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__5706 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__5706,0,null);var s = vec__5706;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; +})() +; +/** +* sc must be a sorted collection, test(s) one of <, <=, > or +* >=. Returns a reverse seq of those entries with keys ek for +* which (test (.. sc comparator (compare ek key)) 0) is true +*/ +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__5709 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__5709,0,null);var s = vec__5709;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__5710 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__5710,0,null);var s = vec__5710;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; +})() +; + +/** +* @constructor +*/ +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$partition0$ = 32375006; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.Range.cljs$lang$type = true; +cljs.core.Range.cljs$lang$ctorStr = "cljs.core/Range"; +cljs.core.Range.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,rng__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.Range(self__.meta,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)); +}); +/** +* Returns a lazy seq of nums from start (inclusive) to end +* (exclusive), by step, where start defaults to 0, step to 1, +* and end to infinity. +*/ +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; +})() +; +/** +* Returns a lazy seq of every nth item in coll. +*/ +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)); +}); +/** +* Returns a vector of [(take-while pred coll) (drop-while pred coll)] +*/ +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); +}); +/** +* Applies f to each value in coll, splitting it each time f returns +* a new value. Returns a lazy seq of partitions. +*/ +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__5711_SHARP_){return cljs.core._EQ_.call(null,fv,f.call(null,p1__5711_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)); +}); +/** +* Returns a map from distinct items in coll to the number of times +* they appear. +*/ +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)); +}); +/** +* Returns a lazy seq of the intermediate values of the reduction (as +* per reduce) of coll by f, starting with init. +*/ +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; +})() +; +/** +* Takes a set of functions and returns a fn that is the juxtaposition +* of those fns. The returned fn takes a variable number of args, and +* returns a vector containing the result of applying each fn to the +* args (left-to-right). +* ((juxt a b c) x) => [(a x) (b x) (c x)] +* @param {...*} var_args +*/ +cljs.core.juxt = (function() { +var juxt = null; +var juxt__1 = (function (f){return (function() { +var G__5722 = null; +var G__5722__0 = (function (){return (new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[f.call(null)],null)); +}); +var G__5722__1 = (function (x){return (new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[f.call(null,x)],null)); +}); +var G__5722__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__5722__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__5722__4 = (function() { +var G__5723__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__5723 = 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__5723__delegate.call(this,x,y,z,args);}; +G__5723.cljs$lang$maxFixedArity = 3; +G__5723.cljs$lang$applyTo = (function (arglist__5724){ +var x = cljs.core.first(arglist__5724); +arglist__5724 = cljs.core.next(arglist__5724); +var y = cljs.core.first(arglist__5724); +arglist__5724 = cljs.core.next(arglist__5724); +var z = cljs.core.first(arglist__5724); +var args = cljs.core.rest(arglist__5724); +return G__5723__delegate(x,y,z,args); +}); +G__5723.cljs$core$IFn$_invoke$arity$variadic = G__5723__delegate; +return G__5723; +})() +; +G__5722 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__5722__0.call(this); +case 1: +return G__5722__1.call(this,x); +case 2: +return G__5722__2.call(this,x,y); +case 3: +return G__5722__3.call(this,x,y,z); +default: +return G__5722__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5722.cljs$lang$maxFixedArity = 3; +G__5722.cljs$lang$applyTo = G__5722__4.cljs$lang$applyTo; +return G__5722; +})() +}); +var juxt__2 = (function (f,g){return (function() { +var G__5725 = null; +var G__5725__0 = (function (){return (new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[f.call(null),g.call(null)],null)); +}); +var G__5725__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__5725__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__5725__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__5725__4 = (function() { +var G__5726__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__5726 = 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__5726__delegate.call(this,x,y,z,args);}; +G__5726.cljs$lang$maxFixedArity = 3; +G__5726.cljs$lang$applyTo = (function (arglist__5727){ +var x = cljs.core.first(arglist__5727); +arglist__5727 = cljs.core.next(arglist__5727); +var y = cljs.core.first(arglist__5727); +arglist__5727 = cljs.core.next(arglist__5727); +var z = cljs.core.first(arglist__5727); +var args = cljs.core.rest(arglist__5727); +return G__5726__delegate(x,y,z,args); +}); +G__5726.cljs$core$IFn$_invoke$arity$variadic = G__5726__delegate; +return G__5726; +})() +; +G__5725 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__5725__0.call(this); +case 1: +return G__5725__1.call(this,x); +case 2: +return G__5725__2.call(this,x,y); +case 3: +return G__5725__3.call(this,x,y,z); +default: +return G__5725__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5725.cljs$lang$maxFixedArity = 3; +G__5725.cljs$lang$applyTo = G__5725__4.cljs$lang$applyTo; +return G__5725; +})() +}); +var juxt__3 = (function (f,g,h){return (function() { +var G__5728 = null; +var G__5728__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__5728__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__5728__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__5728__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__5728__4 = (function() { +var G__5729__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__5729 = 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__5729__delegate.call(this,x,y,z,args);}; +G__5729.cljs$lang$maxFixedArity = 3; +G__5729.cljs$lang$applyTo = (function (arglist__5730){ +var x = cljs.core.first(arglist__5730); +arglist__5730 = cljs.core.next(arglist__5730); +var y = cljs.core.first(arglist__5730); +arglist__5730 = cljs.core.next(arglist__5730); +var z = cljs.core.first(arglist__5730); +var args = cljs.core.rest(arglist__5730); +return G__5729__delegate(x,y,z,args); +}); +G__5729.cljs$core$IFn$_invoke$arity$variadic = G__5729__delegate; +return G__5729; +})() +; +G__5728 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__5728__0.call(this); +case 1: +return G__5728__1.call(this,x); +case 2: +return G__5728__2.call(this,x,y); +case 3: +return G__5728__3.call(this,x,y,z); +default: +return G__5728__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5728.cljs$lang$maxFixedArity = 3; +G__5728.cljs$lang$applyTo = G__5728__4.cljs$lang$applyTo; +return G__5728; +})() +}); +var juxt__4 = (function() { +var G__5731__delegate = function (f,g,h,fs){var fs__$1 = cljs.core.list_STAR_.call(null,f,g,h,fs);return (function() { +var G__5732 = null; +var G__5732__0 = (function (){return cljs.core.reduce.call(null,(function (p1__5712_SHARP_,p2__5713_SHARP_){return cljs.core.conj.call(null,p1__5712_SHARP_,p2__5713_SHARP_.call(null)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__5732__1 = (function (x){return cljs.core.reduce.call(null,(function (p1__5714_SHARP_,p2__5715_SHARP_){return cljs.core.conj.call(null,p1__5714_SHARP_,p2__5715_SHARP_.call(null,x)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__5732__2 = (function (x,y){return cljs.core.reduce.call(null,(function (p1__5716_SHARP_,p2__5717_SHARP_){return cljs.core.conj.call(null,p1__5716_SHARP_,p2__5717_SHARP_.call(null,x,y)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__5732__3 = (function (x,y,z){return cljs.core.reduce.call(null,(function (p1__5718_SHARP_,p2__5719_SHARP_){return cljs.core.conj.call(null,p1__5718_SHARP_,p2__5719_SHARP_.call(null,x,y,z)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__5732__4 = (function() { +var G__5733__delegate = function (x,y,z,args){return cljs.core.reduce.call(null,(function (p1__5720_SHARP_,p2__5721_SHARP_){return cljs.core.conj.call(null,p1__5720_SHARP_,cljs.core.apply.call(null,p2__5721_SHARP_,x,y,z,args)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}; +var G__5733 = 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__5733__delegate.call(this,x,y,z,args);}; +G__5733.cljs$lang$maxFixedArity = 3; +G__5733.cljs$lang$applyTo = (function (arglist__5734){ +var x = cljs.core.first(arglist__5734); +arglist__5734 = cljs.core.next(arglist__5734); +var y = cljs.core.first(arglist__5734); +arglist__5734 = cljs.core.next(arglist__5734); +var z = cljs.core.first(arglist__5734); +var args = cljs.core.rest(arglist__5734); +return G__5733__delegate(x,y,z,args); +}); +G__5733.cljs$core$IFn$_invoke$arity$variadic = G__5733__delegate; +return G__5733; +})() +; +G__5732 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__5732__0.call(this); +case 1: +return G__5732__1.call(this,x); +case 2: +return G__5732__2.call(this,x,y); +case 3: +return G__5732__3.call(this,x,y,z); +default: +return G__5732__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__5732.cljs$lang$maxFixedArity = 3; +G__5732.cljs$lang$applyTo = G__5732__4.cljs$lang$applyTo; +return G__5732; +})() +}; +var G__5731 = 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__5731__delegate.call(this,f,g,h,fs);}; +G__5731.cljs$lang$maxFixedArity = 3; +G__5731.cljs$lang$applyTo = (function (arglist__5735){ +var f = cljs.core.first(arglist__5735); +arglist__5735 = cljs.core.next(arglist__5735); +var g = cljs.core.first(arglist__5735); +arglist__5735 = cljs.core.next(arglist__5735); +var h = cljs.core.first(arglist__5735); +var fs = cljs.core.rest(arglist__5735); +return G__5731__delegate(f,g,h,fs); +}); +G__5731.cljs$core$IFn$_invoke$arity$variadic = G__5731__delegate; +return G__5731; +})() +; +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; +})() +; +/** +* When lazy sequences are produced via functions that have side +* effects, any effects other than those needed to produce the first +* element in the seq do not occur until the seq is consumed. dorun can +* be used to force any effects. Walks through the successive nexts of +* the seq, does not retain the head and returns nil. +*/ +cljs.core.dorun = (function() { +var dorun = null; +var dorun__1 = (function (coll){while(true){ +if(cljs.core.seq.call(null,coll)) +{{ +var G__5736 = cljs.core.next.call(null,coll); +coll = G__5736; +continue; +} +} else +{return null; +} +break; +} +}); +var dorun__2 = (function (n,coll){while(true){ +if((cljs.core.seq.call(null,coll)) && ((n > 0))) +{{ +var G__5737 = (n - 1); +var G__5738 = cljs.core.next.call(null,coll); +n = G__5737; +coll = G__5738; +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; +})() +; +/** +* When lazy sequences are produced via functions that have side +* effects, any effects other than those needed to produce the first +* element in the seq do not occur until the seq is consumed. doall can +* be used to force any effects. Walks through the successive nexts of +* the seq, retains the head and returns it, thus causing the entire +* seq to reside in memory at one time. +*/ +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); +}); +/** +* Returns the result of (re-find re s) if re fully matches s. +*/ +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; +} +}); +/** +* Returns the first regex match, if any, of s to re, using +* re.exec(s). Returns a vector, containing first the matching +* substring, then any capturing groups if the regular expression contains +* capturing groups. +*/ +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); +} +} +}); +/** +* Returns a lazy sequence of successive matches of re in s. +*/ +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; +} +}); +/** +* Returns an instance of RegExp which has compiled the provided string. +*/ +cljs.core.re_pattern = (function re_pattern(s){var vec__5740 = cljs.core.re_find.call(null,/^(?:\(\?([idmsux]*)\))?(.*)/,s);var _ = cljs.core.nth.call(null,vec__5740,0,null);var flags = cljs.core.nth.call(null,vec__5740,1,null);var pattern = cljs.core.nth.call(null,vec__5740,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_5742 = 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_5743__$1 = cljs.core.next.call(null,coll);var n_5744 = new cljs.core.Keyword(null,"print-length","print-length",3960797560).cljs$core$IFn$_invoke$arity$1(opts);while(true){ +if((coll_5743__$1) && (((n_5744 == null)) || (!((n_5744 === 0))))) +{cljs.core._write.call(null,writer,sep); +print_one.call(null,cljs.core.first.call(null,coll_5743__$1),writer,opts); +{ +var G__5745 = cljs.core.next.call(null,coll_5743__$1); +var G__5746 = (n_5744 - 1); +coll_5743__$1 = G__5745; +n_5744 = G__5746; +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_5742; +}}); +/** +* @param {...*} var_args +*/ +cljs.core.write_all = (function() { +var write_all__delegate = function (writer,ss){var seq__5751 = cljs.core.seq.call(null,ss);var chunk__5752 = null;var count__5753 = 0;var i__5754 = 0;while(true){ +if((i__5754 < count__5753)) +{var s = cljs.core._nth.call(null,chunk__5752,i__5754);cljs.core._write.call(null,writer,s); +{ +var G__5755 = seq__5751; +var G__5756 = chunk__5752; +var G__5757 = count__5753; +var G__5758 = (i__5754 + 1); +seq__5751 = G__5755; +chunk__5752 = G__5756; +count__5753 = G__5757; +i__5754 = G__5758; +continue; +} +} else +{var temp__4092__auto__ = cljs.core.seq.call(null,seq__5751);if(temp__4092__auto__) +{var seq__5751__$1 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,seq__5751__$1)) +{var c__4288__auto__ = cljs.core.chunk_first.call(null,seq__5751__$1);{ +var G__5759 = cljs.core.chunk_rest.call(null,seq__5751__$1); +var G__5760 = c__4288__auto__; +var G__5761 = cljs.core.count.call(null,c__4288__auto__); +var G__5762 = 0; +seq__5751 = G__5759; +chunk__5752 = G__5760; +count__5753 = G__5761; +i__5754 = G__5762; +continue; +} +} else +{var s = cljs.core.first.call(null,seq__5751__$1);cljs.core._write.call(null,writer,s); +{ +var G__5763 = cljs.core.next.call(null,seq__5751__$1); +var G__5764 = null; +var G__5765 = 0; +var G__5766 = 0; +seq__5751 = G__5763; +chunk__5752 = G__5764; +count__5753 = G__5765; +i__5754 = G__5766; +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__5767){ +var writer = cljs.core.first(arglist__5767); +var ss = cljs.core.rest(arglist__5767); +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 obj5769 = {"\"":"\\\"","\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"};return obj5769; +})(); +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(''); +}); +/** +* Prefer this to pr-seq, because it makes the printing function +* configurable, allowing efficient implementations such as appending +* to a StringBuffer. +*/ +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,"#"); +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{if(cljs.core.truth_((function (){var and__3528__auto__ = cljs.core.get.call(null,opts,new cljs.core.Keyword(null,"meta","meta",1017252215));if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = (function (){var G__5775 = obj;if(G__5775) +{var bit__4190__auto__ = (G__5775.cljs$lang$protocol_mask$partition0$ & 131072);if((bit__4190__auto__) || (G__5775.cljs$core$IMeta$)) +{return true; +} else +{if((!G__5775.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__5775); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__5775); +} +})();if(and__3528__auto____$1) +{return cljs.core.meta.call(null,obj); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__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__5776 = obj;if(G__5776) +{var bit__4183__auto__ = (G__5776.cljs$lang$protocol_mask$partition0$ & 2147483648);if((bit__4183__auto__) || (G__5776.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,"#<",[cljs.core.str(obj)].join(''),">"); +} else +{if((obj instanceof Date)) +{var normalize = (function (n,len){var ns = [cljs.core.str(n)].join('');while(true){ +if((cljs.core.count.call(null,ns) < len)) +{{ +var G__5778 = [cljs.core.str("0"),cljs.core.str(ns)].join(''); +ns = G__5778; +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__5777 = obj;if(G__5777) +{var bit__4190__auto__ = (G__5777.cljs$lang$protocol_mask$partition0$ & 2147483648);if((bit__4190__auto__) || (G__5777.cljs$core$IPrintWithWriter$)) +{return true; +} else +{if((!G__5777.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IPrintWithWriter,G__5777); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IPrintWithWriter,G__5777); +} +})()) +{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,"#<",[cljs.core.str(obj)].join(''),">"); +} else +{return null; +} +} +} +} +} +} +} +} +} +} +} +} +} else +{return null; +} +} +} +}); +cljs.core.pr_seq_writer = (function pr_seq_writer(objs,writer,opts){cljs.core.pr_writer.call(null,cljs.core.first.call(null,objs),writer,opts); +var seq__5783 = cljs.core.seq.call(null,cljs.core.next.call(null,objs));var chunk__5784 = null;var count__5785 = 0;var i__5786 = 0;while(true){ +if((i__5786 < count__5785)) +{var obj = cljs.core._nth.call(null,chunk__5784,i__5786);cljs.core._write.call(null,writer," "); +cljs.core.pr_writer.call(null,obj,writer,opts); +{ +var G__5787 = seq__5783; +var G__5788 = chunk__5784; +var G__5789 = count__5785; +var G__5790 = (i__5786 + 1); +seq__5783 = G__5787; +chunk__5784 = G__5788; +count__5785 = G__5789; +i__5786 = G__5790; +continue; +} +} else +{var temp__4092__auto__ = cljs.core.seq.call(null,seq__5783);if(temp__4092__auto__) +{var seq__5783__$1 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,seq__5783__$1)) +{var c__4288__auto__ = cljs.core.chunk_first.call(null,seq__5783__$1);{ +var G__5791 = cljs.core.chunk_rest.call(null,seq__5783__$1); +var G__5792 = c__4288__auto__; +var G__5793 = cljs.core.count.call(null,c__4288__auto__); +var G__5794 = 0; +seq__5783 = G__5791; +chunk__5784 = G__5792; +count__5785 = G__5793; +i__5786 = G__5794; +continue; +} +} else +{var obj = cljs.core.first.call(null,seq__5783__$1);cljs.core._write.call(null,writer," "); +cljs.core.pr_writer.call(null,obj,writer,opts); +{ +var G__5795 = cljs.core.next.call(null,seq__5783__$1); +var G__5796 = null; +var G__5797 = 0; +var G__5798 = 0; +seq__5783 = G__5795; +chunk__5784 = G__5796; +count__5785 = G__5797; +i__5786 = G__5798; +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; +}); +/** +* Prints a sequence of objects to a string, observing all the +* options given in opts +*/ +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(''); +} +}); +/** +* Same as pr-str-with-opts followed by (newline) +*/ +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(''); +} +}); +/** +* Prints a sequence of objects using string-print, observing all +* the options given in opts +*/ +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; +} +}); +/** +* pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter. +* @param {...*} var_args +*/ +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__5799){ +var objs = cljs.core.seq(arglist__5799); +return pr_str__delegate(objs); +}); +pr_str.cljs$core$IFn$_invoke$arity$variadic = pr_str__delegate; +return pr_str; +})() +; +/** +* Same as pr-str followed by (newline) +* @param {...*} var_args +*/ +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__5800){ +var objs = cljs.core.seq(arglist__5800); +return prn_str__delegate(objs); +}); +prn_str.cljs$core$IFn$_invoke$arity$variadic = prn_str__delegate; +return prn_str; +})() +; +/** +* Prints the object(s) using string-print. Prints the +* object(s), separated by spaces if there is more than one. +* By default, pr and prn print in a way that objects can be +* read by the reader +* @param {...*} var_args +*/ +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__5801){ +var objs = cljs.core.seq(arglist__5801); +return pr__delegate(objs); +}); +pr.cljs$core$IFn$_invoke$arity$variadic = pr__delegate; +return pr; +})() +; +/** +* Prints the object(s) using string-print. +* print and println produce output for human consumption. +* @param {...*} var_args +*/ +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__5802){ +var objs = cljs.core.seq(arglist__5802); +return cljs_core_print__delegate(objs); +}); +cljs_core_print.cljs$core$IFn$_invoke$arity$variadic = cljs_core_print__delegate; +return cljs_core_print; +})() +; +/** +* print to a string, returning it +* @param {...*} var_args +*/ +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__5803){ +var objs = cljs.core.seq(arglist__5803); +return print_str__delegate(objs); +}); +print_str.cljs$core$IFn$_invoke$arity$variadic = print_str__delegate; +return print_str; +})() +; +/** +* Same as print followed by (newline) +* @param {...*} var_args +*/ +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__5804){ +var objs = cljs.core.seq(arglist__5804); +return println__delegate(objs); +}); +println.cljs$core$IFn$_invoke$arity$variadic = println__delegate; +return println; +})() +; +/** +* println to a string, returning it +* @param {...*} var_args +*/ +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__5805){ +var objs = cljs.core.seq(arglist__5805); +return println_str__delegate(objs); +}); +println_str.cljs$core$IFn$_invoke$arity$variadic = println_str__delegate; +return println_str; +})() +; +/** +* Same as pr followed by (newline). +* @param {...*} var_args +*/ +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__5806){ +var objs = cljs.core.seq(arglist__5806); +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.IAtom = (function (){var obj5808 = {};return obj5808; +})(); +cljs.core.IReset = (function (){var obj5810 = {};return obj5810; +})(); +cljs.core._reset_BANG_ = (function _reset_BANG_(o,new_value){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IReset$_reset_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IReset$_reset_BANG_$arity$2(o,new_value); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._reset_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reset_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IReset.-reset!",o); +} +} +})().call(null,o,new_value); +} +}); +cljs.core.ISwap = (function (){var obj5812 = {};return obj5812; +})(); +cljs.core._swap_BANG_ = (function() { +var _swap_BANG_ = null; +var _swap_BANG___2 = (function (o,f){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$2(o,f); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f); +} +}); +var _swap_BANG___3 = (function (o,f,a){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$3(o,f,a); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f,a); +} +}); +var _swap_BANG___4 = (function (o,f,a,b){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$4(o,f,a,b); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f,a,b); +} +}); +var _swap_BANG___5 = (function (o,f,a,b,xs){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$5; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$5(o,f,a,b,xs); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f,a,b,xs); +} +}); +_swap_BANG_ = function(o,f,a,b,xs){ +switch(arguments.length){ +case 2: +return _swap_BANG___2.call(this,o,f); +case 3: +return _swap_BANG___3.call(this,o,f,a); +case 4: +return _swap_BANG___4.call(this,o,f,a,b); +case 5: +return _swap_BANG___5.call(this,o,f,a,b,xs); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +_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; +return _swap_BANG_; +})() +; + +/** +* @constructor +*/ +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$ = 16386; +}) +cljs.core.Atom.cljs$lang$type = true; +cljs.core.Atom.cljs$lang$ctorStr = "cljs.core/Atom"; +cljs.core.Atom.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5813 = cljs.core.seq.call(null,self__.watches);var chunk__5814 = null;var count__5815 = 0;var i__5816 = 0;while(true){ +if((i__5816 < count__5815)) +{var vec__5817 = cljs.core._nth.call(null,chunk__5814,i__5816);var key = cljs.core.nth.call(null,vec__5817,0,null);var f = cljs.core.nth.call(null,vec__5817,1,null);f.call(null,key,this$__$1,oldval,newval); +{ +var G__5819 = seq__5813; +var G__5820 = chunk__5814; +var G__5821 = count__5815; +var G__5822 = (i__5816 + 1); +seq__5813 = G__5819; +chunk__5814 = G__5820; +count__5815 = G__5821; +i__5816 = G__5822; +continue; +} +} else +{var temp__4092__auto__ = cljs.core.seq.call(null,seq__5813);if(temp__4092__auto__) +{var seq__5813__$1 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,seq__5813__$1)) +{var c__4288__auto__ = cljs.core.chunk_first.call(null,seq__5813__$1);{ +var G__5823 = cljs.core.chunk_rest.call(null,seq__5813__$1); +var G__5824 = c__4288__auto__; +var G__5825 = cljs.core.count.call(null,c__4288__auto__); +var G__5826 = 0; +seq__5813 = G__5823; +chunk__5814 = G__5824; +count__5815 = G__5825; +i__5816 = G__5826; +continue; +} +} else +{var vec__5818 = cljs.core.first.call(null,seq__5813__$1);var key = cljs.core.nth.call(null,vec__5818,0,null);var f = cljs.core.nth.call(null,vec__5818,1,null);f.call(null,key,this$__$1,oldval,newval); +{ +var G__5827 = cljs.core.next.call(null,seq__5813__$1); +var G__5828 = null; +var G__5829 = 0; +var G__5830 = 0; +seq__5813 = G__5827; +chunk__5814 = G__5828; +count__5815 = G__5829; +i__5816 = G__5830; +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,"#"); +}); +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)); +}); +/** +* Creates and returns an Atom with an initial value of x and zero or +* more options (in any order): +* +* :meta metadata-map +* +* :validator validate-fn +* +* If metadata-map is supplied, it will be come the metadata on the +* atom. validate-fn must be nil or a side-effect-free fn of one +* argument, which will be passed the intended new state on any state +* change. If the new state is unacceptable, the validate-fn should +* return false or throw an Error. If either of these error conditions +* occur, then the value of the atom will not change. +* @param {...*} var_args +*/ +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__5834__delegate = function (x,p__5831){var map__5833 = p__5831;var map__5833__$1 = ((cljs.core.seq_QMARK_.call(null,map__5833))?cljs.core.apply.call(null,cljs.core.hash_map,map__5833):map__5833);var validator = cljs.core.get.call(null,map__5833__$1,new cljs.core.Keyword(null,"validator","validator",4199087812));var meta = cljs.core.get.call(null,map__5833__$1,new cljs.core.Keyword(null,"meta","meta",1017252215));return (new cljs.core.Atom(x,meta,validator,null)); +}; +var G__5834 = function (x,var_args){ +var p__5831 = null;if (arguments.length > 1) { + p__5831 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1),0);} +return G__5834__delegate.call(this,x,p__5831);}; +G__5834.cljs$lang$maxFixedArity = 1; +G__5834.cljs$lang$applyTo = (function (arglist__5835){ +var x = cljs.core.first(arglist__5835); +var p__5831 = cljs.core.rest(arglist__5835); +return G__5834__delegate(x,p__5831); +}); +G__5834.cljs$core$IFn$_invoke$arity$variadic = G__5834__delegate; +return G__5834; +})() +; +atom = function(x,var_args){ +var p__5831 = 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; +})() +; +/** +* Sets the value of atom to newval without regard for the +* current value. Returns newval. +*/ +cljs.core.reset_BANG_ = (function reset_BANG_(a,new_value){if((a instanceof cljs.core.Atom)) +{var validate = a.validator;if((validate == null)) +{} else +{if(cljs.core.truth_(validate.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 = a.state;a.state = new_value; +if((a.watches == null)) +{} else +{cljs.core._notify_watches.call(null,a,old_value,new_value); +} +return new_value; +} else +{return cljs.core._reset_BANG_.call(null,a,new_value); +} +}); +cljs.core.deref = (function deref(o){return cljs.core._deref.call(null,o); +}); +/** +* Atomically swaps the value of atom to be: +* (apply f current-value-of-atom args). Note that f may be called +* multiple times, and thus should be free of side effects. Returns +* the value that was swapped in. +* @param {...*} var_args +*/ +cljs.core.swap_BANG_ = (function() { +var swap_BANG_ = null; +var swap_BANG___2 = (function (a,f){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,f.call(null,a.state)); +} else +{return cljs.core._swap_BANG_.call(null,a,f); +} +}); +var swap_BANG___3 = (function (a,f,x){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,f.call(null,a.state,x)); +} else +{return cljs.core._swap_BANG_.call(null,a,f,x); +} +}); +var swap_BANG___4 = (function (a,f,x,y){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,f.call(null,a.state,x,y)); +} else +{return cljs.core._swap_BANG_.call(null,a,f,x,y); +} +}); +var swap_BANG___5 = (function() { +var G__5836__delegate = function (a,f,x,y,more){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,cljs.core.apply.call(null,f,a.state,x,y,more)); +} else +{return cljs.core._swap_BANG_.call(null,a,f,x,y,more); +} +}; +var G__5836 = function (a,f,x,y,var_args){ +var more = null;if (arguments.length > 4) { + more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4),0);} +return G__5836__delegate.call(this,a,f,x,y,more);}; +G__5836.cljs$lang$maxFixedArity = 4; +G__5836.cljs$lang$applyTo = (function (arglist__5837){ +var a = cljs.core.first(arglist__5837); +arglist__5837 = cljs.core.next(arglist__5837); +var f = cljs.core.first(arglist__5837); +arglist__5837 = cljs.core.next(arglist__5837); +var x = cljs.core.first(arglist__5837); +arglist__5837 = cljs.core.next(arglist__5837); +var y = cljs.core.first(arglist__5837); +var more = cljs.core.rest(arglist__5837); +return G__5836__delegate(a,f,x,y,more); +}); +G__5836.cljs$core$IFn$_invoke$arity$variadic = G__5836__delegate; +return G__5836; +})() +; +swap_BANG_ = function(a,f,x,y,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); +default: +return swap_BANG___5.cljs$core$IFn$_invoke$arity$variadic(a,f,x,y, cljs.core.array_seq(arguments, 4)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +swap_BANG_.cljs$lang$maxFixedArity = 4; +swap_BANG_.cljs$lang$applyTo = swap_BANG___5.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$variadic = swap_BANG___5.cljs$core$IFn$_invoke$arity$variadic; +return swap_BANG_; +})() +; +/** +* Atomically sets the value of atom to newval if and only if the +* current value of the atom is identical to oldval. Returns true if +* set happened, else false. +*/ +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; +} +}); +/** +* Sets the validator-fn for an atom. validator-fn must be nil or a +* side-effect-free fn of one argument, which will be passed the intended +* new state on any state change. If the new state is unacceptable, the +* validator-fn should return false or throw an Error. If the current state +* is not acceptable to the new validator, an Error will be thrown and the +* validator will not be changed. +*/ +cljs.core.set_validator_BANG_ = (function set_validator_BANG_(iref,val){return iref.validator = val; +}); +/** +* Gets the validator-fn for a var/ref/agent/atom. +*/ +cljs.core.get_validator = (function get_validator(iref){return iref.validator; +}); +/** +* Atomically sets the metadata for a namespace/var/ref/agent/atom to be: +* +* (apply f its-current-meta args) +* +* f must be free of side-effects +* @param {...*} var_args +*/ +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__5838){ +var iref = cljs.core.first(arglist__5838); +arglist__5838 = cljs.core.next(arglist__5838); +var f = cljs.core.first(arglist__5838); +var args = cljs.core.rest(arglist__5838); +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_; +})() +; +/** +* Atomically resets the metadata for an atom +*/ +cljs.core.reset_meta_BANG_ = (function reset_meta_BANG_(iref,m){return iref.meta = m; +}); +/** +* Alpha - subject to change. +* +* Adds a watch function to an atom reference. The watch fn must be a +* fn of 4 args: a key, the reference, its old-state, its +* new-state. Whenever the reference's state might have been changed, +* any registered watches will have their functions called. The watch +* fn will be called synchronously. Note that an atom's state +* may have changed again prior to the fn call, so use old/new-state +* rather than derefing the reference. Keys must be unique per +* reference, and can be used to remove the watch with remove-watch, +* but are otherwise considered opaque by the watch mechanism. Bear in +* mind that regardless of the result or action of the watch fns the +* atom's value will change. Example: +* +* (def a (atom 0)) +* (add-watch a :inc (fn [k r o n] (assert (== 0 n)))) +* (swap! a inc) +* ;; Assertion Error +* (deref a) +* ;=> 1 +*/ +cljs.core.add_watch = (function add_watch(iref,key,f){return cljs.core._add_watch.call(null,iref,key,f); +}); +/** +* Alpha - subject to change. +* +* Removes a watch (set by add-watch) from a reference +*/ +cljs.core.remove_watch = (function remove_watch(iref,key){return cljs.core._remove_watch.call(null,iref,key); +}); +cljs.core.gensym_counter = null; +/** +* Returns a new symbol with a unique name. If a prefix string is +* supplied, the name is prefix# where # is some unique number. If +* prefix is not supplied, the prefix is 'G__'. +*/ +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; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5839){var map__5840 = p__5839;var map__5840__$1 = ((cljs.core.seq_QMARK_.call(null,map__5840))?cljs.core.apply.call(null,cljs.core.hash_map,map__5840):map__5840);var curr_state = map__5840__$1;var done = cljs.core.get.call(null,map__5840__$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)); +}); +/** +* returns true if x is a Delay created with delay +*/ +cljs.core.delay_QMARK_ = (function delay_QMARK_(x){return (x instanceof cljs.core.Delay); +}); +/** +* If x is a Delay, returns the (possibly cached) value of its expression, else returns x +*/ +cljs.core.force = (function force(x){if(cljs.core.delay_QMARK_.call(null,x)) +{return cljs.core.deref.call(null,x); +} else +{return x; +} +}); +/** +* Returns true if a value has been produced for a promise, delay, future or lazy sequence. +*/ +cljs.core.realized_QMARK_ = (function realized_QMARK_(d){return cljs.core._realized_QMARK_.call(null,d); +}); +cljs.core.IEncodeJS = (function (){var obj5842 = {};return obj5842; +})(); +cljs.core._clj__GT_js = (function _clj__GT_js(x){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._clj__GT_js[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._clj__GT_js["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEncodeJS.-clj->js",x); +} +} +})().call(null,x); +} +}); +cljs.core._key__GT_js = (function _key__GT_js(x){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IEncodeJS$_key__GT_js$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._key__GT_js[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._key__GT_js["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEncodeJS.-key->js",x); +} +} +})().call(null,x); +} +}); +cljs.core.key__GT_js = (function key__GT_js(k){if((function (){var G__5844 = k;if(G__5844) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto__ = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return G__5844.cljs$core$IEncodeJS$; +} +})())) +{return true; +} else +{if((!G__5844.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__5844); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__5844); +} +})()) +{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); +} +} +}); +/** +* Recursively transforms ClojureScript values to JavaScript. +* sets/vectors/lists become Arrays, Keywords and Symbol become Strings, +* Maps become Objects. Arbitrary keys are encoded to by key->js. +*/ +cljs.core.clj__GT_js = (function clj__GT_js(x){if((x == null)) +{return null; +} else +{if((function (){var G__5858 = x;if(G__5858) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto__ = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return G__5858.cljs$core$IEncodeJS$; +} +})())) +{return true; +} else +{if((!G__5858.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__5858); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__5858); +} +})()) +{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 obj5860 = {};return obj5860; +})();var seq__5861_5871 = cljs.core.seq.call(null,x);var chunk__5862_5872 = null;var count__5863_5873 = 0;var i__5864_5874 = 0;while(true){ +if((i__5864_5874 < count__5863_5873)) +{var vec__5865_5875 = cljs.core._nth.call(null,chunk__5862_5872,i__5864_5874);var k_5876 = cljs.core.nth.call(null,vec__5865_5875,0,null);var v_5877 = cljs.core.nth.call(null,vec__5865_5875,1,null);(m[cljs.core.key__GT_js.call(null,k_5876)] = clj__GT_js.call(null,v_5877)); +{ +var G__5878 = seq__5861_5871; +var G__5879 = chunk__5862_5872; +var G__5880 = count__5863_5873; +var G__5881 = (i__5864_5874 + 1); +seq__5861_5871 = G__5878; +chunk__5862_5872 = G__5879; +count__5863_5873 = G__5880; +i__5864_5874 = G__5881; +continue; +} +} else +{var temp__4092__auto___5882 = cljs.core.seq.call(null,seq__5861_5871);if(temp__4092__auto___5882) +{var seq__5861_5883__$1 = temp__4092__auto___5882;if(cljs.core.chunked_seq_QMARK_.call(null,seq__5861_5883__$1)) +{var c__4288__auto___5884 = cljs.core.chunk_first.call(null,seq__5861_5883__$1);{ +var G__5885 = cljs.core.chunk_rest.call(null,seq__5861_5883__$1); +var G__5886 = c__4288__auto___5884; +var G__5887 = cljs.core.count.call(null,c__4288__auto___5884); +var G__5888 = 0; +seq__5861_5871 = G__5885; +chunk__5862_5872 = G__5886; +count__5863_5873 = G__5887; +i__5864_5874 = G__5888; +continue; +} +} else +{var vec__5866_5889 = cljs.core.first.call(null,seq__5861_5883__$1);var k_5890 = cljs.core.nth.call(null,vec__5866_5889,0,null);var v_5891 = cljs.core.nth.call(null,vec__5866_5889,1,null);(m[cljs.core.key__GT_js.call(null,k_5890)] = clj__GT_js.call(null,v_5891)); +{ +var G__5892 = cljs.core.next.call(null,seq__5861_5883__$1); +var G__5893 = null; +var G__5894 = 0; +var G__5895 = 0; +seq__5861_5871 = G__5892; +chunk__5862_5872 = G__5893; +count__5863_5873 = G__5894; +i__5864_5874 = G__5895; +continue; +} +} +} else +{} +} +break; +} +return m; +} else +{if(cljs.core.coll_QMARK_.call(null,x)) +{var arr = [];var seq__5867_5896 = cljs.core.seq.call(null,cljs.core.map.call(null,clj__GT_js,x));var chunk__5868_5897 = null;var count__5869_5898 = 0;var i__5870_5899 = 0;while(true){ +if((i__5870_5899 < count__5869_5898)) +{var x_5900__$1 = cljs.core._nth.call(null,chunk__5868_5897,i__5870_5899);arr.push(x_5900__$1); +{ +var G__5901 = seq__5867_5896; +var G__5902 = chunk__5868_5897; +var G__5903 = count__5869_5898; +var G__5904 = (i__5870_5899 + 1); +seq__5867_5896 = G__5901; +chunk__5868_5897 = G__5902; +count__5869_5898 = G__5903; +i__5870_5899 = G__5904; +continue; +} +} else +{var temp__4092__auto___5905 = cljs.core.seq.call(null,seq__5867_5896);if(temp__4092__auto___5905) +{var seq__5867_5906__$1 = temp__4092__auto___5905;if(cljs.core.chunked_seq_QMARK_.call(null,seq__5867_5906__$1)) +{var c__4288__auto___5907 = cljs.core.chunk_first.call(null,seq__5867_5906__$1);{ +var G__5908 = cljs.core.chunk_rest.call(null,seq__5867_5906__$1); +var G__5909 = c__4288__auto___5907; +var G__5910 = cljs.core.count.call(null,c__4288__auto___5907); +var G__5911 = 0; +seq__5867_5896 = G__5908; +chunk__5868_5897 = G__5909; +count__5869_5898 = G__5910; +i__5870_5899 = G__5911; +continue; +} +} else +{var x_5912__$1 = cljs.core.first.call(null,seq__5867_5906__$1);arr.push(x_5912__$1); +{ +var G__5913 = cljs.core.next.call(null,seq__5867_5906__$1); +var G__5914 = null; +var G__5915 = 0; +var G__5916 = 0; +seq__5867_5896 = G__5913; +chunk__5868_5897 = G__5914; +count__5869_5898 = G__5915; +i__5870_5899 = G__5916; +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 obj5918 = {};return obj5918; +})(); +cljs.core._js__GT_clj = (function _js__GT_clj(x,options){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x,options); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._js__GT_clj[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._js__GT_clj["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEncodeClojure.-js->clj",x); +} +} +})().call(null,x,options); +} +}); +/** +* Recursively transforms JavaScript arrays into ClojureScript +* vectors, and JavaScript objects into ClojureScript maps. With +* option ':keywordize-keys true' will convert object fields from +* strings to keywords. +* @param {...*} var_args +*/ +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__5939__delegate = function (x,opts){if((function (){var G__5929 = x;if(G__5929) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto__ = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return G__5929.cljs$core$IEncodeClojure$; +} +})())) +{return true; +} else +{if((!G__5929.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeClojure,G__5929); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeClojure,G__5929); +} +})()) +{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__5930 = opts;var map__5930__$1 = ((cljs.core.seq_QMARK_.call(null,map__5930))?cljs.core.apply.call(null,cljs.core.hash_map,map__5930):map__5930);var keywordize_keys = cljs.core.get.call(null,map__5930__$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__5930,map__5930__$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__4257__auto__ = ((function (map__5930,map__5930__$1,keywordize_keys,keyfn){ +return (function iter__5935(s__5936){return (new cljs.core.LazySeq(null,((function (map__5930,map__5930__$1,keywordize_keys,keyfn){ +return (function (){var s__5936__$1 = s__5936;while(true){ +var temp__4092__auto__ = cljs.core.seq.call(null,s__5936__$1);if(temp__4092__auto__) +{var s__5936__$2 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,s__5936__$2)) +{var c__4255__auto__ = cljs.core.chunk_first.call(null,s__5936__$2);var size__4256__auto__ = cljs.core.count.call(null,c__4255__auto__);var b__5938 = cljs.core.chunk_buffer.call(null,size__4256__auto__);if((function (){var i__5937 = 0;while(true){ +if((i__5937 < size__4256__auto__)) +{var k = cljs.core._nth.call(null,c__4255__auto__,i__5937);cljs.core.chunk_append.call(null,b__5938,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__5940 = (i__5937 + 1); +i__5937 = G__5940; +continue; +} +} else +{return true; +} +break; +} +})()) +{return cljs.core.chunk_cons.call(null,cljs.core.chunk.call(null,b__5938),iter__5935.call(null,cljs.core.chunk_rest.call(null,s__5936__$2))); +} else +{return cljs.core.chunk_cons.call(null,cljs.core.chunk.call(null,b__5938),null); +} +} else +{var k = cljs.core.first.call(null,s__5936__$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__5935.call(null,cljs.core.rest.call(null,s__5936__$2))); +} +} else +{return null; +} +break; +} +});})(map__5930,map__5930__$1,keywordize_keys,keyfn)) +,null,null)); +});})(map__5930,map__5930__$1,keywordize_keys,keyfn)) +;return iter__4257__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__5930,map__5930__$1,keywordize_keys,keyfn)) +;return f.call(null,x); +} else +{return null; +} +} +}; +var G__5939 = 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__5939__delegate.call(this,x,opts);}; +G__5939.cljs$lang$maxFixedArity = 1; +G__5939.cljs$lang$applyTo = (function (arglist__5941){ +var x = cljs.core.first(arglist__5941); +var opts = cljs.core.rest(arglist__5941); +return G__5939__delegate(x,opts); +}); +G__5939.cljs$core$IFn$_invoke$arity$variadic = G__5939__delegate; +return G__5939; +})() +; +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; +})() +; +/** +* Returns a memoized version of a referentially transparent function. The +* memoized version of the function keeps a cache of the mapping from arguments +* to results and, when calls with the same arguments are repeated often, has +* higher performance at the expense of higher memory use. +*/ +cljs.core.memoize = (function memoize(f){var mem = cljs.core.atom.call(null,cljs.core.PersistentArrayMap.EMPTY);return (function() { +var G__5942__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__5942 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__5942__delegate.call(this,args);}; +G__5942.cljs$lang$maxFixedArity = 0; +G__5942.cljs$lang$applyTo = (function (arglist__5943){ +var args = cljs.core.seq(arglist__5943); +return G__5942__delegate(args); +}); +G__5942.cljs$core$IFn$_invoke$arity$variadic = G__5942__delegate; +return G__5942; +})() +; +}); +/** +* trampoline can be used to convert algorithms requiring mutual +* recursion without stack consumption. Calls f with supplied args, if +* any. If f returns a fn, calls that fn with no arguments, and +* continues to repeat, until the return value is not a fn, then +* returns that non-fn value. Note that if you want to return a fn as a +* final value, you must wrap it in some data structure and unpack it +* after trampoline returns. +* @param {...*} var_args +*/ +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__5944 = ret; +f = G__5944; +continue; +} +} else +{return ret; +} +break; +} +}); +var trampoline__2 = (function() { +var G__5945__delegate = function (f,args){return trampoline.call(null,(function (){return cljs.core.apply.call(null,f,args); +})); +}; +var G__5945 = 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__5945__delegate.call(this,f,args);}; +G__5945.cljs$lang$maxFixedArity = 1; +G__5945.cljs$lang$applyTo = (function (arglist__5946){ +var f = cljs.core.first(arglist__5946); +var args = cljs.core.rest(arglist__5946); +return G__5945__delegate(f,args); +}); +G__5945.cljs$core$IFn$_invoke$arity$variadic = G__5945__delegate; +return G__5945; +})() +; +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; +})() +; +/** +* Returns a random floating point number between 0 (inclusive) and +* n (default 1) (exclusive). +*/ +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; +})() +; +/** +* Returns a random integer between 0 (inclusive) and n (exclusive). +*/ +cljs.core.rand_int = (function rand_int(n){return Math.floor.call(null,(Math.random.call(null) * n)); +}); +/** +* Return a random element of the (sequential) collection. Will have +* the same performance characteristics as nth for the given +* collection. +*/ +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))); +}); +/** +* Returns a map of the elements of coll keyed by the result of +* f on each element. The value at each key will be a vector of the +* corresponding elements, in the order they appeared in 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); +}); +/** +* Creates a hierarchy object for use with derive, isa? etc. +*/ +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; +}); +/** +* @param {...*} var_args +*/ +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__5947){ +var f = cljs.core.first(arglist__5947); +var args = cljs.core.rest(arglist__5947); +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_; +})() +; +/** +* Returns true if (= child parent), or child is directly or indirectly derived from +* parent, either via a JavaScript type inheritance relationship or a +* relationship established via derive. h must be a hierarchy obtained +* from make-hierarchy, if not supplied defaults to the global +* hierarchy +*/ +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__3540__auto__ = cljs.core._EQ_.call(null,child,parent);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__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__3540__auto____$1) +{return or__3540__auto____$1; +} else +{var and__3528__auto__ = cljs.core.vector_QMARK_.call(null,parent);if(and__3528__auto__) +{var and__3528__auto____$1 = cljs.core.vector_QMARK_.call(null,child);if(and__3528__auto____$1) +{var and__3528__auto____$2 = (cljs.core.count.call(null,parent) === cljs.core.count.call(null,child));if(and__3528__auto____$2) +{var ret = true;var i = 0;while(true){ +if((!(ret)) || ((i === cljs.core.count.call(null,parent)))) +{return ret; +} else +{{ +var G__5948 = isa_QMARK_.call(null,h,child.call(null,i),parent.call(null,i)); +var G__5949 = (i + 1); +ret = G__5948; +i = G__5949; +continue; +} +} +break; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__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_; +})() +; +/** +* Returns the immediate parents of tag, either via a JavaScript type +* inheritance relationship or a relationship established via derive. h +* must be a hierarchy obtained from make-hierarchy, if not supplied +* defaults to the global hierarchy +*/ +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; +})() +; +/** +* Returns the immediate and indirect parents of tag, either via a JavaScript type +* inheritance relationship or a relationship established via derive. h +* must be a hierarchy obtained from make-hierarchy, if not supplied +* defaults to the global hierarchy +*/ +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; +})() +; +/** +* Returns the immediate and indirect children of tag, through a +* relationship established via derive. h must be a hierarchy obtained +* from make-hierarchy, if not supplied defaults to the global +* hierarchy. Note: does not work on JavaScript type inheritance +* relationships. +*/ +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; +})() +; +/** +* Establishes a parent/child relationship between parent and +* tag. Parent must be a namespace-qualified symbol or keyword and +* child can be either a namespace-qualified symbol or keyword or a +* class. h must be a hierarchy obtained from make-hierarchy, if not +* supplied defaults to, and modifies, the global hierarchy. +*/ +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=","not=",-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__3540__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__3540__auto__)) +{return or__3540__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; +})() +; +/** +* Removes a parent/child relationship between parent and +* tag. h must be a hierarchy obtained from make-hierarchy, if not +* supplied defaults to, and modifies, the global hierarchy. +*/ +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__5950_SHARP_){return cljs.core.cons.call(null,cljs.core.first.call(null,p1__5950_SHARP_),cljs.core.interpose.call(null,cljs.core.first.call(null,p1__5950_SHARP_),cljs.core.second.call(null,p1__5950_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__5951_SHARP_,p2__5952_SHARP_){return cljs.core.apply.call(null,cljs.core.derive,p1__5951_SHARP_,p2__5952_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__3540__auto__ = (cljs.core.truth_((function (){var and__3528__auto__ = xprefs;if(cljs.core.truth_(and__3528__auto__)) +{return xprefs.call(null,y); +} else +{return and__3528__auto__; +} +})())?true:null);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__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__5953 = cljs.core.rest.call(null,ps); +ps = G__5953; +continue; +} +} else +{return null; +} +break; +} +})();if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__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__5954 = cljs.core.rest.call(null,ps); +ps = G__5954; +continue; +} +} else +{return null; +} +break; +} +})();if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{return false; +} +} +} +}); +cljs.core.dominates = (function dominates(x,y,prefer_table){var or__3540__auto__ = cljs.core.prefers_STAR_.call(null,x,y,prefer_table);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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__5957){var vec__5958 = p__5957;var k = cljs.core.nth.call(null,vec__5958,0,null);var _ = cljs.core.nth.call(null,vec__5958,1,null);var e = vec__5958;if(cljs.core.isa_QMARK_.call(null,cljs.core.deref.call(null,hierarchy),dispatch_val,k)) +{var be2 = (cljs.core.truth_((function (){var or__3540__auto__ = (be == null);if(or__3540__auto__) +{return or__3540__auto__; +} else +{return cljs.core.dominates.call(null,k,cljs.core.first.call(null,be),prefer_table); +} +})())?e:be);if(cljs.core.truth_(cljs.core.dominates.call(null,cljs.core.first.call(null,be2),k,prefer_table))) +{} else +{throw (new Error([cljs.core.str("Multiple methods in multimethod '"),cljs.core.str(name),cljs.core.str("' match dispatch value: "),cljs.core.str(dispatch_val),cljs.core.str(" -> "),cljs.core.str(k),cljs.core.str(" and "),cljs.core.str(cljs.core.first.call(null,be2)),cljs.core.str(", and neither is preferred")].join(''))); +} +return be2; +} else +{return be; +} +}),null,cljs.core.deref.call(null,method_table));if(cljs.core.truth_(best_entry)) +{if(cljs.core._EQ_.call(null,cljs.core.deref.call(null,cached_hierarchy),cljs.core.deref.call(null,hierarchy))) +{cljs.core.swap_BANG_.call(null,method_cache,cljs.core.assoc,dispatch_val,cljs.core.second.call(null,best_entry)); +return cljs.core.second.call(null,best_entry); +} else +{cljs.core.reset_cache.call(null,method_cache,method_table,cached_hierarchy,hierarchy); +return find_and_cache_best_method.call(null,name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy); +} +} else +{return null; +} +}); +cljs.core.IMultiFn = (function (){var obj5960 = {};return obj5960; +})(); +cljs.core._reset = (function _reset(mf){if((function (){var and__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_reset$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_reset$arity$1(mf); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._reset[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reset["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_add_method$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_add_method$arity$3(mf,dispatch_val,method); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._add_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._add_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_remove_method$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf,dispatch_val); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._remove_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._remove_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_prefer_method$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf,dispatch_val,dispatch_val_y); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._prefer_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._prefer_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_get_method$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_get_method$arity$2(mf,dispatch_val); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._get_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._get_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_methods$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_methods$arity$1(mf); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._methods[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._methods["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_prefers$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_prefers$arity$1(mf); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._prefers[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._prefers["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_dispatch$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_dispatch$arity$2(mf,args); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._dispatch[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._dispatch["_"]);if(or__3540__auto____$1) +{return or__3540__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); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__5961__delegate = function (_,args){var self = this;return cljs.core._dispatch.call(null,self,args); +}; +var G__5961 = function (_,var_args){ +var args = null;if (arguments.length > 1) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1),0);} +return G__5961__delegate.call(this,_,args);}; +G__5961.cljs$lang$maxFixedArity = 1; +G__5961.cljs$lang$applyTo = (function (arglist__5962){ +var _ = cljs.core.first(arglist__5962); +var args = cljs.core.rest(arglist__5962); +return G__5961__delegate(_,args); +}); +G__5961.cljs$core$IFn$_invoke$arity$variadic = G__5961__delegate; +return G__5961; +})() +; +cljs.core.MultiFn.prototype.apply = (function (_,args){var self = this;return cljs.core._dispatch.call(null,self,args); +}); +/** +* Removes all of the methods of multimethod. +*/ +cljs.core.remove_all_methods = (function remove_all_methods(multifn){return cljs.core._reset.call(null,multifn); +}); +/** +* Removes the method of multimethod associated with dispatch-value. +*/ +cljs.core.remove_method = (function remove_method(multifn,dispatch_val){return cljs.core._remove_method.call(null,multifn,dispatch_val); +}); +/** +* Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y +* when there is a conflict +*/ +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); +}); +/** +* Given a multimethod, returns a map of dispatch values -> dispatch fns +*/ +cljs.core.methods$ = (function methods$(multifn){return cljs.core._methods.call(null,multifn); +}); +/** +* Given a multimethod and a dispatch value, returns the dispatch fn +* that would apply to that value, or nil if none apply and no default +*/ +cljs.core.get_method = (function get_method(multifn,dispatch_val){return cljs.core._get_method.call(null,multifn,dispatch_val); +}); +/** +* Given a multimethod, returns a map of preferred value -> set of other values +*/ +cljs.core.prefers = (function prefers(multifn){return cljs.core._prefers.call(null,multifn); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); + +/** +* @constructor +*/ +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__4110__auto__,writer__4111__auto__,opts__4112__auto__){return cljs.core._write.call(null,writer__4111__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; +/** +* Alpha - subject to change. +* Create an instance of ExceptionInfo, an Error type that carries a +* map of additional data. +*/ +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; +})() +; +/** +* Alpha - subject to change. +* Returns exception data (a map) if ex is an ExceptionInfo. +* Otherwise returns nil. +*/ +cljs.core.ex_data = (function ex_data(ex){if((ex instanceof cljs.core.ExceptionInfo)) +{return ex.data; +} else +{return null; +} +}); +/** +* Alpha - subject to change. +* Returns the message attached to the given Error / ExceptionInfo object. +* For non-Errors returns nil. +*/ +cljs.core.ex_message = (function ex_message(ex){if((ex instanceof Error)) +{return ex.message; +} else +{return null; +} +}); +/** +* Alpha - subject to change. +* Returns exception cause (an Error / ExceptionInfo) if ex is an +* ExceptionInfo. +* Otherwise returns nil. +*/ +cljs.core.ex_cause = (function ex_cause(ex){if((ex instanceof cljs.core.ExceptionInfo)) +{return ex.cause; +} else +{return null; +} +}); +/** +* Returns an JavaScript compatible comparator based upon pred. +*/ +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,"&","&",-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); +}); diff --git a/out/clojure/browser/event.cljs b/out/clojure/browser/event.cljs new file mode 100644 index 0000000..449ed5b --- /dev/null +++ b/out/clojure/browser/event.cljs @@ -0,0 +1,100 @@ +;; Copyright (c) Rich Hickey. All rights reserved. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "This namespace contains functions to work with browser +events. It is based on the Google Closure Library event system." + :author "Bobby Calderwood"} + clojure.browser.event + (:require [goog.events :as events] + [goog.events.EventTarget :as gevent-target] + [goog.events.EventType :as gevent-type])) + +(defprotocol EventType + (event-types [this])) + +(extend-protocol EventType + + goog.events.EventTarget + (event-types + [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.events.EventType))))) + + js/Element + (event-types + [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.events.EventType)))))) + +(defn listen + ([src type fn] + (listen src type fn false)) + ([src type fn capture?] + (goog.events/listen src + (get (event-types src) type type) + fn + capture?))) + +(defn listen-once + ([src type fn] + (listen-once src type fn false)) + ([src type fn capture?] + (goog.events/listenOnce src + (get (event-types src) type type) + fn + capture?))) + +(defn unlisten + ([src type fn] + (unlisten src type fn false)) + ([src type fn capture?] + (goog.events/unlisten src + (get (event-types src) type type) + fn + capture?))) + +(defn unlisten-by-key + [key] + (goog.events/unlistenByKey key)) + +(defn dispatch-event + [src event] + (goog.events/dispatchEvent src event)) + +(defn expose [e] + (goog.events/expose e)) + +(defn fire-listeners + [obj type capture event]) + +(defn total-listener-count [] + (goog.events/getTotalListenerCount)) + +;; TODO +(defn get-listener [src type listener opt_capt opt_handler]); ⇒ ?Listener +(defn all-listeners [obj type capture]); ⇒ Array. + +(defn unique-event-id [event-type]); ⇒ string + +(defn has-listener [obj opt_type opt_capture]); ⇒ boolean +;; TODO? (defn listen-with-wrapper [src wrapper listener opt_capt opt_handler]) +;; TODO? (defn protect-browser-event-entry-point [errorHandler]) + +(defn remove-all [opt_obj opt_type opt_capt]); ⇒ number +;; TODO? (defn unlisten-with-wrapper [src wrapper listener opt_capt opt_handler]) + diff --git a/out/clojure/browser/event.js b/out/clojure/browser/event.js new file mode 100644 index 0000000..add325a --- /dev/null +++ b/out/clojure/browser/event.js @@ -0,0 +1,119 @@ +// Compiled by ClojureScript 0.0-2173 +goog.provide('clojure.browser.event'); +goog.require('cljs.core'); +goog.require('goog.events.EventType'); +goog.require('goog.events.EventType'); +goog.require('goog.events.EventTarget'); +goog.require('goog.events.EventTarget'); +goog.require('goog.events'); +goog.require('goog.events'); +clojure.browser.event.EventType = (function (){var obj5984 = {};return obj5984; +})(); +clojure.browser.event.event_types = (function event_types(this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$event$EventType$event_types$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$event$EventType$event_types$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.event.event_types[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.event.event_types["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"EventType.event-types",this$); +} +} +})().call(null,this$); +} +}); +Element.prototype.clojure$browser$event$EventType$ = true; +Element.prototype.clojure$browser$event$EventType$event_types$arity$1 = (function (this$){var this$__$1 = this;return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__5985){var vec__5986 = p__5985;var k = cljs.core.nth.call(null,vec__5986,0,null);var v = cljs.core.nth.call(null,vec__5986,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.events.EventType)))); +}); +goog.events.EventTarget.prototype.clojure$browser$event$EventType$ = true; +goog.events.EventTarget.prototype.clojure$browser$event$EventType$event_types$arity$1 = (function (this$){var this$__$1 = this;return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__5987){var vec__5988 = p__5987;var k = cljs.core.nth.call(null,vec__5988,0,null);var v = cljs.core.nth.call(null,vec__5988,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.events.EventType)))); +}); +clojure.browser.event.listen = (function() { +var listen = null; +var listen__3 = (function (src,type,fn){return listen.call(null,src,type,fn,false); +}); +var listen__4 = (function (src,type,fn,capture_QMARK_){return goog.events.listen(src,cljs.core.get.call(null,clojure.browser.event.event_types.call(null,src),type,type),fn,capture_QMARK_); +}); +listen = function(src,type,fn,capture_QMARK_){ +switch(arguments.length){ +case 3: +return listen__3.call(this,src,type,fn); +case 4: +return listen__4.call(this,src,type,fn,capture_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +listen.cljs$core$IFn$_invoke$arity$3 = listen__3; +listen.cljs$core$IFn$_invoke$arity$4 = listen__4; +return listen; +})() +; +clojure.browser.event.listen_once = (function() { +var listen_once = null; +var listen_once__3 = (function (src,type,fn){return listen_once.call(null,src,type,fn,false); +}); +var listen_once__4 = (function (src,type,fn,capture_QMARK_){return goog.events.listenOnce(src,cljs.core.get.call(null,clojure.browser.event.event_types.call(null,src),type,type),fn,capture_QMARK_); +}); +listen_once = function(src,type,fn,capture_QMARK_){ +switch(arguments.length){ +case 3: +return listen_once__3.call(this,src,type,fn); +case 4: +return listen_once__4.call(this,src,type,fn,capture_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +listen_once.cljs$core$IFn$_invoke$arity$3 = listen_once__3; +listen_once.cljs$core$IFn$_invoke$arity$4 = listen_once__4; +return listen_once; +})() +; +clojure.browser.event.unlisten = (function() { +var unlisten = null; +var unlisten__3 = (function (src,type,fn){return unlisten.call(null,src,type,fn,false); +}); +var unlisten__4 = (function (src,type,fn,capture_QMARK_){return goog.events.unlisten(src,cljs.core.get.call(null,clojure.browser.event.event_types.call(null,src),type,type),fn,capture_QMARK_); +}); +unlisten = function(src,type,fn,capture_QMARK_){ +switch(arguments.length){ +case 3: +return unlisten__3.call(this,src,type,fn); +case 4: +return unlisten__4.call(this,src,type,fn,capture_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +unlisten.cljs$core$IFn$_invoke$arity$3 = unlisten__3; +unlisten.cljs$core$IFn$_invoke$arity$4 = unlisten__4; +return unlisten; +})() +; +clojure.browser.event.unlisten_by_key = (function unlisten_by_key(key){return goog.events.unlistenByKey(key); +}); +clojure.browser.event.dispatch_event = (function dispatch_event(src,event){return goog.events.dispatchEvent(src,event); +}); +clojure.browser.event.expose = (function expose(e){return goog.events.expose(e); +}); +clojure.browser.event.fire_listeners = (function fire_listeners(obj,type,capture,event){return null; +}); +clojure.browser.event.total_listener_count = (function total_listener_count(){return goog.events.getTotalListenerCount(); +}); +clojure.browser.event.get_listener = (function get_listener(src,type,listener,opt_capt,opt_handler){return null; +}); +clojure.browser.event.all_listeners = (function all_listeners(obj,type,capture){return null; +}); +clojure.browser.event.unique_event_id = (function unique_event_id(event_type){return null; +}); +clojure.browser.event.has_listener = (function has_listener(obj,opt_type,opt_capture){return null; +}); +clojure.browser.event.remove_all = (function remove_all(opt_obj,opt_type,opt_capt){return null; +}); diff --git a/out/clojure/browser/net.cljs b/out/clojure/browser/net.cljs new file mode 100644 index 0000000..29769e2 --- /dev/null +++ b/out/clojure/browser/net.cljs @@ -0,0 +1,183 @@ +;; Copyright (c) Rich Hickey. All rights reserved. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "Network communication library, wrapping goog.net. +Includes a common API over XhrIo, CrossPageChannel, and Websockets." + :author "Bobby Calderwood and Alex Redington"} + clojure.browser.net + (:require [clojure.browser.event :as event] + [goog.net.XhrIo :as gxhrio] + [goog.net.EventType :as gnet-event-type] + [goog.net.xpc.CfgFields :as gxpc-config-fields] + [goog.net.xpc.CrossPageChannel :as xpc] + #_[goog.net.WebSocket :as gwebsocket] + [goog.json :as gjson])) + +(def *timeout* 10000) + +(def event-types + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.net.EventType))))) + +(defprotocol IConnection + (connect + [this] + [this opt1] + [this opt1 opt2] + [this opt1 opt2 opt3]) + (transmit + [this opt] + [this opt opt2] + [this opt opt2 opt3] + [this opt opt2 opt3 opt4] + [this opt opt2 opt3 opt4 opt5]) + (close [this])) + +(extend-type goog.net.XhrIo + + IConnection + (transmit + ([this uri] + (transmit this uri "GET" nil nil *timeout*)) + ([this uri method] + (transmit this uri method nil nil *timeout*)) + ([this uri method content] + (transmit this uri method content nil *timeout*)) + ([this uri method content headers] + (transmit this uri method content headers *timeout*)) + ([this uri method content headers timeout] + (.setTimeoutInterval this timeout) + (.send this uri method content headers))) + + + event/EventType + (event-types [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.net.EventType)))))) + +;; TODO jQuery/sinatra/RestClient style API: (get [uri]), (post [uri payload]), (put [uri payload]), (delete [uri]) + +(def xpc-config-fields + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (js->clj goog.net.xpc.CfgFields)))) + +(defn xhr-connection + "Returns an XhrIo connection" + [] + (goog.net.XhrIo.)) + +(defprotocol ICrossPageChannel + (register-service [this service-name fn] [this service-name fn encode-json?])) + +(extend-type goog.net.xpc.CrossPageChannel + + ICrossPageChannel + (register-service + ([this service-name fn] + (register-service this service-name fn false)) + ([this service-name fn encode-json?] + (.registerService this (name service-name) fn encode-json?))) + + IConnection + (connect + ([this] + (connect this nil)) + ([this on-connect-fn] + (.connect this on-connect-fn)) + ([this on-connect-fn config-iframe-fn] + (connect this on-connect-fn config-iframe-fn (.-body js/document))) + ([this on-connect-fn config-iframe-fn iframe-parent] + (.createPeerIframe this iframe-parent config-iframe-fn) + (.connect this on-connect-fn))) + + (transmit [this service-name payload] + (.send this (name service-name) payload)) + + (close [this] + (.close this ()))) + +(defn xpc-connection + "When passed with a config hash-map, returns a parent + CrossPageChannel object. Keys in the config hash map are downcased + versions of the goog.net.xpc.CfgFields enum keys, + e.g. goog.net.xpc.CfgFields.PEER_URI becomes :peer_uri in the config + hash. + + When passed with no args, creates a child CrossPageChannel object, + and the config is automatically taken from the URL param 'xpc', as + per the CrossPageChannel API." + ([] + (when-let [config (.getParameterValue + (goog.Uri. (.-href (.-location js/window))) + "xpc")] + (goog.net.xpc.CrossPageChannel. (gjson/parse config)))) + ([config] + (goog.net.xpc.CrossPageChannel. + (reduce (fn [sum [k v]] + (if-let [field (get xpc-config-fields k)] + (doto sum (aset field v)) + sum)) + (js-obj) + config)))) + +;; WebSocket is not supported in the 3/23/11 release of Google +;; Closure, but will be included in the next release. + +#_(defprotocol IWebSocket + (open? [this])) + +#_(extend-type goog.net.WebSocket + + IWebSocket + (open? [this] + (.isOpen this ())) + + IConnection + (connect + ([this url] + (connect this url nil)) + ([this url protocol] + (.open this url protocol))) + + (transmit [this message] + (.send this message)) + + (close [this] + (.close this ())) + + event/EventType + (event-types [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.net.WebSocket/EventType)))))) + +#_(defn websocket-connection + ([] + (websocket-connection nil nil)) + ([auto-reconnect?] + (websocket-connection auto-reconnect? nil)) + ([auto-reconnect? next-reconnect-fn] + (goog.net.WebSocket. auto-reconnect? next-reconnect-fn))) \ No newline at end of file diff --git a/out/clojure/browser/net.js b/out/clojure/browser/net.js new file mode 100644 index 0000000..901b74c --- /dev/null +++ b/out/clojure/browser/net.js @@ -0,0 +1,409 @@ +// Compiled by ClojureScript 0.0-2173 +goog.provide('clojure.browser.net'); +goog.require('cljs.core'); +goog.require('goog.net.XhrIo'); +goog.require('goog.net.xpc.CrossPageChannel'); +goog.require('clojure.browser.event'); +goog.require('goog.json'); +goog.require('goog.net.xpc.CfgFields'); +goog.require('clojure.browser.event'); +goog.require('goog.net.EventType'); +goog.require('goog.net.EventType'); +goog.require('goog.net.xpc.CrossPageChannel'); +goog.require('goog.json'); +goog.require('goog.net.XhrIo'); +goog.require('goog.net.xpc.CfgFields'); +clojure.browser.net._STAR_timeout_STAR_ = 10000; +clojure.browser.net.event_types = cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__5963){var vec__5964 = p__5963;var k = cljs.core.nth.call(null,vec__5964,0,null);var v = cljs.core.nth.call(null,vec__5964,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.net.EventType)))); +clojure.browser.net.IConnection = (function (){var obj5966 = {};return obj5966; +})(); +clojure.browser.net.connect = (function() { +var connect = null; +var connect__1 = (function (this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$); +} +}); +var connect__2 = (function (this$,opt1){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$2(this$,opt1); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$,opt1); +} +}); +var connect__3 = (function (this$,opt1,opt2){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$3(this$,opt1,opt2); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$,opt1,opt2); +} +}); +var connect__4 = (function (this$,opt1,opt2,opt3){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$4(this$,opt1,opt2,opt3); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$,opt1,opt2,opt3); +} +}); +connect = function(this$,opt1,opt2,opt3){ +switch(arguments.length){ +case 1: +return connect__1.call(this,this$); +case 2: +return connect__2.call(this,this$,opt1); +case 3: +return connect__3.call(this,this$,opt1,opt2); +case 4: +return connect__4.call(this,this$,opt1,opt2,opt3); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +connect.cljs$core$IFn$_invoke$arity$1 = connect__1; +connect.cljs$core$IFn$_invoke$arity$2 = connect__2; +connect.cljs$core$IFn$_invoke$arity$3 = connect__3; +connect.cljs$core$IFn$_invoke$arity$4 = connect__4; +return connect; +})() +; +clojure.browser.net.transmit = (function() { +var transmit = null; +var transmit__2 = (function (this$,opt){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$2(this$,opt); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt); +} +}); +var transmit__3 = (function (this$,opt,opt2){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$3(this$,opt,opt2); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2); +} +}); +var transmit__4 = (function (this$,opt,opt2,opt3){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$4(this$,opt,opt2,opt3); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2,opt3); +} +}); +var transmit__5 = (function (this$,opt,opt2,opt3,opt4){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$5; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$5(this$,opt,opt2,opt3,opt4); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2,opt3,opt4); +} +}); +var transmit__6 = (function (this$,opt,opt2,opt3,opt4,opt5){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$6; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$6(this$,opt,opt2,opt3,opt4,opt5); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2,opt3,opt4,opt5); +} +}); +transmit = function(this$,opt,opt2,opt3,opt4,opt5){ +switch(arguments.length){ +case 2: +return transmit__2.call(this,this$,opt); +case 3: +return transmit__3.call(this,this$,opt,opt2); +case 4: +return transmit__4.call(this,this$,opt,opt2,opt3); +case 5: +return transmit__5.call(this,this$,opt,opt2,opt3,opt4); +case 6: +return transmit__6.call(this,this$,opt,opt2,opt3,opt4,opt5); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +transmit.cljs$core$IFn$_invoke$arity$2 = transmit__2; +transmit.cljs$core$IFn$_invoke$arity$3 = transmit__3; +transmit.cljs$core$IFn$_invoke$arity$4 = transmit__4; +transmit.cljs$core$IFn$_invoke$arity$5 = transmit__5; +transmit.cljs$core$IFn$_invoke$arity$6 = transmit__6; +return transmit; +})() +; +clojure.browser.net.close = (function close(this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$close$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$close$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.close[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.close["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.close",this$); +} +} +})().call(null,this$); +} +}); +goog.net.XhrIo.prototype.clojure$browser$event$EventType$ = true; +goog.net.XhrIo.prototype.clojure$browser$event$EventType$event_types$arity$1 = (function (this$){var this$__$1 = this;return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__5967){var vec__5968 = p__5967;var k = cljs.core.nth.call(null,vec__5968,0,null);var v = cljs.core.nth.call(null,vec__5968,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.net.EventType)))); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$ = true; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$2 = (function (this$,uri){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,"GET",null,null,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$3 = (function (this$,uri,method){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,method,null,null,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$4 = (function (this$,uri,method,content){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,method,content,null,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$5 = (function (this$,uri,method,content,headers){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,method,content,headers,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$6 = (function (this$,uri,method,content,headers,timeout){var this$__$1 = this;this$__$1.setTimeoutInterval(timeout); +return this$__$1.send(uri,method,content,headers); +}); +clojure.browser.net.xpc_config_fields = cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__5969){var vec__5970 = p__5969;var k = cljs.core.nth.call(null,vec__5970,0,null);var v = cljs.core.nth.call(null,vec__5970,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.js__GT_clj.call(null,goog.net.xpc.CfgFields))); +/** +* Returns an XhrIo connection +*/ +clojure.browser.net.xhr_connection = (function xhr_connection(){return (new goog.net.XhrIo()); +}); +clojure.browser.net.ICrossPageChannel = (function (){var obj5972 = {};return obj5972; +})(); +clojure.browser.net.register_service = (function() { +var register_service = null; +var register_service__3 = (function (this$,service_name,fn){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$3(this$,service_name,fn); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.register_service[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.register_service["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICrossPageChannel.register-service",this$); +} +} +})().call(null,this$,service_name,fn); +} +}); +var register_service__4 = (function (this$,service_name,fn,encode_json_QMARK_){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$4(this$,service_name,fn,encode_json_QMARK_); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.register_service[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.register_service["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICrossPageChannel.register-service",this$); +} +} +})().call(null,this$,service_name,fn,encode_json_QMARK_); +} +}); +register_service = function(this$,service_name,fn,encode_json_QMARK_){ +switch(arguments.length){ +case 3: +return register_service__3.call(this,this$,service_name,fn); +case 4: +return register_service__4.call(this,this$,service_name,fn,encode_json_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +register_service.cljs$core$IFn$_invoke$arity$3 = register_service__3; +register_service.cljs$core$IFn$_invoke$arity$4 = register_service__4; +return register_service; +})() +; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$ = true; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$1 = (function (this$){var this$__$1 = this;return clojure.browser.net.connect.call(null,this$__$1,null); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$2 = (function (this$,on_connect_fn){var this$__$1 = this;return this$__$1.connect(on_connect_fn); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$3 = (function (this$,on_connect_fn,config_iframe_fn){var this$__$1 = this;return clojure.browser.net.connect.call(null,this$__$1,on_connect_fn,config_iframe_fn,document.body); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$4 = (function (this$,on_connect_fn,config_iframe_fn,iframe_parent){var this$__$1 = this;this$__$1.createPeerIframe(iframe_parent,config_iframe_fn); +return this$__$1.connect(on_connect_fn); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$transmit$arity$3 = (function (this$,service_name,payload){var this$__$1 = this;return this$__$1.send(cljs.core.name.call(null,service_name),payload); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$close$arity$1 = (function (this$){var this$__$1 = this;return this$__$1.close(cljs.core.List.EMPTY); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$ = true; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$3 = (function (this$,service_name,fn){var this$__$1 = this;return clojure.browser.net.register_service.call(null,this$__$1,service_name,fn,false); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$4 = (function (this$,service_name,fn,encode_json_QMARK_){var this$__$1 = this;return this$__$1.registerService(cljs.core.name.call(null,service_name),fn,encode_json_QMARK_); +}); +/** +* When passed with a config hash-map, returns a parent +* CrossPageChannel object. Keys in the config hash map are downcased +* versions of the goog.net.xpc.CfgFields enum keys, +* e.g. goog.net.xpc.CfgFields.PEER_URI becomes :peer_uri in the config +* hash. +* +* When passed with no args, creates a child CrossPageChannel object, +* and the config is automatically taken from the URL param 'xpc', as +* per the CrossPageChannel API. +*/ +clojure.browser.net.xpc_connection = (function() { +var xpc_connection = null; +var xpc_connection__0 = (function (){var temp__4092__auto__ = (new goog.Uri(window.location.href)).getParameterValue("xpc");if(cljs.core.truth_(temp__4092__auto__)) +{var config = temp__4092__auto__;return (new goog.net.xpc.CrossPageChannel(goog.json.parse(config))); +} else +{return null; +} +}); +var xpc_connection__1 = (function (config){return (new goog.net.xpc.CrossPageChannel(cljs.core.reduce.call(null,(function (sum,p__5978){var vec__5979 = p__5978;var k = cljs.core.nth.call(null,vec__5979,0,null);var v = cljs.core.nth.call(null,vec__5979,1,null);var temp__4090__auto__ = cljs.core.get.call(null,clojure.browser.net.xpc_config_fields,k);if(cljs.core.truth_(temp__4090__auto__)) +{var field = temp__4090__auto__;var G__5980 = sum;(G__5980[field] = v); +return G__5980; +} else +{return sum; +} +}),(function (){var obj5982 = {};return obj5982; +})(),config))); +}); +xpc_connection = function(config){ +switch(arguments.length){ +case 0: +return xpc_connection__0.call(this); +case 1: +return xpc_connection__1.call(this,config); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +xpc_connection.cljs$core$IFn$_invoke$arity$0 = xpc_connection__0; +xpc_connection.cljs$core$IFn$_invoke$arity$1 = xpc_connection__1; +return xpc_connection; +})() +; diff --git a/out/clojure/browser/repl.cljs b/out/clojure/browser/repl.cljs new file mode 100644 index 0000000..5038e4a --- /dev/null +++ b/out/clojure/browser/repl.cljs @@ -0,0 +1,109 @@ +;; Copyright (c) Rich Hickey. All rights reserved. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "Receive - Eval - Print - Loop + + Receive a block of JS (presumably generated by a ClojureScript compiler) + Evaluate it naively + Print the result of evaluation to a string + Send the resulting string back to the server Loop!" + + :author "Bobby Calderwood and Alex Redington"} + clojure.browser.repl + (:require [clojure.browser.net :as net] + [clojure.browser.event :as event])) + +(def xpc-connection (atom nil)) + +(defn repl-print [data] + (if-let [conn @xpc-connection] + (net/transmit conn :print (pr-str data)))) + +(defn evaluate-javascript + "Process a single block of JavaScript received from the server" + [conn block] + (let [result (try {:status :success :value (str (js* "eval(~{block})"))} + (catch :default e + {:status :exception :value (pr-str e) + :stacktrace (if (.hasOwnProperty e "stack") + (.-stack e) + "No stacktrace available.")}))] + (pr-str result))) + +(defn send-result [connection url data] + (net/transmit connection url "POST" data nil 0)) + +(defn send-print + "Send data to be printed in the REPL. If there is an error, try again + up to 10 times." + ([url data] + (send-print url data 0)) + ([url data n] + (let [conn (net/xhr-connection)] + (event/listen conn :error + (fn [_] + (if (< n 10) + (send-print url data (inc n)) + (.log js/console (str "Could not send " data " after " n " attempts."))))) + (net/transmit conn url "POST" data nil 0)))) + +(def order (atom 0)) + +(defn wrap-message [t data] + (pr-str {:type t :content data :order (swap! order inc)})) + +(defn start-evaluator + "Start the REPL server connection." + [url] + (if-let [repl-connection (net/xpc-connection)] + (let [connection (net/xhr-connection)] + (event/listen connection + :success + (fn [e] + (net/transmit + repl-connection + :evaluate-javascript + (.getResponseText (.-currentTarget e) + ())))) + + (net/register-service repl-connection + :send-result + (fn [data] + (send-result connection url (wrap-message :result data)))) + + (net/register-service repl-connection + :print + (fn [data] + (send-print url (wrap-message :print data)))) + + (net/connect repl-connection + (constantly nil)) + + (js/setTimeout #(send-result connection url (wrap-message :ready "ready")) 50)) + (js/alert "No 'xpc' param provided to child iframe."))) + +(defn connect + "Connects to a REPL server from an HTML document. After the + connection is made, the REPL will evaluate forms in the context of + the document that called this function." + [repl-server-url] + (let [repl-connection (net/xpc-connection + {:peer_uri repl-server-url})] + (swap! xpc-connection (constantly repl-connection)) + (net/register-service repl-connection + :evaluate-javascript + (fn [js] + (net/transmit + repl-connection + :send-result + (evaluate-javascript repl-connection js)))) + (net/connect repl-connection + (constantly nil) + (fn [iframe] + (set! (.-display (.-style iframe)) + "none"))))) diff --git a/out/clojure/browser/repl.js b/out/clojure/browser/repl.js new file mode 100644 index 0000000..fdf2545 --- /dev/null +++ b/out/clojure/browser/repl.js @@ -0,0 +1,84 @@ +// Compiled by ClojureScript 0.0-2173 +goog.provide('clojure.browser.repl'); +goog.require('cljs.core'); +goog.require('clojure.browser.event'); +goog.require('clojure.browser.event'); +goog.require('clojure.browser.net'); +goog.require('clojure.browser.net'); +clojure.browser.repl.xpc_connection = cljs.core.atom.call(null,null); +clojure.browser.repl.repl_print = (function repl_print(data){var temp__4090__auto__ = cljs.core.deref.call(null,clojure.browser.repl.xpc_connection);if(cljs.core.truth_(temp__4090__auto__)) +{var conn = temp__4090__auto__;return clojure.browser.net.transmit.call(null,conn,new cljs.core.Keyword(null,"print","print",1120839199),cljs.core.pr_str.call(null,data)); +} else +{return null; +} +}); +/** +* Process a single block of JavaScript received from the server +*/ +clojure.browser.repl.evaluate_javascript = (function evaluate_javascript(conn,block){var result = (function (){try{return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"status","status",4416389988),new cljs.core.Keyword(null,"success","success",3441701749),new cljs.core.Keyword(null,"value","value",1125876963),[cljs.core.str(eval(block))].join('')], null); +}catch (e4917){var e = e4917;return new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"status","status",4416389988),new cljs.core.Keyword(null,"exception","exception",2495529921),new cljs.core.Keyword(null,"value","value",1125876963),cljs.core.pr_str.call(null,e),new cljs.core.Keyword(null,"stacktrace","stacktrace",3069736751),(cljs.core.truth_(e.hasOwnProperty("stack"))?e.stack:"No stacktrace available.")], null); +}})();return cljs.core.pr_str.call(null,result); +}); +clojure.browser.repl.send_result = (function send_result(connection,url,data){return clojure.browser.net.transmit.call(null,connection,url,"POST",data,null,0); +}); +/** +* Send data to be printed in the REPL. If there is an error, try again +* up to 10 times. +*/ +clojure.browser.repl.send_print = (function() { +var send_print = null; +var send_print__2 = (function (url,data){return send_print.call(null,url,data,0); +}); +var send_print__3 = (function (url,data,n){var conn = clojure.browser.net.xhr_connection.call(null);clojure.browser.event.listen.call(null,conn,new cljs.core.Keyword(null,"error","error",1110689146),(function (_){if((n < 10)) +{return send_print.call(null,url,data,(n + 1)); +} else +{return console.log([cljs.core.str("Could not send "),cljs.core.str(data),cljs.core.str(" after "),cljs.core.str(n),cljs.core.str(" attempts.")].join('')); +} +})); +return clojure.browser.net.transmit.call(null,conn,url,"POST",data,null,0); +}); +send_print = function(url,data,n){ +switch(arguments.length){ +case 2: +return send_print__2.call(this,url,data); +case 3: +return send_print__3.call(this,url,data,n); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +send_print.cljs$core$IFn$_invoke$arity$2 = send_print__2; +send_print.cljs$core$IFn$_invoke$arity$3 = send_print__3; +return send_print; +})() +; +clojure.browser.repl.order = cljs.core.atom.call(null,0); +clojure.browser.repl.wrap_message = (function wrap_message(t,data){return cljs.core.pr_str.call(null,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"type","type",1017479852),t,new cljs.core.Keyword(null,"content","content",1965434859),data,new cljs.core.Keyword(null,"order","order",1119910592),cljs.core.swap_BANG_.call(null,clojure.browser.repl.order,cljs.core.inc)], null)); +}); +/** +* Start the REPL server connection. +*/ +clojure.browser.repl.start_evaluator = (function start_evaluator(url){var temp__4090__auto__ = clojure.browser.net.xpc_connection.call(null);if(cljs.core.truth_(temp__4090__auto__)) +{var repl_connection = temp__4090__auto__;var connection = clojure.browser.net.xhr_connection.call(null);clojure.browser.event.listen.call(null,connection,new cljs.core.Keyword(null,"success","success",3441701749),(function (e){return clojure.browser.net.transmit.call(null,repl_connection,new cljs.core.Keyword(null,"evaluate-javascript","evaluate-javascript",2953437843),e.currentTarget.getResponseText(cljs.core.List.EMPTY)); +})); +clojure.browser.net.register_service.call(null,repl_connection,new cljs.core.Keyword(null,"send-result","send-result",3729280372),(function (data){return clojure.browser.repl.send_result.call(null,connection,url,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"result","result",4374444943),data)); +})); +clojure.browser.net.register_service.call(null,repl_connection,new cljs.core.Keyword(null,"print","print",1120839199),(function (data){return clojure.browser.repl.send_print.call(null,url,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"print","print",1120839199),data)); +})); +clojure.browser.net.connect.call(null,repl_connection,cljs.core.constantly.call(null,null)); +return setTimeout((function (){return clojure.browser.repl.send_result.call(null,connection,url,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"ready","ready",1122290965),"ready")); +}),50); +} else +{return alert("No 'xpc' param provided to child iframe."); +} +}); +/** +* Connects to a REPL server from an HTML document. After the +* connection is made, the REPL will evaluate forms in the context of +* the document that called this function. +*/ +clojure.browser.repl.connect = (function connect(repl_server_url){var repl_connection = clojure.browser.net.xpc_connection.call(null,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"peer_uri","peer_uri",1083496577),repl_server_url], null));cljs.core.swap_BANG_.call(null,clojure.browser.repl.xpc_connection,cljs.core.constantly.call(null,repl_connection)); +clojure.browser.net.register_service.call(null,repl_connection,new cljs.core.Keyword(null,"evaluate-javascript","evaluate-javascript",2953437843),(function (js){return clojure.browser.net.transmit.call(null,repl_connection,new cljs.core.Keyword(null,"send-result","send-result",3729280372),clojure.browser.repl.evaluate_javascript.call(null,repl_connection,js)); +})); +return clojure.browser.net.connect.call(null,repl_connection,cljs.core.constantly.call(null,null),(function (iframe){return iframe.style.display = "none"; +})); +}); diff --git a/project.clj b/project.clj new file mode 100644 index 0000000..f2b6894 --- /dev/null +++ b/project.clj @@ -0,0 +1,29 @@ +(defproject sudorace-cljs "0.1.0-SNAPSHOT" + :description "FIXME: write description" + :url "http://example.com/FIXME" + :license {:name "Eclipse Public License" + :url "http://www.eclipse.org/legal/epl-v10.html"} + + :plugins [[lein-cljsbuild "1.0.1"] + [lein-ring "0.8.10"] + [compojure "1.1.8"]] + + ;; clj and cljs source paths + :source-paths ["src/clj" "src/cljs"] + + :dependencies [[org.clojure/clojure "1.5.1"] + [org.clojure/clojurescript "0.0-2173"] + [domina "1.0.2"] + [hiccups "0.3.0"]] + + :ring {:handler sudorace.core/handler} + + :cljsbuild {:builds + [{ + :source-paths ["src/cljs"] + + ;; google closure options configuration + :compiler { + :output-to "resources/public/js/sudorace.js" + :optimizations :whitespace + :pretty-print true}}]}) \ No newline at end of file diff --git a/repl/client.js b/repl/client.js new file mode 100644 index 0000000..5ef7eee --- /dev/null +++ b/repl/client.js @@ -0,0 +1,1486 @@ +var COMPILED=!0,goog=goog||{};goog.global=this;goog.DEBUG=!0;goog.LOCALE="en";goog.TRUSTED_SITE=!0;goog.provide=function(a){if(!COMPILED){if(goog.isProvided_(a))throw Error('Namespace "'+a+'" already declared.');delete goog.implicitNamespaces_[a];for(var b=a;(b=b.substring(0,b.lastIndexOf(".")))&&!goog.getObjectByName(b);)goog.implicitNamespaces_[b]=!0}goog.exportPath_(a)}; +goog.setTestOnly=function(a){if(COMPILED&&!goog.DEBUG)throw a=a||"",Error("Importing test-only code into non-debug environment"+a?": "+a:".");};COMPILED||(goog.isProvided_=function(a){return!goog.implicitNamespaces_[a]&&!!goog.getObjectByName(a)},goog.implicitNamespaces_={});goog.exportPath_=function(a,b,c){a=a.split(".");c=c||goog.global;a[0]in c||!c.execScript||c.execScript("var "+a[0]);for(var d;a.length&&(d=a.shift());)!a.length&&goog.isDef(b)?c[d]=b:c=c[d]?c[d]:c[d]={}}; +goog.getObjectByName=function(a,b){for(var c=a.split("."),d=b||goog.global,e;e=c.shift();)if(goog.isDefAndNotNull(d[e]))d=d[e];else return null;return d};goog.globalize=function(a,b){var c=b||goog.global,d;for(d in a)c[d]=a[d]}; +goog.addDependency=function(a,b,c){if(!COMPILED){var d;a=a.replace(/\\/g,"/");for(var e=goog.dependencies_,f=0;d=b[f];f++)e.nameToPath[d]=a,a in e.pathToNames||(e.pathToNames[a]={}),e.pathToNames[a][d]=!0;for(d=0;b=c[d];d++)a in e.requires||(e.requires[a]={}),e.requires[a][b]=!0}};goog.ENABLE_DEBUG_LOADER=!0; +goog.require=function(a){if(!COMPILED&&!goog.isProvided_(a)){if(goog.ENABLE_DEBUG_LOADER){var b=goog.getPathFromDeps_(a);if(b){goog.included_[b]=!0;goog.writeScripts_();return}}a="goog.require could not find: "+a;goog.global.console&&goog.global.console.error(a);throw Error(a);}};goog.basePath="";goog.nullFunction=function(){};goog.identityFunction=function(a,b){return a};goog.abstractMethod=function(){throw Error("unimplemented abstract method");}; +goog.addSingletonGetter=function(a){a.getInstance=function(){if(a.instance_)return a.instance_;goog.DEBUG&&(goog.instantiatedSingletons_[goog.instantiatedSingletons_.length]=a);return a.instance_=new a}};goog.instantiatedSingletons_=[]; +!COMPILED&&goog.ENABLE_DEBUG_LOADER&&(goog.included_={},goog.dependencies_={pathToNames:{},nameToPath:{},requires:{},visited:{},written:{}},goog.inHtmlDocument_=function(){var a=goog.global.document;return"undefined"!=typeof a&&"write"in a},goog.findBasePath_=function(){if(goog.global.CLOSURE_BASE_PATH)goog.basePath=goog.global.CLOSURE_BASE_PATH;else if(goog.inHtmlDocument_())for(var a=goog.global.document.getElementsByTagName("script"),b=a.length-1;0<=b;--b){var c=a[b].src,d=c.lastIndexOf("?"),d= +-1==d?c.length:d;if("base.js"==c.substr(d-7,7)){goog.basePath=c.substr(0,d-7);break}}},goog.importScript_=function(a){var b=goog.global.CLOSURE_IMPORT_SCRIPT||goog.writeScriptTag_;!goog.dependencies_.written[a]&&b(a)&&(goog.dependencies_.written[a]=!0)},goog.writeScriptTag_=function(a){if(goog.inHtmlDocument_()){var b=goog.global.document;if("complete"==b.readyState){if(/\bdeps.js$/.test(a))return!1;throw Error('Cannot write "'+a+'" after document load');}b.write('\x3cscript type\x3d"text/javascript" src\x3d"'+ +a+'"\x3e\x3c/script\x3e');return!0}return!1},goog.writeScripts_=function(){function a(e){if(!(e in d.written)){if(!(e in d.visited)&&(d.visited[e]=!0,e in d.requires))for(var g in d.requires[e])if(!goog.isProvided_(g))if(g in d.nameToPath)a(d.nameToPath[g]);else throw Error("Undefined nameToPath for "+g);e in c||(c[e]=!0,b.push(e))}}var b=[],c={},d=goog.dependencies_,e;for(e in goog.included_)d.written[e]||a(e);for(e=0;e>>0);goog.uidCounter_=0;goog.getHashCode=goog.getUid;goog.removeHashCode=goog.removeUid;goog.cloneObject=function(a){var b=goog.typeOf(a);if("object"==b||"array"==b){if(a.clone)return a.clone();var b="array"==b?[]:{},c;for(c in a)b[c]=goog.cloneObject(a[c]);return b}return a};goog.bindNative_=function(a,b,c){return a.call.apply(a.bind,arguments)}; +goog.bindJs_=function(a,b,c){if(!a)throw Error();if(2=a||"\u0080"<=a&&"\ufffd">=a};goog.string.stripNewlines=function(a){return a.replace(/(\r\n|\r|\n)+/g," ")};goog.string.canonicalizeNewlines=function(a){return a.replace(/(\r\n|\r|\n)/g,"\n")}; +goog.string.normalizeWhitespace=function(a){return a.replace(/\xa0|\s/g," ")};goog.string.normalizeSpaces=function(a){return a.replace(/\xa0|[ \t]+/g," ")};goog.string.collapseBreakingSpaces=function(a){return a.replace(/[\t\r\n ]+/g," ").replace(/^[\t\r\n ]+|[\t\r\n ]+$/g,"")};goog.string.trim=function(a){return a.replace(/^[\s\xa0]+|[\s\xa0]+$/g,"")};goog.string.trimLeft=function(a){return a.replace(/^[\s\xa0]+/,"")};goog.string.trimRight=function(a){return a.replace(/[\s\xa0]+$/,"")}; +goog.string.caseInsensitiveCompare=function(a,b){var c=String(a).toLowerCase(),d=String(b).toLowerCase();return c/g;goog.string.quotRe_=/\"/g;goog.string.allRe_=/[&<>\"]/;goog.string.unescapeEntities=function(a){return goog.string.contains(a,"\x26")?"document"in goog.global?goog.string.unescapeEntitiesUsingDom_(a):goog.string.unescapePureXmlEntities_(a):a}; +goog.string.unescapeEntitiesUsingDom_=function(a){var b={"\x26amp;":"\x26","\x26lt;":"\x3c","\x26gt;":"\x3e","\x26quot;":'"'},c=document.createElement("div");return a.replace(goog.string.HTML_ENTITY_PATTERN_,function(a,e){var f=b[a];if(f)return f;if("#"==e.charAt(0)){var g=Number("0"+e.substr(1));isNaN(g)||(f=String.fromCharCode(g))}f||(c.innerHTML=a+" ",f=c.firstChild.nodeValue.slice(0,-1));return b[a]=f})}; +goog.string.unescapePureXmlEntities_=function(a){return a.replace(/&([^;]+);/g,function(a,c){switch(c){case "amp":return"\x26";case "lt":return"\x3c";case "gt":return"\x3e";case "quot":return'"';default:if("#"==c.charAt(0)){var d=Number("0"+c.substr(1));if(!isNaN(d))return String.fromCharCode(d)}return a}})};goog.string.HTML_ENTITY_PATTERN_=/&([^;\s<&]+);?/g;goog.string.whitespaceEscape=function(a,b){return goog.string.newLineToBr(a.replace(/ /g," \x26#160;"),b)}; +goog.string.stripQuotes=function(a,b){for(var c=b.length,d=0;db&&(a=a.substring(0,b-3)+"...");c&&(a=goog.string.htmlEscape(a));return a}; +goog.string.truncateMiddle=function(a,b,c,d){c&&(a=goog.string.unescapeEntities(a));if(d&&a.length>b){d>b&&(d=b);var e=a.length-d;a=a.substring(0,b-d)+"..."+a.substring(e)}else a.length>b&&(d=Math.floor(b/2),e=a.length-d,a=a.substring(0,d+b%2)+"..."+a.substring(e));c&&(a=goog.string.htmlEscape(a));return a};goog.string.specialEscapeChars_={"\x00":"\\0","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t","\x0B":"\\x0B",'"':'\\"',"\\":"\\\\"};goog.string.jsEscapeCache_={"'":"\\'"}; +goog.string.quote=function(a){a=String(a);if(a.quote)return a.quote();for(var b=['"'],c=0;ce?d:goog.string.escapeChar(d))}b.push('"');return b.join("")};goog.string.escapeString=function(a){for(var b=[],c=0;cc)b=a;else{if(256>c){if(b="\\x",16>c||256c&&(b+="0");b+=c.toString(16).toUpperCase()}return goog.string.jsEscapeCache_[a]=b};goog.string.toMap=function(a){for(var b={},c=0;cb?1:0};goog.string.HASHCODE_MAX_=4294967296;goog.string.hashCode=function(a){for(var b=0,c=0;cc?Math.max(0,a.length+c):c;if(goog.isString(a))return goog.isString(b)&&1==b.length?a.indexOf(b,c):-1;for(;cc&&(c=Math.max(0,a.length+c));if(goog.isString(a))return goog.isString(b)&&1==b.length?a.lastIndexOf(b,c):-1;for(;0<=c;c--)if(c in a&&a[c]===b)return c;return-1}; +goog.array.forEach=goog.NATIVE_ARRAY_PROTOTYPES&&goog.array.ARRAY_PROTOTYPE_.forEach?function(a,b,c){goog.asserts.assert(null!=a.length);goog.array.ARRAY_PROTOTYPE_.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;fb?null:goog.isString(a)?a.charAt(b):a[b]};goog.array.findIndex=function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,f=0;fb?null:goog.isString(a)?a.charAt(b):a[b]}; +goog.array.findIndexRight=function(a,b,c){for(var d=a.length,e=goog.isString(a)?a.split(""):a,d=d-1;0<=d;d--)if(d in e&&b.call(c,e[d],d,a))return d;return-1};goog.array.contains=function(a,b){return 0<=goog.array.indexOf(a,b)};goog.array.isEmpty=function(a){return 0==a.length};goog.array.clear=function(a){if(!goog.isArray(a))for(var b=a.length-1;0<=b;b--)delete a[b];a.length=0};goog.array.insert=function(a,b){goog.array.contains(a,b)||a.push(b)}; +goog.array.insertAt=function(a,b,c){goog.array.splice(a,c,0,b)};goog.array.insertArrayAt=function(a,b,c){goog.partial(goog.array.splice,a,c,0).apply(null,b)};goog.array.insertBefore=function(a,b,c){var d;2==arguments.length||0>(d=goog.array.indexOf(a,c))?a.push(b):goog.array.insertAt(a,b,d)};goog.array.remove=function(a,b){var c=goog.array.indexOf(a,b),d;(d=0<=c)&&goog.array.removeAt(a,c);return d}; +goog.array.removeAt=function(a,b){goog.asserts.assert(null!=a.length);return 1==goog.array.ARRAY_PROTOTYPE_.splice.call(a,b,1).length};goog.array.removeIf=function(a,b,c){b=goog.array.findIndex(a,b,c);return 0<=b?(goog.array.removeAt(a,b),!0):!1};goog.array.concat=function(a){return goog.array.ARRAY_PROTOTYPE_.concat.apply(goog.array.ARRAY_PROTOTYPE_,arguments)};goog.array.toArray=function(a){var b=a.length;if(0=arguments.length?goog.array.ARRAY_PROTOTYPE_.slice.call(a,b):goog.array.ARRAY_PROTOTYPE_.slice.call(a,b,c)};goog.array.removeDuplicates=function(a,b){for(var c=b||a,d={},e=0,f=0;f>1,l;l=c?b.call(e,a[k],k,a):b(d,a[k]);0b?1:ac?(goog.array.insertAt(a,b,-(c+1)),!0):!1}; +goog.array.binaryRemove=function(a,b,c){b=goog.array.binarySearch(a,b,c);return 0<=b?goog.array.removeAt(a,b):!1};goog.array.bucket=function(a,b){for(var c={},d=0;dc*(f-e))return[];if(0f;a+=c)d.push(a);return d};goog.array.repeat=function(a,b){for(var c=[],d=0;db&&goog.array.ARRAY_PROTOTYPE_.push.apply(a,a.splice(0,-b)));return a};goog.array.zip=function(a){if(!arguments.length)return[];for(var b=[],c=0;;c++){for(var d=[],e=0;e=f.length)return b;d.push(f[c])}b.push(d)}}; +goog.array.shuffle=function(a,b){for(var c=b||Math.random,d=a.length-1;0=a.length)throw goog.iter.StopIteration;if(b in a)return a[b++];b++}};return c}throw Error("Not implemented");}; +goog.iter.forEach=function(a,b,c){if(goog.isArrayLike(a))try{goog.array.forEach(a,b,c)}catch(d){if(d!==goog.iter.StopIteration)throw d;}else{a=goog.iter.toIterator(a);try{for(;;)b.call(c,a.next(),void 0,a)}catch(e){if(e!==goog.iter.StopIteration)throw e;}}};goog.iter.filter=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;a.next=function(){for(;;){var a=d.next();if(b.call(c,a,void 0,d))return a}};return a}; +goog.iter.range=function(a,b,c){var d=0,e=a,f=c||1;1=e||0>f&&d<=e)throw goog.iter.StopIteration;var a=d;d+=f;return a};return g};goog.iter.join=function(a,b){return goog.iter.toArray(a).join(b)};goog.iter.map=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;a.next=function(){for(;;){var a=d.next();return b.call(c,a,void 0,d)}};return a}; +goog.iter.reduce=function(a,b,c,d){var e=c;goog.iter.forEach(a,function(a){e=b.call(d,e,a)});return e};goog.iter.some=function(a,b,c){a=goog.iter.toIterator(a);try{for(;;)if(b.call(c,a.next(),void 0,a))return!0}catch(d){if(d!==goog.iter.StopIteration)throw d;}return!1};goog.iter.every=function(a,b,c){a=goog.iter.toIterator(a);try{for(;;)if(!b.call(c,a.next(),void 0,a))return!1}catch(d){if(d!==goog.iter.StopIteration)throw d;}return!0}; +goog.iter.chain=function(a){var b=arguments,c=b.length,d=0,e=new goog.iter.Iterator;e.next=function(){try{if(d>=c)throw goog.iter.StopIteration;return goog.iter.toIterator(b[d]).next()}catch(a){if(a!==goog.iter.StopIteration||d>=c)throw a;d++;return this.next()}};return e};goog.iter.dropWhile=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;var e=!0;a.next=function(){for(;;){var a=d.next();if(!e||!b.call(c,a,void 0,d))return e=!1,a}};return a}; +goog.iter.takeWhile=function(a,b,c){var d=goog.iter.toIterator(a);a=new goog.iter.Iterator;var e=!0;a.next=function(){for(;;)if(e){var a=d.next();if(b.call(c,a,void 0,d))return a;e=!1}else throw goog.iter.StopIteration;};return a};goog.iter.toArray=function(a){if(goog.isArrayLike(a))return goog.array.toArray(a);a=goog.iter.toIterator(a);var b=[];goog.iter.forEach(a,function(a){b.push(a)});return b}; +goog.iter.equals=function(a,b){a=goog.iter.toIterator(a);b=goog.iter.toIterator(b);var c,d;try{for(;;){c=d=!1;var e=a.next();c=!0;var f=b.next();d=!0;if(e!=f)break}}catch(g){if(g!==goog.iter.StopIteration)throw g;if(c&&!d)return!1;if(!d)try{b.next()}catch(h){if(h!==goog.iter.StopIteration)throw h;return!0}}return!1};goog.iter.nextOrValue=function(a,b){try{return goog.iter.toIterator(a).next()}catch(c){if(c!=goog.iter.StopIteration)throw c;return b}}; +goog.iter.product=function(a){if(goog.array.some(arguments,function(a){return!a.length})||!arguments.length)return new goog.iter.Iterator;var b=new goog.iter.Iterator,c=arguments,d=goog.array.repeat(0,c.length);b.next=function(){if(d){for(var a=goog.array.map(d,function(a,b){return c[b][a]}),b=d.length-1;0<=b;b--){goog.asserts.assert(d);if(d[b]2*this.count_&&this.cleanupKeysArray_(),!0):!1}; +goog.structs.Map.prototype.cleanupKeysArray_=function(){if(this.count_!=this.keys_.length){for(var a=0,b=0;a=c.length)throw goog.iter.StopIteration;var g=c[b++];return a?g:d[g]}};return g}; +goog.structs.Map.hasKey_=function(a,b){return Object.prototype.hasOwnProperty.call(a,b)};goog.userAgent={};goog.userAgent.ASSUME_IE=!1;goog.userAgent.ASSUME_GECKO=!1;goog.userAgent.ASSUME_WEBKIT=!1;goog.userAgent.ASSUME_MOBILE_WEBKIT=!1;goog.userAgent.ASSUME_OPERA=!1;goog.userAgent.ASSUME_ANY_VERSION=!1;goog.userAgent.BROWSER_KNOWN_=goog.userAgent.ASSUME_IE||goog.userAgent.ASSUME_GECKO||goog.userAgent.ASSUME_MOBILE_WEBKIT||goog.userAgent.ASSUME_WEBKIT||goog.userAgent.ASSUME_OPERA; +goog.userAgent.getUserAgentString=function(){return goog.global.navigator?goog.global.navigator.userAgent:null};goog.userAgent.getNavigator=function(){return goog.global.navigator}; +goog.userAgent.init_=function(){goog.userAgent.detectedOpera_=!1;goog.userAgent.detectedIe_=!1;goog.userAgent.detectedWebkit_=!1;goog.userAgent.detectedMobile_=!1;goog.userAgent.detectedGecko_=!1;var a;if(!goog.userAgent.BROWSER_KNOWN_&&(a=goog.userAgent.getUserAgentString())){var b=goog.userAgent.getNavigator();goog.userAgent.detectedOpera_=0==a.indexOf("Opera");goog.userAgent.detectedIe_=!goog.userAgent.detectedOpera_&&-1!=a.indexOf("MSIE");goog.userAgent.detectedWebkit_=!goog.userAgent.detectedOpera_&& +-1!=a.indexOf("WebKit");goog.userAgent.detectedMobile_=goog.userAgent.detectedWebkit_&&-1!=a.indexOf("Mobile");goog.userAgent.detectedGecko_=!goog.userAgent.detectedOpera_&&!goog.userAgent.detectedWebkit_&&"Gecko"==b.product}};goog.userAgent.BROWSER_KNOWN_||goog.userAgent.init_();goog.userAgent.OPERA=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_OPERA:goog.userAgent.detectedOpera_;goog.userAgent.IE=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_IE:goog.userAgent.detectedIe_; +goog.userAgent.GECKO=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_GECKO:goog.userAgent.detectedGecko_;goog.userAgent.WEBKIT=goog.userAgent.BROWSER_KNOWN_?goog.userAgent.ASSUME_WEBKIT||goog.userAgent.ASSUME_MOBILE_WEBKIT:goog.userAgent.detectedWebkit_;goog.userAgent.MOBILE=goog.userAgent.ASSUME_MOBILE_WEBKIT||goog.userAgent.detectedMobile_;goog.userAgent.SAFARI=goog.userAgent.WEBKIT;goog.userAgent.determinePlatform_=function(){var a=goog.userAgent.getNavigator();return a&&a.platform||""}; +goog.userAgent.PLATFORM=goog.userAgent.determinePlatform_();goog.userAgent.ASSUME_MAC=!1;goog.userAgent.ASSUME_WINDOWS=!1;goog.userAgent.ASSUME_LINUX=!1;goog.userAgent.ASSUME_X11=!1;goog.userAgent.ASSUME_ANDROID=!1;goog.userAgent.ASSUME_IPHONE=!1;goog.userAgent.ASSUME_IPAD=!1;goog.userAgent.PLATFORM_KNOWN_=goog.userAgent.ASSUME_MAC||goog.userAgent.ASSUME_WINDOWS||goog.userAgent.ASSUME_LINUX||goog.userAgent.ASSUME_X11||goog.userAgent.ASSUME_ANDROID||goog.userAgent.ASSUME_IPHONE||goog.userAgent.ASSUME_IPAD; +goog.userAgent.initPlatform_=function(){goog.userAgent.detectedMac_=goog.string.contains(goog.userAgent.PLATFORM,"Mac");goog.userAgent.detectedWindows_=goog.string.contains(goog.userAgent.PLATFORM,"Win");goog.userAgent.detectedLinux_=goog.string.contains(goog.userAgent.PLATFORM,"Linux");goog.userAgent.detectedX11_=!!goog.userAgent.getNavigator()&&goog.string.contains(goog.userAgent.getNavigator().appVersion||"","X11");var a=goog.userAgent.getUserAgentString();goog.userAgent.detectedAndroid_=!!a&& +0<=a.indexOf("Android");goog.userAgent.detectedIPhone_=!!a&&0<=a.indexOf("iPhone");goog.userAgent.detectedIPad_=!!a&&0<=a.indexOf("iPad")};goog.userAgent.PLATFORM_KNOWN_||goog.userAgent.initPlatform_();goog.userAgent.MAC=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_MAC:goog.userAgent.detectedMac_;goog.userAgent.WINDOWS=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_WINDOWS:goog.userAgent.detectedWindows_; +goog.userAgent.LINUX=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_LINUX:goog.userAgent.detectedLinux_;goog.userAgent.X11=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_X11:goog.userAgent.detectedX11_;goog.userAgent.ANDROID=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_ANDROID:goog.userAgent.detectedAndroid_;goog.userAgent.IPHONE=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPHONE:goog.userAgent.detectedIPhone_; +goog.userAgent.IPAD=goog.userAgent.PLATFORM_KNOWN_?goog.userAgent.ASSUME_IPAD:goog.userAgent.detectedIPad_; +goog.userAgent.determineVersion_=function(){var a="",b;goog.userAgent.OPERA&&goog.global.opera?(a=goog.global.opera.version,a="function"==typeof a?a():a):(goog.userAgent.GECKO?b=/rv\:([^\);]+)(\)|;)/:goog.userAgent.IE?b=/MSIE\s+([^\);]+)(\)|;)/:goog.userAgent.WEBKIT&&(b=/WebKit\/(\S+)/),b&&(a=(a=b.exec(goog.userAgent.getUserAgentString()))?a[1]:""));return goog.userAgent.IE&&(b=goog.userAgent.getDocumentMode_(),b>parseFloat(a))?String(b):a}; +goog.userAgent.getDocumentMode_=function(){var a=goog.global.document;return a?a.documentMode:void 0};goog.userAgent.VERSION=goog.userAgent.determineVersion_();goog.userAgent.compare=function(a,b){return goog.string.compareVersions(a,b)};goog.userAgent.isVersionCache_={};goog.userAgent.isVersion=function(a){return goog.userAgent.ASSUME_ANY_VERSION||goog.userAgent.isVersionCache_[a]||(goog.userAgent.isVersionCache_[a]=0<=goog.string.compareVersions(goog.userAgent.VERSION,a))}; +goog.userAgent.isDocumentMode=function(a){return goog.userAgent.IE&&goog.userAgent.DOCUMENT_MODE>=a};goog.userAgent.DOCUMENT_MODE=function(){var a=goog.global.document;return a&&goog.userAgent.IE?goog.userAgent.getDocumentMode_()||("CSS1Compat"==a.compatMode?parseInt(goog.userAgent.VERSION,10):5):void 0}();goog.uri={};goog.uri.utils={};goog.uri.utils.CharCode_={AMPERSAND:38,EQUAL:61,HASH:35,QUESTION:63};goog.uri.utils.buildFromEncodedParts=function(a,b,c,d,e,f,g){var h="";a&&(h+=a+":");c&&(h+="//",b&&(h+=b+"@"),h+=c,d&&(h+=":"+d));e&&(h+=e);f&&(h+="?"+f);g&&(h+="#"+g);return h};goog.uri.utils.splitRe_=RegExp("^(?:([^:/?#.]+):)?(?://(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?\x3d[/#?]|$))?([^?#]+)?(?:\\?([^#]*))?(?:#(.*))?$"); +goog.uri.utils.ComponentIndex={SCHEME:1,USER_INFO:2,DOMAIN:3,PORT:4,PATH:5,QUERY_DATA:6,FRAGMENT:7};goog.uri.utils.split=function(a){return a.match(goog.uri.utils.splitRe_)};goog.uri.utils.decodeIfPossible_=function(a){return a&&decodeURIComponent(a)};goog.uri.utils.getComponentByIndex_=function(a,b){return goog.uri.utils.split(b)[a]||null};goog.uri.utils.getScheme=function(a){return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.SCHEME,a)}; +goog.uri.utils.getEffectiveScheme=function(a){a=goog.uri.utils.getScheme(a);!a&&self.location&&(a=self.location.protocol,a=a.substr(0,a.length-1));return a?a.toLowerCase():""};goog.uri.utils.getUserInfoEncoded=function(a){return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.USER_INFO,a)};goog.uri.utils.getUserInfo=function(a){return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getUserInfoEncoded(a))}; +goog.uri.utils.getDomainEncoded=function(a){return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.DOMAIN,a)};goog.uri.utils.getDomain=function(a){return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getDomainEncoded(a))};goog.uri.utils.getPort=function(a){return Number(goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PORT,a))||null};goog.uri.utils.getPathEncoded=function(a){return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PATH,a)}; +goog.uri.utils.getPath=function(a){return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getPathEncoded(a))};goog.uri.utils.getQueryData=function(a){return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.QUERY_DATA,a)};goog.uri.utils.getFragmentEncoded=function(a){var b=a.indexOf("#");return 0>b?null:a.substr(b+1)};goog.uri.utils.setFragmentEncoded=function(a,b){return goog.uri.utils.removeFragment(a)+(b?"#"+b:"")};goog.uri.utils.getFragment=function(a){return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getFragmentEncoded(a))}; +goog.uri.utils.getHost=function(a){a=goog.uri.utils.split(a);return goog.uri.utils.buildFromEncodedParts(a[goog.uri.utils.ComponentIndex.SCHEME],a[goog.uri.utils.ComponentIndex.USER_INFO],a[goog.uri.utils.ComponentIndex.DOMAIN],a[goog.uri.utils.ComponentIndex.PORT])};goog.uri.utils.getPathAndAfter=function(a){a=goog.uri.utils.split(a);return goog.uri.utils.buildFromEncodedParts(null,null,null,null,a[goog.uri.utils.ComponentIndex.PATH],a[goog.uri.utils.ComponentIndex.QUERY_DATA],a[goog.uri.utils.ComponentIndex.FRAGMENT])}; +goog.uri.utils.removeFragment=function(a){var b=a.indexOf("#");return 0>b?a:a.substr(0,b)};goog.uri.utils.haveSameDomain=function(a,b){var c=goog.uri.utils.split(a),d=goog.uri.utils.split(b);return c[goog.uri.utils.ComponentIndex.DOMAIN]==d[goog.uri.utils.ComponentIndex.DOMAIN]&&c[goog.uri.utils.ComponentIndex.SCHEME]==d[goog.uri.utils.ComponentIndex.SCHEME]&&c[goog.uri.utils.ComponentIndex.PORT]==d[goog.uri.utils.ComponentIndex.PORT]}; +goog.uri.utils.assertNoFragmentsOrQueries_=function(a){if(goog.DEBUG&&(0<=a.indexOf("#")||0<=a.indexOf("?")))throw Error("goog.uri.utils: Fragment or query identifiers are not supported: ["+a+"]");};goog.uri.utils.appendQueryData_=function(a){if(a[1]){var b=a[0],c=b.indexOf("#");0<=c&&(a.push(b.substr(c)),a[0]=b=b.substr(0,c));c=b.indexOf("?");0>c?a[1]="?":c==b.length-1&&(a[1]=void 0)}return a.join("")}; +goog.uri.utils.appendKeyValuePairs_=function(a,b,c){if(goog.isArray(b)){goog.asserts.assertArray(b);for(var d=0;dd)return null;var e=a.indexOf("\x26",d);if(0>e||e>c)e=c;d+=b.length+1;return goog.string.urlDecode(a.substr(d,e-d))};goog.uri.utils.getParamValues=function(a,b){for(var c=a.search(goog.uri.utils.hashOrEndRe_),d=0,e,f=[];0<=(e=goog.uri.utils.findParam_(a,d,b,c));){d=a.indexOf("\x26",e);if(0>d||d>c)d=c;e+=b.length+1;f.push(goog.string.urlDecode(a.substr(e,d-e)))}return f}; +goog.uri.utils.trailingQueryPunctuationRe_=/[?&]($|#)/;goog.uri.utils.removeParam=function(a,b){for(var c=a.search(goog.uri.utils.hashOrEndRe_),d=0,e,f=[];0<=(e=goog.uri.utils.findParam_(a,d,b,c));)f.push(a.substring(d,e)),d=Math.min(a.indexOf("\x26",e)+1||c,c);f.push(a.substr(d));return f.join("").replace(goog.uri.utils.trailingQueryPunctuationRe_,"$1")};goog.uri.utils.setParam=function(a,b,c){return goog.uri.utils.appendParam(goog.uri.utils.removeParam(a,b),b,c)}; +goog.uri.utils.appendPath=function(a,b){goog.uri.utils.assertNoFragmentsOrQueries_(a);goog.string.endsWith(a,"/")&&(a=a.substr(0,a.length-1));goog.string.startsWith(b,"/")&&(b=b.substr(1));return goog.string.buildString(a,"/",b)};goog.uri.utils.StandardQueryParam={RANDOM:"zx"};goog.uri.utils.makeUnique=function(a){return goog.uri.utils.setParam(a,goog.uri.utils.StandardQueryParam.RANDOM,goog.string.getRandomString())};goog.Uri=function(a,b){var c;a instanceof goog.Uri?(this.ignoreCase_=goog.isDef(b)?b:a.getIgnoreCase(),this.setScheme(a.getScheme()),this.setUserInfo(a.getUserInfo()),this.setDomain(a.getDomain()),this.setPort(a.getPort()),this.setPath(a.getPath()),this.setQueryData(a.getQueryData().clone()),this.setFragment(a.getFragment())):a&&(c=goog.uri.utils.split(String(a)))?(this.ignoreCase_=!!b,this.setScheme(c[goog.uri.utils.ComponentIndex.SCHEME]||"",!0),this.setUserInfo(c[goog.uri.utils.ComponentIndex.USER_INFO]|| +"",!0),this.setDomain(c[goog.uri.utils.ComponentIndex.DOMAIN]||"",!0),this.setPort(c[goog.uri.utils.ComponentIndex.PORT]),this.setPath(c[goog.uri.utils.ComponentIndex.PATH]||"",!0),this.setQueryData(c[goog.uri.utils.ComponentIndex.QUERY_DATA]||"",!0),this.setFragment(c[goog.uri.utils.ComponentIndex.FRAGMENT]||"",!0)):(this.ignoreCase_=!!b,this.queryData_=new goog.Uri.QueryData(null,null,this.ignoreCase_))};goog.Uri.preserveParameterTypesCompatibilityFlag=!1;goog.Uri.RANDOM_PARAM=goog.uri.utils.StandardQueryParam.RANDOM; +goog.Uri.prototype.scheme_="";goog.Uri.prototype.userInfo_="";goog.Uri.prototype.domain_="";goog.Uri.prototype.port_=null;goog.Uri.prototype.path_="";goog.Uri.prototype.fragment_="";goog.Uri.prototype.isReadOnly_=!1;goog.Uri.prototype.ignoreCase_=!1; +goog.Uri.prototype.toString=function(){var a=[],b=this.getScheme();b&&a.push(goog.Uri.encodeSpecialChars_(b,goog.Uri.reDisallowedInSchemeOrUserInfo_),":");if(b=this.getDomain()){a.push("//");var c=this.getUserInfo();c&&a.push(goog.Uri.encodeSpecialChars_(c,goog.Uri.reDisallowedInSchemeOrUserInfo_),"@");a.push(goog.string.urlEncode(b));b=this.getPort();null!=b&&a.push(":",String(b))}if(b=this.getPath())this.hasDomain()&&"/"!=b.charAt(0)&&a.push("/"),a.push(goog.Uri.encodeSpecialChars_(b,"/"==b.charAt(0)? +goog.Uri.reDisallowedInAbsolutePath_:goog.Uri.reDisallowedInRelativePath_));(b=this.getEncodedQuery())&&a.push("?",b);(b=this.getFragment())&&a.push("#",goog.Uri.encodeSpecialChars_(b,goog.Uri.reDisallowedInFragment_));return a.join("")}; +goog.Uri.prototype.resolve=function(a){var b=this.clone(),c=a.hasScheme();c?b.setScheme(a.getScheme()):c=a.hasUserInfo();c?b.setUserInfo(a.getUserInfo()):c=a.hasDomain();c?b.setDomain(a.getDomain()):c=a.hasPort();var d=a.getPath();if(c)b.setPort(a.getPort());else if(c=a.hasPath()){if("/"!=d.charAt(0))if(this.hasDomain()&&!this.hasPath())d="/"+d;else{var e=b.getPath().lastIndexOf("/");-1!=e&&(d=b.getPath().substr(0,e+1)+d)}d=goog.Uri.removeDotSegments(d)}c?b.setPath(d):c=a.hasQuery();c?b.setQueryData(a.getDecodedQuery()): +c=a.hasFragment();c&&b.setFragment(a.getFragment());return b};goog.Uri.prototype.clone=function(){return new goog.Uri(this)};goog.Uri.prototype.getScheme=function(){return this.scheme_};goog.Uri.prototype.setScheme=function(a,b){this.enforceReadOnly();if(this.scheme_=b?goog.Uri.decodeOrEmpty_(a):a)this.scheme_=this.scheme_.replace(/:$/,"");return this};goog.Uri.prototype.hasScheme=function(){return!!this.scheme_};goog.Uri.prototype.getUserInfo=function(){return this.userInfo_}; +goog.Uri.prototype.setUserInfo=function(a,b){this.enforceReadOnly();this.userInfo_=b?goog.Uri.decodeOrEmpty_(a):a;return this};goog.Uri.prototype.hasUserInfo=function(){return!!this.userInfo_};goog.Uri.prototype.getDomain=function(){return this.domain_};goog.Uri.prototype.setDomain=function(a,b){this.enforceReadOnly();this.domain_=b?goog.Uri.decodeOrEmpty_(a):a;return this};goog.Uri.prototype.hasDomain=function(){return!!this.domain_};goog.Uri.prototype.getPort=function(){return this.port_}; +goog.Uri.prototype.setPort=function(a){this.enforceReadOnly();if(a){a=Number(a);if(isNaN(a)||0>a)throw Error("Bad port number "+a);this.port_=a}else this.port_=null;return this};goog.Uri.prototype.hasPort=function(){return null!=this.port_};goog.Uri.prototype.getPath=function(){return this.path_};goog.Uri.prototype.setPath=function(a,b){this.enforceReadOnly();this.path_=b?goog.Uri.decodeOrEmpty_(a):a;return this};goog.Uri.prototype.hasPath=function(){return!!this.path_}; +goog.Uri.prototype.hasQuery=function(){return""!==this.queryData_.toString()};goog.Uri.prototype.setQueryData=function(a,b){this.enforceReadOnly();a instanceof goog.Uri.QueryData?(this.queryData_=a,this.queryData_.setIgnoreCase(this.ignoreCase_)):(b||(a=goog.Uri.encodeSpecialChars_(a,goog.Uri.reDisallowedInQuery_)),this.queryData_=new goog.Uri.QueryData(a,null,this.ignoreCase_));return this};goog.Uri.prototype.setQuery=function(a,b){return this.setQueryData(a,b)}; +goog.Uri.prototype.getEncodedQuery=function(){return this.queryData_.toString()};goog.Uri.prototype.getDecodedQuery=function(){return this.queryData_.toDecodedString()};goog.Uri.prototype.getQueryData=function(){return this.queryData_};goog.Uri.prototype.getQuery=function(){return this.getEncodedQuery()};goog.Uri.prototype.setParameterValue=function(a,b){this.enforceReadOnly();this.queryData_.set(a,b);return this}; +goog.Uri.prototype.setParameterValues=function(a,b){this.enforceReadOnly();goog.isArray(b)||(b=[String(b)]);this.queryData_.setValues(a,b);return this};goog.Uri.prototype.getParameterValues=function(a){return this.queryData_.getValues(a)};goog.Uri.prototype.getParameterValue=function(a){return this.queryData_.get(a)};goog.Uri.prototype.getFragment=function(){return this.fragment_};goog.Uri.prototype.setFragment=function(a,b){this.enforceReadOnly();this.fragment_=b?goog.Uri.decodeOrEmpty_(a):a;return this}; +goog.Uri.prototype.hasFragment=function(){return!!this.fragment_};goog.Uri.prototype.hasSameDomainAs=function(a){return(!this.hasDomain()&&!a.hasDomain()||this.getDomain()==a.getDomain())&&(!this.hasPort()&&!a.hasPort()||this.getPort()==a.getPort())};goog.Uri.prototype.makeUnique=function(){this.enforceReadOnly();this.setParameterValue(goog.Uri.RANDOM_PARAM,goog.string.getRandomString());return this};goog.Uri.prototype.removeParameter=function(a){this.enforceReadOnly();this.queryData_.remove(a);return this}; +goog.Uri.prototype.setReadOnly=function(a){this.isReadOnly_=a;return this};goog.Uri.prototype.isReadOnly=function(){return this.isReadOnly_};goog.Uri.prototype.enforceReadOnly=function(){if(this.isReadOnly_)throw Error("Tried to modify a read-only Uri");};goog.Uri.prototype.setIgnoreCase=function(a){this.ignoreCase_=a;this.queryData_&&this.queryData_.setIgnoreCase(a);return this};goog.Uri.prototype.getIgnoreCase=function(){return this.ignoreCase_}; +goog.Uri.parse=function(a,b){return a instanceof goog.Uri?a.clone():new goog.Uri(a,b)};goog.Uri.create=function(a,b,c,d,e,f,g,h){h=new goog.Uri(null,h);a&&h.setScheme(a);b&&h.setUserInfo(b);c&&h.setDomain(c);d&&h.setPort(d);e&&h.setPath(e);f&&h.setQueryData(f);g&&h.setFragment(g);return h};goog.Uri.resolve=function(a,b){a instanceof goog.Uri||(a=goog.Uri.parse(a));b instanceof goog.Uri||(b=goog.Uri.parse(b));return a.resolve(b)}; +goog.Uri.removeDotSegments=function(a){if(".."==a||"."==a)return"";if(goog.string.contains(a,"./")||goog.string.contains(a,"/.")){var b=goog.string.startsWith(a,"/");a=a.split("/");for(var c=[],d=0;d>4&15).toString(16)+(a&15).toString(16)};goog.Uri.reDisallowedInSchemeOrUserInfo_=/[#\/\?@]/g;goog.Uri.reDisallowedInRelativePath_=/[\#\?:]/g;goog.Uri.reDisallowedInAbsolutePath_=/[\#\?]/g;goog.Uri.reDisallowedInQuery_=/[\#\?@]/g;goog.Uri.reDisallowedInFragment_=/#/g; +goog.Uri.haveSameDomain=function(a,b){var c=goog.uri.utils.split(a),d=goog.uri.utils.split(b);return c[goog.uri.utils.ComponentIndex.DOMAIN]==d[goog.uri.utils.ComponentIndex.DOMAIN]&&c[goog.uri.utils.ComponentIndex.PORT]==d[goog.uri.utils.ComponentIndex.PORT]};goog.Uri.QueryData=function(a,b,c){this.encodedQuery_=a||null;this.ignoreCase_=!!c}; +goog.Uri.QueryData.prototype.ensureKeyMapInitialized_=function(){if(!this.keyMap_&&(this.keyMap_=new goog.structs.Map,this.count_=0,this.encodedQuery_))for(var a=this.encodedQuery_.split("\x26"),b=0;b=this.branches_&&this.cancel()}; +goog.async.Deferred.prototype.continue_=function(a,b){this.blocked_=!1;this.updateResult_(a,b)};goog.async.Deferred.prototype.updateResult_=function(a,b){this.fired_=!0;this.result_=b;this.hadError_=!a;this.fire_()};goog.async.Deferred.prototype.check_=function(){if(this.hasFired()){if(!this.silentlyCancelled_)throw new goog.async.Deferred.AlreadyCalledError(this);this.silentlyCancelled_=!1}}; +goog.async.Deferred.prototype.callback=function(a){this.check_();this.assertNotDeferred_(a);this.updateResult_(!0,a)};goog.async.Deferred.prototype.errback=function(a){this.check_();this.assertNotDeferred_(a);this.updateResult_(!1,a)};goog.async.Deferred.prototype.assertNotDeferred_=function(a){goog.asserts.assert(!(a instanceof goog.async.Deferred),"An execution sequence may not be initiated with a blocking Deferred.")}; +goog.async.Deferred.prototype.addCallback=function(a,b){return this.addCallbacks(a,null,b)};goog.async.Deferred.prototype.addErrback=function(a,b){return this.addCallbacks(null,a,b)};goog.async.Deferred.prototype.addBoth=function(a,b){return this.addCallbacks(a,a,b)};goog.async.Deferred.prototype.addCallbacks=function(a,b,c){goog.asserts.assert(!this.blocking_,"Blocking Deferreds can not be re-used");this.sequence_.push([a,b,c]);this.hasFired()&&this.fire_();return this}; +goog.async.Deferred.prototype.chainDeferred=function(a){this.addCallbacks(a.callback,a.errback,a);return this};goog.async.Deferred.prototype.awaitDeferred=function(a){return this.addCallback(goog.bind(a.branch,a))};goog.async.Deferred.prototype.branch=function(a){var b=new goog.async.Deferred;this.chainDeferred(b);a&&(b.parent_=this,this.branches_++);return b};goog.async.Deferred.prototype.hasFired=function(){return this.fired_}; +goog.async.Deferred.prototype.isError=function(a){return a instanceof Error};goog.async.Deferred.prototype.hasErrback_=function(){return goog.array.some(this.sequence_,function(a){return goog.isFunction(a[1])})}; +goog.async.Deferred.prototype.fire_=function(){this.unhandledExceptionTimeoutId_&&this.hasFired()&&this.hasErrback_()&&(goog.global.clearTimeout(this.unhandledExceptionTimeoutId_),delete this.unhandledExceptionTimeoutId_);this.parent_&&(this.parent_.branches_--,delete this.parent_);for(var a=this.result_,b=!1,c=!1;this.sequence_.length&&!this.blocked_;){var d=this.sequence_.shift(),e=d[0],f=d[1],d=d[2];if(e=this.hadError_?f:e)try{var g=e.call(d||this.defaultScope_,a);goog.isDef(g)&&(this.hadError_= +this.hadError_&&(g==a||this.isError(g)),this.result_=a=g);a instanceof goog.async.Deferred&&(this.blocked_=c=!0)}catch(h){a=h,this.hadError_=!0,this.hasErrback_()||(b=!0)}}this.result_=a;c&&(a.addCallbacks(goog.bind(this.continue_,this,!0),goog.bind(this.continue_,this,!1)),a.blocking_=!0);b&&(this.unhandledExceptionTimeoutId_=goog.global.setTimeout(function(){throw a;},0))};goog.async.Deferred.succeed=function(a){var b=new goog.async.Deferred;b.callback(a);return b}; +goog.async.Deferred.fail=function(a){var b=new goog.async.Deferred;b.errback(a);return b};goog.async.Deferred.cancelled=function(){var a=new goog.async.Deferred;a.cancel();return a};goog.async.Deferred.when=function(a,b,c){return a instanceof goog.async.Deferred?a.branch(!0).addCallback(b,c):goog.async.Deferred.succeed(a).addCallback(b,c)};goog.async.Deferred.AlreadyCalledError=function(a){goog.debug.Error.call(this);this.deferred=a};goog.inherits(goog.async.Deferred.AlreadyCalledError,goog.debug.Error); +goog.async.Deferred.AlreadyCalledError.prototype.message="Deferred has already fired";goog.async.Deferred.AlreadyCalledError.prototype.name="AlreadyCalledError";goog.async.Deferred.CancelledError=function(a){goog.debug.Error.call(this);this.deferred=a};goog.inherits(goog.async.Deferred.CancelledError,goog.debug.Error);goog.async.Deferred.CancelledError.prototype.message="Deferred was cancelled";goog.async.Deferred.CancelledError.prototype.name="CancelledError";goog.debug.entryPointRegistry={};goog.debug.EntryPointMonitor=function(){};goog.debug.entryPointRegistry.refList_=[];goog.debug.entryPointRegistry.monitors_=[];goog.debug.entryPointRegistry.monitorsMayExist_=!1;goog.debug.entryPointRegistry.register=function(a){goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length]=a;if(goog.debug.entryPointRegistry.monitorsMayExist_)for(var b=goog.debug.entryPointRegistry.monitors_,c=0;c=a.keyCode)a.keyCode=-1}catch(b){}};goog.events.BrowserEvent.prototype.getBrowserEvent=function(){return this.event_};goog.events.BrowserEvent.prototype.disposeInternal=function(){};goog.events.EventWrapper=function(){};goog.events.EventWrapper.prototype.listen=function(a,b,c,d,e){};goog.events.EventWrapper.prototype.unlisten=function(a,b,c,d,e){};goog.events.Listenable=function(){};goog.events.Listenable.USE_LISTENABLE_INTERFACE=!1;goog.events.Listenable.IMPLEMENTED_BY_PROP_="__closure_listenable";goog.events.Listenable.addImplementation=function(a){a.prototype[goog.events.Listenable.IMPLEMENTED_BY_PROP_]=!0};goog.events.Listenable.isImplementedBy=function(a){return!(!a||!a[goog.events.Listenable.IMPLEMENTED_BY_PROP_])};goog.events.ListenableKey=function(){};goog.events.ListenableKey.counter_=0;goog.events.ListenableKey.reserveKey=function(){return++goog.events.ListenableKey.counter_};goog.events.Listener=function(){goog.events.Listener.ENABLE_MONITORING&&(this.creationStack=Error().stack)};goog.events.Listener.ENABLE_MONITORING=!1;goog.events.Listener.prototype.key=0;goog.events.Listener.prototype.removed=!1;goog.events.Listener.prototype.callOnce=!1; +goog.events.Listener.prototype.init=function(a,b,c,d,e,f){if(goog.isFunction(a))this.isFunctionListener_=!0;else if(a&&a.handleEvent&&goog.isFunction(a.handleEvent))this.isFunctionListener_=!1;else throw Error("Invalid listener argument");this.listener=a;this.proxy=b;this.src=c;this.type=d;this.capture=!!e;this.handler=f;this.callOnce=!1;this.key=goog.events.ListenableKey.reserveKey();this.removed=!1}; +goog.events.Listener.prototype.handleEvent=function(a){return this.isFunctionListener_?this.listener.call(this.handler||this.src,a):this.listener.handleEvent.call(this.listener,a)};goog.events.listeners_={};goog.events.listenerTree_={};goog.events.sources_={};goog.events.onString_="on";goog.events.onStringMap_={};goog.events.keySeparator_="_"; +goog.events.listen=function(a,b,c,d,e){if(goog.isArray(b)){for(var f=0;fa.keyCode||void 0!=a.returnValue};goog.events.uniqueIdCounter_=0;goog.events.getUniqueId=function(a){return a+"_"+goog.events.uniqueIdCounter_++};goog.events.LISTENER_WRAPPER_PROP_="__closure_events_fn_"+(1E9*Math.random()>>>0); +goog.events.wrapListener_=function(a){return goog.isFunction(a)?a:a[goog.events.LISTENER_WRAPPER_PROP_]||(a[goog.events.LISTENER_WRAPPER_PROP_]=function(b){return a.handleEvent(b)})};goog.debug.entryPointRegistry.register(function(a){goog.events.handleBrowserEvent_=a(goog.events.handleBrowserEvent_)});goog.events.EventTarget=function(){goog.Disposable.call(this);goog.events.Listenable.USE_LISTENABLE_INTERFACE&&(this.eventTargetListeners_={},this.reallyDisposed_=!1,this.actualEventTarget_=this)};goog.inherits(goog.events.EventTarget,goog.Disposable);goog.events.Listenable.USE_LISTENABLE_INTERFACE&&goog.events.Listenable.addImplementation(goog.events.EventTarget);goog.events.EventTarget.MAX_ANCESTORS_=1E3;goog.events.EventTarget.prototype.customEvent_=!0; +goog.events.EventTarget.prototype.parentEventTarget_=null;goog.events.EventTarget.prototype.getParentEventTarget=function(){return this.parentEventTarget_};goog.events.EventTarget.prototype.setParentEventTarget=function(a){this.parentEventTarget_=a};goog.events.EventTarget.prototype.addEventListener=function(a,b,c,d){goog.events.listen(this,a,b,c,d)};goog.events.EventTarget.prototype.removeEventListener=function(a,b,c,d){goog.events.unlisten(this,a,b,c,d)}; +goog.events.EventTarget.prototype.dispatchEvent=function(a){if(goog.events.Listenable.USE_LISTENABLE_INTERFACE){if(this.reallyDisposed_)return!0;var b,c=this.getParentEventTarget();if(c){b=[];for(var d=1;c;c=c.getParentEventTarget())b.push(c),goog.asserts.assert(++dgoog.Timer.MAX_TIMEOUT_?-1:goog.Timer.defaultTimerObject.setTimeout(a,b||0)};goog.Timer.clear=function(a){goog.Timer.defaultTimerObject.clearTimeout(a)};goog.async.Delay=function(a,b,c){goog.Disposable.call(this);this.listener_=a;this.interval_=b||0;this.handler_=c;this.callback_=goog.bind(this.doAction_,this)};goog.inherits(goog.async.Delay,goog.Disposable);goog.Delay=goog.async.Delay;goog.async.Delay.prototype.id_=0;goog.async.Delay.prototype.disposeInternal=function(){goog.async.Delay.superClass_.disposeInternal.call(this);this.stop();delete this.listener_;delete this.handler_}; +goog.async.Delay.prototype.start=function(a){this.stop();this.id_=goog.Timer.callOnce(this.callback_,goog.isDef(a)?a:this.interval_)};goog.async.Delay.prototype.stop=function(){this.isActive()&&goog.Timer.clear(this.id_);this.id_=0};goog.async.Delay.prototype.fire=function(){this.stop();this.doAction_()};goog.async.Delay.prototype.fireIfActive=function(){this.isActive()&&this.fire()};goog.async.Delay.prototype.isActive=function(){return 0!=this.id_}; +goog.async.Delay.prototype.doAction_=function(){this.id_=0;this.listener_&&this.listener_.call(this.handler_)};goog.dom={};goog.dom.BrowserFeature={CAN_ADD_NAME_OR_TYPE_ATTRIBUTES:!goog.userAgent.IE||goog.userAgent.isDocumentMode(9),CAN_USE_CHILDREN_ATTRIBUTE:!goog.userAgent.GECKO&&!goog.userAgent.IE||goog.userAgent.IE&&goog.userAgent.isDocumentMode(9)||goog.userAgent.GECKO&&goog.userAgent.isVersion("1.9.1"),CAN_USE_INNER_TEXT:goog.userAgent.IE&&!goog.userAgent.isVersion("9"),CAN_USE_PARENT_ELEMENT_PROPERTY:goog.userAgent.IE||goog.userAgent.OPERA||goog.userAgent.WEBKIT,INNER_HTML_NEEDS_SCOPED_ELEMENT:goog.userAgent.IE};goog.dom.TagName={A:"A",ABBR:"ABBR",ACRONYM:"ACRONYM",ADDRESS:"ADDRESS",APPLET:"APPLET",AREA:"AREA",ARTICLE:"ARTICLE",ASIDE:"ASIDE",AUDIO:"AUDIO",B:"B",BASE:"BASE",BASEFONT:"BASEFONT",BDI:"BDI",BDO:"BDO",BIG:"BIG",BLOCKQUOTE:"BLOCKQUOTE",BODY:"BODY",BR:"BR",BUTTON:"BUTTON",CANVAS:"CANVAS",CAPTION:"CAPTION",CENTER:"CENTER",CITE:"CITE",CODE:"CODE",COL:"COL",COLGROUP:"COLGROUP",COMMAND:"COMMAND",DATA:"DATA",DATALIST:"DATALIST",DD:"DD",DEL:"DEL",DETAILS:"DETAILS",DFN:"DFN",DIALOG:"DIALOG",DIR:"DIR",DIV:"DIV", +DL:"DL",DT:"DT",EM:"EM",EMBED:"EMBED",FIELDSET:"FIELDSET",FIGCAPTION:"FIGCAPTION",FIGURE:"FIGURE",FONT:"FONT",FOOTER:"FOOTER",FORM:"FORM",FRAME:"FRAME",FRAMESET:"FRAMESET",H1:"H1",H2:"H2",H3:"H3",H4:"H4",H5:"H5",H6:"H6",HEAD:"HEAD",HEADER:"HEADER",HGROUP:"HGROUP",HR:"HR",HTML:"HTML",I:"I",IFRAME:"IFRAME",IMG:"IMG",INPUT:"INPUT",INS:"INS",ISINDEX:"ISINDEX",KBD:"KBD",KEYGEN:"KEYGEN",LABEL:"LABEL",LEGEND:"LEGEND",LI:"LI",LINK:"LINK",MAP:"MAP",MARK:"MARK",MATH:"MATH",MENU:"MENU",META:"META",METER:"METER", +NAV:"NAV",NOFRAMES:"NOFRAMES",NOSCRIPT:"NOSCRIPT",OBJECT:"OBJECT",OL:"OL",OPTGROUP:"OPTGROUP",OPTION:"OPTION",OUTPUT:"OUTPUT",P:"P",PARAM:"PARAM",PRE:"PRE",PROGRESS:"PROGRESS",Q:"Q",RP:"RP",RT:"RT",RUBY:"RUBY",S:"S",SAMP:"SAMP",SCRIPT:"SCRIPT",SECTION:"SECTION",SELECT:"SELECT",SMALL:"SMALL",SOURCE:"SOURCE",SPAN:"SPAN",STRIKE:"STRIKE",STRONG:"STRONG",STYLE:"STYLE",SUB:"SUB",SUMMARY:"SUMMARY",SUP:"SUP",SVG:"SVG",TABLE:"TABLE",TBODY:"TBODY",TD:"TD",TEXTAREA:"TEXTAREA",TFOOT:"TFOOT",TH:"TH",THEAD:"THEAD", +TIME:"TIME",TITLE:"TITLE",TR:"TR",TRACK:"TRACK",TT:"TT",U:"U",UL:"UL",VAR:"VAR",VIDEO:"VIDEO",WBR:"WBR"};goog.dom.classes={};goog.dom.classes.set=function(a,b){a.className=b};goog.dom.classes.get=function(a){a=a.className;return goog.isString(a)&&a.match(/\S+/g)||[]};goog.dom.classes.add=function(a,b){var c=goog.dom.classes.get(a),d=goog.array.slice(arguments,1),e=c.length+d.length;goog.dom.classes.add_(c,d);goog.dom.classes.set(a,c.join(" "));return c.length==e}; +goog.dom.classes.remove=function(a,b){var c=goog.dom.classes.get(a),d=goog.array.slice(arguments,1),e=goog.dom.classes.getDifference_(c,d);goog.dom.classes.set(a,e.join(" "));return e.length==c.length-d.length};goog.dom.classes.add_=function(a,b){for(var c=0;cc*b?c+b:c};goog.math.lerp=function(a,b,c){return a+c*(b-a)};goog.math.nearlyEquals=function(a,b,c){return Math.abs(a-b)<=(c||1E-6)};goog.math.standardAngle=function(a){return goog.math.modulo(a,360)}; +goog.math.toRadians=function(a){return a*Math.PI/180};goog.math.toDegrees=function(a){return 180*a/Math.PI};goog.math.angleDx=function(a,b){return b*Math.cos(goog.math.toRadians(a))};goog.math.angleDy=function(a,b){return b*Math.sin(goog.math.toRadians(a))};goog.math.angle=function(a,b,c,d){return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(d-b,c-a)))};goog.math.angleDifference=function(a,b){var c=goog.math.standardAngle(b)-goog.math.standardAngle(a);180=c&&(c=360+c);return c}; +goog.math.sign=function(a){return 0==a?0:0>a?-1:1};goog.math.longestCommonSubsequence=function(a,b,c,d){c=c||function(a,b){return a==b};d=d||function(b,c){return a[b]};for(var e=a.length,f=b.length,g=[],h=0;hg[h][k-1]?h--:k--;return l}; +goog.math.sum=function(a){return goog.array.reduce(arguments,function(a,c){return a+c},0)};goog.math.average=function(a){return goog.math.sum.apply(null,arguments)/arguments.length};goog.math.standardDeviation=function(a){var b=arguments.length;if(2>b)return 0;var c=goog.math.average.apply(null,arguments),b=goog.math.sum.apply(null,goog.array.map(arguments,function(a){return Math.pow(a-c,2)}))/(b-1);return Math.sqrt(b)};goog.math.isInt=function(a){return isFinite(a)&&0==a%1}; +goog.math.isFiniteNumber=function(a){return isFinite(a)&&!isNaN(a)};goog.math.safeFloor=function(a,b){goog.asserts.assert(!goog.isDef(b)||0a.aspectRatio()?a.width/this.width:a.height/this.height;return this.scale(a)};goog.dom.ASSUME_QUIRKS_MODE=!1;goog.dom.ASSUME_STANDARDS_MODE=!1;goog.dom.COMPAT_MODE_KNOWN_=goog.dom.ASSUME_QUIRKS_MODE||goog.dom.ASSUME_STANDARDS_MODE;goog.dom.NodeType={ELEMENT:1,ATTRIBUTE:2,TEXT:3,CDATA_SECTION:4,ENTITY_REFERENCE:5,ENTITY:6,PROCESSING_INSTRUCTION:7,COMMENT:8,DOCUMENT:9,DOCUMENT_TYPE:10,DOCUMENT_FRAGMENT:11,NOTATION:12};goog.dom.getDomHelper=function(a){return a?new goog.dom.DomHelper(goog.dom.getOwnerDocument(a)):goog.dom.defaultDomHelper_||(goog.dom.defaultDomHelper_=new goog.dom.DomHelper)}; +goog.dom.getDocument=function(){return document};goog.dom.getElement=function(a){return goog.isString(a)?document.getElementById(a):a};goog.dom.$=goog.dom.getElement;goog.dom.getElementsByTagNameAndClass=function(a,b,c){return goog.dom.getElementsByTagNameAndClass_(document,a,b,c)}; +goog.dom.getElementsByClass=function(a,b){var c=b||document;return goog.dom.canUseQuerySelector_(c)?c.querySelectorAll("."+a):c.getElementsByClassName?c.getElementsByClassName(a):goog.dom.getElementsByTagNameAndClass_(document,"*",a,b)};goog.dom.getElementByClass=function(a,b){var c=b||document,d=null;return(d=goog.dom.canUseQuerySelector_(c)?c.querySelector("."+a):goog.dom.getElementsByClass(a,b)[0])||null};goog.dom.canUseQuerySelector_=function(a){return!(!a.querySelectorAll||!a.querySelector)}; +goog.dom.getElementsByTagNameAndClass_=function(a,b,c,d){a=d||a;b=b&&"*"!=b?b.toUpperCase():"";if(goog.dom.canUseQuerySelector_(a)&&(b||c))return a.querySelectorAll(b+(c?"."+c:""));if(c&&a.getElementsByClassName){a=a.getElementsByClassName(c);if(b){d={};for(var e=0,f=0,g;g=a[f];f++)b==g.nodeName&&(d[e++]=g);d.length=e;return d}return a}a=a.getElementsByTagName(b||"*");if(c){d={};for(f=e=0;g=a[f];f++)b=g.className,"function"==typeof b.split&&goog.array.contains(b.split(/\s+/),c)&&(d[e++]=g);d.length= +e;return d}return a};goog.dom.$$=goog.dom.getElementsByTagNameAndClass;goog.dom.setProperties=function(a,b){goog.object.forEach(b,function(b,d){"style"==d?a.style.cssText=b:"class"==d?a.className=b:"for"==d?a.htmlFor=b:d in goog.dom.DIRECT_ATTRIBUTE_MAP_?a.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[d],b):goog.string.startsWith(d,"aria-")||goog.string.startsWith(d,"data-")?a.setAttribute(d,b):a[d]=b})}; +goog.dom.DIRECT_ATTRIBUTE_MAP_={cellpadding:"cellPadding",cellspacing:"cellSpacing",colspan:"colSpan",frameborder:"frameBorder",height:"height",maxlength:"maxLength",role:"role",rowspan:"rowSpan",type:"type",usemap:"useMap",valign:"vAlign",width:"width"};goog.dom.getViewportSize=function(a){return goog.dom.getViewportSize_(a||window)};goog.dom.getViewportSize_=function(a){a=a.document;a=goog.dom.isCss1CompatMode_(a)?a.documentElement:a.body;return new goog.math.Size(a.clientWidth,a.clientHeight)}; +goog.dom.getDocumentHeight=function(){return goog.dom.getDocumentHeight_(window)};goog.dom.getDocumentHeight_=function(a){var b=a.document,c=0;if(b){a=goog.dom.getViewportSize_(a).height;var c=b.body,d=b.documentElement;if(goog.dom.isCss1CompatMode_(b)&&d.scrollHeight)c=d.scrollHeight!=a?d.scrollHeight:d.offsetHeight;else{var b=d.scrollHeight,e=d.offsetHeight;d.clientHeight!=e&&(b=c.scrollHeight,e=c.offsetHeight);c=b>a?b>e?b:e:ba):!1};goog.dom.setFocusableTabIndex=function(a,b){b?a.tabIndex=0:(a.tabIndex=-1,a.removeAttribute("tabIndex"))}; +goog.dom.getTextContent=function(a){if(goog.dom.BrowserFeature.CAN_USE_INNER_TEXT&&"innerText"in a)a=goog.string.canonicalizeNewlines(a.innerText);else{var b=[];goog.dom.getTextContent_(a,b,!0);a=b.join("")}a=a.replace(/ \xAD /g," ").replace(/\xAD/g,"");a=a.replace(/\u200B/g,"");goog.dom.BrowserFeature.CAN_USE_INNER_TEXT||(a=a.replace(/ +/g," "));" "!=a&&(a=a.replace(/^\s*/,""));return a};goog.dom.getRawTextContent=function(a){var b=[];goog.dom.getTextContent_(a,b,!1);return b.join("")}; +goog.dom.getTextContent_=function(a,b,c){if(!(a.nodeName in goog.dom.TAGS_TO_IGNORE_))if(a.nodeType==goog.dom.NodeType.TEXT)c?b.push(String(a.nodeValue).replace(/(\r\n|\r|\n)/g,"")):b.push(a.nodeValue);else if(a.nodeName in goog.dom.PREDEFINED_TAG_VALUES_)b.push(goog.dom.PREDEFINED_TAG_VALUES_[a.nodeName]);else for(a=a.firstChild;a;)goog.dom.getTextContent_(a,b,c),a=a.nextSibling};goog.dom.getNodeTextLength=function(a){return goog.dom.getTextContent(a).length}; +goog.dom.getNodeTextOffset=function(a,b){for(var c=b||goog.dom.getOwnerDocument(a).body,d=[];a&&a!=c;){for(var e=a;e=e.previousSibling;)d.unshift(goog.dom.getTextContent(e));a=a.parentNode}return goog.string.trimLeft(d.join("")).replace(/ +/g," ").length}; +goog.dom.getNodeAtOffset=function(a,b,c){a=[a];for(var d=0,e=null;0b?e+="000":256>b?e+="00":4096>b&&(e+="0");return goog.json.Serializer.charToJsonCharCache_[a]=e+b.toString(16)}),'"')};goog.json.Serializer.prototype.serializeNumber_=function(a,b){b.push(isFinite(a)&&!isNaN(a)?a:"null")}; +goog.json.Serializer.prototype.serializeArray=function(a,b){var c=a.length;b.push("[");for(var d="",e=0;eb)return!1;!(a instanceof goog.structs.Set)&&5=goog.debug.MAX_STACK_DEPTH){b.push("[...long stack...]");break}}a&&d>=a?b.push("[...reached max depth limit...]"):b.push("[end]");return b.join("")};goog.debug.MAX_STACK_DEPTH=50; +goog.debug.getStacktrace=function(a){return goog.debug.getStacktraceHelper_(a||arguments.callee.caller,[])}; +goog.debug.getStacktraceHelper_=function(a,b){var c=[];if(goog.array.contains(b,a))c.push("[...circular reference...]");else if(a&&b.length=this.getEffectiveLevel().value};goog.debug.Logger.prototype.log=function(a,b,c){this.isLoggable(a)&&this.doLogRecord_(this.getLogRecord(a,b,c))}; +goog.debug.Logger.prototype.getLogRecord=function(a,b,c){var d=goog.debug.LogBuffer.isBufferingEnabled()?goog.debug.LogBuffer.getInstance().addRecord(a,b,this.name_):new goog.debug.LogRecord(a,String(b),this.name_);c&&(d.setException(c),d.setExceptionText(goog.debug.exposeException(c,arguments.callee.caller)));return d};goog.debug.Logger.prototype.shout=function(a,b){this.log(goog.debug.Logger.Level.SHOUT,a,b)}; +goog.debug.Logger.prototype.severe=function(a,b){this.log(goog.debug.Logger.Level.SEVERE,a,b)};goog.debug.Logger.prototype.warning=function(a,b){this.log(goog.debug.Logger.Level.WARNING,a,b)};goog.debug.Logger.prototype.info=function(a,b){this.log(goog.debug.Logger.Level.INFO,a,b)};goog.debug.Logger.prototype.config=function(a,b){this.log(goog.debug.Logger.Level.CONFIG,a,b)};goog.debug.Logger.prototype.fine=function(a,b){this.log(goog.debug.Logger.Level.FINE,a,b)}; +goog.debug.Logger.prototype.finer=function(a,b){this.log(goog.debug.Logger.Level.FINER,a,b)};goog.debug.Logger.prototype.finest=function(a,b){this.log(goog.debug.Logger.Level.FINEST,a,b)};goog.debug.Logger.prototype.logRecord=function(a){this.isLoggable(a.getLevel())&&this.doLogRecord_(a)}; +goog.debug.Logger.prototype.doLogRecord_=function(a){goog.debug.Logger.logToProfilers("log:"+a.getMessage());if(goog.debug.Logger.ENABLE_HIERARCHY)for(var b=this;b;)b.callPublish_(a),b=b.getParent();else for(var b=0,c;c=goog.debug.Logger.rootHandlers_[b++];)c(a)};goog.debug.Logger.prototype.callPublish_=function(a){if(this.handlers_)for(var b=0,c;c=this.handlers_[b];b++)c(a)};goog.debug.Logger.prototype.setParent_=function(a){this.parent_=a}; +goog.debug.Logger.prototype.addChild_=function(a,b){this.getChildren()[a]=b};goog.debug.LogManager={};goog.debug.LogManager.loggers_={};goog.debug.LogManager.rootLogger_=null;goog.debug.LogManager.initialize=function(){goog.debug.LogManager.rootLogger_||(goog.debug.LogManager.rootLogger_=new goog.debug.Logger(""),goog.debug.LogManager.loggers_[""]=goog.debug.LogManager.rootLogger_,goog.debug.LogManager.rootLogger_.setLevel(goog.debug.Logger.Level.CONFIG))};goog.debug.LogManager.getLoggers=function(){return goog.debug.LogManager.loggers_}; +goog.debug.LogManager.getRoot=function(){goog.debug.LogManager.initialize();return goog.debug.LogManager.rootLogger_};goog.debug.LogManager.getLogger=function(a){goog.debug.LogManager.initialize();return goog.debug.LogManager.loggers_[a]||goog.debug.LogManager.createLogger_(a)};goog.debug.LogManager.createFunctionForCatchErrors=function(a){return function(b){(a||goog.debug.LogManager.getRoot()).severe("Error: "+b.message+" ("+b.fileName+" @ Line: "+b.line+")")}}; +goog.debug.LogManager.createLogger_=function(a){var b=new goog.debug.Logger(a);if(goog.debug.Logger.ENABLE_HIERARCHY){var c=a.lastIndexOf("."),d=a.substr(0,c),c=a.substr(c+1),d=goog.debug.LogManager.getLogger(d);d.addChild_(c,b);b.setParent_(d)}return goog.debug.LogManager.loggers_[a]=b};goog.messaging={};goog.messaging.MessageChannel=function(){};goog.messaging.MessageChannel.prototype.connect=function(a){};goog.messaging.MessageChannel.prototype.isConnected=function(){};goog.messaging.MessageChannel.prototype.registerService=function(a,b,c){};goog.messaging.MessageChannel.prototype.registerDefaultService=function(a){};goog.messaging.MessageChannel.prototype.send=function(a,b){};goog.messaging.AbstractChannel=function(){goog.Disposable.call(this);this.services_={}};goog.inherits(goog.messaging.AbstractChannel,goog.Disposable);goog.messaging.AbstractChannel.prototype.logger=goog.debug.Logger.getLogger("goog.messaging.AbstractChannel");goog.messaging.AbstractChannel.prototype.connect=function(a){a&&a()};goog.messaging.AbstractChannel.prototype.isConnected=function(){return!0}; +goog.messaging.AbstractChannel.prototype.registerService=function(a,b,c){this.services_[a]={callback:b,objectPayload:!!c}};goog.messaging.AbstractChannel.prototype.registerDefaultService=function(a){this.defaultService_=a};goog.messaging.AbstractChannel.prototype.deliver=function(a,b){var c=this.getService(a,b);if(c){var d=this.decodePayload(a,b,c.objectPayload);goog.isDefAndNotNull(d)&&c.callback(d)}}; +goog.messaging.AbstractChannel.prototype.getService=function(a,b){var c=this.services_[a];if(c)return c;if(this.defaultService_){var c=goog.partial(this.defaultService_,a),d=goog.isObject(b);return{callback:c,objectPayload:d}}this.logger.warning('Unknown service name "'+a+'"');return null}; +goog.messaging.AbstractChannel.prototype.decodePayload=function(a,b,c){if(c&&goog.isString(b))try{return goog.json.parse(b)}catch(d){return this.logger.warning("Expected JSON payload for "+a+', was "'+b+'"'),null}else if(!c&&!goog.isString(b))return goog.json.serialize(b);return b};goog.messaging.AbstractChannel.prototype.disposeInternal=function(){goog.messaging.AbstractChannel.superClass_.disposeInternal.call(this);delete this.logger;delete this.services_;delete this.defaultService_};goog.net={};goog.net.xpc={};goog.net.xpc.TransportTypes={NATIVE_MESSAGING:1,FRAME_ELEMENT_METHOD:2,IFRAME_RELAY:3,IFRAME_POLLING:4,FLASH:5,NIX:6};goog.net.xpc.TransportNames={1:"NativeMessagingTransport",2:"FrameElementMethodTransport",3:"IframeRelayTransport",4:"IframePollingTransport",5:"FlashTransport",6:"NixTransport"}; +goog.net.xpc.CfgFields={CHANNEL_NAME:"cn",AUTH_TOKEN:"at",REMOTE_AUTH_TOKEN:"rat",PEER_URI:"pu",IFRAME_ID:"ifrid",TRANSPORT:"tp",LOCAL_RELAY_URI:"lru",PEER_RELAY_URI:"pru",LOCAL_POLL_URI:"lpu",PEER_POLL_URI:"ppu",PEER_HOSTNAME:"ph",ONE_SIDED_HANDSHAKE:"osh",ROLE:"role",NATIVE_TRANSPORT_PROTOCOL_VERSION:"nativeProtocolVersion"}; +goog.net.xpc.UriCfgFields=[goog.net.xpc.CfgFields.PEER_URI,goog.net.xpc.CfgFields.LOCAL_RELAY_URI,goog.net.xpc.CfgFields.PEER_RELAY_URI,goog.net.xpc.CfgFields.LOCAL_POLL_URI,goog.net.xpc.CfgFields.PEER_POLL_URI];goog.net.xpc.ChannelStates={NOT_CONNECTED:1,CONNECTED:2,CLOSED:3};goog.net.xpc.TRANSPORT_SERVICE_="tp";goog.net.xpc.SETUP="SETUP";goog.net.xpc.SETUP_NTPV2="SETUP_NTPV2";goog.net.xpc.SETUP_ACK_="SETUP_ACK";goog.net.xpc.SETUP_ACK_NTPV2="SETUP_ACK_NTPV2";goog.net.xpc.channels={}; +goog.net.xpc.getRandomString=function(a,b){for(var c=b||goog.net.xpc.randomStringCharacters_,d=c.length,e="";0=a;){var c=goog.net.xpc.IframeRelayTransport.iframeRefs_.shift().iframeElement;goog.dom.removeNode(c);goog.net.xpc.logger.finest("iframe removed")}goog.net.xpc.IframeRelayTransport.cleanupTimer_=window.setTimeout(goog.net.xpc.IframeRelayTransport.cleanupCb_, +goog.net.xpc.IframeRelayTransport.CLEANUP_INTERVAL_)},goog.net.xpc.IframeRelayTransport.cleanupCb_=function(){goog.net.xpc.IframeRelayTransport.cleanup_()});goog.net.xpc.IframeRelayTransport.IE_PAYLOAD_MAX_SIZE_=1800;goog.net.xpc.IframeRelayTransport.fragmentMap_={};goog.net.xpc.IframeRelayTransport.prototype.transportType=goog.net.xpc.TransportTypes.IFRAME_RELAY; +goog.net.xpc.IframeRelayTransport.prototype.connect=function(){this.getWindow().xpcRelay||(this.getWindow().xpcRelay=goog.net.xpc.IframeRelayTransport.receiveMessage_);this.send(goog.net.xpc.TRANSPORT_SERVICE_,goog.net.xpc.SETUP)}; +goog.net.xpc.IframeRelayTransport.receiveMessage_=function(a,b){var c=b.indexOf(":"),d=b.substr(0,c),e=b.substr(c+1);if(goog.userAgent.IE&&-1!=(c=d.indexOf("|"))){var f=d.substr(0,c),d=d.substr(c+1),c=d.indexOf("+"),g=d.substr(0,c),c=parseInt(d.substr(c+1),10),h=goog.net.xpc.IframeRelayTransport.fragmentMap_[g];h||(h=goog.net.xpc.IframeRelayTransport.fragmentMap_[g]={fragments:[],received:0,expected:0});goog.string.contains(d,"++")&&(h.expected=c+1);h.fragments[c]=e;h.received++;if(h.received!=h.expected)return; +e=h.fragments.join("");delete goog.net.xpc.IframeRelayTransport.fragmentMap_[g]}else var f=d;goog.net.xpc.channels[a].xpcDeliver(f,decodeURIComponent(e))};goog.net.xpc.IframeRelayTransport.prototype.transportServiceHandler=function(a){a==goog.net.xpc.SETUP?(this.send(goog.net.xpc.TRANSPORT_SERVICE_,goog.net.xpc.SETUP_ACK_),this.channel_.notifyConnected()):a==goog.net.xpc.SETUP_ACK_&&this.channel_.notifyConnected()}; +goog.net.xpc.IframeRelayTransport.prototype.send=function(a,b){var c=encodeURIComponent(b),d=c.length,e=goog.net.xpc.IframeRelayTransport.IE_PAYLOAD_MAX_SIZE_;if(goog.userAgent.IE&&d>e)for(var f=goog.string.getRandomString(),g=0,h=0;g=d?"++":"+")+h)}else this.send_(a,c)}; +goog.net.xpc.IframeRelayTransport.prototype.send_=function(a,b,c){if(goog.userAgent.IE){var d=this.getWindow().document.createElement("div");d.innerHTML='\x3ciframe onload\x3d"this.xpcOnload()"\x3e\x3c/iframe\x3e';d=d.childNodes[0];d.xpcOnload=goog.net.xpc.IframeRelayTransport.iframeLoadHandler_}else d=this.getWindow().document.createElement("iframe"),goog.userAgent.WEBKIT?goog.net.xpc.IframeRelayTransport.iframeRefs_.push({timestamp:goog.now(),iframeElement:d}):goog.events.listen(d,"load",goog.net.xpc.IframeRelayTransport.iframeLoadHandler_); +var e=d.style;e.visibility="hidden";e.width=d.style.height="0px";e.position="absolute";e=this.peerRelayUri_;e+="#"+this.channel_.name;this.peerIframeId_&&(e+=","+this.peerIframeId_);e+="|"+a;c&&(e+="|"+c);e+=":"+b;d.src=e;this.getWindow().document.body.appendChild(d);goog.net.xpc.logger.finest("msg sent: "+e)};goog.net.xpc.IframeRelayTransport.iframeLoadHandler_=function(){goog.net.xpc.logger.finest("iframe-load");goog.dom.removeNode(this);this.xpcOnload=null}; +goog.net.xpc.IframeRelayTransport.prototype.disposeInternal=function(){goog.net.xpc.IframeRelayTransport.superClass_.disposeInternal.call(this);goog.userAgent.WEBKIT&&goog.net.xpc.IframeRelayTransport.cleanup_(0)};goog.net.xpc.NativeMessagingTransport=function(a,b,c,d,e){goog.net.xpc.Transport.call(this,c);this.channel_=a;this.protocolVersion_=e||2;goog.asserts.assert(1<=this.protocolVersion_);goog.asserts.assert(2>=this.protocolVersion_);this.peerHostname_=b||"*";this.eventHandler_=new goog.events.EventHandler(this);this.maybeAttemptToConnectTimer_=new goog.Timer(100,this.getWindow());this.oneSidedHandshake_=!!d;this.setupAckReceived_=new goog.async.Deferred;this.setupAckSent_=new goog.async.Deferred;this.connected_= +new goog.async.Deferred;this.endpointId_=goog.net.xpc.getRandomString(10);this.peerEndpointId_=null;this.oneSidedHandshake_?this.channel_.getRole()==goog.net.xpc.CrossPageChannelRole.INNER?this.connected_.awaitDeferred(this.setupAckReceived_):this.connected_.awaitDeferred(this.setupAckSent_):(this.connected_.awaitDeferred(this.setupAckReceived_),2==this.protocolVersion_&&this.connected_.awaitDeferred(this.setupAckSent_));this.connected_.addCallback(this.notifyConnected_,this);this.connected_.callback(!0); +this.eventHandler_.listen(this.maybeAttemptToConnectTimer_,goog.Timer.TICK,this.maybeAttemptToConnect_);goog.net.xpc.logger.info("NativeMessagingTransport created. protocolVersion\x3d"+this.protocolVersion_+", oneSidedHandshake\x3d"+this.oneSidedHandshake_+", role\x3d"+this.channel_.getRole())};goog.inherits(goog.net.xpc.NativeMessagingTransport,goog.net.xpc.Transport);goog.net.xpc.NativeMessagingTransport.CONNECTION_DELAY_MS_=200; +goog.net.xpc.NativeMessagingTransport.prototype.peerProtocolVersion_=null;goog.net.xpc.NativeMessagingTransport.prototype.initialized_=!1;goog.net.xpc.NativeMessagingTransport.prototype.transportType=goog.net.xpc.TransportTypes.NATIVE_MESSAGING;goog.net.xpc.NativeMessagingTransport.MESSAGE_DELIMITER_=",";goog.net.xpc.NativeMessagingTransport.activeCount_={};goog.net.xpc.NativeMessagingTransport.sendTimerId_=0; +goog.net.xpc.NativeMessagingTransport.prototype.couldPeerVersionBe_=function(a){return null==this.peerProtocolVersion_||this.peerProtocolVersion_==a}; +goog.net.xpc.NativeMessagingTransport.initialize_=function(a){var b=goog.getUid(a),c=goog.net.xpc.NativeMessagingTransport.activeCount_[b];goog.isNumber(c)||(c=0);0==c&&goog.events.listen(a.postMessage?a:a.document,"message",goog.net.xpc.NativeMessagingTransport.messageReceived_,!1,goog.net.xpc.NativeMessagingTransport);goog.net.xpc.NativeMessagingTransport.activeCount_[b]=c+1}; +goog.net.xpc.NativeMessagingTransport.messageReceived_=function(a){var b=a.getBrowserEvent().data;if(!goog.isString(b))return!1;var c=b.indexOf("|"),d=b.indexOf(":");if(-1==c||-1==d)return!1;var e=b.substring(0,c),c=b.substring(c+1,d),b=b.substring(d+1);goog.net.xpc.logger.fine("messageReceived: channel\x3d"+e+", service\x3d"+c+", payload\x3d"+b);if(d=goog.net.xpc.channels[e])return d.xpcDeliver(c,b,a.getBrowserEvent().origin),!0;a=goog.net.xpc.NativeMessagingTransport.parseTransportPayload_(b)[0]; +for(var f in goog.net.xpc.channels)if(d=goog.net.xpc.channels[f],d.getRole()==goog.net.xpc.CrossPageChannelRole.INNER&&!d.isConnected()&&c==goog.net.xpc.TRANSPORT_SERVICE_&&(a==goog.net.xpc.SETUP||a==goog.net.xpc.SETUP_NTPV2))return goog.net.xpc.logger.fine("changing channel name to "+e),d.name=e,delete goog.net.xpc.channels[f],goog.net.xpc.channels[e]=d,d.xpcDeliver(c,b),!0;goog.net.xpc.logger.info('channel name mismatch; message ignored"');return!1}; +goog.net.xpc.NativeMessagingTransport.prototype.transportServiceHandler=function(a){var b=goog.net.xpc.NativeMessagingTransport.parseTransportPayload_(a);a=b[1];switch(b[0]){case goog.net.xpc.SETUP_ACK_:this.setPeerProtocolVersion_(1);this.setupAckReceived_.hasFired()||this.setupAckReceived_.callback(!0);break;case goog.net.xpc.SETUP_ACK_NTPV2:2==this.protocolVersion_&&(this.setPeerProtocolVersion_(2),this.setupAckReceived_.hasFired()||this.setupAckReceived_.callback(!0));break;case goog.net.xpc.SETUP:this.setPeerProtocolVersion_(1); +this.sendSetupAckMessage_(1);break;case goog.net.xpc.SETUP_NTPV2:2==this.protocolVersion_&&(b=this.peerProtocolVersion_,this.setPeerProtocolVersion_(2),this.sendSetupAckMessage_(2),1!=b&&null==this.peerEndpointId_||this.peerEndpointId_==a||(goog.net.xpc.logger.info("Sending SETUP and changing peer ID to: "+a),this.sendSetupMessage_()),this.peerEndpointId_=a)}}; +goog.net.xpc.NativeMessagingTransport.prototype.sendSetupMessage_=function(){goog.asserts.assert(!(1==this.protocolVersion_&&2==this.peerProtocolVersion_));if(2==this.protocolVersion_&&this.couldPeerVersionBe_(2)){var a=goog.net.xpc.SETUP_NTPV2,a=a+goog.net.xpc.NativeMessagingTransport.MESSAGE_DELIMITER_,a=a+this.endpointId_;this.send(goog.net.xpc.TRANSPORT_SERVICE_,a)}this.couldPeerVersionBe_(1)&&this.send(goog.net.xpc.TRANSPORT_SERVICE_,goog.net.xpc.SETUP)}; +goog.net.xpc.NativeMessagingTransport.prototype.sendSetupAckMessage_=function(a){goog.asserts.assert(1!=this.protocolVersion_||2!=a,"Shouldn't try to send a v2 setup ack in v1 mode.");if(2==this.protocolVersion_&&this.couldPeerVersionBe_(2)&&2==a)this.send(goog.net.xpc.TRANSPORT_SERVICE_,goog.net.xpc.SETUP_ACK_NTPV2);else if(this.couldPeerVersionBe_(1)&&1==a)this.send(goog.net.xpc.TRANSPORT_SERVICE_,goog.net.xpc.SETUP_ACK_);else return;this.setupAckSent_.hasFired()||this.setupAckSent_.callback(!0)}; +goog.net.xpc.NativeMessagingTransport.prototype.setPeerProtocolVersion_=function(a){a>this.peerProtocolVersion_&&(this.peerProtocolVersion_=a);1==this.peerProtocolVersion_&&(this.setupAckSent_.hasFired()||this.oneSidedHandshake_||this.setupAckSent_.callback(!0),this.peerEndpointId_=null)};goog.net.xpc.NativeMessagingTransport.prototype.connect=function(){goog.net.xpc.NativeMessagingTransport.initialize_(this.getWindow());this.initialized_=!0;this.maybeAttemptToConnect_()}; +goog.net.xpc.NativeMessagingTransport.prototype.maybeAttemptToConnect_=function(){var a=this.channel_.getRole()==goog.net.xpc.CrossPageChannelRole.OUTER;this.oneSidedHandshake_&&a||this.channel_.isConnected()||this.isDisposed()?this.maybeAttemptToConnectTimer_.stop():(this.maybeAttemptToConnectTimer_.start(),this.sendSetupMessage_())}; +goog.net.xpc.NativeMessagingTransport.prototype.send=function(a,b){var c=this.channel_.getPeerWindowObject();c?(this.send=function(a,b){var f=this,g=this.channel_.name;this.sendTimerId_=goog.Timer.callOnce(function(){f.sendTimerId_=0;try{var h=c.postMessage?c:c.document;h.postMessage?(h.postMessage(g+"|"+a+":"+b,f.peerHostname_),goog.net.xpc.logger.fine("send(): service\x3d"+a+" payload\x3d"+b+" to hostname\x3d"+f.peerHostname_)):goog.net.xpc.logger.warning("Peer window had no postMessage function.")}catch(k){goog.net.xpc.logger.warning("Error performing postMessage, ignoring.", +k)}},0)},this.send(a,b)):goog.net.xpc.logger.fine("send(): window not ready")};goog.net.xpc.NativeMessagingTransport.prototype.notifyConnected_=function(){this.channel_.notifyConnected(1==this.protocolVersion_||1==this.peerProtocolVersion_?goog.net.xpc.NativeMessagingTransport.CONNECTION_DELAY_MS_:void 0)}; +goog.net.xpc.NativeMessagingTransport.prototype.disposeInternal=function(){if(this.initialized_){var a=this.getWindow(),b=goog.getUid(a),c=goog.net.xpc.NativeMessagingTransport.activeCount_[b];goog.net.xpc.NativeMessagingTransport.activeCount_[b]=c-1;1==c&&goog.events.unlisten(a.postMessage?a:a.document,"message",goog.net.xpc.NativeMessagingTransport.messageReceived_,!1,goog.net.xpc.NativeMessagingTransport)}this.sendTimerId_&&(goog.Timer.clear(this.sendTimerId_),this.sendTimerId_=0);goog.dispose(this.eventHandler_); +delete this.eventHandler_;goog.dispose(this.maybeAttemptToConnectTimer_);delete this.maybeAttemptToConnectTimer_;this.setupAckReceived_.cancel();delete this.setupAckReceived_;this.setupAckSent_.cancel();delete this.setupAckSent_;this.connected_.cancel();delete this.connected_;delete this.send;goog.net.xpc.NativeMessagingTransport.superClass_.disposeInternal.call(this)}; +goog.net.xpc.NativeMessagingTransport.parseTransportPayload_=function(a){a=a.split(goog.net.xpc.NativeMessagingTransport.MESSAGE_DELIMITER_);a[1]=a[1]||null;return a};goog.net.xpc.NixTransport=function(a,b){goog.net.xpc.Transport.call(this,b);this.channel_=a;this.authToken_=a[goog.net.xpc.CfgFields.AUTH_TOKEN]||"";this.remoteAuthToken_=a[goog.net.xpc.CfgFields.REMOTE_AUTH_TOKEN]||"";goog.net.xpc.NixTransport.conductGlobalSetup_(this.getWindow());this[goog.net.xpc.NixTransport.NIX_HANDLE_MESSAGE]=this.handleMessage_;this[goog.net.xpc.NixTransport.NIX_CREATE_CHANNEL]=this.createChannel_};goog.inherits(goog.net.xpc.NixTransport,goog.net.xpc.Transport); +goog.net.xpc.NixTransport.NIX_WRAPPER="GCXPC____NIXVBS_wrapper";goog.net.xpc.NixTransport.NIX_GET_WRAPPER="GCXPC____NIXVBS_get_wrapper";goog.net.xpc.NixTransport.NIX_HANDLE_MESSAGE="GCXPC____NIXJS_handle_message";goog.net.xpc.NixTransport.NIX_CREATE_CHANNEL="GCXPC____NIXJS_create_channel";goog.net.xpc.NixTransport.NIX_ID_FIELD="GCXPC____NIXVBS_container"; +goog.net.xpc.NixTransport.isNixSupported=function(){var a=!1;try{var b=window.opener;window.opener={};a=goog.reflect.canAccessProperty(window,"opener");window.opener=b}catch(c){}return a}; +goog.net.xpc.NixTransport.conductGlobalSetup_=function(a){if(!a.nix_setup_complete){var b="Class "+goog.net.xpc.NixTransport.NIX_WRAPPER+"\n Private m_Transport\nPrivate m_Auth\nPublic Sub SetTransport(transport)\nIf isEmpty(m_Transport) Then\nSet m_Transport \x3d transport\nEnd If\nEnd Sub\nPublic Sub SetAuth(auth)\nIf isEmpty(m_Auth) Then\nm_Auth \x3d auth\nEnd If\nEnd Sub\nPublic Function GetAuthToken()\n GetAuthToken \x3d m_Auth\nEnd Function\nPublic Sub SendMessage(service, payload)\n Call m_Transport."+goog.net.xpc.NixTransport.NIX_HANDLE_MESSAGE+ +"(service, payload)\nEnd Sub\nPublic Sub CreateChannel(channel)\n Call m_Transport."+goog.net.xpc.NixTransport.NIX_CREATE_CHANNEL+"(channel)\nEnd Sub\nPublic Sub "+goog.net.xpc.NixTransport.NIX_ID_FIELD+"()\n End Sub\nEnd Class\n Function "+goog.net.xpc.NixTransport.NIX_GET_WRAPPER+"(transport, auth)\nDim wrap\nSet wrap \x3d New "+goog.net.xpc.NixTransport.NIX_WRAPPER+"\nwrap.SetTransport transport\nwrap.SetAuth auth\nSet "+goog.net.xpc.NixTransport.NIX_GET_WRAPPER+" \x3d wrap\nEnd Function";try{a.execScript(b, +"vbscript"),a.nix_setup_complete=!0}catch(c){goog.net.xpc.logger.severe("exception caught while attempting global setup: "+c)}}};goog.net.xpc.NixTransport.prototype.transportType=goog.net.xpc.TransportTypes.NIX;goog.net.xpc.NixTransport.prototype.localSetupCompleted_=!1;goog.net.xpc.NixTransport.prototype.nixChannel_=null;goog.net.xpc.NixTransport.prototype.connect=function(){this.channel_.getRole()==goog.net.xpc.CrossPageChannelRole.OUTER?this.attemptOuterSetup_():this.attemptInnerSetup_()}; +goog.net.xpc.NixTransport.prototype.attemptOuterSetup_=function(){if(!this.localSetupCompleted_){var a=this.channel_.getIframeElement();try{var b=this.getWindow()[goog.net.xpc.NixTransport.NIX_GET_WRAPPER];a.contentWindow.opener=b(this,this.authToken_);this.localSetupCompleted_=!0}catch(c){goog.net.xpc.logger.severe("exception caught while attempting setup: "+c)}this.localSetupCompleted_||this.getWindow().setTimeout(goog.bind(this.attemptOuterSetup_,this),100)}}; +goog.net.xpc.NixTransport.prototype.attemptInnerSetup_=function(){if(!this.localSetupCompleted_){try{var a=this.getWindow().opener;if(a&&goog.net.xpc.NixTransport.NIX_ID_FIELD in a){this.nixChannel_=a;if(this.nixChannel_.GetAuthToken()!=this.remoteAuthToken_){goog.net.xpc.logger.severe("Invalid auth token from other party");return}var b=this.getWindow()[goog.net.xpc.NixTransport.NIX_GET_WRAPPER];this.nixChannel_.CreateChannel(b(this,this.authToken_));this.localSetupCompleted_=!0;this.channel_.notifyConnected()}}catch(c){goog.net.xpc.logger.severe("exception caught while attempting setup: "+ +c);return}this.localSetupCompleted_||this.getWindow().setTimeout(goog.bind(this.attemptInnerSetup_,this),100)}};goog.net.xpc.NixTransport.prototype.createChannel_=function(a){"unknown"==typeof a&&goog.net.xpc.NixTransport.NIX_ID_FIELD in a||goog.net.xpc.logger.severe("Invalid NIX channel given to createChannel_");this.nixChannel_=a;this.nixChannel_.GetAuthToken()!=this.remoteAuthToken_?goog.net.xpc.logger.severe("Invalid auth token from other party"):this.channel_.notifyConnected()}; +goog.net.xpc.NixTransport.prototype.handleMessage_=function(a,b){this.getWindow().setTimeout(goog.bind(function(){this.channel_.xpcDeliver(a,b)},this),1)};goog.net.xpc.NixTransport.prototype.send=function(a,b){"unknown"!==typeof this.nixChannel_&&goog.net.xpc.logger.severe("NIX channel not connected");this.nixChannel_.SendMessage(a,b)};goog.net.xpc.NixTransport.prototype.disposeInternal=function(){goog.net.xpc.NixTransport.superClass_.disposeInternal.call(this);this.nixChannel_=null};goog.net.xpc.CrossPageChannel=function(a,b){goog.messaging.AbstractChannel.call(this);for(var c=0,d;d=goog.net.xpc.UriCfgFields[c];c++)if(d in a&&!/^https?:\/\//.test(a[d]))throw Error("URI "+a[d]+" is invalid for field "+d);this.cfg_=a;this.name=this.cfg_[goog.net.xpc.CfgFields.CHANNEL_NAME]||goog.net.xpc.getRandomString(10);this.domHelper_=b||goog.dom.getDomHelper();this.deferredDeliveries_=[];this.peerLoadHandler_=new goog.events.EventHandler(this);a[goog.net.xpc.CfgFields.LOCAL_POLL_URI]=a[goog.net.xpc.CfgFields.LOCAL_POLL_URI]|| +goog.uri.utils.getHost(this.domHelper_.getWindow().location.href)+"/robots.txt";a[goog.net.xpc.CfgFields.PEER_POLL_URI]=a[goog.net.xpc.CfgFields.PEER_POLL_URI]||goog.uri.utils.getHost(a[goog.net.xpc.CfgFields.PEER_URI]||"")+"/robots.txt";goog.net.xpc.channels[this.name]=this;goog.events.listen(window,"unload",goog.net.xpc.CrossPageChannel.disposeAll_);goog.net.xpc.logger.info("CrossPageChannel created: "+this.name)};goog.inherits(goog.net.xpc.CrossPageChannel,goog.messaging.AbstractChannel); +goog.net.xpc.CrossPageChannel.TRANSPORT_SERVICE_ESCAPE_RE_=RegExp("^%*"+goog.net.xpc.TRANSPORT_SERVICE_+"$");goog.net.xpc.CrossPageChannel.TRANSPORT_SERVICE_UNESCAPE_RE_=RegExp("^%+"+goog.net.xpc.TRANSPORT_SERVICE_+"$");goog.net.xpc.CrossPageChannel.prototype.connectionDelay_=null;goog.net.xpc.CrossPageChannel.prototype.peerWindowDeferred_=null;goog.net.xpc.CrossPageChannel.prototype.transport_=null;goog.net.xpc.CrossPageChannel.prototype.state_=goog.net.xpc.ChannelStates.NOT_CONNECTED; +goog.net.xpc.CrossPageChannel.prototype.isConnected=function(){return this.state_==goog.net.xpc.ChannelStates.CONNECTED};goog.net.xpc.CrossPageChannel.prototype.peerWindowObject_=null;goog.net.xpc.CrossPageChannel.prototype.iframeElement_=null;goog.net.xpc.CrossPageChannel.prototype.getConfig=function(){return this.cfg_};goog.net.xpc.CrossPageChannel.prototype.getIframeElement=function(){return this.iframeElement_}; +goog.net.xpc.CrossPageChannel.prototype.setPeerWindowObject=function(a){this.peerWindowObject_=a};goog.net.xpc.CrossPageChannel.prototype.getPeerWindowObject=function(){return this.peerWindowObject_};goog.net.xpc.CrossPageChannel.prototype.isPeerAvailable=function(){try{return!!this.peerWindowObject_&&!Boolean(this.peerWindowObject_.closed)}catch(a){return!1}}; +goog.net.xpc.CrossPageChannel.prototype.determineTransportType_=function(){return goog.isFunction(document.postMessage)||goog.isFunction(window.postMessage)||goog.userAgent.IE&&window.postMessage?goog.net.xpc.TransportTypes.NATIVE_MESSAGING:goog.userAgent.GECKO?goog.net.xpc.TransportTypes.FRAME_ELEMENT_METHOD:goog.userAgent.IE&&this.cfg_[goog.net.xpc.CfgFields.PEER_RELAY_URI]?goog.net.xpc.TransportTypes.IFRAME_RELAY:goog.userAgent.IE&&goog.net.xpc.NixTransport.isNixSupported()?goog.net.xpc.TransportTypes.NIX: +goog.net.xpc.TransportTypes.IFRAME_POLLING}; +goog.net.xpc.CrossPageChannel.prototype.createTransport_=function(){if(!this.transport_){this.cfg_[goog.net.xpc.CfgFields.TRANSPORT]||(this.cfg_[goog.net.xpc.CfgFields.TRANSPORT]=this.determineTransportType_());switch(this.cfg_[goog.net.xpc.CfgFields.TRANSPORT]){case goog.net.xpc.TransportTypes.NATIVE_MESSAGING:this.transport_=new goog.net.xpc.NativeMessagingTransport(this,this.cfg_[goog.net.xpc.CfgFields.PEER_HOSTNAME],this.domHelper_,!!this.cfg_[goog.net.xpc.CfgFields.ONE_SIDED_HANDSHAKE],this.cfg_[goog.net.xpc.CfgFields.NATIVE_TRANSPORT_PROTOCOL_VERSION]|| +2);break;case goog.net.xpc.TransportTypes.NIX:this.transport_=new goog.net.xpc.NixTransport(this,this.domHelper_);break;case goog.net.xpc.TransportTypes.FRAME_ELEMENT_METHOD:this.transport_=new goog.net.xpc.FrameElementMethodTransport(this,this.domHelper_);break;case goog.net.xpc.TransportTypes.IFRAME_RELAY:this.transport_=new goog.net.xpc.IframeRelayTransport(this,this.domHelper_);break;case goog.net.xpc.TransportTypes.IFRAME_POLLING:this.transport_=new goog.net.xpc.IframePollingTransport(this,this.domHelper_)}if(this.transport_)goog.net.xpc.logger.info("Transport created: "+ +this.transport_.getName());else throw Error("CrossPageChannel: No suitable transport found!");}};goog.net.xpc.CrossPageChannel.prototype.getTransportType=function(){return this.transport_.getType()};goog.net.xpc.CrossPageChannel.prototype.getTransportName=function(){return this.transport_.getName()}; +goog.net.xpc.CrossPageChannel.prototype.getPeerConfiguration=function(){var a={};a[goog.net.xpc.CfgFields.CHANNEL_NAME]=this.name;a[goog.net.xpc.CfgFields.TRANSPORT]=this.cfg_[goog.net.xpc.CfgFields.TRANSPORT];a[goog.net.xpc.CfgFields.ONE_SIDED_HANDSHAKE]=this.cfg_[goog.net.xpc.CfgFields.ONE_SIDED_HANDSHAKE];this.cfg_[goog.net.xpc.CfgFields.LOCAL_RELAY_URI]&&(a[goog.net.xpc.CfgFields.PEER_RELAY_URI]=this.cfg_[goog.net.xpc.CfgFields.LOCAL_RELAY_URI]);this.cfg_[goog.net.xpc.CfgFields.LOCAL_POLL_URI]&& +(a[goog.net.xpc.CfgFields.PEER_POLL_URI]=this.cfg_[goog.net.xpc.CfgFields.LOCAL_POLL_URI]);this.cfg_[goog.net.xpc.CfgFields.PEER_POLL_URI]&&(a[goog.net.xpc.CfgFields.LOCAL_POLL_URI]=this.cfg_[goog.net.xpc.CfgFields.PEER_POLL_URI]);var b=this.cfg_[goog.net.xpc.CfgFields.ROLE];b&&(a[goog.net.xpc.CfgFields.ROLE]=b==goog.net.xpc.CrossPageChannelRole.INNER?goog.net.xpc.CrossPageChannelRole.OUTER:goog.net.xpc.CrossPageChannelRole.INNER);return a}; +goog.net.xpc.CrossPageChannel.prototype.createPeerIframe=function(a,b,c){goog.net.xpc.logger.info("createPeerIframe()");var d=this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID];d||(d=this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]="xpcpeer"+goog.net.xpc.getRandomString(4));var e=goog.dom.getDomHelper(a).createElement("IFRAME");e.id=e.name=d;b?b(e):e.style.width=e.style.height="100%";this.cleanUpIncompleteConnection_();this.peerWindowDeferred_=new goog.async.Deferred(void 0,this);var f=this.getPeerUri(c);this.peerLoadHandler_.listenOnce(e, +"load",this.peerWindowDeferred_.callback,!1,this.peerWindowDeferred_);goog.userAgent.GECKO||goog.userAgent.WEBKIT?window.setTimeout(goog.bind(function(){a.appendChild(e);e.src=f.toString();goog.net.xpc.logger.info("peer iframe created ("+d+")")},this),1):(e.src=f.toString(),a.appendChild(e),goog.net.xpc.logger.info("peer iframe created ("+d+")"));return e}; +goog.net.xpc.CrossPageChannel.prototype.cleanUpIncompleteConnection_=function(){this.peerWindowDeferred_&&(this.peerWindowDeferred_.cancel(),this.peerWindowDeferred_=null);this.deferredDeliveries_.length=0;this.peerLoadHandler_.removeAll()}; +goog.net.xpc.CrossPageChannel.prototype.getPeerUri=function(a){var b=this.cfg_[goog.net.xpc.CfgFields.PEER_URI];goog.isString(b)&&(b=this.cfg_[goog.net.xpc.CfgFields.PEER_URI]=new goog.Uri(b));!1!==a&&b.setParameterValue("xpc",goog.json.serialize(this.getPeerConfiguration()));return b};goog.net.xpc.CrossPageChannel.prototype.connect=function(a){this.connectCb_=a||goog.nullFunction;this.peerWindowDeferred_?this.peerWindowDeferred_.addCallback(this.continueConnection_):this.continueConnection_()}; +goog.net.xpc.CrossPageChannel.prototype.continueConnection_=function(){goog.net.xpc.logger.info("continueConnection_()");this.peerWindowDeferred_=null;this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]&&(this.iframeElement_=this.domHelper_.getElement(this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]));if(this.iframeElement_){var a=this.iframeElement_.contentWindow;a||(a=window.frames[this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]]);this.setPeerWindowObject(a)}if(!this.peerWindowObject_){if(window==window.top)throw Error("CrossPageChannel: Can't connect, peer window-object not set."); +this.setPeerWindowObject(window.parent)}this.createTransport_();for(this.transport_.connect();0g?1:new cljs.core.Keyword(null,"else","else",1017020587)?a.call(null,b,c,f,0):null},c=function(a,b,c,g){for(;;){var h=cljs.core.compare.call(null,cljs.core.nth.call(null,a,g),cljs.core.nth.call(null,b,g));if(0===h&&g+1b)if(cljs.core.next.call(null,c))a=b,b=cljs.core.first.call(null,c),c=cljs.core.next.call(null,c);else return b>cljs.core.first.call(null,c);else return!1},b=function(b,d,g){var h=null;2d;default:return b.cljs$core$IFn$_invoke$arity$variadic(a,d,cljs.core.array_seq(arguments,2))}throw Error("Invalid arity: "+arguments.length);};a.cljs$lang$maxFixedArity=2;a.cljs$lang$applyTo=b.cljs$lang$applyTo;a.cljs$core$IFn$_invoke$arity$1=function(a){return!0};a.cljs$core$IFn$_invoke$arity$2=function(a,b){return a>b};a.cljs$core$IFn$_invoke$arity$variadic= +b.cljs$core$IFn$_invoke$arity$variadic;return a}(); +cljs.core._GT__EQ_=function(){var a=null,b=function(){var a=function(a,b,c){for(;;)if(a>=b)if(cljs.core.next.call(null,c))a=b,b=cljs.core.first.call(null,c),c=cljs.core.next.call(null,c);else return b>=cljs.core.first.call(null,c);else return!1},b=function(b,d,g){var h=null;2=d;default:return b.cljs$core$IFn$_invoke$arity$variadic(a,d,cljs.core.array_seq(arguments,2))}throw Error("Invalid arity: "+arguments.length);};a.cljs$lang$maxFixedArity=2;a.cljs$lang$applyTo=b.cljs$lang$applyTo;a.cljs$core$IFn$_invoke$arity$1=function(a){return!0};a.cljs$core$IFn$_invoke$arity$2=function(a,b){return a>=b};a.cljs$core$IFn$_invoke$arity$variadic= +b.cljs$core$IFn$_invoke$arity$variadic;return a}();cljs.core.dec=function(a){return a-1}; +cljs.core.max=function(){var a=null,b=function(a,b){return a>b?a:b},c=function(){var b=function(b,c,d){return cljs.core.reduce.call(null,a,b>c?b:c,d)},c=function(a,c,e){var k=null;2>b}; +cljs.core.bit_shift_right_zero_fill=function(a,b){return a>>>b};cljs.core.unsigned_bit_shift_right=function(a,b){return a>>>b};cljs.core.bit_count=function(a){a-=a>>1&1431655765;a=(a&858993459)+(a>>2&858993459);return 16843009*(a+(a>>4)&252645135)>>24}; +cljs.core._EQ__EQ_=function(){var a=null,b=function(a,b){return cljs.core._equiv.call(null,a,b)},c=function(){var b=function(b,c,d){for(;;)if(a.call(null,b,c))if(cljs.core.next.call(null,d))b=c,c=cljs.core.first.call(null,d),d=cljs.core.next.call(null,d);else return a.call(null,c,cljs.core.first.call(null,d));else return!1},c=function(a,c,e){var k=null;2a};cljs.core.nthnext=function(a,b){for(var c=b,d=cljs.core.seq.call(null,a);;)if(d&&0>2)};cljs.core.hash_coll=function(a){if(cljs.core.seq.call(null,a)){var b=cljs.core.hash.call(null,cljs.core.first.call(null,a));for(a=cljs.core.next.call(null,a);;){if(null==a)return b;b=cljs.core.hash_combine.call(null,b,cljs.core.hash.call(null,cljs.core.first.call(null,a)));a=cljs.core.next.call(null,a)}}else return 0}; +cljs.core.hash_imap=function(a){var b=0;for(a=cljs.core.seq.call(null,a);;)if(a){var c=cljs.core.first.call(null,a),b=(b+(cljs.core.hash.call(null,cljs.core.key.call(null,c))^cljs.core.hash.call(null,cljs.core.val.call(null,c))))%4503599627370496;a=cljs.core.next.call(null,a)}else return b};cljs.core.hash_iset=function(a){var b=0;for(a=cljs.core.seq.call(null,a);;)if(a){var c=cljs.core.first.call(null,a),b=(b+cljs.core.hash.call(null,c))%4503599627370496;a=cljs.core.next.call(null,a)}else return b}; +cljs.core.extend_object_BANG_=function(a,b){for(var c=cljs.core.seq.call(null,b),d=null,e=0,f=0;;)if(fa?0:a-1>>>5<<5};cljs.core.new_path=function(a,b,c){for(;;){if(0===b)return c;var d=cljs.core.pv_fresh_node.call(null,a);cljs.core.pv_aset.call(null,d,0,c);c=d;b-=5}}; +cljs.core.push_tail=function push_tail(b,c,d,e){var f=cljs.core.pv_clone_node.call(null,d),g=b.cnt-1>>>c&31;5===c?cljs.core.pv_aset.call(null,f,g,e):(d=cljs.core.pv_aget.call(null,d,g),b=null!=d?push_tail.call(null,b,c-5,d,e):cljs.core.new_path.call(null,null,c-5,e),cljs.core.pv_aset.call(null,f,g,b));return f};cljs.core.vector_index_out_of_bounds=function(a,b){throw Error([cljs.core.str("No item "),cljs.core.str(a),cljs.core.str(" in vector of length "),cljs.core.str(b)].join(""));}; +cljs.core.array_for=function(a,b){if(0<=b&&b=cljs.core.tail_off.call(null,a))return a.tail;for(var c=a.root,d=a.shift;;)if(0>>d&31),d-=5;else return c.arr}else return cljs.core.vector_index_out_of_bounds.call(null,b,a.cnt)}; +cljs.core.do_assoc=function do_assoc(b,c,d,e,f){var g=cljs.core.pv_clone_node.call(null,d);if(0===c)cljs.core.pv_aset.call(null,g,e&31,f);else{var h=e>>>c&31;cljs.core.pv_aset.call(null,g,h,do_assoc.call(null,b,c-5,cljs.core.pv_aget.call(null,d,h),e,f))}return g}; +cljs.core.pop_tail=function pop_tail(b,c,d){var e=b.cnt-2>>>c&31;if(5this.cnt-cljs.core.tail_off.call(null,this)){for(var c=this.tail.length,d=Array(c+1),e=0;;)if(e>>5>1<this.cnt?cljs.core.array_seq.call(null,this.tail):new cljs.core.Keyword(null,"else","else",1017020587)?cljs.core.chunked_seq.call(null,this,0,0):null};cljs.core.PersistentVector.prototype.cljs$core$ICounted$_count$arity$1=function(a){return this.cnt}; +cljs.core.PersistentVector.prototype.cljs$core$IStack$_peek$arity$1=function(a){return 0c)return new cljs.core.PersistentVector(null,c,5,cljs.core.PersistentVector.EMPTY_NODE,d,null);for(var e=d.slice(0,32),f=new cljs.core.PersistentVector(null,32,5,cljs.core.PersistentVector.EMPTY_NODE,e,null),e=32,g=cljs.core._as_transient.call(null,f);;)if(eb?a:b}(),null)}; +cljs.core.Subvec.prototype.cljs$core$IEquiv$_equiv$arity$2=function(a,b){return cljs.core.equiv_sequential.call(null,this,b)};cljs.core.Subvec.prototype.cljs$core$IWithMeta$_with_meta$arity$2=function(a,b){return cljs.core.build_subvec.call(null,b,this.v,this.start,this.end,this.__hash)};cljs.core.Subvec.prototype.cljs$core$ICloneable$_clone$arity$1=function(a){return new cljs.core.Subvec(this.meta,this.v,this.start,this.end,this.__hash)};cljs.core.Subvec.prototype.cljs$core$IMeta$_meta$arity$1=function(a){return this.meta}; +cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$2=function(a,b){return 0>b||this.end<=this.start+b?cljs.core.vector_index_out_of_bounds.call(null,b,this.end-this.start):cljs.core._nth.call(null,this.v,this.start+b)};cljs.core.Subvec.prototype.cljs$core$IIndexed$_nth$arity$3=function(a,b,c){return 0>b||this.end<=this.start+b?c:cljs.core._nth.call(null,this.v,this.start+b,c)}; +cljs.core.Subvec.prototype.cljs$core$IEmptyableCollection$_empty$arity$1=function(a){return cljs.core.with_meta.call(null,cljs.core.PersistentVector.EMPTY,this.meta)};cljs.core.__GT_Subvec=function(a,b,c,d,e){return new cljs.core.Subvec(a,b,c,d,e)};cljs.core.build_subvec=function(a,b,c,d,e){for(;;)if(b instanceof cljs.core.Subvec)c=b.start+c,d=b.start+d,b=b.v;else{var f=cljs.core.count.call(null,b);if(0>c||0>d||c>f||d>f)throw Error("Index out of bounds");return new cljs.core.Subvec(a,b,c,d,e)}}; +cljs.core.subvec=function(){var a=null,b=function(b,c){return a.call(null,b,c,cljs.core.count.call(null,b))},c=function(a,b,c){return cljs.core.build_subvec.call(null,null,a,b,c,null)},a=function(a,e,f){switch(arguments.length){case 2:return b.call(this,a,e);case 3:return c.call(this,a,e,f)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$2=b;a.cljs$core$IFn$_invoke$arity$3=c;return a}(); +cljs.core.tv_ensure_editable=function(a,b){return a===b.edit?b:new cljs.core.VectorNode(a,cljs.core.aclone.call(null,b.arr))};cljs.core.tv_editable_root=function(a){return new cljs.core.VectorNode({},cljs.core.aclone.call(null,a.arr))};cljs.core.tv_editable_tail=function(a){var b=[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,a,0,b,0,a.length);return b}; +cljs.core.tv_push_tail=function tv_push_tail(b,c,d,e){var f=cljs.core.tv_ensure_editable.call(null,b.root.edit,d),g=b.cnt-1>>>c&31;cljs.core.pv_aset.call(null,f,g,5===c?e:function(){var d=cljs.core.pv_aget.call(null,f,g);return null!=d?tv_push_tail.call(null,b,c-5,d,e):cljs.core.new_path.call(null,b.root.edit,c-5,e)}());return f}; +cljs.core.tv_pop_tail=function tv_pop_tail(b,c,d){d=cljs.core.tv_ensure_editable.call(null,b.root.edit,d);var e=b.cnt-2>>>c&31;if(5=cljs.core.tail_off.call(null,a))return a.tail;for(var c=a.root,d=c,e=a.shift;;)if(0>>e&31)),e-=5;else return d.arr}else throw Error([cljs.core.str("No item "),cljs.core.str(b),cljs.core.str(" in transient vector of length "),cljs.core.str(a.cnt)].join(""));}; +cljs.core.TransientVector=function(a,b,c,d){this.cnt=a;this.shift=b;this.root=c;this.tail=d;this.cljs$lang$protocol_mask$partition0$=275;this.cljs$lang$protocol_mask$partition1$=88};cljs.core.TransientVector.cljs$lang$type=!0;cljs.core.TransientVector.cljs$lang$ctorStr="cljs.core/TransientVector";cljs.core.TransientVector.cljs$lang$ctorPrWriter=function(a,b,c){return cljs.core._write.call(null,b,"cljs.core/TransientVector")}; +cljs.core.TransientVector.prototype.call=function(){var a=null;return a=function(a,c,d){switch(arguments.length){case 2:return this.cljs$core$ILookup$_lookup$arity$2(null,c);case 3:return this.cljs$core$ILookup$_lookup$arity$3(null,c,d)}throw Error("Invalid arity: "+arguments.length);}}();cljs.core.TransientVector.prototype.apply=function(a,b){return this.call.apply(this,[this].concat(cljs.core.aclone.call(null,b)))}; +cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$1=function(a){return this.cljs$core$ILookup$_lookup$arity$2(null,a)};cljs.core.TransientVector.prototype.cljs$core$IFn$_invoke$arity$2=function(a,b){return this.cljs$core$ILookup$_lookup$arity$3(null,a,b)};cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$2=function(a,b){return cljs.core._nth.call(null,this,b,null)}; +cljs.core.TransientVector.prototype.cljs$core$ILookup$_lookup$arity$3=function(a,b,c){return cljs.core._nth.call(null,this,b,c)};cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$2=function(a,b){if(this.root.edit)return cljs.core.array_for.call(null,this,b)[b&31];throw Error("nth after persistent!");};cljs.core.TransientVector.prototype.cljs$core$IIndexed$_nth$arity$3=function(a,b,c){return 0<=b&&b>>a&31;cljs.core.pv_aset.call(null,k,l,f.call(null,a-5,cljs.core.pv_aget.call(null,k,l)))}return k}.call(null,d.shift,d.root),d.root=a),this;if(b===d.cnt)return cljs.core._conj_BANG_.call(null, +this,c);if(new cljs.core.Keyword(null,"else","else",1017020587))throw Error([cljs.core.str("Index "),cljs.core.str(b),cljs.core.str(" out of bounds for TransientVector of length"),cljs.core.str(d.cnt)].join(""));return null}throw Error("assoc! after persistent!");}; +cljs.core.TransientVector.prototype.cljs$core$ITransientVector$_pop_BANG_$arity$1=function(a){if(this.root.edit){if(0===this.cnt)throw Error("Can't pop empty vector");if(1===this.cnt)return this.cnt=0,this;if(0<(this.cnt-1&31))return this.cnt-=1,this;if(new cljs.core.Keyword(null,"else","else",1017020587)){a=cljs.core.editable_array_for.call(null,this,this.cnt-2);var b;b=cljs.core.tv_pop_tail.call(null,this,this.shift,this.root);b=null!=b?b:new cljs.core.VectorNode(this.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]);5this.cnt-cljs.core.tail_off.call(null,this))this.tail[this.cnt&31]=b;else{var c=new cljs.core.VectorNode(this.root.edit,this.tail),d=[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];d[0]=b;this.tail=d;if(this.cnt>>>5>1<d?1:new cljs.core.Keyword(null,"else","else",1017020587)?0:null}; +cljs.core.obj_map__GT_hash_map=function(a,b,c){var d=a.keys,e=d.length,f=a.strobj;a=cljs.core.meta.call(null,a);for(var g=0,h=cljs.core.transient$.call(null,cljs.core.PersistentHashMap.EMPTY);;)if(gcljs.core.ObjMap.HASHMAP_THRESHOLD||this.keys.length>=cljs.core.ObjMap.HASHMAP_THRESHOLD)return cljs.core.obj_map__GT_hash_map.call(null,this,b,c);if(null!=cljs.core.scan_array.call(null,1,b,this.keys))return a=cljs.core.obj_clone.call(null,this.strobj,this.keys),a[b]=c,new cljs.core.ObjMap(this.meta,this.keys,a,this.update_count+1,null);a=cljs.core.obj_clone.call(null,this.strobj, +this.keys);var d=cljs.core.aclone.call(null,this.keys);a[b]=c;d.push(b);return new cljs.core.ObjMap(this.meta,d,a,this.update_count+1,null)}return cljs.core.obj_map__GT_hash_map.call(null,this,b,c)};cljs.core.ObjMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2=function(a,b){return goog.isString(b)&&null!=cljs.core.scan_array.call(null,1,b,this.keys)?!0:!1}; +cljs.core.ObjMap.prototype.call=function(){var a=null;return a=function(a,c,d){switch(arguments.length){case 2:return this.cljs$core$ILookup$_lookup$arity$2(null,c);case 3:return this.cljs$core$ILookup$_lookup$arity$3(null,c,d)}throw Error("Invalid arity: "+arguments.length);}}();cljs.core.ObjMap.prototype.apply=function(a,b){return this.call.apply(this,[this].concat(cljs.core.aclone.call(null,b)))}; +cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$1=function(a){return this.cljs$core$ILookup$_lookup$arity$2(null,a)};cljs.core.ObjMap.prototype.cljs$core$IFn$_invoke$arity$2=function(a,b){return this.cljs$core$ILookup$_lookup$arity$3(null,a,b)}; +cljs.core.ObjMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3=function(a,b,c){for(a=this.keys.sort(cljs.core.obj_map_compare_keys);;)if(cljs.core.seq.call(null,a)){var d=cljs.core.first.call(null,a);c=b.call(null,c,d,this.strobj[d]);if(cljs.core.reduced_QMARK_.call(null,c))return cljs.core.deref.call(null,c);a=cljs.core.rest.call(null,a)}else return c}; +cljs.core.ObjMap.prototype.cljs$core$ICollection$_conj$arity$2=function(a,b){return cljs.core.vector_QMARK_.call(null,b)?cljs.core._assoc.call(null,this,cljs.core._nth.call(null,b,0),cljs.core._nth.call(null,b,1)):cljs.core.reduce.call(null,cljs.core._conj,this,b)};cljs.core.ObjMap.prototype.toString=function(){return cljs.core.pr_str_STAR_.call(null,this)}; +cljs.core.ObjMap.prototype.cljs$core$ISeqable$_seq$arity$1=function(a){var b=this;return 0=c)return new cljs.core.PersistentArrayMap(this.meta,this.cnt-1,d,null);if(cljs.core._EQ_.call(null,b,this.arr[e]))e+=2;else if(new cljs.core.Keyword(null,"else","else",1017020587))d[f]=this.arr[e],d[f+1]=this.arr[e+1],f+=2,e+=2;else return null}}else return this}; +cljs.core.__GT_PersistentArrayMap=function(a,b,c,d){return new cljs.core.PersistentArrayMap(a,b,c,d)};cljs.core.PersistentArrayMap.EMPTY=new cljs.core.PersistentArrayMap(null,0,[],null);cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD=8; +cljs.core.PersistentArrayMap.fromArray=function(a,b,c){a=b?a:cljs.core.aclone.call(null,a);if(c)return new cljs.core.PersistentArrayMap(null,a.length/2,a,null);c=a.length;b=0;for(var d=cljs.core.transient$.call(null,cljs.core.PersistentArrayMap.EMPTY);;)if(b>>b&31}; +cljs.core.clone_and_set=function(){var a=null,b=function(a,b,c){a=cljs.core.aclone.call(null,a);a[b]=c;return a},c=function(a,b,c,g,h){a=cljs.core.aclone.call(null,a);a[b]=c;a[g]=h;return a},a=function(a,e,f,g,h){switch(arguments.length){case 3:return b.call(this,a,e,f);case 5:return c.call(this,a,e,f,g,h)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$3=b;a.cljs$core$IFn$_invoke$arity$5=c;return a}(); +cljs.core.remove_pair=function(a,b){var c=Array(a.length-2);cljs.core.array_copy.call(null,a,0,c,0,2*b);cljs.core.array_copy.call(null,a,2*(b+1),c,2*b,c.length-2*b);return c};cljs.core.bitmap_indexed_node_index=function(a,b){return cljs.core.bit_count.call(null,a&b-1)};cljs.core.bitpos=function(a,b){return 1<<(a>>>b&31)}; +cljs.core.edit_and_set=function(){var a=null,b=function(a,b,c,g){a=a.ensure_editable(b);a.arr[c]=g;return a},c=function(a,b,c,g,h,k){a=a.ensure_editable(b);a.arr[c]=g;a.arr[h]=k;return a},a=function(a,e,f,g,h,k){switch(arguments.length){case 4:return b.call(this,a,e,f,g);case 6:return c.call(this,a,e,f,g,h,k)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$4=b;a.cljs$core$IFn$_invoke$arity$6=c;return a}(); +cljs.core.inode_kv_reduce=function(a,b,c){for(var d=a.length,e=0;;)if(e>>b&31),h=cljs.core.bitmap_indexed_node_index.call(null,this.bitmap,g);if(0===(this.bitmap&g)){var k=cljs.core.bit_count.call(null,this.bitmap);if(2*k>>b&31]=cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(a,b+5,c,d,e,f);for(e=d=0;;)if(32>d)0!==(this.bitmap>>>d&1)&&(h[d]=null!=this.arr[e]?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(a,b+5,cljs.core.hash.call(null,this.arr[e]),this.arr[e],this.arr[e+1],f):this.arr[e+1],e+=2),d+=1;else break;return new cljs.core.ArrayNode(a,k+1,h)}return new cljs.core.Keyword(null,"else","else",1017020587)?(b=Array(2*(k+4)), +cljs.core.array_copy.call(null,this.arr,0,b,0,2*h),b[2*h]=d,b[2*h+1]=e,cljs.core.array_copy.call(null,this.arr,2*h,b,2*(h+1),2*(k-h)),f.val=!0,a=this.ensure_editable(a),a.arr=b,a.bitmap|=g,a):null}k=this.arr[2*h];g=this.arr[2*h+1];return null==k?(k=g.inode_assoc_BANG_(a,b+5,c,d,e,f),k===g?this:cljs.core.edit_and_set.call(null,this,a,2*h+1,k)):cljs.core.key_test.call(null,d,k)?e===g?this:cljs.core.edit_and_set.call(null,this,a,2*h+1,e):new cljs.core.Keyword(null,"else","else",1017020587)?(f.val=!0, +cljs.core.edit_and_set.call(null,this,a,2*h,null,2*h+1,cljs.core.create_node.call(null,a,b+5,k,g,c,d,e))):null};cljs.core.BitmapIndexedNode.prototype.inode_seq=function(){return cljs.core.create_inode_seq.call(null,this.arr)}; +cljs.core.BitmapIndexedNode.prototype.inode_without_BANG_=function(a,b,c,d,e){var f=1<<(c>>>b&31);if(0===(this.bitmap&f))return this;var g=cljs.core.bitmap_indexed_node_index.call(null,this.bitmap,f),h=this.arr[2*g],k=this.arr[2*g+1];return null==h?(b=k.inode_without_BANG_(a,b+5,c,d,e),b===k?this:null!=b?cljs.core.edit_and_set.call(null,this,a,2*g+1,b):this.bitmap===f?null:new cljs.core.Keyword(null,"else","else",1017020587)?this.edit_and_remove_pair(a,f,g):null):cljs.core.key_test.call(null,d,h)? +(e[0]=!0,this.edit_and_remove_pair(a,f,g)):new cljs.core.Keyword(null,"else","else",1017020587)?this:null};cljs.core.BitmapIndexedNode.prototype.ensure_editable=function(a){if(a===this.edit)return this;var b=cljs.core.bit_count.call(null,this.bitmap),c=Array(0>b?4:2*(b+1));cljs.core.array_copy.call(null,this.arr,0,c,0,2*b);return new cljs.core.BitmapIndexedNode(a,this.bitmap,c)};cljs.core.BitmapIndexedNode.prototype.kv_reduce=function(a,b){return cljs.core.inode_kv_reduce.call(null,this.arr,a,b)}; +cljs.core.BitmapIndexedNode.prototype.inode_find=function(a,b,c,d){var e=1<<(b>>>a&31);if(0===(this.bitmap&e))return d;var f=cljs.core.bitmap_indexed_node_index.call(null,this.bitmap,e),e=this.arr[2*f],f=this.arr[2*f+1];return null==e?f.inode_find(a+5,b,c,d):cljs.core.key_test.call(null,c,e)?new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[e,f],null):new cljs.core.Keyword(null,"else","else",1017020587)?d:null}; +cljs.core.BitmapIndexedNode.prototype.inode_without=function(a,b,c){var d=1<<(b>>>a&31);if(0===(this.bitmap&d))return this;var e=cljs.core.bitmap_indexed_node_index.call(null,this.bitmap,d),f=this.arr[2*e],g=this.arr[2*e+1];return null==f?(a=g.inode_without(a+5,b,c),a===g?this:null!=a?new cljs.core.BitmapIndexedNode(null,this.bitmap,cljs.core.clone_and_set.call(null,this.arr,2*e+1,a)):this.bitmap===d?null:new cljs.core.Keyword(null,"else","else",1017020587)?new cljs.core.BitmapIndexedNode(null,this.bitmap^ +d,cljs.core.remove_pair.call(null,this.arr,e)):null):cljs.core.key_test.call(null,c,f)?new cljs.core.BitmapIndexedNode(null,this.bitmap^d,cljs.core.remove_pair.call(null,this.arr,e)):new cljs.core.Keyword(null,"else","else",1017020587)?this:null}; +cljs.core.BitmapIndexedNode.prototype.inode_assoc=function(a,b,c,d,e){var f=1<<(b>>>a&31),g=cljs.core.bitmap_indexed_node_index.call(null,this.bitmap,f);if(0===(this.bitmap&f)){var h=cljs.core.bit_count.call(null,this.bitmap);if(16<=h){g=[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];g[b>>>a&31]=cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(a+5,b,c,d,e);for(d=c=0;;)if(32>c)0!==(this.bitmap>>> +c&1)&&(g[c]=null!=this.arr[d]?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(a+5,cljs.core.hash.call(null,this.arr[d]),this.arr[d],this.arr[d+1],e):this.arr[d+1],d+=2),c+=1;else break;return new cljs.core.ArrayNode(null,h+1,g)}a=Array(2*(h+1));cljs.core.array_copy.call(null,this.arr,0,a,0,2*g);a[2*g]=c;a[2*g+1]=d;cljs.core.array_copy.call(null,this.arr,2*g,a,2*(g+1),2*(h-g));e.val=!0;return new cljs.core.BitmapIndexedNode(null,this.bitmap|f,a)}h=this.arr[2*g];f=this.arr[2*g+1];return null==h?(h=f.inode_assoc(a+ +5,b,c,d,e),h===f?this:new cljs.core.BitmapIndexedNode(null,this.bitmap,cljs.core.clone_and_set.call(null,this.arr,2*g+1,h))):cljs.core.key_test.call(null,c,h)?d===f?this:new cljs.core.BitmapIndexedNode(null,this.bitmap,cljs.core.clone_and_set.call(null,this.arr,2*g+1,d)):new cljs.core.Keyword(null,"else","else",1017020587)?(e.val=!0,new cljs.core.BitmapIndexedNode(null,this.bitmap,cljs.core.clone_and_set.call(null,this.arr,2*g,null,2*g+1,cljs.core.create_node.call(null,a+5,h,f,b,c,d)))):null}; +cljs.core.BitmapIndexedNode.prototype.inode_lookup=function(a,b,c,d){var e=1<<(b>>>a&31);if(0===(this.bitmap&e))return d;var f=cljs.core.bitmap_indexed_node_index.call(null,this.bitmap,e),e=this.arr[2*f],f=this.arr[2*f+1];return null==e?f.inode_lookup(a+5,b,c,d):cljs.core.key_test.call(null,c,e)?f:new cljs.core.Keyword(null,"else","else",1017020587)?d:null};cljs.core.__GT_BitmapIndexedNode=function(a,b,c){return new cljs.core.BitmapIndexedNode(a,b,c)}; +cljs.core.BitmapIndexedNode.EMPTY=new cljs.core.BitmapIndexedNode(null,0,[]);cljs.core.pack_array_node=function(a,b,c){var d=a.arr;a=2*(a.cnt-1);for(var e=Array(a),f=0,g=1,h=0;;)if(f>>b&31,h=this.arr[g];if(null==h)return a=cljs.core.edit_and_set.call(null,this,a,g,cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(a,b+5,c,d,e,f)),a.cnt+=1,a;b=h.inode_assoc_BANG_(a,b+5,c,d,e,f);return b===h?this:cljs.core.edit_and_set.call(null,this,a,g,b)}; +cljs.core.ArrayNode.prototype.inode_seq=function(){return cljs.core.create_array_node_seq.call(null,this.arr)}; +cljs.core.ArrayNode.prototype.inode_without_BANG_=function(a,b,c,d,e){var f=c>>>b&31,g=this.arr[f];if(null==g)return this;b=g.inode_without_BANG_(a,b+5,c,d,e);if(b===g)return this;if(null==b){if(8>=this.cnt)return cljs.core.pack_array_node.call(null,this,a,f);a=cljs.core.edit_and_set.call(null,this,a,f,b);a.cnt-=1;return a}return new cljs.core.Keyword(null,"else","else",1017020587)?cljs.core.edit_and_set.call(null,this,a,f,b):null}; +cljs.core.ArrayNode.prototype.ensure_editable=function(a){return a===this.edit?this:new cljs.core.ArrayNode(a,this.cnt,cljs.core.aclone.call(null,this.arr))};cljs.core.ArrayNode.prototype.kv_reduce=function(a,b){for(var c=this.arr.length,d=0,e=b;;)if(d>>a&31];return null!=e?e.inode_find(a+5,b,c,d):d}; +cljs.core.ArrayNode.prototype.inode_without=function(a,b,c){var d=b>>>a&31,e=this.arr[d];return null!=e?(a=e.inode_without(a+5,b,c),a===e?this:null==a?8>=this.cnt?cljs.core.pack_array_node.call(null,this,null,d):new cljs.core.ArrayNode(null,this.cnt-1,cljs.core.clone_and_set.call(null,this.arr,d,a)):new cljs.core.Keyword(null,"else","else",1017020587)?new cljs.core.ArrayNode(null,this.cnt,cljs.core.clone_and_set.call(null,this.arr,d,a)):null):this}; +cljs.core.ArrayNode.prototype.inode_assoc=function(a,b,c,d,e){var f=b>>>a&31,g=this.arr[f];if(null==g)return new cljs.core.ArrayNode(null,this.cnt+1,cljs.core.clone_and_set.call(null,this.arr,f,cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(a+5,b,c,d,e)));a=g.inode_assoc(a+5,b,c,d,e);return a===g?this:new cljs.core.ArrayNode(null,this.cnt,cljs.core.clone_and_set.call(null,this.arr,f,a))}; +cljs.core.ArrayNode.prototype.inode_lookup=function(a,b,c,d){var e=this.arr[b>>>a&31];return null!=e?e.inode_lookup(a+5,b,c,d):d};cljs.core.__GT_ArrayNode=function(a,b,c){return new cljs.core.ArrayNode(a,b,c)};cljs.core.hash_collision_node_find_index=function(a,b,c){b*=2;for(var d=0;;)if(d2*this.cnt)return a=cljs.core.edit_and_set.call(null,this,a,2*this.cnt,d,2*this.cnt+1,e),f.val=!0,a.cnt+=1,a;b=this.arr.length;c=Array(b+2);cljs.core.array_copy.call(null,this.arr,0,c,0,b);c[b]=d;c[b+1]=e;f.val=!0;return this.ensure_editable_array(a,this.cnt+1,c)}return this.arr[b+1]===e?this: +cljs.core.edit_and_set.call(null,this,a,b+1,e)}return(new cljs.core.BitmapIndexedNode(a,1<<(this.collision_hash>>>b&31),[null,this,null,null])).inode_assoc_BANG_(a,b,c,d,e,f)};cljs.core.HashCollisionNode.prototype.inode_seq=function(){return cljs.core.create_inode_seq.call(null,this.arr)}; +cljs.core.HashCollisionNode.prototype.inode_without_BANG_=function(a,b,c,d,e){b=cljs.core.hash_collision_node_find_index.call(null,this.arr,this.cnt,d);if(-1===b)return this;e[0]=!0;if(1===this.cnt)return null;a=this.ensure_editable(a);e=a.arr;e[b]=e[2*this.cnt-2];e[b+1]=e[2*this.cnt-1];e[2*this.cnt-1]=null;e[2*this.cnt-2]=null;a.cnt-=1;return a}; +cljs.core.HashCollisionNode.prototype.ensure_editable=function(a){if(a===this.edit)return this;var b=Array(2*(this.cnt+1));cljs.core.array_copy.call(null,this.arr,0,b,0,2*this.cnt);return new cljs.core.HashCollisionNode(a,this.collision_hash,this.cnt,b)};cljs.core.HashCollisionNode.prototype.kv_reduce=function(a,b){return cljs.core.inode_kv_reduce.call(null,this.arr,a,b)}; +cljs.core.HashCollisionNode.prototype.inode_find=function(a,b,c,d){a=cljs.core.hash_collision_node_find_index.call(null,this.arr,this.cnt,c);return 0>a?d:cljs.core.key_test.call(null,c,this.arr[a])?new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.arr[a],this.arr[a+1]],null):new cljs.core.Keyword(null,"else","else",1017020587)?d:null}; +cljs.core.HashCollisionNode.prototype.inode_without=function(a,b,c){a=cljs.core.hash_collision_node_find_index.call(null,this.arr,this.cnt,c);return-1===a?this:1===this.cnt?null:new cljs.core.Keyword(null,"else","else",1017020587)?new cljs.core.HashCollisionNode(null,this.collision_hash,this.cnt-1,cljs.core.remove_pair.call(null,this.arr,cljs.core.quot.call(null,a,2))):null}; +cljs.core.HashCollisionNode.prototype.inode_assoc=function(a,b,c,d,e){return b===this.collision_hash?(a=cljs.core.hash_collision_node_find_index.call(null,this.arr,this.cnt,c),-1===a?(a=2*this.cnt,b=Array(a+2),cljs.core.array_copy.call(null,this.arr,0,b,0,a),b[a]=c,b[a+1]=d,e.val=!0,new cljs.core.HashCollisionNode(null,this.collision_hash,this.cnt+1,b)):cljs.core._EQ_.call(null,this.arr[a],d)?this:new cljs.core.HashCollisionNode(null,this.collision_hash,this.cnt,cljs.core.clone_and_set.call(null, +this.arr,a+1,d))):(new cljs.core.BitmapIndexedNode(null,1<<(this.collision_hash>>>a&31),[null,this])).inode_assoc(a,b,c,d,e)};cljs.core.HashCollisionNode.prototype.inode_lookup=function(a,b,c,d){a=cljs.core.hash_collision_node_find_index.call(null,this.arr,this.cnt,c);return 0>a?d:cljs.core.key_test.call(null,c,this.arr[a])?this.arr[a+1]:new cljs.core.Keyword(null,"else","else",1017020587)?d:null}; +cljs.core.HashCollisionNode.prototype.ensure_editable_array=function(a,b,c){return a===this.edit?(this.arr=c,this.cnt=b,this):new cljs.core.HashCollisionNode(this.edit,this.collision_hash,b,c)};cljs.core.__GT_HashCollisionNode=function(a,b,c,d){return new cljs.core.HashCollisionNode(a,b,c,d)}; +cljs.core.create_node=function(){var a=null,b=function(a,b,c,g,h,k){var l=cljs.core.hash.call(null,b);if(l===g)return new cljs.core.HashCollisionNode(null,l,2,[b,c,h,k]);var m=new cljs.core.Box(!1);return cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(a,l,b,c,m).inode_assoc(a,g,h,k,m)},c=function(a,b,c,g,h,k,l){var m=cljs.core.hash.call(null,c);if(m===h)return new cljs.core.HashCollisionNode(null,m,2,[c,g,k,l]);var n=new cljs.core.Box(!1);return cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(a, +b,m,c,g,n).inode_assoc_BANG_(a,b,h,k,l,n)},a=function(a,e,f,g,h,k,l){switch(arguments.length){case 6:return b.call(this,a,e,f,g,h,k);case 7:return c.call(this,a,e,f,g,h,k,l)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$6=b;a.cljs$core$IFn$_invoke$arity$7=c;return a}();cljs.core.NodeSeq=function(a,b,c,d,e){this.meta=a;this.nodes=b;this.i=c;this.s=d;this.__hash=e;this.cljs$lang$protocol_mask$partition1$=0;this.cljs$lang$protocol_mask$partition0$=32374860}; +cljs.core.NodeSeq.cljs$lang$type=!0;cljs.core.NodeSeq.cljs$lang$ctorStr="cljs.core/NodeSeq";cljs.core.NodeSeq.cljs$lang$ctorPrWriter=function(a,b,c){return cljs.core._write.call(null,b,"cljs.core/NodeSeq")};cljs.core.NodeSeq.prototype.cljs$core$IHash$_hash$arity$1=function(a){a=this.__hash;return null!=a?a:this.__hash=a=cljs.core.hash_coll.call(null,this)};cljs.core.NodeSeq.prototype.cljs$core$ICollection$_conj$arity$2=function(a,b){return cljs.core.cons.call(null,b,this)}; +cljs.core.NodeSeq.prototype.toString=function(){return cljs.core.pr_str_STAR_.call(null,this)};cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$2=function(a,b){return cljs.core.seq_reduce.call(null,b,this)};cljs.core.NodeSeq.prototype.cljs$core$IReduce$_reduce$arity$3=function(a,b,c){return cljs.core.seq_reduce.call(null,b,c,this)};cljs.core.NodeSeq.prototype.cljs$core$ISeqable$_seq$arity$1=function(a){return this}; +cljs.core.NodeSeq.prototype.cljs$core$ISeq$_first$arity$1=function(a){return null==this.s?new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.nodes[this.i],this.nodes[this.i+1]],null):cljs.core.first.call(null,this.s)};cljs.core.NodeSeq.prototype.cljs$core$ISeq$_rest$arity$1=function(a){return null==this.s?cljs.core.create_inode_seq.call(null,this.nodes,this.i+2,null):cljs.core.create_inode_seq.call(null,this.nodes,this.i,cljs.core.next.call(null,this.s))}; +cljs.core.NodeSeq.prototype.cljs$core$IEquiv$_equiv$arity$2=function(a,b){return cljs.core.equiv_sequential.call(null,this,b)};cljs.core.NodeSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2=function(a,b){return new cljs.core.NodeSeq(b,this.nodes,this.i,this.s,this.__hash)};cljs.core.NodeSeq.prototype.cljs$core$IMeta$_meta$arity$1=function(a){return this.meta}; +cljs.core.NodeSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1=function(a){return cljs.core.with_meta.call(null,cljs.core.List.EMPTY,this.meta)};cljs.core.__GT_NodeSeq=function(a,b,c,d,e){return new cljs.core.NodeSeq(a,b,c,d,e)}; +cljs.core.create_inode_seq=function(){var a=null,b=function(b){return a.call(null,b,0,null)},c=function(a,b,c){if(null==c)for(c=a.length;;)if(bthis.cnt?cljs.core.count.call(null,cljs.core.next.call(null,this))+1:this.cnt};cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_first$arity$1=function(a){return cljs.core.peek.call(null,this.stack)}; +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$ISeq$_rest$arity$1=function(a){a=cljs.core.first.call(null,this.stack);a=cljs.core.tree_map_seq_push.call(null,this.ascending_QMARK_?a.right:a.left,cljs.core.next.call(null,this.stack),this.ascending_QMARK_);return null!=a?new cljs.core.PersistentTreeMapSeq(null,a,this.ascending_QMARK_,this.cnt-1,null):cljs.core.List.EMPTY}; +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEquiv$_equiv$arity$2=function(a,b){return cljs.core.equiv_sequential.call(null,this,b)};cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IWithMeta$_with_meta$arity$2=function(a,b){return new cljs.core.PersistentTreeMapSeq(b,this.stack,this.ascending_QMARK_,this.cnt,this.__hash)};cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IMeta$_meta$arity$1=function(a){return this.meta}; +cljs.core.PersistentTreeMapSeq.prototype.cljs$core$IEmptyableCollection$_empty$arity$1=function(a){return cljs.core.with_meta.call(null,cljs.core.List.EMPTY,this.meta)};cljs.core.__GT_PersistentTreeMapSeq=function(a,b,c,d,e){return new cljs.core.PersistentTreeMapSeq(a,b,c,d,e)};cljs.core.create_tree_map_seq=function(a,b,c){return new cljs.core.PersistentTreeMapSeq(null,cljs.core.tree_map_seq_push.call(null,a,null,b),b,c,null)}; +cljs.core.balance_left=function(a,b,c,d){return c instanceof cljs.core.RedNode?c.left instanceof cljs.core.RedNode?new cljs.core.RedNode(c.key,c.val,c.left.blacken(),new cljs.core.BlackNode(a,b,c.right,d,null),null):c.right instanceof cljs.core.RedNode?new cljs.core.RedNode(c.right.key,c.right.val,new cljs.core.BlackNode(c.key,c.val,c.left,c.right.left,null),new cljs.core.BlackNode(a,b,c.right.right,d,null),null):new cljs.core.Keyword(null,"else","else",1017020587)?new cljs.core.BlackNode(a,b,c,d, +null):null:new cljs.core.BlackNode(a,b,c,d,null)}; +cljs.core.balance_right=function(a,b,c,d){return d instanceof cljs.core.RedNode?d.right instanceof cljs.core.RedNode?new cljs.core.RedNode(d.key,d.val,new cljs.core.BlackNode(a,b,c,d.left,null),d.right.blacken(),null):d.left instanceof cljs.core.RedNode?new cljs.core.RedNode(d.left.key,d.left.val,new cljs.core.BlackNode(a,b,c,d.left.left,null),new cljs.core.BlackNode(d.key,d.val,d.left.right,d.right,null),null):new cljs.core.Keyword(null,"else","else",1017020587)?new cljs.core.BlackNode(a,b,c,d,null): +null:new cljs.core.BlackNode(a,b,c,d,null)}; +cljs.core.balance_left_del=function(a,b,c,d){if(c instanceof cljs.core.RedNode)return new cljs.core.RedNode(a,b,c.blacken(),d,null);if(d instanceof cljs.core.BlackNode)return cljs.core.balance_right.call(null,a,b,c,d.redden());if(d instanceof cljs.core.RedNode&&d.left instanceof cljs.core.BlackNode)return new cljs.core.RedNode(d.left.key,d.left.val,new cljs.core.BlackNode(a,b,c,d.left.left,null),cljs.core.balance_right.call(null,d.key,d.val,d.left.right,d.right.redden()),null);if(new cljs.core.Keyword(null, +"else","else",1017020587))throw Error("red-black tree invariant violation");return null}; +cljs.core.balance_right_del=function(a,b,c,d){if(d instanceof cljs.core.RedNode)return new cljs.core.RedNode(a,b,c,d.blacken(),null);if(c instanceof cljs.core.BlackNode)return cljs.core.balance_left.call(null,a,b,c.redden(),d);if(c instanceof cljs.core.RedNode&&c.right instanceof cljs.core.BlackNode)return new cljs.core.RedNode(c.right.key,c.right.val,cljs.core.balance_left.call(null,c.key,c.val,c.left.redden(),c.right.left),new cljs.core.BlackNode(a,b,c.right.right,d,null),null);if(new cljs.core.Keyword(null, +"else","else",1017020587))throw Error("red-black tree invariant violation");return null}; +cljs.core.tree_map_kv_reduce=function tree_map_kv_reduce(b,c,d){d=null!=b.left?tree_map_kv_reduce.call(null,b.left,c,d):d;if(cljs.core.reduced_QMARK_.call(null,d))return cljs.core.deref.call(null,d);d=c.call(null,d,b.key,b.val);if(cljs.core.reduced_QMARK_.call(null,d))return cljs.core.deref.call(null,d);b=null!=b.right?tree_map_kv_reduce.call(null,b.right,c,d):d;return cljs.core.reduced_QMARK_.call(null,b)?cljs.core.deref.call(null,b):b}; +cljs.core.BlackNode=function(a,b,c,d,e){this.key=a;this.val=b;this.left=c;this.right=d;this.__hash=e;this.cljs$lang$protocol_mask$partition1$=0;this.cljs$lang$protocol_mask$partition0$=32402207};cljs.core.BlackNode.cljs$lang$type=!0;cljs.core.BlackNode.cljs$lang$ctorStr="cljs.core/BlackNode";cljs.core.BlackNode.cljs$lang$ctorPrWriter=function(a,b,c){return cljs.core._write.call(null,b,"cljs.core/BlackNode")}; +cljs.core.BlackNode.prototype.cljs$core$IHash$_hash$arity$1=function(a){a=this.__hash;return null!=a?a:this.__hash=a=cljs.core.hash_coll.call(null,this)};cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$2=function(a,b){return cljs.core._nth.call(null,this,b,null)};cljs.core.BlackNode.prototype.cljs$core$ILookup$_lookup$arity$3=function(a,b,c){return cljs.core._nth.call(null,this,b,c)}; +cljs.core.BlackNode.prototype.cljs$core$IAssociative$_assoc$arity$3=function(a,b,c){return cljs.core.assoc.call(null,new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val],null),b,c)}; +cljs.core.BlackNode.prototype.call=function(){var a=null;return a=function(a,c,d){switch(arguments.length){case 2:return this.cljs$core$ILookup$_lookup$arity$2(null,c);case 3:return this.cljs$core$ILookup$_lookup$arity$3(null,c,d)}throw Error("Invalid arity: "+arguments.length);}}();cljs.core.BlackNode.prototype.apply=function(a,b){return this.call.apply(this,[this].concat(cljs.core.aclone.call(null,b)))}; +cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$1=function(a){return this.cljs$core$ILookup$_lookup$arity$2(null,a)};cljs.core.BlackNode.prototype.cljs$core$IFn$_invoke$arity$2=function(a,b){return this.cljs$core$ILookup$_lookup$arity$3(null,a,b)};cljs.core.BlackNode.prototype.cljs$core$ICollection$_conj$arity$2=function(a,b){return new cljs.core.PersistentVector(null,3,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val,b],null)}; +cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_key$arity$1=function(a){return this.key};cljs.core.BlackNode.prototype.cljs$core$IMapEntry$_val$arity$1=function(a){return this.val};cljs.core.BlackNode.prototype.add_right=function(a){return a.balance_right(this)};cljs.core.BlackNode.prototype.redden=function(){return new cljs.core.RedNode(this.key,this.val,this.left,this.right,null)}; +cljs.core.BlackNode.prototype.remove_right=function(a){return cljs.core.balance_right_del.call(null,this.key,this.val,this.left,a)};cljs.core.BlackNode.prototype.replace=function(a,b,c,d){return new cljs.core.BlackNode(a,b,c,d,null)};cljs.core.BlackNode.prototype.kv_reduce=function(a,b){return cljs.core.tree_map_kv_reduce.call(null,this,a,b)};cljs.core.BlackNode.prototype.remove_left=function(a){return cljs.core.balance_left_del.call(null,this.key,this.val,a,this.right)}; +cljs.core.BlackNode.prototype.add_left=function(a){return a.balance_left(this)};cljs.core.BlackNode.prototype.balance_left=function(a){return new cljs.core.BlackNode(a.key,a.val,this,a.right,null)};cljs.core.BlackNode.prototype.balance_right=function(a){return new cljs.core.BlackNode(a.key,a.val,a.left,this,null)};cljs.core.BlackNode.prototype.blacken=function(){return this};cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$2=function(a,b){return cljs.core.ci_reduce.call(null,this,b)}; +cljs.core.BlackNode.prototype.cljs$core$IReduce$_reduce$arity$3=function(a,b,c){return cljs.core.ci_reduce.call(null,this,b,c)};cljs.core.BlackNode.prototype.cljs$core$ISeqable$_seq$arity$1=function(a){return cljs.core._conj.call(null,cljs.core._conj.call(null,cljs.core.List.EMPTY,this.val),this.key)};cljs.core.BlackNode.prototype.cljs$core$ICounted$_count$arity$1=function(a){return 2};cljs.core.BlackNode.prototype.cljs$core$IStack$_peek$arity$1=function(a){return this.val}; +cljs.core.BlackNode.prototype.cljs$core$IStack$_pop$arity$1=function(a){return new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key],null)};cljs.core.BlackNode.prototype.cljs$core$IVector$_assoc_n$arity$3=function(a,b,c){return(new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val],null)).cljs$core$IVector$_assoc_n$arity$3(null,b,c)}; +cljs.core.BlackNode.prototype.cljs$core$IEquiv$_equiv$arity$2=function(a,b){return cljs.core.equiv_sequential.call(null,this,b)};cljs.core.BlackNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2=function(a,b){return cljs.core.with_meta.call(null,new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val],null),b)};cljs.core.BlackNode.prototype.cljs$core$IMeta$_meta$arity$1=function(a){return null}; +cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$2=function(a,b){if(0===b)return this.key;if(1===b)return this.val;new cljs.core.Keyword(null,"else","else",1017020587);return null};cljs.core.BlackNode.prototype.cljs$core$IIndexed$_nth$arity$3=function(a,b,c){return 0===b?this.key:1===b?this.val:new cljs.core.Keyword(null,"else","else",1017020587)?c:null};cljs.core.BlackNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1=function(a){return cljs.core.PersistentVector.EMPTY}; +cljs.core.__GT_BlackNode=function(a,b,c,d,e){return new cljs.core.BlackNode(a,b,c,d,e)};cljs.core.RedNode=function(a,b,c,d,e){this.key=a;this.val=b;this.left=c;this.right=d;this.__hash=e;this.cljs$lang$protocol_mask$partition1$=0;this.cljs$lang$protocol_mask$partition0$=32402207};cljs.core.RedNode.cljs$lang$type=!0;cljs.core.RedNode.cljs$lang$ctorStr="cljs.core/RedNode";cljs.core.RedNode.cljs$lang$ctorPrWriter=function(a,b,c){return cljs.core._write.call(null,b,"cljs.core/RedNode")}; +cljs.core.RedNode.prototype.cljs$core$IHash$_hash$arity$1=function(a){a=this.__hash;return null!=a?a:this.__hash=a=cljs.core.hash_coll.call(null,this)};cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$2=function(a,b){return cljs.core._nth.call(null,this,b,null)};cljs.core.RedNode.prototype.cljs$core$ILookup$_lookup$arity$3=function(a,b,c){return cljs.core._nth.call(null,this,b,c)}; +cljs.core.RedNode.prototype.cljs$core$IAssociative$_assoc$arity$3=function(a,b,c){return cljs.core.assoc.call(null,new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val],null),b,c)}; +cljs.core.RedNode.prototype.call=function(){var a=null;return a=function(a,c,d){switch(arguments.length){case 2:return this.cljs$core$ILookup$_lookup$arity$2(null,c);case 3:return this.cljs$core$ILookup$_lookup$arity$3(null,c,d)}throw Error("Invalid arity: "+arguments.length);}}();cljs.core.RedNode.prototype.apply=function(a,b){return this.call.apply(this,[this].concat(cljs.core.aclone.call(null,b)))}; +cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$1=function(a){return this.cljs$core$ILookup$_lookup$arity$2(null,a)};cljs.core.RedNode.prototype.cljs$core$IFn$_invoke$arity$2=function(a,b){return this.cljs$core$ILookup$_lookup$arity$3(null,a,b)};cljs.core.RedNode.prototype.cljs$core$ICollection$_conj$arity$2=function(a,b){return new cljs.core.PersistentVector(null,3,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val,b],null)}; +cljs.core.RedNode.prototype.cljs$core$IMapEntry$_key$arity$1=function(a){return this.key};cljs.core.RedNode.prototype.cljs$core$IMapEntry$_val$arity$1=function(a){return this.val};cljs.core.RedNode.prototype.add_right=function(a){return new cljs.core.RedNode(this.key,this.val,this.left,a,null)};cljs.core.RedNode.prototype.redden=function(){throw Error("red-black tree invariant violation");}; +cljs.core.RedNode.prototype.remove_right=function(a){return new cljs.core.RedNode(this.key,this.val,this.left,a,null)};cljs.core.RedNode.prototype.replace=function(a,b,c,d){return new cljs.core.RedNode(a,b,c,d,null)};cljs.core.RedNode.prototype.kv_reduce=function(a,b){return cljs.core.tree_map_kv_reduce.call(null,this,a,b)};cljs.core.RedNode.prototype.remove_left=function(a){return new cljs.core.RedNode(this.key,this.val,a,this.right,null)}; +cljs.core.RedNode.prototype.add_left=function(a){return new cljs.core.RedNode(this.key,this.val,a,this.right,null)}; +cljs.core.RedNode.prototype.balance_left=function(a){return this.left instanceof cljs.core.RedNode?new cljs.core.RedNode(this.key,this.val,this.left.blacken(),new cljs.core.BlackNode(a.key,a.val,this.right,a.right,null),null):this.right instanceof cljs.core.RedNode?new cljs.core.RedNode(this.right.key,this.right.val,new cljs.core.BlackNode(this.key,this.val,this.left,this.right.left,null),new cljs.core.BlackNode(a.key,a.val,this.right.right,a.right,null),null):new cljs.core.Keyword(null,"else","else", +1017020587)?new cljs.core.BlackNode(a.key,a.val,this,a.right,null):null}; +cljs.core.RedNode.prototype.balance_right=function(a){return this.right instanceof cljs.core.RedNode?new cljs.core.RedNode(this.key,this.val,new cljs.core.BlackNode(a.key,a.val,a.left,this.left,null),this.right.blacken(),null):this.left instanceof cljs.core.RedNode?new cljs.core.RedNode(this.left.key,this.left.val,new cljs.core.BlackNode(a.key,a.val,a.left,this.left.left,null),new cljs.core.BlackNode(this.key,this.val,this.left.right,this.right,null),null):new cljs.core.Keyword(null,"else","else", +1017020587)?new cljs.core.BlackNode(a.key,a.val,a.left,this,null):null};cljs.core.RedNode.prototype.blacken=function(){return new cljs.core.BlackNode(this.key,this.val,this.left,this.right,null)};cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$2=function(a,b){return cljs.core.ci_reduce.call(null,this,b)};cljs.core.RedNode.prototype.cljs$core$IReduce$_reduce$arity$3=function(a,b,c){return cljs.core.ci_reduce.call(null,this,b,c)}; +cljs.core.RedNode.prototype.cljs$core$ISeqable$_seq$arity$1=function(a){return cljs.core._conj.call(null,cljs.core._conj.call(null,cljs.core.List.EMPTY,this.val),this.key)};cljs.core.RedNode.prototype.cljs$core$ICounted$_count$arity$1=function(a){return 2};cljs.core.RedNode.prototype.cljs$core$IStack$_peek$arity$1=function(a){return this.val}; +cljs.core.RedNode.prototype.cljs$core$IStack$_pop$arity$1=function(a){return new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key],null)};cljs.core.RedNode.prototype.cljs$core$IVector$_assoc_n$arity$3=function(a,b,c){return(new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val],null)).cljs$core$IVector$_assoc_n$arity$3(null,b,c)}; +cljs.core.RedNode.prototype.cljs$core$IEquiv$_equiv$arity$2=function(a,b){return cljs.core.equiv_sequential.call(null,this,b)};cljs.core.RedNode.prototype.cljs$core$IWithMeta$_with_meta$arity$2=function(a,b){return cljs.core.with_meta.call(null,new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[this.key,this.val],null),b)};cljs.core.RedNode.prototype.cljs$core$IMeta$_meta$arity$1=function(a){return null}; +cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$2=function(a,b){if(0===b)return this.key;if(1===b)return this.val;new cljs.core.Keyword(null,"else","else",1017020587);return null};cljs.core.RedNode.prototype.cljs$core$IIndexed$_nth$arity$3=function(a,b,c){return 0===b?this.key:1===b?this.val:new cljs.core.Keyword(null,"else","else",1017020587)?c:null};cljs.core.RedNode.prototype.cljs$core$IEmptyableCollection$_empty$arity$1=function(a){return cljs.core.PersistentVector.EMPTY}; +cljs.core.__GT_RedNode=function(a,b,c,d,e){return new cljs.core.RedNode(a,b,c,d,e)};cljs.core.tree_map_add=function tree_map_add(b,c,d,e,f){if(null==c)return new cljs.core.RedNode(d,e,null,null,null);var g=b.call(null,d,c.key);return 0===g?(f[0]=c,null):0>g?(b=tree_map_add.call(null,b,c.left,d,e,f),null!=b?c.add_left(b):null):new cljs.core.Keyword(null,"else","else",1017020587)?(b=tree_map_add.call(null,b,c.right,d,e,f),null!=b?c.add_right(b):null):null}; +cljs.core.tree_map_append=function tree_map_append(b,c){if(null==b)return c;if(null==c)return b;if(b instanceof cljs.core.RedNode){if(c instanceof cljs.core.RedNode){var d=tree_map_append.call(null,b.right,c.left);return d instanceof cljs.core.RedNode?new cljs.core.RedNode(d.key,d.val,new cljs.core.RedNode(b.key,b.val,b.left,d.left,null),new cljs.core.RedNode(c.key,c.val,d.right,c.right,null),null):new cljs.core.RedNode(b.key,b.val,b.left,new cljs.core.RedNode(c.key,c.val,d,c.right,null),null)}return new cljs.core.RedNode(b.key, +b.val,b.left,tree_map_append.call(null,b.right,c),null)}return c instanceof cljs.core.RedNode?new cljs.core.RedNode(c.key,c.val,tree_map_append.call(null,b,c.left),c.right,null):new cljs.core.Keyword(null,"else","else",1017020587)?(d=tree_map_append.call(null,b.right,c.left),d instanceof cljs.core.RedNode?new cljs.core.RedNode(d.key,d.val,new cljs.core.BlackNode(b.key,b.val,b.left,d.left,null),new cljs.core.BlackNode(c.key,c.val,d.right,c.right,null),null):cljs.core.balance_left_del.call(null,b.key, +b.val,b.left,new cljs.core.BlackNode(c.key,c.val,d,c.right,null))):null}; +cljs.core.tree_map_remove=function tree_map_remove(b,c,d,e){if(null!=c){var f=b.call(null,d,c.key);if(0===f)return e[0]=c,cljs.core.tree_map_append.call(null,c.left,c.right);if(0>f)return b=tree_map_remove.call(null,b,c.left,d,e),null!=b||null!=e[0]?c.left instanceof cljs.core.BlackNode?cljs.core.balance_left_del.call(null,c.key,c.val,b,c.right):new cljs.core.RedNode(c.key,c.val,b,c.right,null):null;if(new cljs.core.Keyword(null,"else","else",1017020587))return b=tree_map_remove.call(null,b,c.right, +d,e),null!=b||null!=e[0]?c.right instanceof cljs.core.BlackNode?cljs.core.balance_right_del.call(null,c.key,c.val,c.left,b):new cljs.core.RedNode(c.key,c.val,c.left,b,null):null}return null}; +cljs.core.tree_map_replace=function tree_map_replace(b,c,d,e){var f=c.key,g=b.call(null,d,f);return 0===g?c.replace(f,e,c.left,c.right):0>g?c.replace(f,c.val,tree_map_replace.call(null,b,c.left,d,e),c.right):new cljs.core.Keyword(null,"else","else",1017020587)?c.replace(f,c.val,c.left,tree_map_replace.call(null,b,c.right,d,e)):null}; +cljs.core.PersistentTreeMap=function(a,b,c,d,e){this.comp=a;this.tree=b;this.cnt=c;this.meta=d;this.__hash=e;this.cljs$lang$protocol_mask$partition0$=418776847;this.cljs$lang$protocol_mask$partition1$=8192};cljs.core.PersistentTreeMap.cljs$lang$type=!0;cljs.core.PersistentTreeMap.cljs$lang$ctorStr="cljs.core/PersistentTreeMap";cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter=function(a,b,c){return cljs.core._write.call(null,b,"cljs.core/PersistentTreeMap")}; +cljs.core.PersistentTreeMap.prototype.cljs$core$IHash$_hash$arity$1=function(a){a=this.__hash;return null!=a?a:this.__hash=a=cljs.core.hash_imap.call(null,this)};cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$2=function(a,b){return cljs.core._lookup.call(null,this,b,null)};cljs.core.PersistentTreeMap.prototype.cljs$core$ILookup$_lookup$arity$3=function(a,b,c){a=this.entry_at(b);return null!=a?a.val:c}; +cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_assoc$arity$3=function(a,b,c){a=[null];var d=cljs.core.tree_map_add.call(null,this.comp,this.tree,b,c,a);return null==d?(a=cljs.core.nth.call(null,a,0),cljs.core._EQ_.call(null,c,a.val)?this:new cljs.core.PersistentTreeMap(this.comp,cljs.core.tree_map_replace.call(null,this.comp,this.tree,b,c),this.cnt,this.meta,null)):new cljs.core.PersistentTreeMap(this.comp,d.blacken(),this.cnt+1,this.meta,null)}; +cljs.core.PersistentTreeMap.prototype.cljs$core$IAssociative$_contains_key_QMARK_$arity$2=function(a,b){return null!=this.entry_at(b)};cljs.core.PersistentTreeMap.prototype.call=function(){var a=null;return a=function(a,c,d){switch(arguments.length){case 2:return this.cljs$core$ILookup$_lookup$arity$2(null,c);case 3:return this.cljs$core$ILookup$_lookup$arity$3(null,c,d)}throw Error("Invalid arity: "+arguments.length);}}(); +cljs.core.PersistentTreeMap.prototype.apply=function(a,b){return this.call.apply(this,[this].concat(cljs.core.aclone.call(null,b)))};cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$1=function(a){return this.cljs$core$ILookup$_lookup$arity$2(null,a)};cljs.core.PersistentTreeMap.prototype.cljs$core$IFn$_invoke$arity$2=function(a,b){return this.cljs$core$ILookup$_lookup$arity$3(null,a,b)}; +cljs.core.PersistentTreeMap.prototype.cljs$core$IKVReduce$_kv_reduce$arity$3=function(a,b,c){return null!=this.tree?cljs.core.tree_map_kv_reduce.call(null,this.tree,b,c):c};cljs.core.PersistentTreeMap.prototype.cljs$core$ICollection$_conj$arity$2=function(a,b){return cljs.core.vector_QMARK_.call(null,b)?cljs.core._assoc.call(null,this,cljs.core._nth.call(null,b,0),cljs.core._nth.call(null,b,1)):cljs.core.reduce.call(null,cljs.core._conj,this,b)}; +cljs.core.PersistentTreeMap.prototype.cljs$core$IReversible$_rseq$arity$1=function(a){return 0c)b=b.left;else if(new cljs.core.Keyword(null,"else","else",1017020587))b=b.right;else return null}else return null};cljs.core.PersistentTreeMap.prototype.cljs$core$ISorted$_sorted_seq$arity$2=function(a,b){return 0e?(a=cljs.core.conj.call(null,a,d),d=d.left):d=d.right;else if(new cljs.core.Keyword(null,"else","else",1017020587))0a.call(null,c)?b:c},c=function(){var b=function(b,c,d,e){return cljs.core.reduce.call(null,function(c,d){return a.call(null,b,c,d)},a.call(null,b,c,d),e)},c=function(a,c,e,k){var l=null;3this.end?new cljs.core.Range(this.meta,this.start+this.step,this.end,this.step,null):null}; +cljs.core.Range.prototype.cljs$core$ICollection$_conj$arity$2=function(a,b){return cljs.core.cons.call(null,b,this)};cljs.core.Range.prototype.toString=function(){return cljs.core.pr_str_STAR_.call(null,this)};cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$2=function(a,b){return cljs.core.ci_reduce.call(null,this,b)};cljs.core.Range.prototype.cljs$core$IReduce$_reduce$arity$3=function(a,b,c){return cljs.core.ci_reduce.call(null,this,b,c)}; +cljs.core.Range.prototype.cljs$core$ISeqable$_seq$arity$1=function(a){return 0this.end?this:null};cljs.core.Range.prototype.cljs$core$ICounted$_count$arity$1=function(a){return cljs.core.not.call(null,cljs.core._seq.call(null,this))?0:Math.ceil((this.end-this.start)/this.step)};cljs.core.Range.prototype.cljs$core$ISeq$_first$arity$1=function(a){return null==cljs.core._seq.call(null,this)?null:this.start}; +cljs.core.Range.prototype.cljs$core$ISeq$_rest$arity$1=function(a){return null!=cljs.core._seq.call(null,this)?new cljs.core.Range(this.meta,this.start+this.step,this.end,this.step,null):cljs.core.List.EMPTY};cljs.core.Range.prototype.cljs$core$IEquiv$_equiv$arity$2=function(a,b){return cljs.core.equiv_sequential.call(null,this,b)};cljs.core.Range.prototype.cljs$core$IWithMeta$_with_meta$arity$2=function(a,b){return new cljs.core.Range(b,this.start,this.end,this.step,this.__hash)}; +cljs.core.Range.prototype.cljs$core$ICloneable$_clone$arity$1=function(a){return new cljs.core.Range(this.meta,this.start,this.end,this.step,this.__hash)};cljs.core.Range.prototype.cljs$core$IMeta$_meta$arity$1=function(a){return this.meta};cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$2=function(a,b){if(bthis.end&&0===this.step)return this.start;throw Error("Index out of bounds");}; +cljs.core.Range.prototype.cljs$core$IIndexed$_nth$arity$3=function(a,b,c){return bthis.end&&0===this.step?this.start:c};cljs.core.Range.prototype.cljs$core$IEmptyableCollection$_empty$arity$1=function(a){return cljs.core.with_meta.call(null,cljs.core.List.EMPTY,this.meta)};cljs.core.__GT_Range=function(a,b,c,d,e){return new cljs.core.Range(a,b,c,d,e)}; +cljs.core.range=function(){var a=null,b=function(){return a.call(null,0,Number.MAX_VALUE,1)},c=function(b){return a.call(null,0,b,1)},d=function(b,c){return a.call(null,b,c,1)},e=function(a,b,c){return new cljs.core.Range(null,a,b,c,null)},a=function(a,g,h){switch(arguments.length){case 0:return b.call(this);case 1:return c.call(this,a);case 2:return d.call(this,a,g);case 3:return e.call(this,a,g,h)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$0=b;a.cljs$core$IFn$_invoke$arity$1= +c;a.cljs$core$IFn$_invoke$arity$2=d;a.cljs$core$IFn$_invoke$arity$3=e;return a}();cljs.core.take_nth=function take_nth(b,c){return new cljs.core.LazySeq(null,function(){var d=cljs.core.seq.call(null,c);return d?cljs.core.cons.call(null,cljs.core.first.call(null,d),take_nth.call(null,b,cljs.core.drop.call(null,b,d))):null},null,null)}; +cljs.core.split_with=function(a,b){return new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.take_while.call(null,a,b),cljs.core.drop_while.call(null,a,b)],null)}; +cljs.core.partition_by=function partition_by(b,c){return new cljs.core.LazySeq(null,function(){var d=cljs.core.seq.call(null,c);if(d){var e=cljs.core.first.call(null,d),f=b.call(null,e),e=cljs.core.cons.call(null,e,cljs.core.take_while.call(null,function(c,d){return function(c){return cljs.core._EQ_.call(null,d,b.call(null,c))}}(e,f),cljs.core.next.call(null,d)));return cljs.core.cons.call(null,e,partition_by.call(null,b,cljs.core.seq.call(null,cljs.core.drop.call(null,cljs.core.count.call(null,e), +d))))}return null},null,null)};cljs.core.frequencies=function(a){return cljs.core.persistent_BANG_.call(null,cljs.core.reduce.call(null,function(a,c){return cljs.core.assoc_BANG_.call(null,a,c,cljs.core.get.call(null,a,c,0)+1)},cljs.core.transient$.call(null,cljs.core.PersistentArrayMap.EMPTY),a))}; +cljs.core.reductions=function(){var a=null,b=function(b,c){return new cljs.core.LazySeq(null,function(){var f=cljs.core.seq.call(null,c);return f?a.call(null,b,cljs.core.first.call(null,f),cljs.core.rest.call(null,f)):cljs.core._conj.call(null,cljs.core.List.EMPTY,b.call(null))},null,null)},c=function(b,c,f){return cljs.core.cons.call(null,c,new cljs.core.LazySeq(null,function(){var g=cljs.core.seq.call(null,f);return g?a.call(null,b,b.call(null,c,cljs.core.first.call(null,g)),cljs.core.rest.call(null, +g)):null},null,null))},a=function(a,e,f){switch(arguments.length){case 2:return b.call(this,a,e);case 3:return c.call(this,a,e,f)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$2=b;a.cljs$core$IFn$_invoke$arity$3=c;return a}(); +cljs.core.juxt=function(){var a=null,b=function(a){return function(){var b=null,c=function(){var b=function(b,c,d,e){return new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.apply.call(null,a,b,c,d,e)],null)},c=function(a,c,d,e){var f=null;3cljs.core._STAR_print_level_STAR_)return cljs.core._write.call(null,a,"#");cljs.core._write.call(null,a,c);cljs.core.seq.call(null,g)&&b.call(null,cljs.core.first.call(null,g),a,f);for(var k=cljs.core.next.call(null,g),l=(new cljs.core.Keyword(null, +"print-length","print-length",3960797560)).cljs$core$IFn$_invoke$arity$1(f);k&&(null==l||0!==l);){cljs.core._write.call(null,a,d);b.call(null,cljs.core.first.call(null,k),a,f);var m=cljs.core.next.call(null,k);c=l-1;k=m;l=c}cljs.core.truth_((new cljs.core.Keyword(null,"print-length","print-length",3960797560)).cljs$core$IFn$_invoke$arity$1(f))&&(cljs.core._write.call(null,a,d),b.call(null,"...",a,f));return cljs.core._write.call(null,a,e)}finally{cljs.core._STAR_print_level_STAR_=h}}; +cljs.core.write_all=function(){var a=function(a,b){for(var e=cljs.core.seq.call(null,b),f=null,g=0,h=0;;)if(hgoog.net.XmlHttp.ReadyState.LOADED?this.xhr_.status:-1}catch(a){return this.logger_.warning("Can not get status: "+a.message),-1}}; +goog.net.XhrIo.prototype.getStatusText=function(){try{return this.getReadyState()>goog.net.XmlHttp.ReadyState.LOADED?this.xhr_.statusText:""}catch(a){return this.logger_.fine("Can not get status: "+a.message),""}};goog.net.XhrIo.prototype.getLastUri=function(){return String(this.lastUri_)};goog.net.XhrIo.prototype.getResponseText=function(){try{return this.xhr_?this.xhr_.responseText:""}catch(a){return this.logger_.fine("Can not get responseText: "+a.message),""}}; +goog.net.XhrIo.prototype.getResponseBody=function(){try{if(this.xhr_&&"responseBody"in this.xhr_)return this.xhr_.responseBody}catch(a){this.logger_.fine("Can not get responseBody: "+a.message)}return null};goog.net.XhrIo.prototype.getResponseXml=function(){try{return this.xhr_?this.xhr_.responseXML:null}catch(a){return this.logger_.fine("Can not get responseXML: "+a.message),null}}; +goog.net.XhrIo.prototype.getResponseJson=function(a){if(this.xhr_){var b=this.xhr_.responseText;a&&0==b.indexOf(a)&&(b=b.substring(a.length));return goog.json.parse(b)}}; +goog.net.XhrIo.prototype.getResponse=function(){try{if(!this.xhr_)return null;if("response"in this.xhr_)return this.xhr_.response;switch(this.responseType_){case goog.net.XhrIo.ResponseType.DEFAULT:case goog.net.XhrIo.ResponseType.TEXT:return this.xhr_.responseText;case goog.net.XhrIo.ResponseType.ARRAY_BUFFER:if("mozResponseArrayBuffer"in this.xhr_)return this.xhr_.mozResponseArrayBuffer}this.logger_.severe("Response type "+this.responseType_+" is not supported on this browser");return null}catch(a){return this.logger_.fine("Can not get response: "+ +a.message),null}};goog.net.XhrIo.prototype.getResponseHeader=function(a){return this.xhr_&&this.isComplete()?this.xhr_.getResponseHeader(a):void 0};goog.net.XhrIo.prototype.getAllResponseHeaders=function(){return this.xhr_&&this.isComplete()?this.xhr_.getAllResponseHeaders():""};goog.net.XhrIo.prototype.getLastErrorCode=function(){return this.lastErrorCode_};goog.net.XhrIo.prototype.getLastError=function(){return goog.isString(this.lastError_)?this.lastError_:String(this.lastError_)}; +goog.net.XhrIo.prototype.formatMsg_=function(a){return a+" ["+this.lastMethod_+" "+this.lastUri_+" "+this.getStatus()+"]"};goog.debug.entryPointRegistry.register(function(a){goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_=a(goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_)});clojure.browser.net={};clojure.browser.net._STAR_timeout_STAR_=1E4;clojure.browser.net.event_types=cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,function(a){var b=cljs.core.nth.call(null,a,0,null);a=cljs.core.nth.call(null,a,1,null);return new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.keyword.call(null,b.toLowerCase()),a],null)},cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.net.EventType)))); +clojure.browser.net.IConnection=function(){return{}}(); +clojure.browser.net.connect=function(){var a=null,b=function(a){if(a?a.clojure$browser$net$IConnection$connect$arity$1:a)return a.clojure$browser$net$IConnection$connect$arity$1(a);var b;b=clojure.browser.net.connect[goog.typeOf(null==a?null:a)];if(!b&&(b=clojure.browser.net.connect._,!b))throw cljs.core.missing_protocol.call(null,"IConnection.connect",a);return b.call(null,a)},c=function(a,b){if(a?a.clojure$browser$net$IConnection$connect$arity$2:a)return a.clojure$browser$net$IConnection$connect$arity$2(a, +b);var c;c=clojure.browser.net.connect[goog.typeOf(null==a?null:a)];if(!c&&(c=clojure.browser.net.connect._,!c))throw cljs.core.missing_protocol.call(null,"IConnection.connect",a);return c.call(null,a,b)},d=function(a,b,c){if(a?a.clojure$browser$net$IConnection$connect$arity$3:a)return a.clojure$browser$net$IConnection$connect$arity$3(a,b,c);var d;d=clojure.browser.net.connect[goog.typeOf(null==a?null:a)];if(!d&&(d=clojure.browser.net.connect._,!d))throw cljs.core.missing_protocol.call(null,"IConnection.connect", +a);return d.call(null,a,b,c)},e=function(a,b,c,d){if(a?a.clojure$browser$net$IConnection$connect$arity$4:a)return a.clojure$browser$net$IConnection$connect$arity$4(a,b,c,d);var e;e=clojure.browser.net.connect[goog.typeOf(null==a?null:a)];if(!e&&(e=clojure.browser.net.connect._,!e))throw cljs.core.missing_protocol.call(null,"IConnection.connect",a);return e.call(null,a,b,c,d)},a=function(a,g,h,k){switch(arguments.length){case 1:return b.call(this,a);case 2:return c.call(this,a,g);case 3:return d.call(this, +a,g,h);case 4:return e.call(this,a,g,h,k)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$1=b;a.cljs$core$IFn$_invoke$arity$2=c;a.cljs$core$IFn$_invoke$arity$3=d;a.cljs$core$IFn$_invoke$arity$4=e;return a}(); +clojure.browser.net.transmit=function(){var a=null,b=function(a,b){if(a?a.clojure$browser$net$IConnection$transmit$arity$2:a)return a.clojure$browser$net$IConnection$transmit$arity$2(a,b);var c;c=clojure.browser.net.transmit[goog.typeOf(null==a?null:a)];if(!c&&(c=clojure.browser.net.transmit._,!c))throw cljs.core.missing_protocol.call(null,"IConnection.transmit",a);return c.call(null,a,b)},c=function(a,b,c){if(a?a.clojure$browser$net$IConnection$transmit$arity$3:a)return a.clojure$browser$net$IConnection$transmit$arity$3(a, +b,c);var d;d=clojure.browser.net.transmit[goog.typeOf(null==a?null:a)];if(!d&&(d=clojure.browser.net.transmit._,!d))throw cljs.core.missing_protocol.call(null,"IConnection.transmit",a);return d.call(null,a,b,c)},d=function(a,b,c,d){if(a?a.clojure$browser$net$IConnection$transmit$arity$4:a)return a.clojure$browser$net$IConnection$transmit$arity$4(a,b,c,d);var e;e=clojure.browser.net.transmit[goog.typeOf(null==a?null:a)];if(!e&&(e=clojure.browser.net.transmit._,!e))throw cljs.core.missing_protocol.call(null, +"IConnection.transmit",a);return e.call(null,a,b,c,d)},e=function(a,b,c,d,e){if(a?a.clojure$browser$net$IConnection$transmit$arity$5:a)return a.clojure$browser$net$IConnection$transmit$arity$5(a,b,c,d,e);var f;f=clojure.browser.net.transmit[goog.typeOf(null==a?null:a)];if(!f&&(f=clojure.browser.net.transmit._,!f))throw cljs.core.missing_protocol.call(null,"IConnection.transmit",a);return f.call(null,a,b,c,d,e)},f=function(a,b,c,d,e,f){if(a?a.clojure$browser$net$IConnection$transmit$arity$6:a)return a.clojure$browser$net$IConnection$transmit$arity$6(a, +b,c,d,e,f);var p;p=clojure.browser.net.transmit[goog.typeOf(null==a?null:a)];if(!p&&(p=clojure.browser.net.transmit._,!p))throw cljs.core.missing_protocol.call(null,"IConnection.transmit",a);return p.call(null,a,b,c,d,e,f)},a=function(a,h,k,l,m,n){switch(arguments.length){case 2:return b.call(this,a,h);case 3:return c.call(this,a,h,k);case 4:return d.call(this,a,h,k,l);case 5:return e.call(this,a,h,k,l,m);case 6:return f.call(this,a,h,k,l,m,n)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$2= +b;a.cljs$core$IFn$_invoke$arity$3=c;a.cljs$core$IFn$_invoke$arity$4=d;a.cljs$core$IFn$_invoke$arity$5=e;a.cljs$core$IFn$_invoke$arity$6=f;return a}();clojure.browser.net.close=function(a){if(a?a.clojure$browser$net$IConnection$close$arity$1:a)return a.clojure$browser$net$IConnection$close$arity$1(a);var b;b=clojure.browser.net.close[goog.typeOf(null==a?null:a)];if(!b&&(b=clojure.browser.net.close._,!b))throw cljs.core.missing_protocol.call(null,"IConnection.close",a);return b.call(null,a)}; +goog.net.XhrIo.prototype.clojure$browser$event$EventType$=!0; +goog.net.XhrIo.prototype.clojure$browser$event$EventType$event_types$arity$1=function(a){return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,function(a){var c=cljs.core.nth.call(null,a,0,null);a=cljs.core.nth.call(null,a,1,null);return new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.keyword.call(null,c.toLowerCase()),a],null)},cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.net.EventType))))}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$=!0;goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$2=function(a,b){return clojure.browser.net.transmit.call(null,this,b,"GET",null,null,clojure.browser.net._STAR_timeout_STAR_)};goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$3=function(a,b,c){return clojure.browser.net.transmit.call(null,this,b,c,null,null,clojure.browser.net._STAR_timeout_STAR_)}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$4=function(a,b,c,d){return clojure.browser.net.transmit.call(null,this,b,c,d,null,clojure.browser.net._STAR_timeout_STAR_)};goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$5=function(a,b,c,d,e){return clojure.browser.net.transmit.call(null,this,b,c,d,e,clojure.browser.net._STAR_timeout_STAR_)}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$6=function(a,b,c,d,e,f){this.setTimeoutInterval(f);return this.send(b,c,d,e)}; +clojure.browser.net.xpc_config_fields=cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,function(a){var b=cljs.core.nth.call(null,a,0,null);a=cljs.core.nth.call(null,a,1,null);return new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[cljs.core.keyword.call(null,b.toLowerCase()),a],null)},cljs.core.js__GT_clj.call(null,goog.net.xpc.CfgFields)));clojure.browser.net.xhr_connection=function(){return new goog.net.XhrIo}; +clojure.browser.net.ICrossPageChannel=function(){return{}}(); +clojure.browser.net.register_service=function(){var a=null,b=function(a,b,c){if(a?a.clojure$browser$net$ICrossPageChannel$register_service$arity$3:a)return a.clojure$browser$net$ICrossPageChannel$register_service$arity$3(a,b,c);var g;g=clojure.browser.net.register_service[goog.typeOf(null==a?null:a)];if(!g&&(g=clojure.browser.net.register_service._,!g))throw cljs.core.missing_protocol.call(null,"ICrossPageChannel.register-service",a);return g.call(null,a,b,c)},c=function(a,b,c,g){if(a?a.clojure$browser$net$ICrossPageChannel$register_service$arity$4: +a)return a.clojure$browser$net$ICrossPageChannel$register_service$arity$4(a,b,c,g);var h;h=clojure.browser.net.register_service[goog.typeOf(null==a?null:a)];if(!h&&(h=clojure.browser.net.register_service._,!h))throw cljs.core.missing_protocol.call(null,"ICrossPageChannel.register-service",a);return h.call(null,a,b,c,g)},a=function(a,e,f,g){switch(arguments.length){case 3:return b.call(this,a,e,f);case 4:return c.call(this,a,e,f,g)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$3= +b;a.cljs$core$IFn$_invoke$arity$4=c;return a}();goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$=!0;goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$1=function(a){return clojure.browser.net.connect.call(null,this,null)};goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$2=function(a,b){return this.connect(b)}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$3=function(a,b,c){return clojure.browser.net.connect.call(null,this,b,c,document.body)};goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$4=function(a,b,c,d){this.createPeerIframe(d,c);return this.connect(b)};goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$transmit$arity$3=function(a,b,c){return this.send(cljs.core.name.call(null,b),c)}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$close$arity$1=function(a){return this.close(cljs.core.List.EMPTY)};goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$=!0;goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$3=function(a,b,c){return clojure.browser.net.register_service.call(null,this,b,c,!1)}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$4=function(a,b,c,d){return this.registerService(cljs.core.name.call(null,b),c,d)}; +clojure.browser.net.xpc_connection=function(){var a=null,b=function(){var a=(new goog.Uri(window.location.href)).getParameterValue("xpc");return cljs.core.truth_(a)?new goog.net.xpc.CrossPageChannel(goog.json.parse(a)):null},c=function(a){return new goog.net.xpc.CrossPageChannel(cljs.core.reduce.call(null,function(a,b){var c=cljs.core.nth.call(null,b,0,null),d=cljs.core.nth.call(null,b,1,null),c=cljs.core.get.call(null,clojure.browser.net.xpc_config_fields,c);cljs.core.truth_(c)&&(a[c]=d);return a}, +{},a))},a=function(a){switch(arguments.length){case 0:return b.call(this);case 1:return c.call(this,a)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$0=b;a.cljs$core$IFn$_invoke$arity$1=c;return a}();clojure.browser.repl={};clojure.browser.repl.xpc_connection=cljs.core.atom.call(null,null);clojure.browser.repl.repl_print=function(a){var b=cljs.core.deref.call(null,clojure.browser.repl.xpc_connection);return cljs.core.truth_(b)?clojure.browser.net.transmit.call(null,b,new cljs.core.Keyword(null,"print","print",1120839199),cljs.core.pr_str.call(null,a)):null}; +clojure.browser.repl.evaluate_javascript=function(a,b){var c=function(){try{return new cljs.core.PersistentArrayMap(null,2,[new cljs.core.Keyword(null,"status","status",4416389988),new cljs.core.Keyword(null,"success","success",3441701749),new cljs.core.Keyword(null,"value","value",1125876963),""+cljs.core.str(eval(b))],null)}catch(a){return new cljs.core.PersistentArrayMap(null,3,[new cljs.core.Keyword(null,"status","status",4416389988),new cljs.core.Keyword(null,"exception","exception",2495529921), +new cljs.core.Keyword(null,"value","value",1125876963),cljs.core.pr_str.call(null,a),new cljs.core.Keyword(null,"stacktrace","stacktrace",3069736751),cljs.core.truth_(a.hasOwnProperty("stack"))?a.stack:"No stacktrace available."],null)}}();return cljs.core.pr_str.call(null,c)};clojure.browser.repl.send_result=function(a,b,c){return clojure.browser.net.transmit.call(null,a,b,"POST",c,null,0)}; +clojure.browser.repl.send_print=function(){var a=null,b=function(b,c){return a.call(null,b,c,0)},c=function(b,c,f){var g=clojure.browser.net.xhr_connection.call(null);clojure.browser.event.listen.call(null,g,new cljs.core.Keyword(null,"error","error",1110689146),function(g){return 10>f?a.call(null,b,c,f+1):console.log([cljs.core.str("Could not send "),cljs.core.str(c),cljs.core.str(" after "),cljs.core.str(f),cljs.core.str(" attempts.")].join(""))});return clojure.browser.net.transmit.call(null,g, +b,"POST",c,null,0)},a=function(a,e,f){switch(arguments.length){case 2:return b.call(this,a,e);case 3:return c.call(this,a,e,f)}throw Error("Invalid arity: "+arguments.length);};a.cljs$core$IFn$_invoke$arity$2=b;a.cljs$core$IFn$_invoke$arity$3=c;return a}();clojure.browser.repl.order=cljs.core.atom.call(null,0); +clojure.browser.repl.wrap_message=function(a,b){return cljs.core.pr_str.call(null,new cljs.core.PersistentArrayMap(null,3,[new cljs.core.Keyword(null,"type","type",1017479852),a,new cljs.core.Keyword(null,"content","content",1965434859),b,new cljs.core.Keyword(null,"order","order",1119910592),cljs.core.swap_BANG_.call(null,clojure.browser.repl.order,cljs.core.inc)],null))}; +clojure.browser.repl.start_evaluator=function(a){var b=clojure.browser.net.xpc_connection.call(null);if(cljs.core.truth_(b)){var c=clojure.browser.net.xhr_connection.call(null);clojure.browser.event.listen.call(null,c,new cljs.core.Keyword(null,"success","success",3441701749),function(a){return clojure.browser.net.transmit.call(null,b,new cljs.core.Keyword(null,"evaluate-javascript","evaluate-javascript",2953437843),a.currentTarget.getResponseText(cljs.core.List.EMPTY))});clojure.browser.net.register_service.call(null, +b,new cljs.core.Keyword(null,"send-result","send-result",3729280372),function(b){return clojure.browser.repl.send_result.call(null,c,a,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"result","result",4374444943),b))});clojure.browser.net.register_service.call(null,b,new cljs.core.Keyword(null,"print","print",1120839199),function(b){return clojure.browser.repl.send_print.call(null,a,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"print","print",1120839199), +b))});clojure.browser.net.connect.call(null,b,cljs.core.constantly.call(null,null));return setTimeout(function(){return clojure.browser.repl.send_result.call(null,c,a,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"ready","ready",1122290965),"ready"))},50)}return alert("No 'xpc' param provided to child iframe.")}; +clojure.browser.repl.connect=function(a){var b=clojure.browser.net.xpc_connection.call(null,new cljs.core.PersistentArrayMap(null,1,[new cljs.core.Keyword(null,"peer_uri","peer_uri",1083496577),a],null));cljs.core.swap_BANG_.call(null,clojure.browser.repl.xpc_connection,cljs.core.constantly.call(null,b));clojure.browser.net.register_service.call(null,b,new cljs.core.Keyword(null,"evaluate-javascript","evaluate-javascript",2953437843),function(a){return clojure.browser.net.transmit.call(null,b,new cljs.core.Keyword(null, +"send-result","send-result",3729280372),clojure.browser.repl.evaluate_javascript.call(null,b,a))});return clojure.browser.net.connect.call(null,b,cljs.core.constantly.call(null,null),function(a){return a.style.display="none"})};clojure.browser.repl.client={};clojure.browser.repl.client.start=function(a){return goog.events.listen(window,"load",function(){return clojure.browser.repl.start_evaluator.call(null,a)})}; \ No newline at end of file diff --git a/repl/cljs/core.cljs b/repl/cljs/core.cljs new file mode 100644 index 0000000..970e539 --- /dev/null +++ b/repl/cljs/core.cljs @@ -0,0 +1,7754 @@ +; Copyright (c) Rich Hickey. All rights reserved. +; The use and distribution terms for this software are covered by the +; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +; which can be found in the file epl-v10.html at the root of this distribution. +; By using this software in any fashion, you are agreeing to be bound by +; the terms of this license. +; You must not remove this notice, or any other, from this software. + +(ns cljs.core + (:require [goog.string :as gstring] + [goog.string.StringBuffer :as gstringbuf] + [goog.object :as gobject] + [goog.array :as garray])) + +;; next line is auto-generated by the build-script - Do not edit! +(def *clojurescript-version* "0.0-2173") + +(def *unchecked-if* false) + +(def + ^{:doc "Each runtime environment provides a different way to print output. + Whatever function *print-fn* is bound to will be passed any + Strings which should be printed." :dynamic true} + *print-fn* + (fn [_] + (throw (js/Error. "No *print-fn* fn set for evaluation environment")))) + +(defn set-print-fn! + "Set *print-fn* to f." + [f] (set! *print-fn* f)) + +(def ^:dynamic *flush-on-newline* true) +(def ^:dynamic *print-newline* true) +(def ^:dynamic *print-readably* true) +(def ^:dynamic *print-meta* false) +(def ^:dynamic *print-dup* false) +(def ^:dynamic *print-length* nil) +(def ^:dynamic *print-level* nil) + +(defn- pr-opts [] + {:flush-on-newline *flush-on-newline* + :readably *print-readably* + :meta *print-meta* + :dup *print-dup* + :print-length *print-length*}) + +(declare into-array) + +(defn enable-console-print! + "Set *print-fn* to console.log" + [] + (set! *print-newline* false) + (set! *print-fn* + (fn [& args] + (.apply js/console.log js/console (into-array args))))) + +(def + ^{:doc "bound in a repl thread to the most recent value printed"} + *1) + +(def + ^{:doc "bound in a repl thread to the second most recent value printed"} + *2) + +(def + ^{:doc "bound in a repl thread to the third most recent value printed"} + *3) + +(defn truth_ + "Internal - do not use!" + [x] + (cljs.core/truth_ x)) + +(def not-native nil) + +(declare instance? Keyword) + +(defn ^boolean identical? + "Tests if 2 arguments are the same object" + [x y] + (cljs.core/identical? x y)) + +(defn ^boolean nil? + "Returns true if x is nil, false otherwise." + [x] + (coercive-= x nil)) + +(defn ^boolean array? [x] + (cljs.core/array? x)) + +(defn ^boolean number? [n] + (cljs.core/number? n)) + +(defn ^boolean not + "Returns true if x is logical false, false otherwise." + [x] (if x false true)) + +(defn ^boolean object? [x] + (if-not (nil? x) + (identical? (.-constructor x) js/Object) + false)) + +(defn ^boolean string? [x] + (goog/isString x)) + +(set! *unchecked-if* true) +(defn ^boolean native-satisfies? + "Internal - do not use!" + [p x] + (let [x (if (nil? x) nil x)] + (cond + (aget p (goog.typeOf x)) true + (aget p "_") true + :else false))) +(set! *unchecked-if* false) + +(defn is_proto_ + [x] + (identical? (.-prototype (.-constructor x)) x)) + +(def + ^{:doc "When compiled for a command-line target, whatever + function *main-fn* is set to will be called with the command-line + argv as arguments"} + *main-cli-fn* nil) + +(defn type [x] + (when-not (nil? x) + (.-constructor x))) + +(defn missing-protocol [proto obj] + (let [ty (type obj) + ty (if (and ty (.-cljs$lang$type ty)) + (.-cljs$lang$ctorStr ty) + (goog/typeOf obj))] + (js/Error. + (.join (array "No protocol method " proto + " defined for type " ty ": " obj) "")))) + +(defn type->str [ty] + (if-let [s (.-cljs$lang$ctorStr ty)] + s + (str ty))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; arrays ;;;;;;;;;;;;;;;; + +(defn ^array make-array + ([size] + (js/Array. size)) + ([type size] + (make-array size))) + +(defn aclone + "Returns a javascript array, cloned from the passed in array" + [arr] + (let [len (alength arr) + new-arr (make-array len)] + (dotimes [i len] + (aset new-arr i (aget arr i))) + new-arr)) + +(defn ^array array + "Creates a new javascript array. +@param {...*} var_args" ;;array is a special case, don't emulate this doc string + [var-args] ;; [& items] + (.call (.-slice (.-prototype js/Array)) (cljs.core/js-arguments))) + +(declare apply) + +(defn aget + "Returns the value at the index." + ([array i] + (cljs.core/aget array i)) + ([array i & idxs] + (apply aget (aget array i) idxs))) + +(defn aset + "Sets the value at the index." + ([array i val] + (cljs.core/aset array i val)) + ([array idx idx2 & idxv] + (apply aset (aget array idx) idx2 idxv))) + +(defn ^number alength + "Returns the length of the array. Works on arrays of all types." + [array] + (cljs.core/alength array)) + +(declare reduce) + +(defn ^array into-array + ([aseq] + (into-array nil aseq)) + ([type aseq] + (reduce (fn [a x] (.push a x) a) (array) aseq))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;; core protocols ;;;;;;;;;;;;; + +(defprotocol Fn + "Marker protocol") + +(defprotocol IFn + (-invoke + [this] + [this a] + [this a b] + [this a b c] + [this a b c d] + [this a b c d e] + [this a b c d e f] + [this a b c d e f g] + [this a b c d e f g h] + [this a b c d e f g h i] + [this a b c d e f g h i j] + [this a b c d e f g h i j k] + [this a b c d e f g h i j k l] + [this a b c d e f g h i j k l m] + [this a b c d e f g h i j k l m n] + [this a b c d e f g h i j k l m n o] + [this a b c d e f g h i j k l m n o p] + [this a b c d e f g h i j k l m n o p q] + [this a b c d e f g h i j k l m n o p q s] + [this a b c d e f g h i j k l m n o p q s t] + [this a b c d e f g h i j k l m n o p q s t rest])) + +(defprotocol ICloneable + (^clj -clone [value])) + +(defprotocol ICounted + (^number -count [coll] "constant time count")) + +(defprotocol IEmptyableCollection + (-empty [coll])) + +(defprotocol ICollection + (^clj -conj [coll o])) + +#_(defprotocol IOrdinal + (-index [coll])) + +(defprotocol IIndexed + (-nth [coll n] [coll n not-found])) + +(defprotocol ASeq) + +(defprotocol ISeq + (-first [coll]) + (^clj -rest [coll])) + +(defprotocol INext + (^clj-or-nil -next [coll])) + +(defprotocol ILookup + (-lookup [o k] [o k not-found])) + +(defprotocol IAssociative + (^boolean -contains-key? [coll k]) + #_(-entry-at [coll k]) + (^clj -assoc [coll k v])) + +(defprotocol IMap + #_(-assoc-ex [coll k v]) + (^clj -dissoc [coll k])) + +(defprotocol IMapEntry + (-key [coll]) + (-val [coll])) + +(defprotocol ISet + (^clj -disjoin [coll v])) + +(defprotocol IStack + (-peek [coll]) + (^clj -pop [coll])) + +(defprotocol IVector + (^clj -assoc-n [coll n val])) + +(defprotocol IDeref + (-deref [o])) + +(defprotocol IDerefWithTimeout + (-deref-with-timeout [o msec timeout-val])) + +(defprotocol IMeta + (^clj-or-nil -meta [o])) + +(defprotocol IWithMeta + (^clj -with-meta [o meta])) + +(defprotocol IReduce + (-reduce [coll f] [coll f start])) + +(defprotocol IKVReduce + (-kv-reduce [coll f init])) + +(defprotocol IEquiv + (^boolean -equiv [o other])) + +(defprotocol IHash + (-hash [o])) + +(defprotocol ISeqable + (^clj-or-nil -seq [o])) + +(defprotocol ISequential + "Marker interface indicating a persistent collection of sequential items") + +(defprotocol IList + "Marker interface indicating a persistent list") + +(defprotocol IRecord + "Marker interface indicating a record object") + +(defprotocol IReversible + (^clj -rseq [coll])) + +(defprotocol ISorted + (^clj -sorted-seq [coll ascending?]) + (^clj -sorted-seq-from [coll k ascending?]) + (-entry-key [coll entry]) + (-comparator [coll])) + +(defprotocol IWriter + (-write [writer s]) + (-flush [writer])) + +(defprotocol IPrintWithWriter + "The old IPrintable protocol's implementation consisted of building a giant + list of strings to concatenate. This involved lots of concat calls, + intermediate vectors, and lazy-seqs, and was very slow in some older JS + engines. IPrintWithWriter implements printing via the IWriter protocol, so it + be implemented efficiently in terms of e.g. a StringBuffer append." + (-pr-writer [o writer opts])) + +(defprotocol IPending + (^boolean -realized? [d])) + +(defprotocol IWatchable + (-notify-watches [this oldval newval]) + (-add-watch [this key f]) + (-remove-watch [this key])) + +(defprotocol IEditableCollection + (^clj -as-transient [coll])) + +(defprotocol ITransientCollection + (^clj -conj! [tcoll val]) + (^clj -persistent! [tcoll])) + +(defprotocol ITransientAssociative + (^clj -assoc! [tcoll key val])) + +(defprotocol ITransientMap + (^clj -dissoc! [tcoll key])) + +(defprotocol ITransientVector + (^clj -assoc-n! [tcoll n val]) + (^clj -pop! [tcoll])) + +(defprotocol ITransientSet + (^clj -disjoin! [tcoll v])) + +(defprotocol IComparable + (^number -compare [x y])) + +(defprotocol IChunk + (-drop-first [coll])) + +(defprotocol IChunkedSeq + (-chunked-first [coll]) + (-chunked-rest [coll])) + +(defprotocol IChunkedNext + (-chunked-next [coll])) + +(defprotocol INamed + (^string -name [x]) + (^string -namespace [x])) + +;; Printing support + +(deftype StringBufferWriter [sb] + IWriter + (-write [_ s] (.append sb s)) + (-flush [_] nil)) + +(defn pr-str* + "Support so that collections can implement toString without + loading all the printing machinery." + [^not-native obj] + (let [sb (gstring/StringBuffer.) + writer (StringBufferWriter. sb)] + (-pr-writer obj writer (pr-opts)) + (-flush writer) + (str sb))) + +;;;;;;;;;;;;;;;;;;; symbols ;;;;;;;;;;;;;;; + +(declare list hash-combine hash Symbol = compare) + +(defn ^boolean instance? [t o] + (cljs.core/instance? t o)) + +(defn ^boolean symbol? [x] + (instance? Symbol x)) + +(defn- hash-symbol [sym] + (hash-combine (hash (.-ns sym)) (hash (.-name sym)))) + +(defn- compare-symbols [a b] + (cond + (= a b) 0 + (and (not (.-ns a)) (.-ns b)) -1 + (.-ns a) (if-not (.-ns b) + 1 + (let [nsc (compare (.-ns a) (.-ns b))] + (if (zero? nsc) + (compare (.-name a) (.-name b)) + nsc))) + :default (compare (.-name a) (.-name b)))) + +(deftype Symbol [ns name str ^:mutable _hash _meta] + Object + (toString [_] str) + IEquiv + (-equiv [_ other] + (if (instance? Symbol other) + (identical? str (.-str other)) + false)) + IFn + (-invoke [sym coll] + (-lookup coll sym nil)) + (-invoke [sym coll not-found] + (-lookup coll sym not-found)) + IMeta + (-meta [_] _meta) + IWithMeta + (-with-meta [_ new-meta] (Symbol. ns name str _hash new-meta)) + IHash + (-hash [sym] + (caching-hash sym hash-symbol _hash)) + INamed + (-name [_] name) + (-namespace [_] ns) + IPrintWithWriter + (-pr-writer [o writer _] (-write writer str))) + +(defn symbol + ([name] + (if (symbol? name) + name + (symbol nil name))) + ([ns name] + (let [sym-str (if-not (nil? ns) + (str ns "/" name) + name)] + (Symbol. ns name sym-str nil nil)))) + +;;;;;;;;;;;;;;;;;;; fundamentals ;;;;;;;;;;;;;;; + +(declare array-seq prim-seq IndexedSeq) + +(defn clone [value] + (-clone value)) + +(defn cloneable? [value] + (satisfies? ICloneable value)) + +(defn ^seq seq + "Returns a seq on the collection. If the collection is + empty, returns nil. (seq nil) returns nil. seq also works on + Strings." + [coll] + (when-not (nil? coll) + (cond + (implements? ISeqable coll) + (-seq ^not-native coll) + + (array? coll) + (when-not (zero? (alength coll)) + (IndexedSeq. coll 0)) + + (string? coll) + (when-not (zero? (alength coll)) + (IndexedSeq. coll 0)) + + (native-satisfies? ISeqable coll) + (-seq coll) + + :else (throw (js/Error. (str coll "is not ISeqable")))))) + +(defn first + "Returns the first item in the collection. Calls seq on its + argument. If coll is nil, returns nil." + [coll] + (when-not (nil? coll) + (if (implements? ISeq coll) + (-first ^not-native coll) + (let [s (seq coll)] + (when-not (nil? s) + (-first s)))))) + +(defn ^seq rest + "Returns a possibly empty seq of the items after the first. Calls seq on its + argument." + [coll] + (if-not (nil? coll) + (if (implements? ISeq coll) + (-rest ^not-native coll) + (let [s (seq coll)] + (if s + (-rest ^not-native s) + ()))) + ())) + +(defn ^seq next + "Returns a seq of the items after the first. Calls seq on its + argument. If there are no more items, returns nil" + [coll] + (when-not (nil? coll) + (if (implements? INext coll) + (-next ^not-native coll) + (seq (rest coll))))) + +(defn ^boolean = + "Equality. Returns true if x equals y, false if not. Compares + numbers and collections in a type-independent manner. Clojure's immutable data + structures define -equiv (and thus =) as a value, not an identity, + comparison." + ([x] true) + ([x y] + (if (nil? x) + (nil? y) + (or (identical? x y) + ^boolean (-equiv x y)))) + ([x y & more] + (if (= x y) + (if (next more) + (recur y (first more) (next more)) + (= y (first more))) + false))) + +;;;;;;;;;;;;;;;;;;; protocols on primitives ;;;;;;;; +(declare hash-map list equiv-sequential) + +(extend-type nil + ICounted + (-count [_] 0)) + +;; TODO: we should remove this and handle date equality checking +;; by some other means, probably by adding a new primitive type +;; case to the hash table lookup - David + +(extend-type js/Date + IEquiv + (-equiv [o other] + (and (instance? js/Date other) + (identical? (.toString o) (.toString other))))) + +(extend-type number + IEquiv + (-equiv [x o] (identical? x o))) + +(declare with-meta) + +(extend-type function + Fn + IMeta + (-meta [_] nil)) + +(extend-type default + IHash + (-hash [o] + (goog/getUid o))) + +;;this is primitive because & emits call to array-seq +(defn inc + "Returns a number one greater than num." + [x] (cljs.core/+ x 1)) + +(declare deref) + +(deftype Reduced [val] + IDeref + (-deref [o] val)) + +(defn reduced + "Wraps x in a way such that a reduce will terminate with the value x" + [x] + (Reduced. x)) + +(defn ^boolean reduced? + "Returns true if x is the result of a call to reduced" + [r] + (instance? Reduced r)) + +(defn- ci-reduce + "Accepts any collection which satisfies the ICount and IIndexed protocols and +reduces them without incurring seq initialization" + ([cicoll f] + (let [cnt (-count cicoll)] + (if (zero? cnt) + (f) + (loop [val (-nth cicoll 0), n 1] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + ([cicoll f val] + (let [cnt (-count cicoll)] + (loop [val val, n 0] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val)))) + ([cicoll f val idx] + (let [cnt (-count cicoll)] + (loop [val val, n idx] + (if (< n cnt) + (let [nval (f val (-nth cicoll n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + +(defn- array-reduce + ([arr f] + (let [cnt (alength arr)] + (if (zero? (alength arr)) + (f) + (loop [val (aget arr 0), n 1] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + ([arr f val] + (let [cnt (alength arr)] + (loop [val val, n 0] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val)))) + ([arr f val idx] + (let [cnt (alength arr)] + (loop [val val, n idx] + (if (< n cnt) + (let [nval (f val (aget arr n))] + (if (reduced? nval) + @nval + (recur nval (inc n)))) + val))))) + +(declare hash-coll cons RSeq) + +(defn ^boolean counted? + "Returns true if coll implements count in constant time" + [x] (satisfies? ICounted x)) + +(defn ^boolean indexed? + "Returns true if coll implements nth in constant time" + [x] (satisfies? IIndexed x)) + +(deftype IndexedSeq [arr i] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (IndexedSeq. arr i)) + + ISeqable + (-seq [this] this) + + ASeq + ISeq + (-first [_] (aget arr i)) + (-rest [_] (if (< (inc i) (alength arr)) + (IndexedSeq. arr (inc i)) + (list))) + + INext + (-next [_] (if (< (inc i) (alength arr)) + (IndexedSeq. arr (inc i)) + nil)) + + ICounted + (-count [_] (- (alength arr) i)) + + IIndexed + (-nth [coll n] + (let [i (+ n i)] + (when (< i (alength arr)) + (aget arr i)))) + (-nth [coll n not-found] + (let [i (+ n i)] + (if (< i (alength arr)) + (aget arr i) + not-found))) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] cljs.core.List.EMPTY) + + IReduce + (-reduce [coll f] + (array-reduce arr f (aget arr i) (inc i))) + (-reduce [coll f start] + (array-reduce arr f start i)) + + IHash + (-hash [coll] (hash-coll coll)) + + IReversible + (-rseq [coll] + (let [c (-count coll)] + (if (pos? c) + (RSeq. coll (dec c) nil))))) + +(defn prim-seq + ([prim] + (prim-seq prim 0)) + ([prim i] + (when (< i (alength prim)) + (IndexedSeq. prim i)))) + +(defn array-seq + ([array] + (prim-seq array 0)) + ([array i] + (prim-seq array i))) + +(declare with-meta seq-reduce) + +(deftype RSeq [ci i meta] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (RSeq. ci i meta)) + + IMeta + (-meta [coll] meta) + IWithMeta + (-with-meta [coll new-meta] + (RSeq. ci i new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ISeq + (-first [coll] + (-nth ci i)) + (-rest [coll] + (if (pos? i) + (RSeq. ci (dec i) nil))) + + ICounted + (-count [coll] (inc i)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + IReduce + (-reduce [col f] (seq-reduce f col)) + (-reduce [col f start] (seq-reduce f start col))) + +(defn second + "Same as (first (next x))" + [coll] + (first (next coll))) + +(defn ffirst + "Same as (first (first x))" + [coll] + (first (first coll))) + +(defn nfirst + "Same as (next (first x))" + [coll] + (next (first coll))) + +(defn fnext + "Same as (first (next x))" + [coll] + (first (next coll))) + +(defn nnext + "Same as (next (next x))" + [coll] + (next (next coll))) + +(defn last + "Return the last item in coll, in linear time" + [s] + (let [sn (next s)] + (if-not (nil? sn) + (recur sn) + (first s)))) + +(extend-type default + IEquiv + (-equiv [x o] (identical? x o))) + +(defn conj + "conj[oin]. Returns a new collection with the xs + 'added'. (conj nil item) returns (item). The 'addition' may + happen at different 'places' depending on the concrete type." + ([coll x] + (if-not (nil? coll) + (-conj coll x) + (list x))) + ([coll x & xs] + (if xs + (recur (conj coll x) (first xs) (next xs)) + (conj coll x)))) + +(defn empty + "Returns an empty collection of the same category as coll, or nil" + [coll] + (when-not (nil? coll) + (-empty coll))) + +(defn- accumulating-seq-count [coll] + (loop [s (seq coll) acc 0] + (if (counted? s) ; assumes nil is counted, which it currently is + (+ acc (-count s)) + (recur (next s) (inc acc))))) + +(defn count + "Returns the number of items in the collection. (count nil) returns + 0. Also works on strings, arrays, and Maps" + [coll] + (if-not (nil? coll) + (cond + (implements? ICounted coll) + (-count ^not-native coll) + + (array? coll) + (alength coll) + + (string? coll) + (alength coll) + + (native-satisfies? ICounted coll) + (-count coll) + + :else (accumulating-seq-count coll)) + 0)) + +(defn- linear-traversal-nth + ([coll n] + (cond + (nil? coll) (throw (js/Error. "Index out of bounds")) + (zero? n) (if (seq coll) + (first coll) + (throw (js/Error. "Index out of bounds"))) + (indexed? coll) (-nth coll n) + (seq coll) (recur (next coll) (dec n)) + :else (throw (js/Error. "Index out of bounds")))) + ([coll n not-found] + (cond + (nil? coll) not-found + (zero? n) (if (seq coll) + (first coll) + not-found) + (indexed? coll) (-nth coll n not-found) + (seq coll) (recur (next coll) (dec n) not-found) + :else not-found))) + +(defn nth + "Returns the value at the index. get returns nil if index out of + bounds, nth throws an exception unless not-found is supplied. nth + also works for strings, arrays, regex Matchers and Lists, and, + in O(n) time, for sequences." + ([coll n] + (when-not (nil? coll) + (cond + (implements? IIndexed coll) + (-nth ^not-native coll n) + + (array? coll) + (when (< n (.-length coll)) + (aget coll n)) + + (string? coll) + (when (< n (.-length coll)) + (aget coll n)) + + (native-satisfies? IIndexed coll) + (-nth coll n) + + :else + (if (satisfies? ISeq coll) + (linear-traversal-nth coll n) + (throw + (js/Error. + (str "nth not supported on this type " + (type->str (type coll))))))))) + ([coll n not-found] + (if-not (nil? coll) + (cond + (implements? IIndexed coll) + (-nth ^not-native coll n not-found) + + (array? coll) + (if (< n (.-length coll)) + (aget coll n) + not-found) + + (string? coll) + (if (< n (.-length coll)) + (aget coll n) + not-found) + + (native-satisfies? IIndexed coll) + (-nth coll n) + + :else + (if (satisfies? ISeq coll) + (linear-traversal-nth coll n not-found) + (throw + (js/Error. + (str "nth not supported on this type " + (type->str (type coll))))))) + not-found))) + +(defn get + "Returns the value mapped to key, not-found or nil if key not present." + ([o k] + (when-not (nil? o) + (cond + (implements? ILookup o) + (-lookup ^not-native o k) + + (array? o) + (when (< k (.-length o)) + (aget o k)) + + (string? o) + (when (< k (.-length o)) + (aget o k)) + + (native-satisfies? ILookup o) + (-lookup o k) + + :else nil))) + ([o k not-found] + (if-not (nil? o) + (cond + (implements? ILookup o) + (-lookup ^not-native o k not-found) + + (array? o) + (if (< k (.-length o)) + (aget o k) + not-found) + + (string? o) + (if (< k (.-length o)) + (aget o k) + not-found) + + (native-satisfies? ILookup o) + (-lookup o k not-found) + + :else not-found) + not-found))) + +(defn assoc + "assoc[iate]. When applied to a map, returns a new map of the + same (hashed/sorted) type, that contains the mapping of key(s) to + val(s). When applied to a vector, returns a new vector that + contains val at index." + ([coll k v] + (if-not (nil? coll) + (-assoc coll k v) + (hash-map k v))) + ([coll k v & kvs] + (let [ret (assoc coll k v)] + (if kvs + (recur ret (first kvs) (second kvs) (nnext kvs)) + ret)))) + +(defn dissoc + "dissoc[iate]. Returns a new map of the same (hashed/sorted) type, + that does not contain a mapping for key(s)." + ([coll] coll) + ([coll k] + (when-not (nil? coll) + (-dissoc coll k))) + ([coll k & ks] + (when-not (nil? coll) + (let [ret (dissoc coll k)] + (if ks + (recur ret (first ks) (next ks)) + ret))))) + +(defn ^boolean fn? [f] + (or ^boolean (goog/isFunction f) (satisfies? Fn f))) + +(defn with-meta + "Returns an object of the same type and value as obj, with + map m as its metadata." + [o meta] + (if (and (fn? o) (not (satisfies? IWithMeta o))) + (with-meta + (reify + Fn + IFn + (-invoke [_ & args] + (apply o args))) + meta) + (when-not (nil? o) + (-with-meta o meta)))) + +(defn meta + "Returns the metadata of obj, returns nil if there is no metadata." + [o] + (when (and (not (nil? o)) + (satisfies? IMeta o)) + (-meta o))) + +(defn peek + "For a list or queue, same as first, for a vector, same as, but much + more efficient than, last. If the collection is empty, returns nil." + [coll] + (when-not (nil? coll) + (-peek coll))) + +(defn pop + "For a list or queue, returns a new list/queue without the first + item, for a vector, returns a new vector without the last item. + Note - not the same as next/butlast." + [coll] + (when-not (nil? coll) + (-pop coll))) + +(defn disj + "disj[oin]. Returns a new set of the same (hashed/sorted) type, that + does not contain key(s)." + ([coll] coll) + ([coll k] + (when-not (nil? coll) + (-disjoin coll k))) + ([coll k & ks] + (when-not (nil? coll) + (let [ret (disj coll k)] + (if ks + (recur ret (first ks) (next ks)) + ret))))) + +;; Simple caching of string hashcode +(def string-hash-cache (js-obj)) +(def string-hash-cache-count 0) + +(defn add-to-string-hash-cache [k] + (let [h (goog.string/hashCode k)] + (aset string-hash-cache k h) + (set! string-hash-cache-count (inc string-hash-cache-count)) + h)) + +(defn check-string-hash-cache [k] + (when (> string-hash-cache-count 255) + (set! string-hash-cache (js-obj)) + (set! string-hash-cache-count 0)) + (let [h (aget string-hash-cache k)] + (if (number? h) + h + (add-to-string-hash-cache k)))) + +(defn hash [o] + (cond + (implements? IHash o) + (-hash ^not-native o) + + (number? o) + (js-mod (.floor js/Math o) 2147483647) + + (true? o) 1 + + (false? o) 0 + + (string? o) + (check-string-hash-cache o) + + (nil? o) 0 + + :else + (-hash o))) + +(defn ^boolean empty? + "Returns true if coll has no items - same as (not (seq coll)). + Please use the idiom (seq x) rather than (not (empty? x))" + [coll] (or (nil? coll) + (not (seq coll)))) + +(defn ^boolean coll? + "Returns true if x satisfies ICollection" + [x] + (if (nil? x) + false + (satisfies? ICollection x))) + +(defn ^boolean set? + "Returns true if x satisfies ISet" + [x] + (if (nil? x) + false + (satisfies? ISet x))) + +(defn ^boolean associative? + "Returns true if coll implements Associative" + [x] (satisfies? IAssociative x)) + +(defn ^boolean sequential? + "Returns true if coll satisfies ISequential" + [x] (satisfies? ISequential x)) + +(defn ^boolean sorted? + "Returns true if coll satisfies ISorted" + [x] (satisfies? ISorted x)) + +(defn ^boolean reduceable? + "Returns true if coll satisfies IReduce" + [x] (satisfies? IReduce x)) + +(defn ^boolean map? + "Return true if x satisfies IMap" + [x] + (if (nil? x) + false + (satisfies? IMap x))) + +(defn ^boolean vector? + "Return true if x satisfies IVector" + [x] (satisfies? IVector x)) + +(declare ChunkedCons ChunkedSeq) + +(defn ^boolean chunked-seq? + [x] (implements? IChunkedSeq x)) + +;;;;;;;;;;;;;;;;;;;; js primitives ;;;;;;;;;;;; +(defn js-obj + ([] + (cljs.core/js-obj)) + ([& keyvals] + (apply gobject/create keyvals))) + +(defn js-keys [obj] + (let [keys (array)] + (goog.object/forEach obj (fn [val key obj] (.push keys key))) + keys)) + +(defn js-delete [obj key] + (cljs.core/js-delete obj key)) + +(defn- array-copy + ([from i to j len] + (loop [i i j j len len] + (if (zero? len) + to + (do (aset to j (aget from i)) + (recur (inc i) (inc j) (dec len))))))) + +(defn- array-copy-downward + ([from i to j len] + (loop [i (+ i (dec len)) j (+ j (dec len)) len len] + (if (zero? len) + to + (do (aset to j (aget from i)) + (recur (dec i) (dec j) (dec len))))))) + +;;;;;;;;;;;;;;;; preds ;;;;;;;;;;;;;;;;;; + +(def ^:private lookup-sentinel (js-obj)) + +(defn ^boolean false? + "Returns true if x is the value false, false otherwise." + [x] (cljs.core/false? x)) + +(defn ^boolean true? + "Returns true if x is the value true, false otherwise." + [x] (cljs.core/true? x)) + +(defn ^boolean undefined? [x] + (cljs.core/undefined? x)) + +(defn ^boolean seq? + "Return true if s satisfies ISeq" + [s] + (if (nil? s) + false + (satisfies? ISeq s))) + +(defn ^boolean seqable? + "Return true if s satisfies ISeqable" + [s] + (satisfies? ISeqable s)) + +(defn ^boolean boolean [x] + (if x true false)) + +(defn ^boolean ifn? [f] + (or (fn? f) (satisfies? IFn f))) + +(defn ^boolean integer? + "Returns true if n is an integer." + [n] + (and (number? n) + (not ^boolean (js/isNaN n)) + (not (identical? n js/Infinity)) + (== (js/parseFloat n) (js/parseInt n 10)))) + +(defn ^boolean contains? + "Returns true if key is present in the given collection, otherwise + returns false. Note that for numerically indexed collections like + vectors and arrays, this tests if the numeric key is within the + range of indexes. 'contains?' operates constant or logarithmic time; + it will not perform a linear search for a value. See also 'some'." + [coll v] + (if (identical? (get coll v lookup-sentinel) lookup-sentinel) + false + true)) + +(defn find + "Returns the map entry for key, or nil if key not present." + [coll k] + (when (and (not (nil? coll)) + (associative? coll) + (contains? coll k)) + [k (get coll k)])) + +(defn ^boolean distinct? + "Returns true if no two of the arguments are =" + ([x] true) + ([x y] (not (= x y))) + ([x y & more] + (if (not (= x y)) + (loop [s #{x y} xs more] + (let [x (first xs) + etc (next xs)] + (if xs + (if (contains? s x) + false + (recur (conj s x) etc)) + true))) + false))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Seq fns ;;;;;;;;;;;;;;;; + +(defn ^seq sequence + "Coerces coll to a (possibly empty) sequence, if it is not already + one. Will not force a lazy seq. (sequence nil) yields ()" + [coll] + (if (seq? coll) + coll + (or (seq coll) ()))) + +(defn ^number compare + "Comparator. Returns a negative number, zero, or a positive number + when x is logically 'less than', 'equal to', or 'greater than' + y. Uses IComparable if available and google.array.defaultCompare for objects + of the same type and special-cases nil to be less than any other object." + [x y] + (cond + (identical? x y) 0 + + (nil? x) -1 + + (nil? y) 1 + + (identical? (type x) (type y)) + (if (implements? IComparable x) + (-compare ^not-native x y) + (garray/defaultCompare x y)) + + :else + (throw (js/Error. "compare on non-nil objects of different types")))) + +(defn ^:private compare-indexed + "Compare indexed collection." + ([xs ys] + (let [xl (count xs) + yl (count ys)] + (cond + (< xl yl) -1 + (> xl yl) 1 + :else (compare-indexed xs ys xl 0)))) + ([xs ys len n] + (let [d (compare (nth xs n) (nth ys n))] + (if (and (zero? d) (< (+ n 1) len)) + (recur xs ys len (inc n)) + d)))) + +(defn ^:private fn->comparator + "Given a fn that might be boolean valued or a comparator, + return a fn that is a comparator." + [f] + (if (= f compare) + compare + (fn [x y] + (let [r (f x y)] + (if (number? r) + r + (if r + -1 + (if (f y x) 1 0))))))) + +(declare to-array) + +(defn sort + "Returns a sorted sequence of the items in coll. Comp can be + boolean-valued comparison funcion, or a -/0/+ valued comparator. + Comp defaults to compare." + ([coll] + (sort compare coll)) + ([comp coll] + (if (seq coll) + (let [a (to-array coll)] + ;; matching Clojure's stable sort, though docs don't promise it + (garray/stableSort a (fn->comparator comp)) + (seq a)) + ()))) + +(defn sort-by + "Returns a sorted sequence of the items in coll, where the sort + order is determined by comparing (keyfn item). Comp can be + boolean-valued comparison funcion, or a -/0/+ valued comparator. + Comp defaults to compare." + ([keyfn coll] + (sort-by keyfn compare coll)) + ([keyfn comp coll] + (sort (fn [x y] ((fn->comparator comp) (keyfn x) (keyfn y))) coll))) + +; simple reduce based on seqs, used as default +(defn- seq-reduce + ([f coll] + (if-let [s (seq coll)] + (reduce f (first s) (next s)) + (f))) + ([f val coll] + (loop [val val, coll (seq coll)] + (if coll + (let [nval (f val (first coll))] + (if (reduced? nval) + @nval + (recur nval (next coll)))) + val)))) + +(declare vec) + +(defn shuffle + "Return a random permutation of coll" + [coll] + (let [a (to-array coll)] + (garray/shuffle a) + (vec a))) + +(defn reduce + "f should be a function of 2 arguments. If val is not supplied, + returns the result of applying f to the first 2 items in coll, then + applying f to that result and the 3rd item, etc. If coll contains no + items, f must accept no arguments as well, and reduce returns the + result of calling f with no arguments. If coll has only 1 item, it + is returned and f is not called. If val is supplied, returns the + result of applying f to val and the first item in coll, then + applying f to that result and the 2nd item, etc. If coll contains no + items, returns val and f is not called." + ([f coll] + (cond + (implements? IReduce coll) + (-reduce ^not-native coll f) + + (array? coll) + (array-reduce coll f) + + (string? coll) + (array-reduce coll f) + + (native-satisfies? IReduce coll) + (-reduce coll f) + + :else + (seq-reduce f coll))) + ([f val coll] + (cond + (implements? IReduce coll) + (-reduce ^not-native coll f val) + + (array? coll) + (array-reduce coll f val) + + (string? coll) + (array-reduce coll f val) + + (native-satisfies? IReduce coll) + (-reduce coll f val) + + :else + (seq-reduce f val coll)))) + +(defn reduce-kv + "Reduces an associative collection. f should be a function of 3 + arguments. Returns the result of applying f to init, the first key + and the first value in coll, then applying f to that result and the + 2nd key and value, etc. If coll contains no entries, returns init + and f is not called. Note that reduce-kv is supported on vectors, + where the keys will be the ordinals." + ([f init coll] + (if-not (nil? coll) + (-kv-reduce coll f init) + init))) + +;;; Math - variadic forms will not work until the following implemented: +;;; first, next, reduce + +(defn ^number + + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/+ x y)) + ([x y & more] + (reduce + (cljs.core/+ x y) more))) + +(defn ^number - + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/- x)) + ([x y] (cljs.core/- x y)) + ([x y & more] (reduce - (cljs.core/- x y) more))) + +(defn ^number * + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/* x y)) + ([x y & more] (reduce * (cljs.core/* x y) more))) + +(declare divide) + +(defn ^number / + "If no denominators are supplied, returns 1/numerator, + else returns numerator divided by all of the denominators." + ([x] (/ 1 x)) + ([x y] (cljs.core/divide x y)) ;; FIXME: waiting on cljs.core// + ([x y & more] (reduce / (/ x y) more))) + +(defn ^boolean < + "Returns non-nil if nums are in monotonically increasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/< x y)) + ([x y & more] + (if (cljs.core/< x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/< y (first more))) + false))) + +(defn ^boolean <= + "Returns non-nil if nums are in monotonically non-decreasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/<= x y)) + ([x y & more] + (if (cljs.core/<= x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/<= y (first more))) + false))) + +(defn ^boolean > + "Returns non-nil if nums are in monotonically decreasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/> x y)) + ([x y & more] + (if (cljs.core/> x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/> y (first more))) + false))) + +(defn ^boolean >= + "Returns non-nil if nums are in monotonically non-increasing order, + otherwise false." + ([x] true) + ([x y] (cljs.core/>= x y)) + ([x y & more] + (if (cljs.core/>= x y) + (if (next more) + (recur y (first more) (next more)) + (cljs.core/>= y (first more))) + false))) + +(defn dec + "Returns a number one less than num." + [x] (- x 1)) + +(defn ^number max + "Returns the greatest of the nums." + ([x] x) + ([x y] (cljs.core/max x y)) + ([x y & more] + (reduce max (cljs.core/max x y) more))) + +(defn ^number min + "Returns the least of the nums." + ([x] x) + ([x y] (cljs.core/min x y)) + ([x y & more] + (reduce min (cljs.core/min x y) more))) + +(defn ^number byte [x] x) + +(defn char + "Coerce to char" + [x] + (cond + (number? x) (.fromCharCode js/String x) + (and (string? x) (== (.-length x) 1)) x + :else (throw (js/Error. "Argument to char must be a character or number")))) + +(defn ^number short [x] x) +(defn ^number float [x] x) +(defn ^number double [x] x) + +(defn ^number unchecked-byte [x] x) +(defn ^number unchecked-char [x] x) +(defn ^number unchecked-short [x] x) +(defn ^number unchecked-float [x] x) +(defn ^number unchecked-double [x] x) + +(defn ^number unchecked-add + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/unchecked-add x y)) + ([x y & more] (reduce unchecked-add (cljs.core/unchecked-add x y) more))) + +(defn ^number unchecked-add-int + "Returns the sum of nums. (+) returns 0." + ([] 0) + ([x] x) + ([x y] (cljs.core/unchecked-add-int x y)) + ([x y & more] (reduce unchecked-add-int (cljs.core/unchecked-add-int x y) more))) + +(defn unchecked-dec [x] + (cljs.core/unchecked-dec x)) + +(defn unchecked-dec-int [x] + (cljs.core/unchecked-dec-int x)) + +(defn ^number unchecked-divide-int + "If no denominators are supplied, returns 1/numerator, + else returns numerator divided by all of the denominators." + ([x] (unchecked-divide-int 1 x)) + ([x y] (cljs.core/divide x y)) ;; FIXME: waiting on cljs.core// + ([x y & more] (reduce unchecked-divide-int (unchecked-divide-int x y) more))) + +(defn unchecked-inc [x] + (cljs.core/unchecked-inc x)) + +(defn unchecked-inc-int [x] + (cljs.core/unchecked-inc-int x)) + +(defn ^number unchecked-multiply + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/unchecked-multiply x y)) + ([x y & more] (reduce unchecked-multiply (cljs.core/unchecked-multiply x y) more))) + +(defn ^number unchecked-multiply-int + "Returns the product of nums. (*) returns 1." + ([] 1) + ([x] x) + ([x y] (cljs.core/unchecked-multiply-int x y)) + ([x y & more] (reduce unchecked-multiply-int (cljs.core/unchecked-multiply-int x y) more))) + +(defn unchecked-negate [x] + (cljs.core/unchecked-negate x)) + +(defn unchecked-negate-int [x] + (cljs.core/unchecked-negate-int x)) + +(declare mod) + +(defn unchecked-remainder-int [x n] + (cljs.core/unchecked-remainder-int x n)) + +(defn ^number unchecked-substract + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/unchecked-subtract x)) + ([x y] (cljs.core/unchecked-subtract x y)) + ([x y & more] (reduce unchecked-substract (cljs.core/unchecked-subtract x y) more))) + +(defn ^number unchecked-substract-int + "If no ys are supplied, returns the negation of x, else subtracts + the ys from x and returns the result." + ([x] (cljs.core/unchecked-subtract-int x)) + ([x y] (cljs.core/unchecked-subtract-int x y)) + ([x y & more] (reduce unchecked-substract-int (cljs.core/unchecked-subtract-int x y) more))) + +(defn- ^number fix [q] + (if (>= q 0) + (Math/floor q) + (Math/ceil q))) + +(defn int + "Coerce to int by stripping decimal places." + [x] + (bit-or x 0)) + +(defn unchecked-int + "Coerce to int by stripping decimal places." + [x] + (fix x)) + +(defn long + "Coerce to long by stripping decimal places. Identical to `int'." + [x] + (fix x)) + +(defn unchecked-long + "Coerce to long by stripping decimal places. Identical to `int'." + [x] + (fix x)) + +(defn booleans [x] x) +(defn bytes [x] x) +(defn chars [x] x) +(defn shorts [x] x) +(defn ints [x] x) +(defn floats [x] x) +(defn doubles [x] x) +(defn longs [x] x) + +(defn js-mod + "Modulus of num and div with original javascript behavior. i.e. bug for negative numbers" + [n d] + (cljs.core/js-mod n d)) + +(defn mod + "Modulus of num and div. Truncates toward negative infinity." + [n d] + (js-mod (+ (js-mod n d) d) d)) + +(defn quot + "quot[ient] of dividing numerator by denominator." + [n d] + (let [rem (js-mod n d)] + (fix (/ (- n rem) d)))) + +(defn rem + "remainder of dividing numerator by denominator." + [n d] + (let [q (quot n d)] + (- n (* d q)))) + +(defn ^number rand + "Returns a random floating point number between 0 (inclusive) and n (default 1) (exclusive)." + ([] (Math/random)) + ([n] (* n (rand)))) + +(defn rand-int + "Returns a random integer between 0 (inclusive) and n (exclusive)." + [n] (fix (rand n))) + +(defn bit-xor + "Bitwise exclusive or" + [x y] (cljs.core/bit-xor x y)) + +(defn bit-and + "Bitwise and" + [x y] (cljs.core/bit-and x y)) + +(defn bit-or + "Bitwise or" + [x y] (cljs.core/bit-or x y)) + +(defn bit-and-not + "Bitwise and" + [x y] (cljs.core/bit-and-not x y)) + +(defn bit-clear + "Clear bit at index n" + [x n] + (cljs.core/bit-clear x n)) + +(defn bit-flip + "Flip bit at index n" + [x n] + (cljs.core/bit-flip x n)) + +(defn bit-not + "Bitwise complement" + [x] (cljs.core/bit-not x)) + +(defn bit-set + "Set bit at index n" + [x n] + (cljs.core/bit-set x n)) + +(defn bit-test + "Test bit at index n" + [x n] + (cljs.core/bit-test x n)) + +(defn bit-shift-left + "Bitwise shift left" + [x n] (cljs.core/bit-shift-left x n)) + +(defn bit-shift-right + "Bitwise shift right" + [x n] (cljs.core/bit-shift-right x n)) + +(defn bit-shift-right-zero-fill + "DEPRECATED: Bitwise shift right with zero fill" + [x n] (cljs.core/bit-shift-right-zero-fill x n)) + +(defn unsigned-bit-shift-right + "Bitwise shift right with zero fill" + [x n] (cljs.core/unsigned-bit-shift-right x n)) + +(defn bit-count + "Counts the number of bits set in n" + [v] + (let [v (- v (bit-and (bit-shift-right v 1) 0x55555555)) + v (+ (bit-and v 0x33333333) (bit-and (bit-shift-right v 2) 0x33333333))] + (bit-shift-right (* (bit-and (+ v (bit-shift-right v 4)) 0xF0F0F0F) 0x1010101) 24))) + +(defn ^boolean == + "Returns non-nil if nums all have the equivalent + value, otherwise false. Behavior on non nums is + undefined." + ([x] true) + ([x y] (-equiv x y)) + ([x y & more] + (if (== x y) + (if (next more) + (recur y (first more) (next more)) + (== y (first more))) + false))) + +(defn ^boolean pos? + "Returns true if num is greater than zero, else false" + [n] (cljs.core/pos? n)) + +(defn ^boolean zero? [n] + (cljs.core/zero? n)) + +(defn ^boolean neg? + "Returns true if num is less than zero, else false" + [x] (cljs.core/neg? x)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; protocols for host types ;;;;;; + +(defn nthnext + "Returns the nth next of coll, (seq coll) when n is 0." + [coll n] + (loop [n n xs (seq coll)] + (if (and xs (pos? n)) + (recur (dec n) (next xs)) + xs))) + +;;;;;;;;;;;;;;;;;;;;;;;;;; basics ;;;;;;;;;;;;;;;;;; + +(defn str + "With no args, returns the empty string. With one arg x, returns + x.toString(). (str nil) returns the empty string. With more than + one arg, returns the concatenation of the str values of the args." + ([] "") + ([x] (if (nil? x) + "" + (.toString x))) + ([x & ys] + (loop [sb (gstring/StringBuffer. (str x)) more ys] + (if more + (recur (. sb (append (str (first more)))) (next more)) + (.toString sb))))) + +(defn subs + "Returns the substring of s beginning at start inclusive, and ending + at end (defaults to length of string), exclusive." + ([s start] (.substring s start)) + ([s start end] (.substring s start end))) + +(declare map name) + +(defn- equiv-sequential + "Assumes x is sequential. Returns true if x equals y, otherwise + returns false." + [x y] + (boolean + (when (sequential? y) + (loop [xs (seq x) ys (seq y)] + (cond (nil? xs) (nil? ys) + (nil? ys) false + (= (first xs) (first ys)) (recur (next xs) (next ys)) + :else false))))) + +(defn hash-combine [seed hash] + ; a la boost + (bit-xor seed (+ hash 0x9e3779b9 + (bit-shift-left seed 6) + (bit-shift-right seed 2)))) + +(defn- hash-coll [coll] + (if (seq coll) + (loop [res (hash (first coll)) s (next coll)] + (if (nil? s) + res + (recur (hash-combine res (hash (first s))) (next s)))) + 0)) + +(declare key val) + +(defn- hash-imap [m] + ;; a la clojure.lang.APersistentMap + (loop [h 0 s (seq m)] + (if s + (let [e (first s)] + (recur (js-mod (+ h (bit-xor (hash (key e)) (hash (val e)))) + 4503599627370496) + (next s))) + h))) + +(defn- hash-iset [s] + ;; a la clojure.lang.APersistentSet + (loop [h 0 s (seq s)] + (if s + (let [e (first s)] + (recur (js-mod (+ h (hash e)) 4503599627370496) + (next s))) + h))) + +(declare name chunk-first chunk-rest) + +(defn- extend-object! + "Takes a JavaScript object and a map of names to functions and + attaches said functions as methods on the object. Any references to + JavaScript's implict this (via the this-as macro) will resolve to the + object that the function is attached." + [obj fn-map] + (doseq [[key-name f] fn-map] + (let [str-name (name key-name)] + (aset obj str-name f))) + obj) + +;;;;;;;;;;;;;;;; cons ;;;;;;;;;;;;;;;; +(deftype List [meta first rest count ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IList + + ICloneable + (-clone [_] (List. meta first rest count __hash)) + + IWithMeta + (-with-meta [coll meta] (List. meta first rest count __hash)) + + IMeta + (-meta [coll] meta) + + ASeq + ISeq + (-first [coll] first) + (-rest [coll] + (if (== count 1) + () + rest)) + + INext + (-next [coll] + (if (== count 1) + nil + rest)) + + IStack + (-peek [coll] first) + (-pop [coll] (-rest coll)) + + ICollection + (-conj [coll o] (List. meta o coll (inc count) nil)) + + IEmptyableCollection + (-empty [coll] cljs.core.List.EMPTY) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] coll) + + ICounted + (-count [coll] count) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(deftype EmptyList [meta] + Object + (toString [coll] + (pr-str* coll)) + + IList + + ICloneable + (-clone [_] (EmptyList. meta)) + + IWithMeta + (-with-meta [coll meta] (EmptyList. meta)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] nil) + (-rest [coll] ()) + + INext + (-next [coll] nil) + + IStack + (-peek [coll] nil) + (-pop [coll] (throw (js/Error. "Can't pop empty list"))) + + ICollection + (-conj [coll o] (List. meta o nil 1 nil)) + + IEmptyableCollection + (-empty [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] 0) + + ISeqable + (-seq [coll] nil) + + ICounted + (-count [coll] 0) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(set! cljs.core.List.EMPTY (EmptyList. nil)) + +(defn ^boolean reversible? [coll] + (satisfies? IReversible coll)) + +(defn ^seq rseq [coll] + (-rseq coll)) + +(defn reverse + "Returns a seq of the items in coll in reverse order. Not lazy." + [coll] + (if (reversible? coll) + (rseq coll) + (reduce conj () coll))) + +(defn list [& xs] + (let [arr (if (and (instance? IndexedSeq xs) (zero? (.-i xs))) + (.-arr xs) + (let [arr (array)] + (loop [^not-native xs xs] + (if-not (nil? xs) + (do + (.push arr (-first xs)) + (recur (-next xs))) + arr))))] + (loop [i (alength arr) ^not-native r ()] + (if (> i 0) + (recur (dec i) (-conj r (aget arr (dec i)))) + r)))) + +(deftype Cons [meta first rest ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IList + + ICloneable + (-clone [_] (Cons. meta first rest __hash)) + + IWithMeta + (-with-meta [coll meta] (Cons. meta first rest __hash)) + + IMeta + (-meta [coll] meta) + + ASeq + ISeq + (-first [coll] first) + (-rest [coll] (if (nil? rest) () rest)) + + INext + (-next [coll] + (if (nil? rest) nil (seq rest))) + + ICollection + (-conj [coll o] (Cons. nil o coll __hash)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] coll) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn cons + "Returns a new seq where x is the first element and seq is the rest." + [x coll] + (if (or (nil? coll) + (implements? ISeq coll)) + (Cons. nil x coll nil) + (Cons. nil x (seq coll) nil))) + +(defn ^boolean list? [x] + (satisfies? IList x)) + +(deftype Keyword [ns name fqn ^:mutable _hash] + Object + (toString [_] (str ":" fqn)) + + IEquiv + (-equiv [_ other] + (if (instance? Keyword other) + (identical? fqn (.-fqn other)) + false)) + IFn + (-invoke [kw coll] + (get coll kw)) + (-invoke [kw coll not-found] + (get coll kw not-found)) + + IHash + (-hash [_] + ; This was checking if _hash == -1, should it stay that way? + (if (nil? _hash) + (do + (set! _hash (+ (hash-combine (hash ns) (hash name)) + 0x9e3779b9)) + _hash) + _hash)) + + INamed + (-name [_] name) + (-namespace [_] ns) + + IPrintWithWriter + (-pr-writer [o writer _] (-write writer (str ":" fqn)))) + +(defn ^boolean keyword? [x] + (instance? Keyword x)) + +(defn ^boolean keyword-identical? [x y] + (if (identical? x y) + true + (if (and (keyword? x) + (keyword? y)) + (identical? (.-fqn x) (.-fqn y)) + false))) + +(defn namespace + "Returns the namespace String of a symbol or keyword, or nil if not present." + [x] + (if (implements? INamed x) + (-namespace ^not-native x) + (throw (js/Error. (str "Doesn't support namespace: " x))))) + +(defn keyword + "Returns a Keyword with the given namespace and name. Do not use : + in the keyword strings, it will be added automatically." + ([name] (cond + (keyword? name) name + (symbol? name) (Keyword. + (cljs.core/namespace name) + (cljs.core/name name) (.-str name) nil) + (string? name) (let [parts (.split name "/")] + (if (== (alength parts) 2) + (Keyword. (aget parts 0) (aget parts 1) name nil) + (Keyword. nil (aget parts 0) name nil))))) + ([ns name] (Keyword. ns name (str (when ns (str ns "/")) name) nil))) + + +(deftype LazySeq [meta ^:mutable fn ^:mutable s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + (sval [coll] + (if (nil? fn) + s + (do + (set! s (fn)) + (set! fn nil) + s))) + + IWithMeta + (-with-meta [coll meta] (LazySeq. meta fn s __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] + (-seq coll) + (when-not (nil? s) + (first s))) + (-rest [coll] + (-seq coll) + (if-not (nil? s) + (rest s) + ())) + + INext + (-next [coll] + (-seq coll) + (when-not (nil? s) + (next s))) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (.sval coll) + (when-not (nil? s) + (loop [ls s] + (if (instance? LazySeq ls) + (recur (.sval ls)) + (do (set! s ls) + (seq s)))))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(declare ArrayChunk) + +(deftype ChunkBuffer [^:mutable buf ^:mutable end] + Object + (add [_ o] + (aset buf end o) + (set! end (inc end))) + + (chunk [_ o] + (let [ret (ArrayChunk. buf 0 end)] + (set! buf nil) + ret)) + + ICounted + (-count [_] end)) + +(defn chunk-buffer [capacity] + (ChunkBuffer. (make-array capacity) 0)) + +(deftype ArrayChunk [arr off end] + ICounted + (-count [_] (- end off)) + + IIndexed + (-nth [coll i] + (aget arr (+ off i))) + (-nth [coll i not-found] + (if (and (>= i 0) (< i (- end off))) + (aget arr (+ off i)) + not-found)) + + IChunk + (-drop-first [coll] + (if (== off end) + (throw (js/Error. "-drop-first of empty chunk")) + (ArrayChunk. arr (inc off) end))) + + IReduce + (-reduce [coll f] + (array-reduce arr f (aget arr off) (inc off))) + (-reduce [coll f start] + (array-reduce arr f start off))) + +(defn array-chunk + ([arr] + (ArrayChunk. arr 0 (alength arr))) + ([arr off] + (ArrayChunk. arr off (alength arr))) + ([arr off end] + (ArrayChunk. arr off end))) + +(deftype ChunkedCons [chunk more meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll m] + (ChunkedCons. chunk more m __hash)) + + IMeta + (-meta [coll] meta) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ISeqable + (-seq [coll] coll) + + ASeq + ISeq + (-first [coll] (-nth chunk 0)) + (-rest [coll] + (if (> (-count chunk) 1) + (ChunkedCons. (-drop-first chunk) more meta nil) + (if (nil? more) + () + more))) + + INext + (-next [coll] + (if (> (-count chunk) 1) + (ChunkedCons. (-drop-first chunk) more meta nil) + (let [more (-seq more)] + (when-not (nil? more) + more)))) + + IChunkedSeq + (-chunked-first [coll] chunk) + (-chunked-rest [coll] + (if (nil? more) + () + more)) + + IChunkedNext + (-chunked-next [coll] + (if (nil? more) + nil + more)) + + ICollection + (-conj [this o] + (cons o this)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash))) + +(defn chunk-cons [chunk rest] + (if (zero? (-count chunk)) + rest + (ChunkedCons. chunk rest nil nil))) + +(defn chunk-append [b x] + (.add b x)) + +(defn chunk [b] + (.chunk b)) + +(defn chunk-first [s] + (-chunked-first s)) + +(defn chunk-rest [s] + (-chunked-rest s)) + +(defn chunk-next [s] + (if (implements? IChunkedNext s) + (-chunked-next s) + (seq (-chunked-rest s)))) + +;;;;;;;;;;;;;;;; + +(defn to-array + "Naive impl of to-array as a start." + [s] + (let [ary (array)] + (loop [s s] + (if (seq s) + (do (. ary push (first s)) + (recur (next s))) + ary)))) + +(defn to-array-2d + "Returns a (potentially-ragged) 2-dimensional array + containing the contents of coll." + [coll] + (let [ret (make-array (count coll))] + (loop [i 0 xs (seq coll)] + (when xs + (aset ret i (to-array (first xs))) + (recur (inc i) (next xs)))) + ret)) + +(defn int-array + ([size-or-seq] + (if (number? size-or-seq) + (int-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn long-array + ([size-or-seq] + (if (number? size-or-seq) + (long-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn double-array + ([size-or-seq] + (if (number? size-or-seq) + (double-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn object-array + ([size-or-seq] + (if (number? size-or-seq) + (object-array size-or-seq nil) + (into-array size-or-seq))) + ([size init-val-or-seq] + (let [a (make-array size)] + (if (seq? init-val-or-seq) + (let [s (seq init-val-or-seq)] + (loop [i 0 s s] + (if (and s (< i size)) + (do + (aset a i (first s)) + (recur (inc i) (next s))) + a))) + (do + (dotimes [i size] + (aset a i init-val-or-seq)) + a))))) + +(defn- bounded-count [s n] + (if (counted? s) + (count s) + (loop [s s i n sum 0] + (if (and (pos? i) (seq s)) + (recur (next s) (dec i) (inc sum)) + sum)))) + +(defn spread + [arglist] + (cond + (nil? arglist) nil + (nil? (next arglist)) (seq (first arglist)) + :else (cons (first arglist) + (spread (next arglist))))) + +(defn concat + "Returns a lazy seq representing the concatenation of the elements in the supplied colls." + ([] (lazy-seq nil)) + ([x] (lazy-seq x)) + ([x y] + (lazy-seq + (let [s (seq x)] + (if s + (if (chunked-seq? s) + (chunk-cons (chunk-first s) (concat (chunk-rest s) y)) + (cons (first s) (concat (rest s) y))) + y)))) + ([x y & zs] + (let [cat (fn cat [xys zs] + (lazy-seq + (let [xys (seq xys)] + (if xys + (if (chunked-seq? xys) + (chunk-cons (chunk-first xys) + (cat (chunk-rest xys) zs)) + (cons (first xys) (cat (rest xys) zs))) + (when zs + (cat (first zs) (next zs)))))))] + (cat (concat x y) zs)))) + +(defn list* + "Creates a new list containing the items prepended to the rest, the + last of which will be treated as a sequence." + ([args] (seq args)) + ([a args] (cons a args)) + ([a b args] (cons a (cons b args))) + ([a b c args] (cons a (cons b (cons c args)))) + ([a b c d & more] + (cons a (cons b (cons c (cons d (spread more))))))) + + +;;; Transients + +(defn transient + "Returns a new, transient version of the collection, in constant time." + [coll] + (-as-transient coll)) + +(defn persistent! + "Returns a new, persistent version of the transient collection, in + constant time. The transient collection cannot be used after this + call, any such use will throw an exception." + [tcoll] + (-persistent! tcoll)) + +(defn conj! + "Adds x to the transient collection, and return coll. The 'addition' + may happen at different 'places' depending on the concrete type." + ([tcoll val] + (-conj! tcoll val)) + ([tcoll val & vals] + (let [ntcoll (-conj! tcoll val)] + (if vals + (recur ntcoll (first vals) (next vals)) + ntcoll)))) + +(defn assoc! + "When applied to a transient map, adds mapping of key(s) to + val(s). When applied to a transient vector, sets the val at index. + Note - index must be <= (count vector). Returns coll." + ([tcoll key val] + (-assoc! tcoll key val)) + ([tcoll key val & kvs] + (let [ntcoll (-assoc! tcoll key val)] + (if kvs + (recur ntcoll (first kvs) (second kvs) (nnext kvs)) + ntcoll)))) + +(defn dissoc! + "Returns a transient map that doesn't contain a mapping for key(s)." + ([tcoll key] + (-dissoc! tcoll key)) + ([tcoll key & ks] + (let [ntcoll (-dissoc! tcoll key)] + (if ks + (recur ntcoll (first ks) (next ks)) + ntcoll)))) + +(defn pop! + "Removes the last item from a transient vector. If + the collection is empty, throws an exception. Returns coll" + [tcoll] + (-pop! tcoll)) + +(defn disj! + "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that + does not contain key(s)." + ([tcoll val] + (-disjoin! tcoll val)) + ([tcoll val & vals] + (let [ntcoll (-disjoin! tcoll val)] + (if vals + (recur ntcoll (first vals) (next vals)) + ntcoll)))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; apply ;;;;;;;;;;;;;;;; + +;; see core.clj +(gen-apply-to) + +(set! *unchecked-if* true) +(defn apply + "Applies fn f to the argument list formed by prepending intervening arguments to args. + First cut. Not lazy. Needs to use emitted toApply." + ([f args] + (let [fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count args (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc args) + (.cljs$lang$applyTo f args))) + (.apply f f (to-array args))))) + ([f x args] + (let [arglist (list* x args) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist))))) + ([f x y args] + (let [arglist (list* x y args) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist))))) + ([f x y z args] + (let [arglist (list* x y z args) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist))))) + ([f a b c d & args] + (let [arglist (cons a (cons b (cons c (cons d (spread args))))) + fixed-arity (.-cljs$lang$maxFixedArity f)] + (if (.-cljs$lang$applyTo f) + (let [bc (bounded-count arglist (inc fixed-arity))] + (if (<= bc fixed-arity) + (apply-to f bc arglist) + (.cljs$lang$applyTo f arglist))) + (.apply f f (to-array arglist)))))) +(set! *unchecked-if* false) + +(defn vary-meta + "Returns an object of the same type and value as obj, with + (apply f (meta obj) args) as its metadata." + ([obj f] + (with-meta obj (f (meta obj)))) + ([obj f a] + (with-meta obj (f (meta obj) a))) + ([obj f a b] + (with-meta obj (f (meta obj) a b))) + ([obj f a b c] + (with-meta obj (f (meta obj) a b c))) + ([obj f a b c d] + (with-meta obj (f (meta obj) a b c d))) + ([obj f a b c d & args] + (with-meta obj (apply f (meta obj) a b c d args)))) + +(defn ^boolean not= + "Same as (not (= obj1 obj2))" + ([x] false) + ([x y] (not (= x y))) + ([x y & more] + (not (apply = x y more)))) + +(defn not-empty + "If coll is empty, returns nil, else coll" + [coll] (when (seq coll) coll)) + +(defn ^boolean every? + "Returns true if (pred x) is logical true for every x in coll, else + false." + [pred coll] + (cond + (nil? (seq coll)) true + (pred (first coll)) (recur pred (next coll)) + :else false)) + +(defn ^boolean not-every? + "Returns false if (pred x) is logical true for every x in + coll, else true." + [pred coll] (not (every? pred coll))) + +(defn some + "Returns the first logical true value of (pred x) for any x in coll, + else nil. One common idiom is to use a set as pred, for example + this will return :fred if :fred is in the sequence, otherwise nil: + (some #{:fred} coll)" + [pred coll] + (when (seq coll) + (or (pred (first coll)) (recur pred (next coll))))) + +(defn ^boolean not-any? + "Returns false if (pred x) is logical true for any x in coll, + else true." + [pred coll] (not (some pred coll))) + +(defn ^boolean even? + "Returns true if n is even, throws an exception if n is not an integer" + [n] (if (integer? n) + (zero? (bit-and n 1)) + (throw (js/Error. (str "Argument must be an integer: " n))))) + +(defn ^boolean odd? + "Returns true if n is odd, throws an exception if n is not an integer" + [n] (not (even? n))) + +(defn identity [x] x) + +(defn ^boolean complement + "Takes a fn f and returns a fn that takes the same arguments as f, + has the same effects, if any, and returns the opposite truth value." + [f] + (fn + ([] (not (f))) + ([x] (not (f x))) + ([x y] (not (f x y))) + ([x y & zs] (not (apply f x y zs))))) + +(defn constantly + "Returns a function that takes any number of arguments and returns x." + [x] (fn [& args] x)) + +(defn comp + "Takes a set of functions and returns a fn that is the composition + of those fns. The returned fn takes a variable number of args, + applies the rightmost of fns to the args, the next + fn (right-to-left) to the result, etc." + ([] identity) + ([f] f) + ([f g] + (fn + ([] (f (g))) + ([x] (f (g x))) + ([x y] (f (g x y))) + ([x y z] (f (g x y z))) + ([x y z & args] (f (apply g x y z args))))) + ([f g h] + (fn + ([] (f (g (h)))) + ([x] (f (g (h x)))) + ([x y] (f (g (h x y)))) + ([x y z] (f (g (h x y z)))) + ([x y z & args] (f (g (apply h x y z args)))))) + ([f1 f2 f3 & fs] + (let [fs (reverse (list* f1 f2 f3 fs))] + (fn [& args] + (loop [ret (apply (first fs) args) fs (next fs)] + (if fs + (recur ((first fs) ret) (next fs)) + ret)))))) + +(defn partial + "Takes a function f and fewer than the normal arguments to f, and + returns a fn that takes a variable number of additional args. When + called, the returned function calls f with args + additional args." + ([f] f) + ([f arg1] + (fn [& args] (apply f arg1 args))) + ([f arg1 arg2] + (fn [& args] (apply f arg1 arg2 args))) + ([f arg1 arg2 arg3] + (fn [& args] (apply f arg1 arg2 arg3 args))) + ([f arg1 arg2 arg3 & more] + (fn [& args] (apply f arg1 arg2 arg3 (concat more args))))) + +(defn fnil + "Takes a function f, and returns a function that calls f, replacing + a nil first argument to f with the supplied value x. Higher arity + versions can replace arguments in the second and third + positions (y, z). Note that the function f can take any number of + arguments, not just the one(s) being nil-patched." + ([f x] + (fn + ([a] (f (if (nil? a) x a))) + ([a b] (f (if (nil? a) x a) b)) + ([a b c] (f (if (nil? a) x a) b c)) + ([a b c & ds] (apply f (if (nil? a) x a) b c ds)))) + ([f x y] + (fn + ([a b] (f (if (nil? a) x a) (if (nil? b) y b))) + ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) c)) + ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) c ds)))) + ([f x y z] + (fn + ([a b] (f (if (nil? a) x a) (if (nil? b) y b))) + ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c))) + ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) ds))))) + +(defn map-indexed + "Returns a lazy sequence consisting of the result of applying f to 0 + and the first item of coll, followed by applying f to 1 and the second + item in coll, etc, until coll is exhausted. Thus function f should + accept 2 arguments, index and item." + [f coll] + (letfn [(mapi [idx coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (chunk-append b (f (+ idx i) (-nth c i)))) + (chunk-cons (chunk b) (mapi (+ idx size) (chunk-rest s)))) + (cons (f idx (first s)) (mapi (inc idx) (rest s)))))))] + (mapi 0 coll))) + +(defn keep + "Returns a lazy sequence of the non-nil results of (f item). Note, + this means false return values will be included. f must be free of + side-effects." + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (let [x (f (-nth c i))] + (when-not (nil? x) + (chunk-append b x)))) + (chunk-cons (chunk b) (keep f (chunk-rest s)))) + (let [x (f (first s))] + (if (nil? x) + (keep f (rest s)) + (cons x (keep f (rest s)))))))))) + +(defn keep-indexed + "Returns a lazy sequence of the non-nil results of (f index item). Note, + this means false return values will be included. f must be free of + side-effects." + ([f coll] + (letfn [(keepi [idx coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (let [x (f (+ idx i) (-nth c i))] + (when-not (nil? x) + (chunk-append b x)))) + (chunk-cons (chunk b) (keepi (+ idx size) (chunk-rest s)))) + (let [x (f idx (first s))] + (if (nil? x) + (keepi (inc idx) (rest s)) + (cons x (keepi (inc idx) (rest s)))))))))] + (keepi 0 coll)))) + +(defn every-pred + "Takes a set of predicates and returns a function f that returns true if all of its + composing predicates return a logical true value against all of its arguments, else it returns + false. Note that f is short-circuiting in that it will stop execution on the first + argument that triggers a logical false result against the original predicates." + ([p] + (fn ep1 + ([] true) + ([x] (boolean (p x))) + ([x y] (boolean (and (p x) (p y)))) + ([x y z] (boolean (and (p x) (p y) (p z)))) + ([x y z & args] (boolean (and (ep1 x y z) + (every? p args)))))) + ([p1 p2] + (fn ep2 + ([] true) + ([x] (boolean (and (p1 x) (p2 x)))) + ([x y] (boolean (and (p1 x) (p1 y) (p2 x) (p2 y)))) + ([x y z] (boolean (and (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z)))) + ([x y z & args] (boolean (and (ep2 x y z) + (every? #(and (p1 %) (p2 %)) args)))))) + ([p1 p2 p3] + (fn ep3 + ([] true) + ([x] (boolean (and (p1 x) (p2 x) (p3 x)))) + ([x y] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y)))) + ([x y z] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y) (p1 z) (p2 z) (p3 z)))) + ([x y z & args] (boolean (and (ep3 x y z) + (every? #(and (p1 %) (p2 %) (p3 %)) args)))))) + ([p1 p2 p3 & ps] + (let [ps (list* p1 p2 p3 ps)] + (fn epn + ([] true) + ([x] (every? #(% x) ps)) + ([x y] (every? #(and (% x) (% y)) ps)) + ([x y z] (every? #(and (% x) (% y) (% z)) ps)) + ([x y z & args] (boolean (and (epn x y z) + (every? #(every? % args) ps)))))))) + +(defn some-fn + "Takes a set of predicates and returns a function f that returns the first logical true value + returned by one of its composing predicates against any of its arguments, else it returns + logical false. Note that f is short-circuiting in that it will stop execution on the first + argument that triggers a logical true result against the original predicates." + ([p] + (fn sp1 + ([] nil) + ([x] (p x)) + ([x y] (or (p x) (p y))) + ([x y z] (or (p x) (p y) (p z))) + ([x y z & args] (or (sp1 x y z) + (some p args))))) + ([p1 p2] + (fn sp2 + ([] nil) + ([x] (or (p1 x) (p2 x))) + ([x y] (or (p1 x) (p1 y) (p2 x) (p2 y))) + ([x y z] (or (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z))) + ([x y z & args] (or (sp2 x y z) + (some #(or (p1 %) (p2 %)) args))))) + ([p1 p2 p3] + (fn sp3 + ([] nil) + ([x] (or (p1 x) (p2 x) (p3 x))) + ([x y] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y))) + ([x y z] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y) (p1 z) (p2 z) (p3 z))) + ([x y z & args] (or (sp3 x y z) + (some #(or (p1 %) (p2 %) (p3 %)) args))))) + ([p1 p2 p3 & ps] + (let [ps (list* p1 p2 p3 ps)] + (fn spn + ([] nil) + ([x] (some #(% x) ps)) + ([x y] (some #(or (% x) (% y)) ps)) + ([x y z] (some #(or (% x) (% y) (% z)) ps)) + ([x y z & args] (or (spn x y z) + (some #(some % args) ps))))))) + +(defn map + "Returns a lazy sequence consisting of the result of applying f to the + set of first items of each coll, followed by applying f to the set + of second items in each coll, until any one of the colls is + exhausted. Any remaining items in other colls are ignored. Function + f should accept number-of-colls arguments." + ([f coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (chunk-append b (f (-nth c i)))) + (chunk-cons (chunk b) (map f (chunk-rest s)))) + (cons (f (first s)) (map f (rest s))))))) + ([f c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (f (first s1) (first s2)) + (map f (rest s1) (rest s2))))))) + ([f c1 c2 c3] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2) s3 (seq c3)] + (when (and s1 s2 s3) + (cons (f (first s1) (first s2) (first s3)) + (map f (rest s1) (rest s2) (rest s3))))))) + ([f c1 c2 c3 & colls] + (let [step (fn step [cs] + (lazy-seq + (let [ss (map seq cs)] + (when (every? identity ss) + (cons (map first ss) (step (map rest ss)))))))] + (map #(apply f %) (step (conj colls c3 c2 c1)))))) + +(defn take + "Returns a lazy sequence of the first n items in coll, or all items if + there are fewer than n." + [n coll] + (lazy-seq + (when (pos? n) + (when-let [s (seq coll)] + (cons (first s) (take (dec n) (rest s))))))) + +(defn drop + "Returns a lazy sequence of all but the first n items in coll." + [n coll] + (let [step (fn [n coll] + (let [s (seq coll)] + (if (and (pos? n) s) + (recur (dec n) (rest s)) + s)))] + (lazy-seq (step n coll)))) + +(defn drop-last + "Return a lazy sequence of all but the last n (default 1) items in coll" + ([s] (drop-last 1 s)) + ([n s] (map (fn [x _] x) s (drop n s)))) + +(defn take-last + "Returns a seq of the last n items in coll. Depending on the type + of coll may be no better than linear time. For vectors, see also subvec." + [n coll] + (loop [s (seq coll), lead (seq (drop n coll))] + (if lead + (recur (next s) (next lead)) + s))) + +(defn drop-while + "Returns a lazy sequence of the items in coll starting from the first + item for which (pred item) returns nil." + [pred coll] + (let [step (fn [pred coll] + (let [s (seq coll)] + (if (and s (pred (first s))) + (recur pred (rest s)) + s)))] + (lazy-seq (step pred coll)))) + +(defn cycle + "Returns a lazy (infinite!) sequence of repetitions of the items in coll." + [coll] (lazy-seq + (when-let [s (seq coll)] + (concat s (cycle s))))) + +(defn split-at + "Returns a vector of [(take n coll) (drop n coll)]" + [n coll] + [(take n coll) (drop n coll)]) + +(defn repeat + "Returns a lazy (infinite!, or length n if supplied) sequence of xs." + ([x] (lazy-seq (cons x (repeat x)))) + ([n x] (take n (repeat x)))) + +(defn replicate + "Returns a lazy seq of n xs." + [n x] (take n (repeat x))) + +(defn repeatedly + "Takes a function of no args, presumably with side effects, and + returns an infinite (or length n if supplied) lazy sequence of calls + to it" + ([f] (lazy-seq (cons (f) (repeatedly f)))) + ([n f] (take n (repeatedly f)))) + +(defn iterate + "Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects" + {:added "1.0"} + [f x] (cons x (lazy-seq (iterate f (f x))))) + +(defn interleave + "Returns a lazy seq of the first item in each coll, then the second etc." + ([c1 c2] + (lazy-seq + (let [s1 (seq c1) s2 (seq c2)] + (when (and s1 s2) + (cons (first s1) (cons (first s2) + (interleave (rest s1) (rest s2)))))))) + ([c1 c2 & colls] + (lazy-seq + (let [ss (map seq (conj colls c2 c1))] + (when (every? identity ss) + (concat (map first ss) (apply interleave (map rest ss)))))))) + +(defn interpose + "Returns a lazy seq of the elements of coll separated by sep" + [sep coll] (drop 1 (interleave (repeat sep) coll))) + + + +(defn- flatten1 + "Take a collection of collections, and return a lazy seq + of items from the inner collection" + [colls] + (let [cat (fn cat [coll colls] + (lazy-seq + (if-let [coll (seq coll)] + (cons (first coll) (cat (rest coll) colls)) + (when (seq colls) + (cat (first colls) (rest colls))))))] + (cat nil colls))) + +(defn mapcat + "Returns the result of applying concat to the result of applying map + to f and colls. Thus function f should return a collection." + ([f coll] + (flatten1 (map f coll))) + ([f coll & colls] + (flatten1 (apply map f coll colls)))) + +(defn filter + "Returns a lazy sequence of the items in coll for which + (pred item) returns true. pred must be free of side-effects." + ([pred coll] + (lazy-seq + (when-let [s (seq coll)] + (if (chunked-seq? s) + (let [c (chunk-first s) + size (count c) + b (chunk-buffer size)] + (dotimes [i size] + (when (pred (-nth c i)) + (chunk-append b (-nth c i)))) + (chunk-cons (chunk b) (filter pred (chunk-rest s)))) + (let [f (first s) r (rest s)] + (if (pred f) + (cons f (filter pred r)) + (filter pred r)))))))) + +(defn remove + "Returns a lazy sequence of the items in coll for which + (pred item) returns false. pred must be free of side-effects." + [pred coll] + (filter (complement pred) coll)) + +(defn tree-seq + "Returns a lazy sequence of the nodes in a tree, via a depth-first walk. + branch? must be a fn of one arg that returns true if passed a node + that can have children (but may not). children must be a fn of one + arg that returns a sequence of the children. Will only be called on + nodes for which branch? returns true. Root is the root node of the + tree." + [branch? children root] + (let [walk (fn walk [node] + (lazy-seq + (cons node + (when (branch? node) + (mapcat walk (children node))))))] + (walk root))) + +(defn flatten + "Takes any nested combination of sequential things (lists, vectors, + etc.) and returns their contents as a single, flat sequence. + (flatten nil) returns nil." + [x] + (filter #(not (sequential? %)) + (rest (tree-seq sequential? seq x)))) + +(defn into + "Returns a new coll consisting of to-coll with all of the items of + from-coll conjoined." + [to from] + (if-not (nil? to) + (if (implements? IEditableCollection to) + (persistent! (reduce -conj! (transient to) from)) + (reduce -conj to from)) + (reduce conj () from))) + +(defn mapv + "Returns a vector consisting of the result of applying f to the + set of first items of each coll, followed by applying f to the set + of second items in each coll, until any one of the colls is + exhausted. Any remaining items in other colls are ignored. Function + f should accept number-of-colls arguments." + ([f coll] + (-> (reduce (fn [v o] (conj! v (f o))) (transient []) coll) + persistent!)) + ([f c1 c2] + (into [] (map f c1 c2))) + ([f c1 c2 c3] + (into [] (map f c1 c2 c3))) + ([f c1 c2 c3 & colls] + (into [] (apply map f c1 c2 c3 colls)))) + +(defn filterv + "Returns a vector of the items in coll for which + (pred item) returns true. pred must be free of side-effects." + [pred coll] + (-> (reduce (fn [v o] (if (pred o) (conj! v o) v)) + (transient []) + coll) + persistent!)) + +(defn partition + "Returns a lazy sequence of lists of n items each, at offsets step + apart. If step is not supplied, defaults to n, i.e. the partitions + do not overlap. If a pad collection is supplied, use its elements as + necessary to complete last partition upto n items. In case there are + not enough padding elements, return a partition with less than n items." + ([n coll] + (partition n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (when (== n (count p)) + (cons p (partition n step (drop step s)))))))) + ([n step pad coll] + (lazy-seq + (when-let [s (seq coll)] + (let [p (take n s)] + (if (== n (count p)) + (cons p (partition n step pad (drop step s))) + (list (take n (concat p pad))))))))) + +(defn get-in + "Returns the value in a nested associative structure, + where ks is a sequence of keys. Returns nil if the key is not present, + or the not-found value if supplied." + {:added "1.2" + :static true} + ([m ks] + (get-in m ks nil)) + ([m ks not-found] + (loop [sentinel lookup-sentinel + m m + ks (seq ks)] + (if ks + (if (not (satisfies? ILookup m)) + not-found + (let [m (get m (first ks) sentinel)] + (if (identical? sentinel m) + not-found + (recur sentinel m (next ks))))) + m)))) + +(defn assoc-in + "Associates a value in a nested associative structure, where ks is a + sequence of keys and v is the new value and returns a new nested structure. + If any levels do not exist, hash-maps will be created." + [m [k & ks] v] + (if ks + (assoc m k (assoc-in (get m k) ks v)) + (assoc m k v))) + +(defn update-in + "'Updates' a value in a nested associative structure, where ks is a + sequence of keys and f is a function that will take the old value + and any supplied args and return the new value, and returns a new + nested structure. If any levels do not exist, hash-maps will be + created." + ([m [k & ks] f] + (if ks + (assoc m k (update-in (get m k) ks f)) + (assoc m k (f (get m k))))) + ([m [k & ks] f a] + (if ks + (assoc m k (update-in (get m k) ks f a)) + (assoc m k (f (get m k) a)))) + ([m [k & ks] f a b] + (if ks + (assoc m k (update-in (get m k) ks f a b)) + (assoc m k (f (get m k) a b)))) + ([m [k & ks] f a b c] + (if ks + (assoc m k (update-in (get m k) ks f a b c)) + (assoc m k (f (get m k) a b c)))) + ([m [k & ks] f a b c & args] + (if ks + (assoc m k (apply update-in (get m k) ks f a b c args)) + (assoc m k (apply f (get m k) a b c args))))) + +;;; PersistentVector + +(deftype VectorNode [edit arr]) + +(defn- pv-fresh-node [edit] + (VectorNode. edit (make-array 32))) + +(defn- pv-aget [node idx] + (aget (.-arr node) idx)) + +(defn- pv-aset [node idx val] + (aset (.-arr node) idx val)) + +(defn- pv-clone-node [node] + (VectorNode. (.-edit node) (aclone (.-arr node)))) + +(defn- tail-off [pv] + (let [cnt (.-cnt pv)] + (if (< cnt 32) + 0 + (bit-shift-left (bit-shift-right-zero-fill (dec cnt) 5) 5)))) + +(defn- new-path [edit level node] + (loop [ll level + ret node] + (if (zero? ll) + ret + (let [embed ret + r (pv-fresh-node edit) + _ (pv-aset r 0 embed)] + (recur (- ll 5) r))))) + +(defn- push-tail [pv level parent tailnode] + (let [ret (pv-clone-node parent) + subidx (bit-and (bit-shift-right-zero-fill (dec (.-cnt pv)) level) 0x01f)] + (if (== 5 level) + (do + (pv-aset ret subidx tailnode) + ret) + (let [child (pv-aget parent subidx)] + (if-not (nil? child) + (let [node-to-insert (push-tail pv (- level 5) child tailnode)] + (pv-aset ret subidx node-to-insert) + ret) + (let [node-to-insert (new-path nil (- level 5) tailnode)] + (pv-aset ret subidx node-to-insert) + ret)))))) + +(defn- vector-index-out-of-bounds [i cnt] + (throw (js/Error. (str "No item " i " in vector of length " cnt)))) + +(defn- array-for [pv i] + (if (and (<= 0 i) (< i (.-cnt pv))) + (if (>= i (tail-off pv)) + (.-tail pv) + (loop [node (.-root pv) + level (.-shift pv)] + (if (pos? level) + (recur (pv-aget node (bit-and (bit-shift-right-zero-fill i level) 0x01f)) + (- level 5)) + (.-arr node)))) + (vector-index-out-of-bounds i (.-cnt pv)))) + +(defn- do-assoc [pv level node i val] + (let [ret (pv-clone-node node)] + (if (zero? level) + (do + (pv-aset ret (bit-and i 0x01f) val) + ret) + (let [subidx (bit-and (bit-shift-right-zero-fill i level) 0x01f)] + (pv-aset ret subidx (do-assoc pv (- level 5) (pv-aget node subidx) i val)) + ret)))) + +(defn- pop-tail [pv level node] + (let [subidx (bit-and (bit-shift-right-zero-fill (- (.-cnt pv) 2) level) 0x01f)] + (cond + (> level 5) (let [new-child (pop-tail pv (- level 5) (pv-aget node subidx))] + (if (and (nil? new-child) (zero? subidx)) + nil + (let [ret (pv-clone-node node)] + (pv-aset ret subidx new-child) + ret))) + (zero? subidx) nil + :else (let [ret (pv-clone-node node)] + (pv-aset ret subidx nil) + ret)))) + +(declare tv-editable-root tv-editable-tail TransientVector deref + pr-sequential-writer pr-writer chunked-seq) + +(deftype PersistentVector [meta cnt shift root tail ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentVector. meta cnt shift root tail __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentVector. meta cnt shift root tail __hash)) + + IMeta + (-meta [coll] meta) + + IStack + (-peek [coll] + (when (> cnt 0) + (-nth coll (dec cnt)))) + (-pop [coll] + (cond + (zero? cnt) (throw (js/Error. "Can't pop empty vector")) + (== 1 cnt) (-with-meta cljs.core.PersistentVector.EMPTY meta) + (< 1 (- cnt (tail-off coll))) + (PersistentVector. meta (dec cnt) shift root (.slice tail 0 -1) nil) + :else (let [new-tail (array-for coll (- cnt 2)) + nr (pop-tail coll shift root) + new-root (if (nil? nr) cljs.core.PersistentVector.EMPTY_NODE nr) + cnt-1 (dec cnt)] + (if (and (< 5 shift) (nil? (pv-aget new-root 1))) + (PersistentVector. meta cnt-1 (- shift 5) (pv-aget new-root 0) new-tail nil) + (PersistentVector. meta cnt-1 shift new-root new-tail nil))))) + + ICollection + (-conj [coll o] + (if (< (- cnt (tail-off coll)) 32) + (let [len (alength tail) + new-tail (make-array (inc len))] + (dotimes [i len] + (aset new-tail i (aget tail i))) + (aset new-tail len o) + (PersistentVector. meta (inc cnt) shift root new-tail nil)) + (let [root-overflow? (> (bit-shift-right-zero-fill cnt 5) (bit-shift-left 1 shift)) + new-shift (if root-overflow? (+ shift 5) shift) + new-root (if root-overflow? + (let [n-r (pv-fresh-node nil)] + (pv-aset n-r 0 root) + (pv-aset n-r 1 (new-path nil shift (VectorNode. nil tail))) + n-r) + (push-tail coll shift root (VectorNode. nil tail)))] + (PersistentVector. meta (inc cnt) new-shift new-root (array o) nil)))) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentVector.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (cond + (zero? cnt) nil + (< cnt 32) (array-seq tail) + :else (chunked-seq coll 0 0))) + + ICounted + (-count [coll] cnt) + + IIndexed + (-nth [coll n] + (aget (array-for coll n) (bit-and n 0x01f))) + (-nth [coll n not-found] + (if (and (<= 0 n) (< n cnt)) + (-nth coll n) + not-found)) + + ILookup + (-lookup [coll k] (-nth coll k nil)) + (-lookup [coll k not-found] (-nth coll k not-found)) + + IMapEntry + (-key [coll] + (-nth coll 0)) + (-val [coll] + (-nth coll 1)) + + IAssociative + (-assoc [coll k v] + (if (number? k) + (-assoc-n coll k v) + (throw (js/Error. "Vector's key for assoc must be a number.")))) + + IVector + (-assoc-n [coll n val] + (cond + (and (<= 0 n) (< n cnt)) + (if (<= (tail-off coll) n) + (let [new-tail (aclone tail)] + (aset new-tail (bit-and n 0x01f) val) + (PersistentVector. meta cnt shift root new-tail nil)) + (PersistentVector. meta cnt shift (do-assoc coll shift root n val) tail nil)) + (== n cnt) (-conj coll val) + :else (throw (js/Error. (str "Index " n " out of bounds [0," cnt "]"))))) + + IReduce + (-reduce [v f] + (ci-reduce v f)) + (-reduce [v f start] + (ci-reduce v f start)) + + IKVReduce + (-kv-reduce [v f init] + (let [step-init (array 0 init)] ; [step 0 init init] + (loop [i 0] + (if (< i cnt) + (let [arr (array-for v i) + len (alength arr)] + (let [init (loop [j 0 init (aget step-init 1)] + (if (< j len) + (let [init (f init (+ j i) (aget arr j))] + (if (reduced? init) + init + (recur (inc j) init))) + (do (aset step-init 0 len) + (aset step-init 1 init) + init)))] + (if (reduced? init) + @init + (recur (+ i (aget step-init 0)))))) + (aget step-init 1))))) + + IFn + (-invoke [coll k] + (-nth coll k)) + (-invoke [coll k not-found] + (-nth coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientVector. cnt shift (tv-editable-root root) (tv-editable-tail tail))) + + IReversible + (-rseq [coll] + (if (pos? cnt) + (RSeq. coll (dec cnt) nil)))) + +(set! cljs.core.PersistentVector.EMPTY_NODE (VectorNode. nil (make-array 32))) + +(set! cljs.core.PersistentVector.EMPTY + (PersistentVector. nil 0 5 cljs.core.PersistentVector.EMPTY_NODE (array) 0)) + +(set! cljs.core.PersistentVector.fromArray + (fn [xs ^boolean no-clone] + (let [l (alength xs) + xs (if no-clone xs (aclone xs))] + (if (< l 32) + (PersistentVector. nil l 5 cljs.core.PersistentVector.EMPTY_NODE xs nil) + (let [node (.slice xs 0 32) + v (PersistentVector. nil 32 5 cljs.core.PersistentVector.EMPTY_NODE node nil)] + (loop [i 32 out (-as-transient v)] + (if (< i l) + (recur (inc i) (conj! out (aget xs i))) + (persistent! out)))))))) + +(defn vec [coll] + (-persistent! + (reduce -conj! + (-as-transient cljs.core.PersistentVector.EMPTY) + coll))) + +(defn vector [& args] + (if (and (instance? IndexedSeq args) (zero? (.-i args))) + (cljs.core.PersistentVector.fromArray (.-arr args) true) + (vec args))) + +(declare subvec) + +(deftype ChunkedSeq [vec node i off meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll m] + (chunked-seq vec node i off m)) + (-meta [coll] meta) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ASeq + ISeq + (-first [coll] + (aget node off)) + (-rest [coll] + (if (< (inc off) (alength node)) + (let [s (chunked-seq vec node i (inc off))] + (if (nil? s) + () + s)) + (-chunked-rest coll))) + + INext + (-next [coll] + (if (< (inc off) (alength node)) + (let [s (chunked-seq vec node i (inc off))] + (if (nil? s) + nil + s)) + (-chunked-next coll))) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] + (with-meta cljs.core.PersistentVector.EMPTY meta)) + + IChunkedSeq + (-chunked-first [coll] + (array-chunk node off)) + (-chunked-rest [coll] + (let [l (alength node) + s (when (< (+ i l) (-count vec)) + (chunked-seq vec (+ i l) 0))] + (if (nil? s) + () + s))) + + IChunkedNext + (-chunked-next [coll] + (let [l (alength node) + s (when (< (+ i l) (-count vec)) + (chunked-seq vec (+ i l) 0))] + (if (nil? s) + nil + s))) + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IReduce + (-reduce [coll f] + (ci-reduce (subvec vec (+ i off) (count vec)) f)) + + (-reduce [coll f start] + (ci-reduce (subvec vec (+ i off) (count vec)) f start))) + +(defn chunked-seq + ([vec i off] (ChunkedSeq. vec (array-for vec i) i off nil nil)) + ([vec node i off] (ChunkedSeq. vec node i off nil nil)) + ([vec node i off meta] + (ChunkedSeq. vec node i off meta nil))) + +(declare build-subvec) + +(deftype Subvec [meta v start end ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (Subvec. meta v start end __hash)) + + IWithMeta + (-with-meta [coll meta] (build-subvec meta v start end __hash)) + + IMeta + (-meta [coll] meta) + + IStack + (-peek [coll] + (-nth v (dec end))) + (-pop [coll] + (if (== start end) + (throw (js/Error. "Can't pop empty vector")) + (build-subvec meta v start (dec end) nil))) + + ICollection + (-conj [coll o] + (build-subvec meta (-assoc-n v end o) start (inc end) nil)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentVector.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (let [subvec-seq (fn subvec-seq [i] + (when-not (== i end) + (cons (-nth v i) + (lazy-seq + (subvec-seq (inc i))))))] + (subvec-seq start))) + + IReversible + (-rseq [coll] + (if-not (== start end) + (RSeq. coll (dec (- end start)) nil))) + + ICounted + (-count [coll] (- end start)) + + IIndexed + (-nth [coll n] + (if (or (neg? n) (<= end (+ start n))) + (vector-index-out-of-bounds n (- end start)) + (-nth v (+ start n)))) + (-nth [coll n not-found] + (if (or (neg? n) (<= end (+ start n))) + not-found + (-nth v (+ start n) not-found))) + + ILookup + (-lookup [coll k] (-nth coll k nil)) + (-lookup [coll k not-found] (-nth coll k not-found)) + + IAssociative + (-assoc [coll key val] + (if (number? key) + (-assoc-n coll key val) + (throw (js/Error. "Subvec's key for assoc must be a number.")))) + + IVector + (-assoc-n [coll n val] + (let [v-pos (+ start n)] + (build-subvec meta (assoc v v-pos val) start (max end (inc v-pos)) nil))) + + IReduce + (-reduce [coll f] + (ci-reduce coll f)) + (-reduce [coll f start] + (ci-reduce coll f start)) + + IFn + (-invoke [coll k] + (-nth coll k)) + (-invoke [coll k not-found] + (-nth coll k not-found))) + +(defn- build-subvec [meta v start end __hash] + (if (instance? Subvec v) + (recur meta (.-v v) (+ (.-start v) start) (+ (.-start v) end) __hash) + (let [c (count v)] + (when (or (neg? start) + (neg? end) + (> start c) + (> end c)) + (throw (js/Error. "Index out of bounds"))) + (Subvec. meta v start end __hash)))) + +(defn subvec + "Returns a persistent vector of the items in vector from + start (inclusive) to end (exclusive). If end is not supplied, + defaults to (count vector). This operation is O(1) and very fast, as + the resulting vector shares structure with the original and no + trimming is done." + ([v start] + (subvec v start (count v))) + ([v start end] + (build-subvec nil v start end nil))) + +(defn- tv-ensure-editable [edit node] + (if (identical? edit (.-edit node)) + node + (VectorNode. edit (aclone (.-arr node))))) + +(defn- tv-editable-root [node] + (VectorNode. (js-obj) (aclone (.-arr node)))) + +(defn- tv-editable-tail [tl] + (let [ret (make-array 32)] + (array-copy tl 0 ret 0 (alength tl)) + ret)) + +(defn- tv-push-tail [tv level parent tail-node] + (let [ret (tv-ensure-editable (.. tv -root -edit) parent) + subidx (bit-and (bit-shift-right-zero-fill (dec (.-cnt tv)) level) 0x01f)] + (pv-aset ret subidx + (if (== level 5) + tail-node + (let [child (pv-aget ret subidx)] + (if-not (nil? child) + (tv-push-tail tv (- level 5) child tail-node) + (new-path (.. tv -root -edit) (- level 5) tail-node))))) + ret)) + +(defn- tv-pop-tail [tv level node] + (let [node (tv-ensure-editable (.. tv -root -edit) node) + subidx (bit-and (bit-shift-right-zero-fill (- (.-cnt tv) 2) level) 0x01f)] + (cond + (> level 5) (let [new-child (tv-pop-tail + tv (- level 5) (pv-aget node subidx))] + (if (and (nil? new-child) (zero? subidx)) + nil + (do (pv-aset node subidx new-child) + node))) + (zero? subidx) nil + :else (do (pv-aset node subidx nil) + node)))) + +(defn- editable-array-for [tv i] + (if (and (<= 0 i) (< i (.-cnt tv))) + (if (>= i (tail-off tv)) + (.-tail tv) + (let [root (.-root tv)] + (loop [node root + level (.-shift tv)] + (if (pos? level) + (recur (tv-ensure-editable + (.-edit root) + (pv-aget node + (bit-and (bit-shift-right-zero-fill i level) + 0x01f))) + (- level 5)) + (.-arr node))))) + (throw (js/Error. + (str "No item " i " in transient vector of length " (.-cnt tv)))))) + +(deftype TransientVector [^:mutable cnt + ^:mutable shift + ^:mutable root + ^:mutable tail] + ITransientCollection + (-conj! [tcoll o] + (if ^boolean (.-edit root) + (if (< (- cnt (tail-off tcoll)) 32) + (do (aset tail (bit-and cnt 0x01f) o) + (set! cnt (inc cnt)) + tcoll) + (let [tail-node (VectorNode. (.-edit root) tail) + new-tail (make-array 32)] + (aset new-tail 0 o) + (set! tail new-tail) + (if (> (bit-shift-right-zero-fill cnt 5) + (bit-shift-left 1 shift)) + (let [new-root-array (make-array 32) + new-shift (+ shift 5)] + (aset new-root-array 0 root) + (aset new-root-array 1 (new-path (.-edit root) shift tail-node)) + (set! root (VectorNode. (.-edit root) new-root-array)) + (set! shift new-shift) + (set! cnt (inc cnt)) + tcoll) + (let [new-root (tv-push-tail tcoll shift root tail-node)] + (set! root new-root) + (set! cnt (inc cnt)) + tcoll)))) + (throw (js/Error. "conj! after persistent!")))) + + (-persistent! [tcoll] + (if ^boolean (.-edit root) + (do (set! (.-edit root) nil) + (let [len (- cnt (tail-off tcoll)) + trimmed-tail (make-array len)] + (array-copy tail 0 trimmed-tail 0 len) + (PersistentVector. nil cnt shift root trimmed-tail nil))) + (throw (js/Error. "persistent! called twice")))) + + ITransientAssociative + (-assoc! [tcoll key val] (-assoc-n! tcoll key val)) + + ITransientVector + (-assoc-n! [tcoll n val] + (if ^boolean (.-edit root) + (cond + (and (<= 0 n) (< n cnt)) + (if (<= (tail-off tcoll) n) + (do (aset tail (bit-and n 0x01f) val) + tcoll) + (let [new-root + ((fn go [level node] + (let [node (tv-ensure-editable (.-edit root) node)] + (if (zero? level) + (do (pv-aset node (bit-and n 0x01f) val) + node) + (let [subidx (bit-and (bit-shift-right-zero-fill n level) + 0x01f)] + (pv-aset node subidx + (go (- level 5) (pv-aget node subidx))) + node)))) + shift root)] + (set! root new-root) + tcoll)) + (== n cnt) (-conj! tcoll val) + :else + (throw + (js/Error. + (str "Index " n " out of bounds for TransientVector of length" cnt)))) + (throw (js/Error. "assoc! after persistent!")))) + + (-pop! [tcoll] + (if ^boolean (.-edit root) + (cond + (zero? cnt) (throw (js/Error. "Can't pop empty vector")) + (== 1 cnt) (do (set! cnt 0) tcoll) + (pos? (bit-and (dec cnt) 0x01f)) (do (set! cnt (dec cnt)) tcoll) + :else + (let [new-tail (editable-array-for tcoll (- cnt 2)) + new-root (let [nr (tv-pop-tail tcoll shift root)] + (if-not (nil? nr) + nr + (VectorNode. (.-edit root) (make-array 32))))] + (if (and (< 5 shift) (nil? (pv-aget new-root 1))) + (let [new-root (tv-ensure-editable (.-edit root) (pv-aget new-root 0))] + (set! root new-root) + (set! shift (- shift 5)) + (set! cnt (dec cnt)) + (set! tail new-tail) + tcoll) + (do (set! root new-root) + (set! cnt (dec cnt)) + (set! tail new-tail) + tcoll)))) + (throw (js/Error. "pop! after persistent!")))) + + ICounted + (-count [coll] + (if ^boolean (.-edit root) + cnt + (throw (js/Error. "count after persistent!")))) + + IIndexed + (-nth [coll n] + (if ^boolean (.-edit root) + (aget (array-for coll n) (bit-and n 0x01f)) + (throw (js/Error. "nth after persistent!")))) + + (-nth [coll n not-found] + (if (and (<= 0 n) (< n cnt)) + (-nth coll n) + not-found)) + + ILookup + (-lookup [coll k] (-nth coll k nil)) + + (-lookup [coll k not-found] (-nth coll k not-found)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found))) + +;;; PersistentQueue ;;; + +(deftype PersistentQueueSeq [meta front rear ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll meta] (PersistentQueueSeq. meta front rear __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] (first front)) + (-rest [coll] + (if-let [f1 (next front)] + (PersistentQueueSeq. meta f1 rear nil) + (if (nil? rear) + (-empty coll) + (PersistentQueueSeq. meta rear nil nil)))) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] coll)) + +(deftype PersistentQueue [meta count front rear ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [coll] (PersistentQueue. meta count front rear __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentQueue. meta count front rear __hash)) + + IMeta + (-meta [coll] meta) + + ISeq + (-first [coll] (first front)) + (-rest [coll] (rest (seq coll))) + + IStack + (-peek [coll] (first front)) + (-pop [coll] + (if front + (if-let [f1 (next front)] + (PersistentQueue. meta (dec count) f1 rear nil) + (PersistentQueue. meta (dec count) (seq rear) [] nil)) + coll)) + + ICollection + (-conj [coll o] + (if front + (PersistentQueue. meta (inc count) front (conj (or rear []) o) nil) + (PersistentQueue. meta (inc count) (conj front o) [] nil))) + + IEmptyableCollection + (-empty [coll] cljs.core.PersistentQueue.EMPTY) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + ISeqable + (-seq [coll] + (let [rear (seq rear)] + (if (or front rear) + (PersistentQueueSeq. nil front (seq rear) nil)))) + + ICounted + (-count [coll] count)) + +(set! cljs.core.PersistentQueue.EMPTY (PersistentQueue. nil 0 nil [] 0)) + +(deftype NeverEquiv [] + IEquiv + (-equiv [o other] false)) + +(def ^:private never-equiv (NeverEquiv.)) + +(defn- equiv-map + "Assumes y is a map. Returns true if x equals y, otherwise returns + false." + [x y] + (boolean + (when (map? y) + ; assume all maps are counted + (when (== (count x) (count y)) + (every? identity + (map (fn [xkv] (= (get y (first xkv) never-equiv) + (second xkv))) + x)))))) + + +(defn- scan-array [incr k array] + (let [len (alength array)] + (loop [i 0] + (when (< i len) + (if (identical? k (aget array i)) + i + (recur (+ i incr))))))) + +; The keys field is an array of all keys of this map, in no particular +; order. Any string, keyword, or symbol key is used as a property name +; to store the value in strobj. If a key is assoc'ed when that same +; key already exists in strobj, the old value is overwritten. If a +; non-string key is assoc'ed, return a HashMap object instead. + +(defn- obj-map-compare-keys [a b] + (let [a (hash a) + b (hash b)] + (cond + (< a b) -1 + (> a b) 1 + :else 0))) + +(defn- obj-map->hash-map [m k v] + (let [ks (.-keys m) + len (alength ks) + so (.-strobj m) + mm (meta m)] + (loop [i 0 + out (transient cljs.core.PersistentHashMap.EMPTY)] + (if (< i len) + (let [k (aget ks i)] + (recur (inc i) (assoc! out k (aget so k)))) + (with-meta (persistent! (assoc! out k v)) mm))))) + +;;; ObjMap - DEPRECATED + +(defn- obj-clone [obj ks] + (let [new-obj (js-obj) + l (alength ks)] + (loop [i 0] + (when (< i l) + (let [k (aget ks i)] + (aset new-obj k (aget obj k)) + (recur (inc i))))) + new-obj)) + +(deftype ObjMap [meta keys strobj update-count ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IWithMeta + (-with-meta [coll meta] (ObjMap. meta keys strobj update-count __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj + coll + entry))) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.ObjMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ISeqable + (-seq [coll] + (when (pos? (alength keys)) + (map #(vector % (aget strobj %)) + (.sort keys obj-map-compare-keys)))) + + ICounted + (-count [coll] (alength keys)) + + ILookup + (-lookup [coll k] (-lookup coll k nil)) + (-lookup [coll k not-found] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (aget strobj k) + not-found)) + + IAssociative + (-assoc [coll k v] + (if ^boolean (goog/isString k) + (if (or (> update-count cljs.core.ObjMap.HASHMAP_THRESHOLD) + (>= (alength keys) cljs.core.ObjMap.HASHMAP_THRESHOLD)) + (obj-map->hash-map coll k v) + (if-not (nil? (scan-array 1 k keys)) + (let [new-strobj (obj-clone strobj keys)] + (aset new-strobj k v) + (ObjMap. meta keys new-strobj (inc update-count) nil)) ; overwrite + (let [new-strobj (obj-clone strobj keys) ; append + new-keys (aclone keys)] + (aset new-strobj k v) + (.push new-keys k) + (ObjMap. meta new-keys new-strobj (inc update-count) nil)))) + ;; non-string key. game over. + (obj-map->hash-map coll k v))) + (-contains-key? [coll k] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + true + false)) + + IKVReduce + (-kv-reduce [coll f init] + (let [len (alength keys)] + (loop [keys (.sort keys obj-map-compare-keys) + init init] + (if (seq keys) + (let [k (first keys) + init (f init k (aget strobj k))] + (if (reduced? init) + @init + (recur (rest keys) init))) + init)))) + + IMap + (-dissoc [coll k] + (if (and ^boolean (goog/isString k) + (not (nil? (scan-array 1 k keys)))) + (let [new-keys (aclone keys) + new-strobj (obj-clone strobj keys)] + (.splice new-keys (scan-array 1 k new-keys) 1) + (js-delete new-strobj k) + (ObjMap. meta new-keys new-strobj (inc update-count) nil)) + coll)) ; key not found, return coll unchanged + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (transient (into (hash-map) coll)))) + +(set! cljs.core.ObjMap.EMPTY (ObjMap. nil (array) (js-obj) 0 0)) + +(set! cljs.core.ObjMap.HASHMAP_THRESHOLD 8) + +(set! cljs.core.ObjMap.fromObject (fn [ks obj] (ObjMap. nil ks obj 0 nil))) + +;;; PersistentArrayMap + +(defn- array-map-index-of-nil? [arr m k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (nil? (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-keyword? [arr m k] + (let [len (alength arr) + kstr (.-fqn k)] + (loop [i 0] + (cond + (<= len i) -1 + (let [k' (aget arr i)] + (and (keyword? k') + (identical? kstr (.-fqn k')))) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-symbol? [arr m k] + (let [len (alength arr) + kstr (.-str k)] + (loop [i 0] + (cond + (<= len i) -1 + (let [k' (aget arr i)] + (and (symbol? k') + (identical? kstr (.-str k')))) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-identical? [arr m k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (identical? k (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of-equiv? [arr m k] + (let [len (alength arr)] + (loop [i 0] + (cond + (<= len i) -1 + (= k (aget arr i)) i + :else (recur (+ i 2)))))) + +(defn- array-map-index-of [m k] + (let [arr (.-arr m)] + (cond + (keyword? k) (array-map-index-of-keyword? arr m k) + + (or ^boolean (goog/isString k) (number? k)) + (array-map-index-of-identical? arr m k) + + (symbol? k) (array-map-index-of-symbol? arr m k) + + (nil? k) + (array-map-index-of-nil? arr m k) + + :else (array-map-index-of-equiv? arr m k)))) + +(defn- array-map-extend-kv [m k v] + (let [arr (.-arr m) + l (alength arr) + narr (make-array (+ l 2))] + (loop [i 0] + (when (< i l) + (aset narr i (aget arr i)) + (recur (inc i)))) + (aset narr l k) + (aset narr (inc l) v) + narr)) + +(declare TransientArrayMap) + +(deftype PersistentArrayMapSeq [arr i _meta] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] + (PersistentArrayMapSeq. arr i new-meta)) + + ICounted + (-count [coll] + (/ (- (alength arr) i) 2)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY _meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + ISeq + (-first [coll] + [(aget arr i) (aget arr (inc i))]) + + (-rest [coll] + (if (< i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr (+ i 2) _meta) + ())) + + INext + (-next [coll] + (when (< i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr (+ i 2) _meta))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn persistent-array-map-seq [arr i _meta] + (when (<= i (- (alength arr) 2)) + (PersistentArrayMapSeq. arr i _meta))) + +(deftype PersistentArrayMap [meta cnt arr ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentArrayMap. meta cnt arr __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentArrayMap. meta cnt arr __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj coll entry))) + + IEmptyableCollection + (-empty [coll] (-with-meta cljs.core.PersistentArrayMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ISeqable + (-seq [coll] + (persistent-array-map-seq arr 0 nil)) + + ICounted + (-count [coll] cnt) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (let [idx (array-map-index-of coll k)] + (if (== idx -1) + not-found + (aget arr (inc idx))))) + + IAssociative + (-assoc [coll k v] + (let [idx (array-map-index-of coll k)] + (cond + (== idx -1) + (if (< cnt cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) + (let [arr (array-map-extend-kv coll k v)] + (PersistentArrayMap. meta (inc cnt) arr nil)) + (-> (into cljs.core.PersistentHashMap.EMPTY coll) + (-assoc k v) + (-with-meta meta))) + + (identical? v (aget arr (inc idx))) + coll + + :else + (let [arr (doto (aclone arr) + (aset (inc idx) v))] + (PersistentArrayMap. meta cnt arr nil))))) + + (-contains-key? [coll k] + (not (== (array-map-index-of coll k) -1))) + + IMap + (-dissoc [coll k] + (let [idx (array-map-index-of coll k)] + (if (>= idx 0) + (let [len (alength arr) + new-len (- len 2)] + (if (zero? new-len) + (-empty coll) + (let [new-arr (make-array new-len)] + (loop [s 0 d 0] + (cond + (>= s len) (PersistentArrayMap. meta (dec cnt) new-arr nil) + (= k (aget arr s)) (recur (+ s 2) d) + :else (do (aset new-arr d (aget arr s)) + (aset new-arr (inc d) (aget arr (inc s))) + (recur (+ s 2) (+ d 2)))))))) + coll))) + + IKVReduce + (-kv-reduce [coll f init] + (let [len (alength arr)] + (loop [i 0 init init] + (if (< i len) + (let [init (f init (aget arr i) (aget arr (inc i)))] + (if (reduced? init) + @init + (recur (+ i 2) init))) + init)))) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientArrayMap. (js-obj) (alength arr) (aclone arr)))) + +(set! cljs.core.PersistentArrayMap.EMPTY (PersistentArrayMap. nil 0 (array) nil)) + +(set! cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD 8) + +(set! cljs.core.PersistentArrayMap.fromArray + (fn [arr ^boolean no-clone ^boolean no-check] + (let [arr (if no-clone arr (aclone arr))] + (if no-check + (let [cnt (/ (alength arr) 2)] + (PersistentArrayMap. nil cnt arr nil)) + (let [len (alength arr)] + (loop [i 0 + ret (transient cljs.core.PersistentArrayMap.EMPTY)] + (if (< i len) + (recur (+ i 2) + (-assoc! ret (aget arr i) (aget arr (inc i)))) + (-persistent! ret)))))))) + +(declare array->transient-hash-map) + +(deftype TransientArrayMap [^:mutable editable? + ^:mutable len + arr] + ICounted + (-count [tcoll] + (if editable? + (quot len 2) + (throw (js/Error. "count after persistent!")))) + + ILookup + (-lookup [tcoll k] + (-lookup tcoll k nil)) + + (-lookup [tcoll k not-found] + (if editable? + (let [idx (array-map-index-of tcoll k)] + (if (== idx -1) + not-found + (aget arr (inc idx)))) + (throw (js/Error. "lookup after persistent!")))) + + ITransientCollection + (-conj! [tcoll o] + (if editable? + (if (satisfies? IMapEntry o) + (-assoc! tcoll (key o) (val o)) + (loop [es (seq o) tcoll tcoll] + (if-let [e (first es)] + (recur (next es) + (-assoc! tcoll (key e) (val e))) + tcoll))) + (throw (js/Error. "conj! after persistent!")))) + + (-persistent! [tcoll] + (if editable? + (do (set! editable? false) + (PersistentArrayMap. nil (quot len 2) arr nil)) + (throw (js/Error. "persistent! called twice")))) + + ITransientAssociative + (-assoc! [tcoll key val] + (if editable? + (let [idx (array-map-index-of tcoll key)] + (if (== idx -1) + (if (<= (+ len 2) (* 2 cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD)) + (do (set! len (+ len 2)) + (.push arr key) + (.push arr val) + tcoll) + (assoc! (array->transient-hash-map len arr) key val)) + (if (identical? val (aget arr (inc idx))) + tcoll + (do (aset arr (inc idx) val) + tcoll)))) + (throw (js/Error. "assoc! after persistent!")))) + + ITransientMap + (-dissoc! [tcoll key] + (if editable? + (let [idx (array-map-index-of tcoll key)] + (when (>= idx 0) + (aset arr idx (aget arr (- len 2))) + (aset arr (inc idx) (aget arr (dec len))) + (doto arr .pop .pop) + (set! len (- len 2))) + tcoll) + (throw (js/Error. "dissoc! after persistent!"))))) + +(declare TransientHashMap PersistentHashMap) + +(defn- array->transient-hash-map [len arr] + (loop [out (transient cljs.core.PersistentHashMap.EMPTY) + i 0] + (if (< i len) + (recur (assoc! out (aget arr i) (aget arr (inc i))) (+ i 2)) + out))) + +;;; PersistentHashMap + +(deftype Box [^:mutable val]) + +(declare create-inode-seq create-array-node-seq reset! create-node atom deref) + +(defn ^boolean key-test [key other] + (cond + (identical? key other) true + (keyword-identical? key other) true + :else (= key other))) + +(defn- mask [hash shift] + (bit-and (bit-shift-right-zero-fill hash shift) 0x01f)) + +(defn- clone-and-set + ([arr i a] + (doto (aclone arr) + (aset i a))) + ([arr i a j b] + (doto (aclone arr) + (aset i a) + (aset j b)))) + +(defn- remove-pair [arr i] + (let [new-arr (make-array (- (alength arr) 2))] + (array-copy arr 0 new-arr 0 (* 2 i)) + (array-copy arr (* 2 (inc i)) new-arr (* 2 i) (- (alength new-arr) (* 2 i))) + new-arr)) + +(defn- bitmap-indexed-node-index [bitmap bit] + (bit-count (bit-and bitmap (dec bit)))) + +(defn- bitpos [hash shift] + (bit-shift-left 1 (mask hash shift))) + +(defn- edit-and-set + ([inode edit i a] + (let [editable (.ensure-editable inode edit)] + (aset (.-arr editable) i a) + editable)) + ([inode edit i a j b] + (let [editable (.ensure-editable inode edit)] + (aset (.-arr editable) i a) + (aset (.-arr editable) j b) + editable))) + +(defn- inode-kv-reduce [arr f init] + (let [len (alength arr)] + (loop [i 0 init init] + (if (< i len) + (let [init (let [k (aget arr i)] + (if-not (nil? k) + (f init k (aget arr (inc i))) + (let [node (aget arr (inc i))] + (if-not (nil? node) + (.kv-reduce node f init) + init))))] + (if (reduced? init) + @init + (recur (+ i 2) init))) + init)))) + +(declare ArrayNode) + +(deftype BitmapIndexedNode [edit ^:mutable bitmap ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (let [bit (bitpos hash shift) + idx (bitmap-indexed-node-index bitmap bit)] + (if (zero? (bit-and bitmap bit)) + (let [n (bit-count bitmap)] + (if (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash shift)] + (aset nodes jdx (.inode-assoc cljs.core.BitmapIndexedNode.EMPTY (+ shift 5) hash key val added-leaf?)) + (loop [i 0 j 0] + (if (< i 32) + (if (zero? (bit-and (bit-shift-right-zero-fill bitmap i) 1)) + (recur (inc i) j) + (do (aset nodes i + (if-not (nil? (aget arr j)) + (.inode-assoc cljs.core.BitmapIndexedNode.EMPTY + (+ shift 5) (cljs.core/hash (aget arr j)) (aget arr j) (aget arr (inc j)) added-leaf?) + (aget arr (inc j)))) + (recur (inc i) (+ j 2)))))) + (ArrayNode. nil (inc n) nodes)) + (let [new-arr (make-array (* 2 (inc n)))] + (array-copy arr 0 new-arr 0 (* 2 idx)) + (aset new-arr (* 2 idx) key) + (aset new-arr (inc (* 2 idx)) val) + (array-copy arr (* 2 idx) new-arr (* 2 (inc idx)) (* 2 (- n idx))) + (set! (.-val added-leaf?) true) + (BitmapIndexedNode. nil (bit-or bitmap bit) new-arr)))) + (let [key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-assoc val-or-node (+ shift 5) hash key val added-leaf?)] + (if (identical? n val-or-node) + inode + (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) n)))) + + (key-test key key-or-nil) + (if (identical? val val-or-node) + inode + (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) val))) + + :else + (do (set! (.-val added-leaf?) true) + (BitmapIndexedNode. nil bitmap + (clone-and-set arr (* 2 idx) nil (inc (* 2 idx)) + (create-node (+ shift 5) key-or-nil val-or-node hash key val))))))))) + + (inode-without [inode shift hash key] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + inode + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-without val-or-node (+ shift 5) hash key)] + (cond (identical? n val-or-node) inode + (not (nil? n)) (BitmapIndexedNode. nil bitmap (clone-and-set arr (inc (* 2 idx)) n)) + (== bitmap bit) nil + :else (BitmapIndexedNode. nil (bit-xor bitmap bit) (remove-pair arr idx)))) + (key-test key key-or-nil) + (BitmapIndexedNode. nil (bit-xor bitmap bit) (remove-pair arr idx)) + :else inode))))) + + (inode-lookup [inode shift hash key not-found] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + not-found + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) (.inode-lookup val-or-node (+ shift 5) hash key not-found) + (key-test key key-or-nil) val-or-node + :else not-found))))) + + (inode-find [inode shift hash key not-found] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + not-found + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) (.inode-find val-or-node (+ shift 5) hash key not-found) + (key-test key key-or-nil) [key-or-nil val-or-node] + :else not-found))))) + + (inode-seq [inode] + (create-inode-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (let [n (bit-count bitmap) + new-arr (make-array (if (neg? n) 4 (* 2 (inc n))))] + (array-copy arr 0 new-arr 0 (* 2 n)) + (BitmapIndexedNode. e bitmap new-arr)))) + + (edit-and-remove-pair [inode e bit i] + (if (== bitmap bit) + nil + (let [editable (.ensure-editable inode e) + earr (.-arr editable) + len (alength earr)] + (set! (.-bitmap editable) (bit-xor bit (.-bitmap editable))) + (array-copy earr (* 2 (inc i)) + earr (* 2 i) + (- len (* 2 (inc i)))) + (aset earr (- len 2) nil) + (aset earr (dec len) nil) + editable))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (let [bit (bitpos hash shift) + idx (bitmap-indexed-node-index bitmap bit)] + (if (zero? (bit-and bitmap bit)) + (let [n (bit-count bitmap)] + (cond + (< (* 2 n) (alength arr)) + (let [editable (.ensure-editable inode edit) + earr (.-arr editable)] + (set! (.-val added-leaf?) true) + (array-copy-downward earr (* 2 idx) + earr (* 2 (inc idx)) + (* 2 (- n idx))) + (aset earr (* 2 idx) key) + (aset earr (inc (* 2 idx)) val) + (set! (.-bitmap editable) (bit-or (.-bitmap editable) bit)) + editable) + + (>= n 16) + (let [nodes (make-array 32) + jdx (mask hash shift)] + (aset nodes jdx (.inode-assoc! cljs.core.BitmapIndexedNode.EMPTY edit (+ shift 5) hash key val added-leaf?)) + (loop [i 0 j 0] + (if (< i 32) + (if (zero? (bit-and (bit-shift-right-zero-fill bitmap i) 1)) + (recur (inc i) j) + (do (aset nodes i + (if-not (nil? (aget arr j)) + (.inode-assoc! cljs.core.BitmapIndexedNode.EMPTY + edit (+ shift 5) (cljs.core/hash (aget arr j)) (aget arr j) (aget arr (inc j)) added-leaf?) + (aget arr (inc j)))) + (recur (inc i) (+ j 2)))))) + (ArrayNode. edit (inc n) nodes)) + + :else + (let [new-arr (make-array (* 2 (+ n 4)))] + (array-copy arr 0 new-arr 0 (* 2 idx)) + (aset new-arr (* 2 idx) key) + (aset new-arr (inc (* 2 idx)) val) + (array-copy arr (* 2 idx) new-arr (* 2 (inc idx)) (* 2 (- n idx))) + (set! (.-val added-leaf?) true) + (let [editable (.ensure-editable inode edit)] + (set! (.-arr editable) new-arr) + (set! (.-bitmap editable) (bit-or (.-bitmap editable) bit)) + editable)))) + (let [key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-assoc! val-or-node edit (+ shift 5) hash key val added-leaf?)] + (if (identical? n val-or-node) + inode + (edit-and-set inode edit (inc (* 2 idx)) n))) + + (key-test key key-or-nil) + (if (identical? val val-or-node) + inode + (edit-and-set inode edit (inc (* 2 idx)) val)) + + :else + (do (set! (.-val added-leaf?) true) + (edit-and-set inode edit (* 2 idx) nil (inc (* 2 idx)) + (create-node edit (+ shift 5) key-or-nil val-or-node hash key val)))))))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [bit (bitpos hash shift)] + (if (zero? (bit-and bitmap bit)) + inode + (let [idx (bitmap-indexed-node-index bitmap bit) + key-or-nil (aget arr (* 2 idx)) + val-or-node (aget arr (inc (* 2 idx)))] + (cond (nil? key-or-nil) + (let [n (.inode-without! val-or-node edit (+ shift 5) hash key removed-leaf?)] + (cond (identical? n val-or-node) inode + (not (nil? n)) (edit-and-set inode edit (inc (* 2 idx)) n) + (== bitmap bit) nil + :else (.edit-and-remove-pair inode edit bit idx))) + (key-test key key-or-nil) + (do (aset removed-leaf? 0 true) + (.edit-and-remove-pair inode edit bit idx)) + :else inode))))) + + (kv-reduce [inode f init] + (inode-kv-reduce arr f init))) + +(set! cljs.core.BitmapIndexedNode.EMPTY (BitmapIndexedNode. nil 0 (make-array 0))) + +(defn- pack-array-node [array-node edit idx] + (let [arr (.-arr array-node) + len (* 2 (dec (.-cnt array-node))) + new-arr (make-array len)] + (loop [i 0 j 1 bitmap 0] + (if (< i len) + (if (and (not (== i idx)) + (not (nil? (aget arr i)))) + (do (aset new-arr j (aget arr i)) + (recur (inc i) (+ j 2) (bit-or bitmap (bit-shift-left 1 i)))) + (recur (inc i) j bitmap)) + (BitmapIndexedNode. edit bitmap new-arr))))) + +(deftype ArrayNode [edit ^:mutable cnt ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + (ArrayNode. nil (inc cnt) (clone-and-set arr idx (.inode-assoc cljs.core.BitmapIndexedNode.EMPTY (+ shift 5) hash key val added-leaf?))) + (let [n (.inode-assoc node (+ shift 5) hash key val added-leaf?)] + (if (identical? n node) + inode + (ArrayNode. nil cnt (clone-and-set arr idx n))))))) + + (inode-without [inode shift hash key] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (let [n (.inode-without node (+ shift 5) hash key)] + (cond + (identical? n node) + inode + + (nil? n) + (if (<= cnt 8) + (pack-array-node inode nil idx) + (ArrayNode. nil (dec cnt) (clone-and-set arr idx n))) + + :else + (ArrayNode. nil cnt (clone-and-set arr idx n)))) + inode))) + + (inode-lookup [inode shift hash key not-found] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (.inode-lookup node (+ shift 5) hash key not-found) + not-found))) + + (inode-find [inode shift hash key not-found] + (let [idx (mask hash shift) + node (aget arr idx)] + (if-not (nil? node) + (.inode-find node (+ shift 5) hash key not-found) + not-found))) + + (inode-seq [inode] + (create-array-node-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (ArrayNode. e cnt (aclone arr)))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + (let [editable (edit-and-set inode edit idx (.inode-assoc! cljs.core.BitmapIndexedNode.EMPTY edit (+ shift 5) hash key val added-leaf?))] + (set! (.-cnt editable) (inc (.-cnt editable))) + editable) + (let [n (.inode-assoc! node edit (+ shift 5) hash key val added-leaf?)] + (if (identical? n node) + inode + (edit-and-set inode edit idx n)))))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [idx (mask hash shift) + node (aget arr idx)] + (if (nil? node) + inode + (let [n (.inode-without! node edit (+ shift 5) hash key removed-leaf?)] + (cond + (identical? n node) + inode + + (nil? n) + (if (<= cnt 8) + (pack-array-node inode edit idx) + (let [editable (edit-and-set inode edit idx n)] + (set! (.-cnt editable) (dec (.-cnt editable))) + editable)) + + :else + (edit-and-set inode edit idx n)))))) + + (kv-reduce [inode f init] + (let [len (alength arr)] ; actually 32 + (loop [i 0 init init] + (if (< i len) + (let [node (aget arr i)] + (if-not (nil? node) + (let [init (.kv-reduce node f init)] + (if (reduced? init) + @init + (recur (inc i) init))) + (recur (inc i) init))) + init))))) + +(defn- hash-collision-node-find-index [arr cnt key] + (let [lim (* 2 cnt)] + (loop [i 0] + (if (< i lim) + (if (key-test key (aget arr i)) + i + (recur (+ i 2))) + -1)))) + +(deftype HashCollisionNode [edit + ^:mutable collision-hash + ^:mutable cnt + ^:mutable arr] + Object + (inode-assoc [inode shift hash key val added-leaf?] + (if (== hash collision-hash) + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + (let [len (* 2 cnt) + new-arr (make-array (+ len 2))] + (array-copy arr 0 new-arr 0 len) + (aset new-arr len key) + (aset new-arr (inc len) val) + (set! (.-val added-leaf?) true) + (HashCollisionNode. nil collision-hash (inc cnt) new-arr)) + (if (= (aget arr idx) val) + inode + (HashCollisionNode. nil collision-hash cnt (clone-and-set arr (inc idx) val))))) + (.inode-assoc (BitmapIndexedNode. nil (bitpos collision-hash shift) (array nil inode)) + shift hash key val added-leaf?))) + + (inode-without [inode shift hash key] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (== idx -1) inode + (== cnt 1) nil + :else (HashCollisionNode. nil collision-hash (dec cnt) (remove-pair arr (quot idx 2)))))) + + (inode-lookup [inode shift hash key not-found] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (< idx 0) not-found + (key-test key (aget arr idx)) (aget arr (inc idx)) + :else not-found))) + + (inode-find [inode shift hash key not-found] + (let [idx (hash-collision-node-find-index arr cnt key)] + (cond (< idx 0) not-found + (key-test key (aget arr idx)) [(aget arr idx) (aget arr (inc idx))] + :else not-found))) + + (inode-seq [inode] + (create-inode-seq arr)) + + (ensure-editable [inode e] + (if (identical? e edit) + inode + (let [new-arr (make-array (* 2 (inc cnt)))] + (array-copy arr 0 new-arr 0 (* 2 cnt)) + (HashCollisionNode. e collision-hash cnt new-arr)))) + + (ensure-editable-array [inode e count array] + (if (identical? e edit) + (do (set! arr array) + (set! cnt count) + inode) + (HashCollisionNode. edit collision-hash count array))) + + (inode-assoc! [inode edit shift hash key val added-leaf?] + (if (== hash collision-hash) + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + (if (> (alength arr) (* 2 cnt)) + (let [editable (edit-and-set inode edit (* 2 cnt) key (inc (* 2 cnt)) val)] + (set! (.-val added-leaf?) true) + (set! (.-cnt editable) (inc (.-cnt editable))) + editable) + (let [len (alength arr) + new-arr (make-array (+ len 2))] + (array-copy arr 0 new-arr 0 len) + (aset new-arr len key) + (aset new-arr (inc len) val) + (set! (.-val added-leaf?) true) + (.ensure-editable-array inode edit (inc cnt) new-arr))) + (if (identical? (aget arr (inc idx)) val) + inode + (edit-and-set inode edit (inc idx) val)))) + (.inode-assoc! (BitmapIndexedNode. edit (bitpos collision-hash shift) (array nil inode nil nil)) + edit shift hash key val added-leaf?))) + + (inode-without! [inode edit shift hash key removed-leaf?] + (let [idx (hash-collision-node-find-index arr cnt key)] + (if (== idx -1) + inode + (do (aset removed-leaf? 0 true) + (if (== cnt 1) + nil + (let [editable (.ensure-editable inode edit) + earr (.-arr editable)] + (aset earr idx (aget earr (- (* 2 cnt) 2))) + (aset earr (inc idx) (aget earr (dec (* 2 cnt)))) + (aset earr (dec (* 2 cnt)) nil) + (aset earr (- (* 2 cnt) 2) nil) + (set! (.-cnt editable) (dec (.-cnt editable))) + editable)))))) + + (kv-reduce [inode f init] + (inode-kv-reduce arr f init))) + +(defn- create-node + ([shift key1 val1 key2hash key2 val2] + (let [key1hash (hash key1)] + (if (== key1hash key2hash) + (HashCollisionNode. nil key1hash 2 (array key1 val1 key2 val2)) + (let [added-leaf? (Box. false)] + (-> cljs.core.BitmapIndexedNode.EMPTY + (.inode-assoc shift key1hash key1 val1 added-leaf?) + (.inode-assoc shift key2hash key2 val2 added-leaf?)))))) + ([edit shift key1 val1 key2hash key2 val2] + (let [key1hash (hash key1)] + (if (== key1hash key2hash) + (HashCollisionNode. nil key1hash 2 (array key1 val1 key2 val2)) + (let [added-leaf? (Box. false)] + (-> cljs.core.BitmapIndexedNode.EMPTY + (.inode-assoc! edit shift key1hash key1 val1 added-leaf?) + (.inode-assoc! edit shift key2hash key2 val2 added-leaf?))))))) + +(deftype NodeSeq [meta nodes i s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] (NodeSeq. meta nodes i s __hash)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + ISeq + (-first [coll] + (if (nil? s) + [(aget nodes i) (aget nodes (inc i))] + (first s))) + + (-rest [coll] + (if (nil? s) + (create-inode-seq nodes (+ i 2) nil) + (create-inode-seq nodes i (next s)))) + + ISeqable + (-seq [this] this) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn- create-inode-seq + ([nodes] + (create-inode-seq nodes 0 nil)) + ([nodes i s] + (if (nil? s) + (let [len (alength nodes)] + (loop [j i] + (if (< j len) + (if-not (nil? (aget nodes j)) + (NodeSeq. nil nodes j nil nil) + (if-let [node (aget nodes (inc j))] + (if-let [node-seq (.inode-seq node)] + (NodeSeq. nil nodes (+ j 2) node-seq nil) + (recur (+ j 2))) + (recur (+ j 2))))))) + (NodeSeq. nil nodes i s nil)))) + +(deftype ArrayNodeSeq [meta nodes i s ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] (ArrayNodeSeq. meta nodes i s __hash)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + ISeq + (-first [coll] (first s)) + (-rest [coll] (create-array-node-seq nil nodes i (next s))) + + ISeqable + (-seq [this] this) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn- create-array-node-seq + ([nodes] (create-array-node-seq nil nodes 0 nil)) + ([meta nodes i s] + (if (nil? s) + (let [len (alength nodes)] + (loop [j i] + (if (< j len) + (if-let [nj (aget nodes j)] + (if-let [ns (.inode-seq nj)] + (ArrayNodeSeq. meta nodes (inc j) ns nil) + (recur (inc j))) + (recur (inc j)))))) + (ArrayNodeSeq. meta nodes i s nil)))) + +(declare TransientHashMap) + +(deftype PersistentHashMap [meta cnt root ^boolean has-nil? nil-val ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentHashMap. meta cnt root has-nil? nil-val __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentHashMap. meta cnt root has-nil? nil-val __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj coll entry))) + + IEmptyableCollection + (-empty [coll] (-with-meta cljs.core.PersistentHashMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ISeqable + (-seq [coll] + (when (pos? cnt) + (let [s (if-not (nil? root) (.inode-seq root))] + (if has-nil? + (cons [nil nil-val] s) + s)))) + + ICounted + (-count [coll] cnt) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (cond (nil? k) (if has-nil? + nil-val + not-found) + (nil? root) not-found + :else (.inode-lookup root 0 (hash k) k not-found))) + + IAssociative + (-assoc [coll k v] + (if (nil? k) + (if (and has-nil? (identical? v nil-val)) + coll + (PersistentHashMap. meta (if has-nil? cnt (inc cnt)) root true v nil)) + (let [added-leaf? (Box. false) + new-root (-> (if (nil? root) + cljs.core.BitmapIndexedNode.EMPTY + root) + (.inode-assoc 0 (hash k) k v added-leaf?))] + (if (identical? new-root root) + coll + (PersistentHashMap. meta (if ^boolean (.-val added-leaf?) (inc cnt) cnt) new-root has-nil? nil-val nil))))) + + (-contains-key? [coll k] + (cond (nil? k) has-nil? + (nil? root) false + :else (not (identical? (.inode-lookup root 0 (hash k) k lookup-sentinel) + lookup-sentinel)))) + + IMap + (-dissoc [coll k] + (cond (nil? k) (if has-nil? + (PersistentHashMap. meta (dec cnt) root false nil nil) + coll) + (nil? root) coll + :else + (let [new-root (.inode-without root 0 (hash k) k)] + (if (identical? new-root root) + coll + (PersistentHashMap. meta (dec cnt) new-root has-nil? nil-val nil))))) + + IKVReduce + (-kv-reduce [coll f init] + (let [init (if has-nil? (f init nil nil-val) init)] + (cond + (reduced? init) @init + (not (nil? root)) (.kv-reduce root f init) + :else init))) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] + (TransientHashMap. (js-obj) root cnt has-nil? nil-val))) + +(set! cljs.core.PersistentHashMap.EMPTY (PersistentHashMap. nil 0 nil false nil 0)) + +(set! cljs.core.PersistentHashMap.fromArrays + (fn [ks vs] + (let [len (alength ks)] + (loop [i 0 ^not-native out (transient cljs.core.PersistentHashMap.EMPTY)] + (if (< i len) + (recur (inc i) (-assoc! out (aget ks i) (aget vs i))) + (persistent! out)))))) + +(deftype TransientHashMap [^:mutable ^boolean edit + ^:mutable root + ^:mutable count + ^:mutable ^boolean has-nil? + ^:mutable nil-val] + Object + (conj! [tcoll o] + (if edit + (if (satisfies? IMapEntry o) + (.assoc! tcoll (key o) (val o)) + (loop [es (seq o) tcoll tcoll] + (if-let [e (first es)] + (recur (next es) + (.assoc! tcoll (key e) (val e))) + tcoll))) + (throw (js/Error. "conj! after persistent")))) + + (assoc! [tcoll k v] + (if edit + (if (nil? k) + (do (if (identical? nil-val v) + nil + (set! nil-val v)) + (if has-nil? + nil + (do (set! count (inc count)) + (set! has-nil? true))) + tcoll) + (let [added-leaf? (Box. false) + node (-> (if (nil? root) + cljs.core.BitmapIndexedNode.EMPTY + root) + (.inode-assoc! edit 0 (hash k) k v added-leaf?))] + (if (identical? node root) + nil + (set! root node)) + (if ^boolean (.-val added-leaf?) + (set! count (inc count))) + tcoll)) + (throw (js/Error. "assoc! after persistent!")))) + + (without! [tcoll k] + (if edit + (if (nil? k) + (if has-nil? + (do (set! has-nil? false) + (set! nil-val nil) + (set! count (dec count)) + tcoll) + tcoll) + (if (nil? root) + tcoll + (let [removed-leaf? (Box. false) + node (.inode-without! root edit 0 (hash k) k removed-leaf?)] + (if (identical? node root) + nil + (set! root node)) + (if (aget removed-leaf? 0) + (set! count (dec count))) + tcoll))) + (throw (js/Error. "dissoc! after persistent!")))) + + (persistent! [tcoll] + (if edit + (do (set! edit nil) + (PersistentHashMap. nil count root has-nil? nil-val nil)) + (throw (js/Error. "persistent! called twice")))) + + ICounted + (-count [coll] + (if edit + count + (throw (js/Error. "count after persistent!")))) + + ILookup + (-lookup [tcoll k] + (if (nil? k) + (if has-nil? + nil-val) + (if (nil? root) + nil + (.inode-lookup root 0 (hash k) k)))) + + (-lookup [tcoll k not-found] + (if (nil? k) + (if has-nil? + nil-val + not-found) + (if (nil? root) + not-found + (.inode-lookup root 0 (hash k) k not-found)))) + + ITransientCollection + (-conj! [tcoll val] (.conj! tcoll val)) + + (-persistent! [tcoll] (.persistent! tcoll)) + + ITransientAssociative + (-assoc! [tcoll key val] (.assoc! tcoll key val)) + + ITransientMap + (-dissoc! [tcoll key] (.without! tcoll key))) + +;;; PersistentTreeMap + +(defn- tree-map-seq-push [node stack ^boolean ascending?] + (loop [t node stack stack] + (if-not (nil? t) + (recur (if ascending? (.-left t) (.-right t)) + (conj stack t)) + stack))) + +(deftype PersistentTreeMapSeq [meta stack ^boolean ascending? cnt ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ISeqable + (-seq [this] this) + + ISequential + ISeq + (-first [this] (peek stack)) + (-rest [this] + (let [t (first stack) + next-stack (tree-map-seq-push (if ascending? (.-right t) (.-left t)) + (next stack) + ascending?)] + (if-not (nil? next-stack) + (PersistentTreeMapSeq. nil next-stack ascending? (dec cnt) nil) + ()))) + + ICounted + (-count [coll] + (if (neg? cnt) + (inc (count (next coll))) + cnt)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY meta)) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IMeta + (-meta [coll] meta) + + IWithMeta + (-with-meta [coll meta] + (PersistentTreeMapSeq. meta stack ascending? cnt __hash)) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn- create-tree-map-seq [tree ascending? cnt] + (PersistentTreeMapSeq. nil (tree-map-seq-push tree nil ascending?) ascending? cnt nil)) + +(declare RedNode BlackNode) + +(defn- balance-left [key val ins right] + (if (instance? RedNode ins) + (cond + (instance? RedNode (.-left ins)) + (RedNode. (.-key ins) (.-val ins) + (.blacken (.-left ins)) + (BlackNode. key val (.-right ins) right nil) + nil) + + (instance? RedNode (.-right ins)) + (RedNode. (.. ins -right -key) (.. ins -right -val) + (BlackNode. (.-key ins) (.-val ins) + (.-left ins) + (.. ins -right -left) + nil) + (BlackNode. key val + (.. ins -right -right) + right + nil) + nil) + + :else + (BlackNode. key val ins right nil)) + (BlackNode. key val ins right nil))) + +(defn- balance-right [key val left ins] + (if (instance? RedNode ins) + (cond + (instance? RedNode (.-right ins)) + (RedNode. (.-key ins) (.-val ins) + (BlackNode. key val left (.-left ins) nil) + (.blacken (.-right ins)) + nil) + + (instance? RedNode (.-left ins)) + (RedNode. (.. ins -left -key) (.. ins -left -val) + (BlackNode. key val left (.. ins -left -left) nil) + (BlackNode. (.-key ins) (.-val ins) + (.. ins -left -right) + (.-right ins) + nil) + nil) + + :else + (BlackNode. key val left ins nil)) + (BlackNode. key val left ins nil))) + +(defn- balance-left-del [key val del right] + (cond + (instance? RedNode del) + (RedNode. key val (.blacken del) right nil) + + (instance? BlackNode right) + (balance-right key val del (.redden right)) + + (and (instance? RedNode right) (instance? BlackNode (.-left right))) + (RedNode. (.. right -left -key) (.. right -left -val) + (BlackNode. key val del (.. right -left -left) nil) + (balance-right (.-key right) (.-val right) + (.. right -left -right) + (.redden (.-right right))) + nil) + + :else + (throw (js/Error. "red-black tree invariant violation")))) + +(defn- balance-right-del [key val left del] + (cond + (instance? RedNode del) + (RedNode. key val left (.blacken del) nil) + + (instance? BlackNode left) + (balance-left key val (.redden left) del) + + (and (instance? RedNode left) (instance? BlackNode (.-right left))) + (RedNode. (.. left -right -key) (.. left -right -val) + (balance-left (.-key left) (.-val left) + (.redden (.-left left)) + (.. left -right -left)) + (BlackNode. key val (.. left -right -right) del nil) + nil) + + :else + (throw (js/Error. "red-black tree invariant violation")))) + +(defn- tree-map-kv-reduce [node f init] + (let [init (if-not (nil? (.-left node)) + (tree-map-kv-reduce (.-left node) f init) + init)] + (if (reduced? init) + @init + (let [init (f init (.-key node) (.-val node))] + (if (reduced? init) + @init + (let [init (if-not (nil? (.-right node)) + (tree-map-kv-reduce (.-right node) f init) + init)] + (if (reduced? init) + @init + init))))))) + +(deftype BlackNode [key val left right ^:mutable __hash] + Object + (add-left [node ins] + (.balance-left ins node)) + + (add-right [node ins] + (.balance-right ins node)) + + (remove-left [node del] + (balance-left-del key val del right)) + + (remove-right [node del] + (balance-right-del key val left del)) + + (blacken [node] node) + + (redden [node] (RedNode. key val left right nil)) + + (balance-left [node parent] + (BlackNode. (.-key parent) (.-val parent) node (.-right parent) nil)) + + (balance-right [node parent] + (BlackNode. (.-key parent) (.-val parent) (.-left parent) node nil)) + + (replace [node key val left right] + (BlackNode. key val left right nil)) + + (kv-reduce [node f init] + (tree-map-kv-reduce node f init)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] []) + + ISequential + ISeqable + (-seq [node] (list key val)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else nil)) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-lookup node k)) + + (-invoke [node k not-found] + (-lookup node k not-found))) + +(deftype RedNode [key val left right ^:mutable __hash] + Object + (add-left [node ins] + (RedNode. key val ins right nil)) + + (add-right [node ins] + (RedNode. key val left ins nil)) + + (remove-left [node del] + (RedNode. key val del right nil)) + + (remove-right [node del] + (RedNode. key val left del nil)) + + (blacken [node] + (BlackNode. key val left right nil)) + + (redden [node] + (throw (js/Error. "red-black tree invariant violation"))) + + (balance-left [node parent] + (cond + (instance? RedNode left) + (RedNode. key val + (.blacken left) + (BlackNode. (.-key parent) (.-val parent) right (.-right parent) nil) + nil) + + (instance? RedNode right) + (RedNode. (.-key right) (.-val right) + (BlackNode. key val left (.-left right) nil) + (BlackNode. (.-key parent) (.-val parent) + (.-right right) + (.-right parent) + nil) + nil) + + :else + (BlackNode. (.-key parent) (.-val parent) node (.-right parent) nil))) + + (balance-right [node parent] + (cond + (instance? RedNode right) + (RedNode. key val + (BlackNode. (.-key parent) (.-val parent) + (.-left parent) + left + nil) + (.blacken right) + nil) + + (instance? RedNode left) + (RedNode. (.-key left) (.-val left) + (BlackNode. (.-key parent) (.-val parent) + (.-left parent) + (.-left left) + nil) + (BlackNode. key val (.-right left) right nil) + nil) + + :else + (BlackNode. (.-key parent) (.-val parent) (.-left parent) node nil))) + + (replace [node key val left right] + (RedNode. key val left right nil)) + + (kv-reduce [node f init] + (tree-map-kv-reduce node f init)) + + IMapEntry + (-key [node] key) + (-val [node] val) + + IHash + (-hash [coll] (caching-hash coll hash-coll __hash)) + + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + IMeta + (-meta [node] nil) + + IWithMeta + (-with-meta [node meta] + (with-meta [key val] meta)) + + IStack + (-peek [node] val) + + (-pop [node] [key]) + + ICollection + (-conj [node o] [key val o]) + + IEmptyableCollection + (-empty [node] []) + + ISequential + ISeqable + (-seq [node] (list key val)) + + ICounted + (-count [node] 2) + + IIndexed + (-nth [node n] + (cond (== n 0) key + (== n 1) val + :else nil)) + + (-nth [node n not-found] + (cond (== n 0) key + (== n 1) val + :else not-found)) + + ILookup + (-lookup [node k] (-nth node k nil)) + (-lookup [node k not-found] (-nth node k not-found)) + + IAssociative + (-assoc [node k v] + (assoc [key val] k v)) + + IVector + (-assoc-n [node n v] + (-assoc-n [key val] n v)) + + IReduce + (-reduce [node f] + (ci-reduce node f)) + + (-reduce [node f start] + (ci-reduce node f start)) + + IFn + (-invoke [node k] + (-lookup node k)) + + (-invoke [node k not-found] + (-lookup node k not-found))) + +(defn- tree-map-add [comp tree k v found] + (if (nil? tree) + (RedNode. k v nil nil nil) + (let [c (comp k (.-key tree))] + (cond + (zero? c) + (do (aset found 0 tree) + nil) + + (neg? c) + (let [ins (tree-map-add comp (.-left tree) k v found)] + (if-not (nil? ins) + (.add-left tree ins))) + + :else + (let [ins (tree-map-add comp (.-right tree) k v found)] + (if-not (nil? ins) + (.add-right tree ins))))))) + +(defn- tree-map-append [left right] + (cond + (nil? left) + right + + (nil? right) + left + + (instance? RedNode left) + (if (instance? RedNode right) + (let [app (tree-map-append (.-right left) (.-left right))] + (if (instance? RedNode app) + (RedNode. (.-key app) (.-val app) + (RedNode. (.-key left) (.-val left) + (.-left left) + (.-left app) + nil) + (RedNode. (.-key right) (.-val right) + (.-right app) + (.-right right) + nil) + nil) + (RedNode. (.-key left) (.-val left) + (.-left left) + (RedNode. (.-key right) (.-val right) app (.-right right) nil) + nil))) + (RedNode. (.-key left) (.-val left) + (.-left left) + (tree-map-append (.-right left) right) + nil)) + + (instance? RedNode right) + (RedNode. (.-key right) (.-val right) + (tree-map-append left (.-left right)) + (.-right right) + nil) + + :else + (let [app (tree-map-append (.-right left) (.-left right))] + (if (instance? RedNode app) + (RedNode. (.-key app) (.-val app) + (BlackNode. (.-key left) (.-val left) + (.-left left) + (.-left app) + nil) + (BlackNode. (.-key right) (.-val right) + (.-right app) + (.-right right) + nil) + nil) + (balance-left-del (.-key left) (.-val left) + (.-left left) + (BlackNode. (.-key right) (.-val right) + app + (.-right right) + nil)))))) + +(defn- tree-map-remove [comp tree k found] + (if-not (nil? tree) + (let [c (comp k (.-key tree))] + (cond + (zero? c) + (do (aset found 0 tree) + (tree-map-append (.-left tree) (.-right tree))) + + (neg? c) + (let [del (tree-map-remove comp (.-left tree) k found)] + (if (or (not (nil? del)) (not (nil? (aget found 0)))) + (if (instance? BlackNode (.-left tree)) + (balance-left-del (.-key tree) (.-val tree) del (.-right tree)) + (RedNode. (.-key tree) (.-val tree) del (.-right tree) nil)))) + + :else + (let [del (tree-map-remove comp (.-right tree) k found)] + (if (or (not (nil? del)) (not (nil? (aget found 0)))) + (if (instance? BlackNode (.-right tree)) + (balance-right-del (.-key tree) (.-val tree) (.-left tree) del) + (RedNode. (.-key tree) (.-val tree) (.-left tree) del nil)))))))) + +(defn- tree-map-replace [comp tree k v] + (let [tk (.-key tree) + c (comp k tk)] + (cond (zero? c) (.replace tree tk v (.-left tree) (.-right tree)) + (neg? c) (.replace tree tk (.-val tree) (tree-map-replace comp (.-left tree) k v) (.-right tree)) + :else (.replace tree tk (.-val tree) (.-left tree) (tree-map-replace comp (.-right tree) k v))))) + +(declare key) + +(deftype PersistentTreeMap [comp tree cnt meta ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + (entry-at [coll k] + (loop [t tree] + (if-not (nil? t) + (let [c (comp k (.-key t))] + (cond (zero? c) t + (neg? c) (recur (.-left t)) + :else (recur (.-right t))))))) + + ICloneable + (-clone [_] (PersistentTreeMap. comp tree cnt meta __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentTreeMap. comp tree cnt meta __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll entry] + (if (vector? entry) + (-assoc coll (-nth entry 0) (-nth entry 1)) + (reduce -conj + coll + entry))) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentTreeMap.EMPTY meta)) + + IEquiv + (-equiv [coll other] (equiv-map coll other)) + + IHash + (-hash [coll] (caching-hash coll hash-imap __hash)) + + ICounted + (-count [coll] cnt) + + IKVReduce + (-kv-reduce [coll f init] + (if-not (nil? tree) + (tree-map-kv-reduce tree f init) + init)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + ISeqable + (-seq [coll] + (if (pos? cnt) + (create-tree-map-seq tree true cnt))) + + IReversible + (-rseq [coll] + (if (pos? cnt) + (create-tree-map-seq tree false cnt))) + + ILookup + (-lookup [coll k] + (-lookup coll k nil)) + + (-lookup [coll k not-found] + (let [n (.entry-at coll k)] + (if-not (nil? n) + (.-val n) + not-found))) + + IAssociative + (-assoc [coll k v] + (let [found (array nil) + t (tree-map-add comp tree k v found)] + (if (nil? t) + (let [found-node (nth found 0)] + (if (= v (.-val found-node)) + coll + (PersistentTreeMap. comp (tree-map-replace comp tree k v) cnt meta nil))) + (PersistentTreeMap. comp (.blacken t) (inc cnt) meta nil)))) + + (-contains-key? [coll k] + (not (nil? (.entry-at coll k)))) + + IMap + (-dissoc [coll k] + (let [found (array nil) + t (tree-map-remove comp tree k found)] + (if (nil? t) + (if (nil? (nth found 0)) + coll + (PersistentTreeMap. comp nil 0 meta nil)) + (PersistentTreeMap. comp (.blacken t) (dec cnt) meta nil)))) + + ISorted + (-sorted-seq [coll ascending?] + (if (pos? cnt) + (create-tree-map-seq tree ascending? cnt))) + + (-sorted-seq-from [coll k ascending?] + (if (pos? cnt) + (loop [stack nil t tree] + (if-not (nil? t) + (let [c (comp k (.-key t))] + (cond + (zero? c) (PersistentTreeMapSeq. nil (conj stack t) ascending? -1 nil) + ascending? (if (neg? c) + (recur (conj stack t) (.-left t)) + (recur stack (.-right t))) + :else (if (pos? c) + (recur (conj stack t) (.-right t)) + (recur stack (.-left t))))) + (when-not (nil? stack) + (PersistentTreeMapSeq. nil stack ascending? -1 nil)))))) + + (-entry-key [coll entry] (key entry)) + + (-comparator [coll] comp)) + +(set! cljs.core.PersistentTreeMap.EMPTY (PersistentTreeMap. compare nil 0 nil 0)) + +(defn hash-map + "keyval => key val + Returns a new hash map with supplied mappings." + [& keyvals] + (loop [in (seq keyvals), out (transient cljs.core.PersistentHashMap.EMPTY)] + (if in + (recur (nnext in) (assoc! out (first in) (second in))) + (persistent! out)))) + +(defn array-map + "keyval => key val + Returns a new array map with supplied mappings." + [& keyvals] + (PersistentArrayMap. nil (quot (count keyvals) 2) (apply array keyvals) nil)) + +(defn obj-map + "keyval => key val + Returns a new object map with supplied mappings." + [& keyvals] + (let [ks (array) + obj (js-obj)] + (loop [kvs (seq keyvals)] + (if kvs + (do (.push ks (first kvs)) + (aset obj (first kvs) (second kvs)) + (recur (nnext kvs))) + (cljs.core.ObjMap.fromObject ks obj))))) + +(defn sorted-map + "keyval => key val + Returns a new sorted map with supplied mappings." + ([& keyvals] + (loop [in (seq keyvals) out cljs.core.PersistentTreeMap.EMPTY] + (if in + (recur (nnext in) (assoc out (first in) (second in))) + out)))) + +(defn sorted-map-by + "keyval => key val + Returns a new sorted map with supplied mappings, using the supplied comparator." + ([comparator & keyvals] + (loop [in (seq keyvals) + out (cljs.core.PersistentTreeMap. (fn->comparator comparator) nil 0 nil 0)] + (if in + (recur (nnext in) (assoc out (first in) (second in))) + out)))) + +(deftype KeySeq [^not-native mseq _meta] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] (KeySeq. mseq new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY _meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + ISeq + (-first [coll] + (let [^not-native me (-first mseq)] + (-key me))) + + (-rest [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (if-not (nil? nseq) + (KeySeq. nseq _meta) + ()))) + + INext + (-next [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (when-not (nil? nseq) + (KeySeq. nseq _meta)))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn keys + "Returns a sequence of the map's keys." + [hash-map] + (when-let [mseq (seq hash-map)] + (KeySeq. mseq nil))) + +(defn key + "Returns the key of the map entry." + [map-entry] + (-key map-entry)) + +(deftype ValSeq [^not-native mseq _meta] + Object + (toString [coll] + (pr-str* coll)) + + IMeta + (-meta [coll] _meta) + + IWithMeta + (-with-meta [coll new-meta] (ValSeq. mseq new-meta)) + + ISeqable + (-seq [coll] coll) + + ISequential + IEquiv + (-equiv [coll other] (equiv-sequential coll other)) + + ICollection + (-conj [coll o] + (cons o coll)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.List.EMPTY _meta)) + + IHash + (-hash [coll] (hash-coll coll)) + + ISeq + (-first [coll] + (let [^not-native me (-first mseq)] + (-val me))) + + (-rest [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (if-not (nil? nseq) + (ValSeq. nseq _meta) + ()))) + + INext + (-next [coll] + (let [nseq (if (satisfies? INext mseq) + (-next mseq) + (next mseq))] + (when-not (nil? nseq) + (ValSeq. nseq _meta)))) + + IReduce + (-reduce [coll f] (seq-reduce f coll)) + (-reduce [coll f start] (seq-reduce f start coll))) + +(defn vals + "Returns a sequence of the map's values." + [hash-map] + (when-let [mseq (seq hash-map)] + (ValSeq. mseq nil))) + +(defn val + "Returns the value in the map entry." + [map-entry] + (-val map-entry)) + +(defn merge + "Returns a map that consists of the rest of the maps conj-ed onto + the first. If a key occurs in more than one map, the mapping from + the latter (left-to-right) will be the mapping in the result." + [& maps] + (when (some identity maps) + (reduce #(conj (or %1 {}) %2) maps))) + +(defn merge-with + "Returns a map that consists of the rest of the maps conj-ed onto + the first. If a key occurs in more than one map, the mapping(s) + from the latter (left-to-right) will be combined with the mapping in + the result by calling (f val-in-result val-in-latter)." + [f & maps] + (when (some identity maps) + (let [merge-entry (fn [m e] + (let [k (first e) v (second e)] + (if (contains? m k) + (assoc m k (f (get m k) v)) + (assoc m k v)))) + merge2 (fn [m1 m2] + (reduce merge-entry (or m1 {}) (seq m2)))] + (reduce merge2 maps)))) + +(defn select-keys + "Returns a map containing only those entries in map whose key is in keys" + [map keyseq] + (loop [ret {} keys (seq keyseq)] + (if keys + (let [key (first keys) + entry (get map key ::not-found)] + (recur + (if (not= entry ::not-found) + (assoc ret key entry) + ret) + (next keys))) + ret))) + +;;; PersistentHashSet + +(declare TransientHashSet) + +(deftype PersistentHashSet [meta hash-map ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentHashSet. meta hash-map __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentHashSet. meta hash-map __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll o] + (PersistentHashSet. meta (assoc hash-map o nil) nil)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentHashSet.EMPTY meta)) + + IEquiv + (-equiv [coll other] + (and + (set? other) + (== (count coll) (count other)) + (every? #(contains? coll %) + other))) + + IHash + (-hash [coll] (caching-hash coll hash-iset __hash)) + + ISeqable + (-seq [coll] (keys hash-map)) + + ICounted + (-count [coll] (-count hash-map)) + + ILookup + (-lookup [coll v] + (-lookup coll v nil)) + (-lookup [coll v not-found] + (if (-contains-key? hash-map v) + v + not-found)) + + ISet + (-disjoin [coll v] + (PersistentHashSet. meta (-dissoc hash-map v) nil)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found)) + + IEditableCollection + (-as-transient [coll] (TransientHashSet. (-as-transient hash-map)))) + +(set! cljs.core.PersistentHashSet.EMPTY + (PersistentHashSet. nil cljs.core.PersistentArrayMap.EMPTY 0)) + +(set! cljs.core.PersistentHashSet.fromArray + (fn [items ^boolean no-clone] + (let [len (alength items)] + (if (<= len cljs.core.PersistentArrayMap.HASHMAP_THRESHOLD) + (let [arr (if no-clone items (aclone items))] + (loop [i 0 + out (transient cljs.core.PersistentArrayMap.EMPTY)] + (if (< i len) + (recur (inc i) (-assoc! out (aget items i) nil)) + (cljs.core.PersistentHashSet. nil (-persistent! out) nil)))) + (loop [i 0 + out (transient cljs.core.PersistentHashSet.EMPTY)] + (if (< i len) + (recur (inc i) (-conj! out (aget items i))) + (-persistent! out))))))) + +(deftype TransientHashSet [^:mutable transient-map] + ITransientCollection + (-conj! [tcoll o] + (set! transient-map (assoc! transient-map o nil)) + tcoll) + + (-persistent! [tcoll] + (PersistentHashSet. nil (persistent! transient-map) nil)) + + ITransientSet + (-disjoin! [tcoll v] + (set! transient-map (dissoc! transient-map v)) + tcoll) + + ICounted + (-count [tcoll] (count transient-map)) + + ILookup + (-lookup [tcoll v] + (-lookup tcoll v nil)) + + (-lookup [tcoll v not-found] + (if (identical? (-lookup transient-map v lookup-sentinel) lookup-sentinel) + not-found + v)) + + IFn + (-invoke [tcoll k] + (if (identical? (-lookup transient-map k lookup-sentinel) lookup-sentinel) + nil + k)) + + (-invoke [tcoll k not-found] + (if (identical? (-lookup transient-map k lookup-sentinel) lookup-sentinel) + not-found + k))) + +(deftype PersistentTreeSet [meta tree-map ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (PersistentTreeSet. meta tree-map __hash)) + + IWithMeta + (-with-meta [coll meta] (PersistentTreeSet. meta tree-map __hash)) + + IMeta + (-meta [coll] meta) + + ICollection + (-conj [coll o] + (PersistentTreeSet. meta (assoc tree-map o nil) nil)) + + IEmptyableCollection + (-empty [coll] (with-meta cljs.core.PersistentTreeSet.EMPTY meta)) + + IEquiv + (-equiv [coll other] + (and + (set? other) + (== (count coll) (count other)) + (every? #(contains? coll %) + other))) + + IHash + (-hash [coll] (caching-hash coll hash-iset __hash)) + + ISeqable + (-seq [coll] (keys tree-map)) + + ISorted + (-sorted-seq [coll ascending?] + (map key (-sorted-seq tree-map ascending?))) + + (-sorted-seq-from [coll k ascending?] + (map key (-sorted-seq-from tree-map k ascending?))) + + (-entry-key [coll entry] entry) + + (-comparator [coll] (-comparator tree-map)) + + IReversible + (-rseq [coll] + (if (pos? (count tree-map)) + (map key (rseq tree-map)))) + + ICounted + (-count [coll] (count tree-map)) + + ILookup + (-lookup [coll v] + (-lookup coll v nil)) + (-lookup [coll v not-found] + (let [n (.entry-at tree-map v)] + (if-not (nil? n) + (.-key n) + not-found))) + + ISet + (-disjoin [coll v] + (PersistentTreeSet. meta (dissoc tree-map v) nil)) + + IFn + (-invoke [coll k] + (-lookup coll k)) + (-invoke [coll k not-found] + (-lookup coll k not-found))) + +(set! cljs.core.PersistentTreeSet.EMPTY + (PersistentTreeSet. nil cljs.core.PersistentTreeMap.EMPTY 0)) + +(defn set-from-indexed-seq [iseq] + (let [arr (.-arr iseq) + ret (areduce arr i ^not-native res (-as-transient #{}) + (-conj! res (aget arr i)))] + (-persistent! ^not-native ret))) + +(defn set + "Returns a set of the distinct elements of coll." + [coll] + (let [^not-native in (seq coll)] + (cond + (nil? in) #{} + + (and (instance? IndexedSeq in) (zero? (.-i in))) + (set-from-indexed-seq in) + + :else + (loop [in in + ^not-native out (-as-transient #{})] + (if-not (nil? in) + (recur (-next in) (-conj! out (-first in))) + (-persistent! out)))))) + +(defn hash-set + ([] #{}) + ([& keys] (set keys))) + +(defn sorted-set + "Returns a new sorted set with supplied keys." + ([& keys] + (reduce -conj cljs.core.PersistentTreeSet.EMPTY keys))) + +(defn sorted-set-by + "Returns a new sorted set with supplied keys, using the supplied comparator." + ([comparator & keys] + (reduce -conj + (cljs.core.PersistentTreeSet. nil (sorted-map-by comparator) 0) + keys))) + +(defn replace + "Given a map of replacement pairs and a vector/collection, returns a + vector/seq with any elements = a key in smap replaced with the + corresponding val in smap" + [smap coll] + (if (vector? coll) + (let [n (count coll)] + (reduce (fn [v i] + (if-let [e (find smap (nth v i))] + (assoc v i (second e)) + v)) + coll (take n (iterate inc 0)))) + (map #(if-let [e (find smap %)] (second e) %) coll))) + +(defn distinct + "Returns a lazy sequence of the elements of coll with duplicates removed" + [coll] + (let [step (fn step [xs seen] + (lazy-seq + ((fn [[f :as xs] seen] + (when-let [s (seq xs)] + (if (contains? seen f) + (recur (rest s) seen) + (cons f (step (rest s) (conj seen f)))))) + xs seen)))] + (step coll #{}))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defn butlast [s] + (loop [ret [] s s] + (if (next s) + (recur (conj ret (first s)) (next s)) + (seq ret)))) + +(defn name + "Returns the name String of a string, symbol or keyword." + [x] + (if (implements? INamed x) + (-name ^not-native x) + (if (string? x) + x + (throw (js/Error. (str "Doesn't support name: " x)))))) + +(defn zipmap + "Returns a map with the keys mapped to the corresponding vals." + [keys vals] + (loop [map (transient {}) + ks (seq keys) + vs (seq vals)] + (if (and ks vs) + (recur (assoc! map (first ks) (first vs)) + (next ks) + (next vs)) + (persistent! map)))) + +(defn max-key + "Returns the x for which (k x), a number, is greatest." + ([k x] x) + ([k x y] (if (> (k x) (k y)) x y)) + ([k x y & more] + (reduce #(max-key k %1 %2) (max-key k x y) more))) + +(defn min-key + "Returns the x for which (k x), a number, is least." + ([k x] x) + ([k x y] (if (< (k x) (k y)) x y)) + ([k x y & more] + (reduce #(min-key k %1 %2) (min-key k x y) more))) + +(defn partition-all + "Returns a lazy sequence of lists like partition, but may include + partitions with fewer than n items at the end." + ([n coll] + (partition-all n n coll)) + ([n step coll] + (lazy-seq + (when-let [s (seq coll)] + (cons (take n s) (partition-all n step (drop step s))))))) + +(defn take-while + "Returns a lazy sequence of successive items from coll while + (pred item) returns true. pred must be free of side-effects." + [pred coll] + (lazy-seq + (when-let [s (seq coll)] + (when (pred (first s)) + (cons (first s) (take-while pred (rest s))))))) + +(defn mk-bound-fn + [sc test key] + (fn [e] + (let [comp (-comparator sc)] + (test (comp (-entry-key sc e) key) 0)))) + +(defn subseq + "sc must be a sorted collection, test(s) one of <, <=, > or + >=. Returns a seq of those entries with keys ek for + which (test (.. sc comparator (compare ek key)) 0) is true" + ([sc test key] + (let [include (mk-bound-fn sc test key)] + (if (#{> >=} test) + (when-let [[e :as s] (-sorted-seq-from sc key true)] + (if (include e) s (next s))) + (take-while include (-sorted-seq sc true))))) + ([sc start-test start-key end-test end-key] + (when-let [[e :as s] (-sorted-seq-from sc start-key true)] + (take-while (mk-bound-fn sc end-test end-key) + (if ((mk-bound-fn sc start-test start-key) e) s (next s)))))) + +(defn rsubseq + "sc must be a sorted collection, test(s) one of <, <=, > or + >=. Returns a reverse seq of those entries with keys ek for + which (test (.. sc comparator (compare ek key)) 0) is true" + ([sc test key] + (let [include (mk-bound-fn sc test key)] + (if (#{< <=} test) + (when-let [[e :as s] (-sorted-seq-from sc key false)] + (if (include e) s (next s))) + (take-while include (-sorted-seq sc false))))) + ([sc start-test start-key end-test end-key] + (when-let [[e :as s] (-sorted-seq-from sc end-key false)] + (take-while (mk-bound-fn sc start-test start-key) + (if ((mk-bound-fn sc end-test end-key) e) s (next s)))))) + +(deftype Range [meta start end step ^:mutable __hash] + Object + (toString [coll] + (pr-str* coll)) + + ICloneable + (-clone [_] (Range. meta start end step __hash)) + + IWithMeta + (-with-meta [rng meta] (Range. meta start end step __hash)) + + IMeta + (-meta [rng] meta) + + ISeqable + (-seq [rng] + (if (pos? step) + (when (< start end) + rng) + (when (> start end) + rng))) + + ISeq + (-first [rng] + (when-not (nil? (-seq rng)) start)) + (-rest [rng] + (if-not (nil? (-seq rng)) + (Range. meta (+ start step) end step nil) + ())) + + INext + (-next [rng] + (if (pos? step) + (when (< (+ start step) end) + (Range. meta (+ start step) end step nil)) + (when (> (+ start step) end) + (Range. meta (+ start step) end step nil)))) + + ICollection + (-conj [rng o] (cons o rng)) + + IEmptyableCollection + (-empty [rng] (with-meta cljs.core.List.EMPTY meta)) + + ISequential + IEquiv + (-equiv [rng other] (equiv-sequential rng other)) + + IHash + (-hash [rng] (caching-hash rng hash-coll __hash)) + + ICounted + (-count [rng] + (if-not (-seq rng) + 0 + (js/Math.ceil (/ (- end start) step)))) + + IIndexed + (-nth [rng n] + (if (< n (-count rng)) + (+ start (* n step)) + (if (and (> start end) (zero? step)) + start + (throw (js/Error. "Index out of bounds"))))) + (-nth [rng n not-found] + (if (< n (-count rng)) + (+ start (* n step)) + (if (and (> start end) (zero? step)) + start + not-found))) + + IReduce + (-reduce [rng f] (ci-reduce rng f)) + (-reduce [rng f s] (ci-reduce rng f s))) + +(defn range + "Returns a lazy seq of nums from start (inclusive) to end + (exclusive), by step, where start defaults to 0, step to 1, + and end to infinity." + ([] (range 0 js/Number.MAX_VALUE 1)) + ([end] (range 0 end 1)) + ([start end] (range start end 1)) + ([start end step] (Range. nil start end step nil))) + +(defn take-nth + "Returns a lazy seq of every nth item in coll." + [n coll] + (lazy-seq + (when-let [s (seq coll)] + (cons (first s) (take-nth n (drop n s)))))) + +(defn split-with + "Returns a vector of [(take-while pred coll) (drop-while pred coll)]" + [pred coll] + [(take-while pred coll) (drop-while pred coll)]) + +(defn partition-by + "Applies f to each value in coll, splitting it each time f returns + a new value. Returns a lazy seq of partitions." + [f coll] + (lazy-seq + (when-let [s (seq coll)] + (let [fst (first s) + fv (f fst) + run (cons fst (take-while #(= fv (f %)) (next s)))] + (cons run (partition-by f (seq (drop (count run) s)))))))) + +(defn frequencies + "Returns a map from distinct items in coll to the number of times + they appear." + [coll] + (persistent! + (reduce (fn [counts x] + (assoc! counts x (inc (get counts x 0)))) + (transient {}) coll))) + +(defn reductions + "Returns a lazy seq of the intermediate values of the reduction (as + per reduce) of coll by f, starting with init." + ([f coll] + (lazy-seq + (if-let [s (seq coll)] + (reductions f (first s) (rest s)) + (list (f))))) + ([f init coll] + (cons init + (lazy-seq + (when-let [s (seq coll)] + (reductions f (f init (first s)) (rest s))))))) + +(defn juxt + "Takes a set of functions and returns a fn that is the juxtaposition + of those fns. The returned fn takes a variable number of args, and + returns a vector containing the result of applying each fn to the + args (left-to-right). + ((juxt a b c) x) => [(a x) (b x) (c x)]" + ([f] + (fn + ([] (vector (f))) + ([x] (vector (f x))) + ([x y] (vector (f x y))) + ([x y z] (vector (f x y z))) + ([x y z & args] (vector (apply f x y z args))))) + ([f g] + (fn + ([] (vector (f) (g))) + ([x] (vector (f x) (g x))) + ([x y] (vector (f x y) (g x y))) + ([x y z] (vector (f x y z) (g x y z))) + ([x y z & args] (vector (apply f x y z args) (apply g x y z args))))) + ([f g h] + (fn + ([] (vector (f) (g) (h))) + ([x] (vector (f x) (g x) (h x))) + ([x y] (vector (f x y) (g x y) (h x y))) + ([x y z] (vector (f x y z) (g x y z) (h x y z))) + ([x y z & args] (vector (apply f x y z args) (apply g x y z args) (apply h x y z args))))) + ([f g h & fs] + (let [fs (list* f g h fs)] + (fn + ([] (reduce #(conj %1 (%2)) [] fs)) + ([x] (reduce #(conj %1 (%2 x)) [] fs)) + ([x y] (reduce #(conj %1 (%2 x y)) [] fs)) + ([x y z] (reduce #(conj %1 (%2 x y z)) [] fs)) + ([x y z & args] (reduce #(conj %1 (apply %2 x y z args)) [] fs)))))) + +(defn dorun + "When lazy sequences are produced via functions that have side + effects, any effects other than those needed to produce the first + element in the seq do not occur until the seq is consumed. dorun can + be used to force any effects. Walks through the successive nexts of + the seq, does not retain the head and returns nil." + ([coll] + (when (seq coll) + (recur (next coll)))) + ([n coll] + (when (and (seq coll) (pos? n)) + (recur (dec n) (next coll))))) + +(defn doall + "When lazy sequences are produced via functions that have side + effects, any effects other than those needed to produce the first + element in the seq do not occur until the seq is consumed. doall can + be used to force any effects. Walks through the successive nexts of + the seq, retains the head and returns it, thus causing the entire + seq to reside in memory at one time." + ([coll] + (dorun coll) + coll) + ([n coll] + (dorun n coll) + coll)) + +;;;;;;;;;;;;;;;;;;;;;;;;; Regular Expressions ;;;;;;;;;; + +(defn regexp? [o] + (instance? js/RegExp o)) + +(defn re-matches + "Returns the result of (re-find re s) if re fully matches s." + [re s] + (let [matches (.exec re s)] + (when (= (first matches) s) + (if (== (count matches) 1) + (first matches) + (vec matches))))) + +(defn re-find + "Returns the first regex match, if any, of s to re, using + re.exec(s). Returns a vector, containing first the matching + substring, then any capturing groups if the regular expression contains + capturing groups." + [re s] + (let [matches (.exec re s)] + (when-not (nil? matches) + (if (== (count matches) 1) + (first matches) + (vec matches))))) + +(defn re-seq + "Returns a lazy sequence of successive matches of re in s." + [re s] + (let [match-data (re-find re s) + match-idx (.search s re) + match-str (if (coll? match-data) (first match-data) match-data) + post-match (subs s (+ match-idx (count match-str)))] + (when match-data (lazy-seq (cons match-data (when (seq post-match) (re-seq re post-match))))))) + +(defn re-pattern + "Returns an instance of RegExp which has compiled the provided string." + [s] + (let [[_ flags pattern] (re-find #"^(?:\(\?([idmsux]*)\))?(.*)" s)] + (js/RegExp. pattern flags))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Printing ;;;;;;;;;;;;;;;; + +(defn pr-sequential-writer [writer print-one begin sep end opts coll] + (binding [*print-level* (when-not (nil? *print-level*) (dec *print-level*))] + (if (and (not (nil? *print-level*)) (neg? *print-level*)) + (-write writer "#") + (do + (-write writer begin) + (when (seq coll) + (print-one (first coll) writer opts)) + (loop [coll (next coll) n (:print-length opts)] + (when (and coll (or (nil? n) (not (zero? n)))) + (-write writer sep) + (print-one (first coll) writer opts) + (recur (next coll) (dec n)))) + (when (:print-length opts) + (-write writer sep) + (print-one "..." writer opts)) + (-write writer end))))) + +(defn write-all [writer & ss] + (doseq [s ss] + (-write writer s))) + +(defn string-print [x] + (*print-fn* x) + nil) + +(defn flush [] ;stub + nil) + +(def ^:private char-escapes + (js-obj + "\"" "\\\"" + "\\" "\\\\" + "\b" "\\b" + "\f" "\\f" + "\n" "\\n" + "\r" "\\r" + "\t" "\\t")) + +(defn ^:private quote-string + [s] + (str \" + (.replace s (js/RegExp "[\\\\\"\b\f\n\r\t]" "g") + (fn [match] (aget char-escapes match))) + \")) + +(declare print-map) + +(defn- pr-writer + "Prefer this to pr-seq, because it makes the printing function + configurable, allowing efficient implementations such as appending + to a StringBuffer." + [obj writer opts] + (cond + (nil? obj) (-write writer "nil") + (undefined? obj) (-write writer "#") + :else (do + (when (and (get opts :meta) + (satisfies? IMeta obj) + (meta obj)) + (-write writer "^") + (pr-writer (meta obj) writer opts) + (-write writer " ")) + (cond + (nil? obj) (-write writer "nil") + + ;; handle CLJS ctors + ^boolean (.-cljs$lang$type obj) + (.cljs$lang$ctorPrWriter obj obj writer opts) + + ; Use the new, more efficient, IPrintWithWriter interface when possible. + (implements? IPrintWithWriter obj) + (-pr-writer ^not-native obj writer opts) + + (or (identical? (type obj) js/Boolean) (number? obj)) + (-write writer (str obj)) + + (object? obj) + (do + (-write writer "#js ") + (print-map + (map (fn [k] [(keyword k) (aget obj k)]) (js-keys obj)) + pr-writer writer opts)) + + (array? obj) + (pr-sequential-writer writer pr-writer "#js [" " " "]" opts obj) + + ^boolean (goog/isString obj) + (if (:readably opts) + (-write writer (quote-string obj)) + (-write writer obj)) + + (fn? obj) + (write-all writer "#<" (str obj) ">") + + (instance? js/Date obj) + (let [normalize (fn [n len] + (loop [ns (str n)] + (if (< (count ns) len) + (recur (str "0" ns)) + ns)))] + (write-all writer + "#inst \"" + (str (.getUTCFullYear obj)) "-" + (normalize (inc (.getUTCMonth obj)) 2) "-" + (normalize (.getUTCDate obj) 2) "T" + (normalize (.getUTCHours obj) 2) ":" + (normalize (.getUTCMinutes obj) 2) ":" + (normalize (.getUTCSeconds obj) 2) "." + (normalize (.getUTCMilliseconds obj) 3) "-" + "00:00\"")) + + (regexp? obj) (write-all writer "#\"" (.-source obj) "\"") + + (satisfies? IPrintWithWriter obj) + (-pr-writer obj writer opts) + + :else (write-all writer "#<" (str obj) ">"))))) + +(defn pr-seq-writer [objs writer opts] + (pr-writer (first objs) writer opts) + (doseq [obj (next objs)] + (-write writer " ") + (pr-writer obj writer opts))) + +(defn- pr-sb-with-opts [objs opts] + (let [sb (gstring/StringBuffer.) + writer (StringBufferWriter. sb)] + (pr-seq-writer objs writer opts) + (-flush writer) + sb)) + +(defn pr-str-with-opts + "Prints a sequence of objects to a string, observing all the + options given in opts" + [objs opts] + (if (empty? objs) + "" + (str (pr-sb-with-opts objs opts)))) + +(defn prn-str-with-opts + "Same as pr-str-with-opts followed by (newline)" + [objs opts] + (if (empty? objs) + "\n" + (let [sb (pr-sb-with-opts objs opts)] + (.append sb \newline) + (str sb)))) + +(defn- pr-with-opts + "Prints a sequence of objects using string-print, observing all + the options given in opts" + [objs opts] + (string-print (pr-str-with-opts objs opts))) + +(defn newline [opts] + (string-print "\n") + (when (get opts :flush-on-newline) + (flush))) + +(defn pr-str + "pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter." + [& objs] + (pr-str-with-opts objs (pr-opts))) + +(defn prn-str + "Same as pr-str followed by (newline)" + [& objs] + (prn-str-with-opts objs (pr-opts))) + +(defn pr + "Prints the object(s) using string-print. Prints the + object(s), separated by spaces if there is more than one. + By default, pr and prn print in a way that objects can be + read by the reader" + [& objs] + (pr-with-opts objs (pr-opts))) + +(def ^{:doc + "Prints the object(s) using string-print. + print and println produce output for human consumption."} + print + (fn cljs-core-print [& objs] + (pr-with-opts objs (assoc (pr-opts) :readably false)))) + +(defn print-str + "print to a string, returning it" + [& objs] + (pr-str-with-opts objs (assoc (pr-opts) :readably false))) + +(defn println + "Same as print followed by (newline)" + [& objs] + (pr-with-opts objs (assoc (pr-opts) :readably false)) + (when *print-newline* + (newline (pr-opts)))) + +(defn println-str + "println to a string, returning it" + [& objs] + (prn-str-with-opts objs (assoc (pr-opts) :readably false))) + +(defn prn + "Same as pr followed by (newline)." + [& objs] + (pr-with-opts objs (pr-opts)) + (when *print-newline* + (newline (pr-opts)))) + +(defn print-map [m print-one writer opts] + (pr-sequential-writer + writer + (fn [e w opts] + (do (print-one (key e) w opts) + (-write w \space) + (print-one (val e) w opts))) + "{" ", " "}" + opts (seq m))) + +(extend-protocol IPrintWithWriter + LazySeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + IndexedSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + RSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentQueue + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#queue [" " " "]" opts (seq coll))) + + PersistentTreeMapSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + NodeSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ArrayNodeSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + List + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Cons + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + EmptyList + (-pr-writer [coll writer opts] (-write writer "()")) + + PersistentVector + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + ChunkedCons + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ChunkedSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + Subvec + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + BlackNode + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + RedNode + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "[" " " "]" opts coll)) + + ObjMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + KeySeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + ValSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentArrayMapSeq + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll)) + + PersistentArrayMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentHashMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentTreeMap + (-pr-writer [coll writer opts] + (print-map coll pr-writer writer opts)) + + PersistentHashSet + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#{" " " "}" opts coll)) + + PersistentTreeSet + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "#{" " " "}" opts coll)) + + Range + (-pr-writer [coll writer opts] (pr-sequential-writer writer pr-writer "(" " " ")" opts coll))) + + +;; IComparable +(extend-protocol IComparable + Symbol + (-compare [x y] (compare-symbols x y)) + + Keyword + ; keyword happens to have the same fields as Symbol, so this just works + (-compare [x y] (compare-symbols x y)) + + Subvec + (-compare [x y] (compare-indexed x y)) + + PersistentVector + (-compare [x y] (compare-indexed x y))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Reference Types ;;;;;;;;;;;;;;;; + +(defprotocol IAtom) + +(defprotocol IReset + (-reset! [o new-value])) + +(defprotocol ISwap + (-swap! [o f] [o f a] [o f a b] [o f a b xs])) + +(deftype Atom [state meta validator watches] + IAtom + + IEquiv + (-equiv [o other] (identical? o other)) + + IDeref + (-deref [_] state) + + IMeta + (-meta [_] meta) + + IPrintWithWriter + (-pr-writer [a writer opts] + (-write writer "#")) + + IWatchable + (-notify-watches [this oldval newval] + (doseq [[key f] watches] + (f key this oldval newval))) + (-add-watch [this key f] + (set! (.-watches this) (assoc watches key f))) + (-remove-watch [this key] + (set! (.-watches this) (dissoc watches key))) + + IHash + (-hash [this] (goog/getUid this))) + +(defn atom + "Creates and returns an Atom with an initial value of x and zero or + more options (in any order): + + :meta metadata-map + + :validator validate-fn + + If metadata-map is supplied, it will be come the metadata on the + atom. validate-fn must be nil or a side-effect-free fn of one + argument, which will be passed the intended new state on any state + change. If the new state is unacceptable, the validate-fn should + return false or throw an Error. If either of these error conditions + occur, then the value of the atom will not change." + ([x] (Atom. x nil nil nil)) + ([x & {:keys [meta validator]}] (Atom. x meta validator nil))) + +(defn reset! + "Sets the value of atom to newval without regard for the + current value. Returns newval." + [a new-value] + (if (instance? Atom a) + (let [validate (.-validator a)] + (when-not (nil? validate) + (assert (validate new-value) "Validator rejected reference state")) + (let [old-value (.-state a)] + (set! (.-state a) new-value) + (when-not (nil? (.-watches a)) + (-notify-watches a old-value new-value)) + new-value)) + (-reset! a new-value))) + +;; generic to all refs +;; (but currently hard-coded to atom!) +(defn deref + [o] + (-deref o)) + +(defn swap! + "Atomically swaps the value of atom to be: + (apply f current-value-of-atom args). Note that f may be called + multiple times, and thus should be free of side effects. Returns + the value that was swapped in." + ([a f] + (if (instance? Atom a) + (reset! a (f (.-state a))) + (-swap! a f))) + ([a f x] + (if (instance? Atom a) + (reset! a (f (.-state a) x)) + (-swap! a f x))) + ([a f x y] + (if (instance? Atom a) + (reset! a (f (.-state a) x y)) + (-swap! a f x y))) + ([a f x y & more] + (if (instance? Atom a) + (reset! a (apply f (.-state a) x y more)) + (-swap! a f x y more)))) + +(defn compare-and-set! + "Atomically sets the value of atom to newval if and only if the + current value of the atom is identical to oldval. Returns true if + set happened, else false." + [a oldval newval] + (if (= (.-state a) oldval) + (do (reset! a newval) true) + false)) + +(defn set-validator! + "Sets the validator-fn for an atom. validator-fn must be nil or a + side-effect-free fn of one argument, which will be passed the intended + new state on any state change. If the new state is unacceptable, the + validator-fn should return false or throw an Error. If the current state + is not acceptable to the new validator, an Error will be thrown and the + validator will not be changed." + [iref val] + (set! (.-validator iref) val)) + +(defn get-validator + "Gets the validator-fn for a var/ref/agent/atom." + [iref] + (.-validator iref)) + +(defn alter-meta! + "Atomically sets the metadata for a namespace/var/ref/agent/atom to be: + + (apply f its-current-meta args) + + f must be free of side-effects" + [iref f & args] + (set! (.-meta iref) (apply f (.-meta iref) args))) + +(defn reset-meta! + "Atomically resets the metadata for an atom" + [iref m] + (set! (.-meta iref) m)) + +(defn add-watch + "Alpha - subject to change. + + Adds a watch function to an atom reference. The watch fn must be a + fn of 4 args: a key, the reference, its old-state, its + new-state. Whenever the reference's state might have been changed, + any registered watches will have their functions called. The watch + fn will be called synchronously. Note that an atom's state + may have changed again prior to the fn call, so use old/new-state + rather than derefing the reference. Keys must be unique per + reference, and can be used to remove the watch with remove-watch, + but are otherwise considered opaque by the watch mechanism. Bear in + mind that regardless of the result or action of the watch fns the + atom's value will change. Example: + + (def a (atom 0)) + (add-watch a :inc (fn [k r o n] (assert (== 0 n)))) + (swap! a inc) + ;; Assertion Error + (deref a) + ;=> 1" + [iref key f] + (-add-watch iref key f)) + +(defn remove-watch + "Alpha - subject to change. + + Removes a watch (set by add-watch) from a reference" + [iref key] + (-remove-watch iref key)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; gensym ;;;;;;;;;;;;;;;; +;; Internal - do not use! +(def gensym_counter nil) + +(defn gensym + "Returns a new symbol with a unique name. If a prefix string is + supplied, the name is prefix# where # is some unique number. If + prefix is not supplied, the prefix is 'G__'." + ([] (gensym "G__")) + ([prefix-string] + (when (nil? gensym_counter) + (set! gensym_counter (atom 0))) + (symbol (str prefix-string (swap! gensym_counter inc))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Fixtures ;;;;;;;;;;;;;;;; + +(def fixture1 1) +(def fixture2 2) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Delay ;;;;;;;;;;;;;;;;;;;; + +(deftype Delay [state f] + IDeref + (-deref [_] + (:value (swap! state (fn [{:keys [done] :as curr-state}] + (if done + curr-state, + {:done true :value (f)}))))) + + IPending + (-realized? [d] + (:done @state))) + +(defn ^boolean delay? + "returns true if x is a Delay created with delay" + [x] (instance? cljs.core.Delay x)) + +(defn force + "If x is a Delay, returns the (possibly cached) value of its expression, else returns x" + [x] + (if (delay? x) + (deref x) + x)) + +(defn ^boolean realized? + "Returns true if a value has been produced for a promise, delay, future or lazy sequence." + [d] + (-realized? d)) + +(defprotocol IEncodeJS + (-clj->js [x] "Recursively transforms clj values to JavaScript") + (-key->js [x] "Transforms map keys to valid JavaScript keys. Arbitrary keys are + encoded to their string representation via (pr-str x)")) + +(declare clj->js) + +(defn key->js [k] + (if (satisfies? IEncodeJS k) + (-clj->js k) + (if (or (string? k) + (number? k) + (keyword? k) + (symbol? k)) + (clj->js k) + (pr-str k)))) + +(defn clj->js + "Recursively transforms ClojureScript values to JavaScript. +sets/vectors/lists become Arrays, Keywords and Symbol become Strings, +Maps become Objects. Arbitrary keys are encoded to by key->js." + [x] + (when-not (nil? x) + (if (satisfies? IEncodeJS x) + (-clj->js x) + (cond + (keyword? x) (name x) + (symbol? x) (str x) + (map? x) (let [m (js-obj)] + (doseq [[k v] x] + (aset m (key->js k) (clj->js v))) + m) + (coll? x) (let [arr (array)] + (doseq [x (map clj->js x)] + (.push arr x)) + arr) + :else x)))) + +(defprotocol IEncodeClojure + (-js->clj [x options] "Transforms JavaScript values to Clojure")) + +(defn js->clj + "Recursively transforms JavaScript arrays into ClojureScript + vectors, and JavaScript objects into ClojureScript maps. With + option ':keywordize-keys true' will convert object fields from + strings to keywords." + ([x] (js->clj x {:keywordize-keys false})) + ([x & opts] + (cond + (satisfies? IEncodeClojure x) + (-js->clj x (apply array-map opts)) + + (seq opts) + (let [{:keys [keywordize-keys]} opts + keyfn (if keywordize-keys keyword str) + f (fn thisfn [x] + (cond + (seq? x) + (doall (map thisfn x)) + + (coll? x) + (into (empty x) (map thisfn x)) + + (array? x) + (vec (map thisfn x)) + + (identical? (type x) js/Object) + (into {} (for [k (js-keys x)] + [(keyfn k) (thisfn (aget x k))])) + + :else x))] + (f x))))) + +(defn memoize + "Returns a memoized version of a referentially transparent function. The + memoized version of the function keeps a cache of the mapping from arguments + to results and, when calls with the same arguments are repeated often, has + higher performance at the expense of higher memory use." + [f] + (let [mem (atom {})] + (fn [& args] + (if-let [v (get @mem args)] + v + (let [ret (apply f args)] + (swap! mem assoc args ret) + ret))))) + +(defn trampoline + "trampoline can be used to convert algorithms requiring mutual + recursion without stack consumption. Calls f with supplied args, if + any. If f returns a fn, calls that fn with no arguments, and + continues to repeat, until the return value is not a fn, then + returns that non-fn value. Note that if you want to return a fn as a + final value, you must wrap it in some data structure and unpack it + after trampoline returns." + ([f] + (let [ret (f)] + (if (fn? ret) + (recur ret) + ret))) + ([f & args] + (trampoline #(apply f args)))) + +(defn rand + "Returns a random floating point number between 0 (inclusive) and + n (default 1) (exclusive)." + ([] (rand 1)) + ([n] (* (Math/random) n))) + +(defn rand-int + "Returns a random integer between 0 (inclusive) and n (exclusive)." + [n] (Math/floor (* (Math/random) n))) + +(defn rand-nth + "Return a random element of the (sequential) collection. Will have + the same performance characteristics as nth for the given + collection." + [coll] + (nth coll (rand-int (count coll)))) + +(defn group-by + "Returns a map of the elements of coll keyed by the result of + f on each element. The value at each key will be a vector of the + corresponding elements, in the order they appeared in coll." + [f coll] + (reduce + (fn [ret x] + (let [k (f x)] + (assoc ret k (conj (get ret k []) x)))) + {} coll)) + +(defn make-hierarchy + "Creates a hierarchy object for use with derive, isa? etc." + [] {:parents {} :descendants {} :ancestors {}}) + +(def ^:private -global-hierarchy nil) + +(defn- get-global-hierarchy [] + (when (nil? -global-hierarchy) + (set! -global-hierarchy (atom (make-hierarchy)))) + -global-hierarchy) + +(defn- swap-global-hierarchy! [f & args] + (apply swap! (get-global-hierarchy) f args)) + +(defn ^boolean isa? + "Returns true if (= child parent), or child is directly or indirectly derived from + parent, either via a JavaScript type inheritance relationship or a + relationship established via derive. h must be a hierarchy obtained + from make-hierarchy, if not supplied defaults to the global + hierarchy" + ([child parent] (isa? @(get-global-hierarchy) child parent)) + ([h child parent] + (or (= child parent) + ;; (and (class? parent) (class? child) + ;; (. ^Class parent isAssignableFrom child)) + (contains? ((:ancestors h) child) parent) + ;;(and (class? child) (some #(contains? ((:ancestors h) %) parent) (supers child))) + (and (vector? parent) (vector? child) + (== (count parent) (count child)) + (loop [ret true i 0] + (if (or (not ret) (== i (count parent))) + ret + (recur (isa? h (child i) (parent i)) (inc i)))))))) + +(defn parents + "Returns the immediate parents of tag, either via a JavaScript type + inheritance relationship or a relationship established via derive. h + must be a hierarchy obtained from make-hierarchy, if not supplied + defaults to the global hierarchy" + ([tag] (parents @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:parents h) tag)))) + +(defn ancestors + "Returns the immediate and indirect parents of tag, either via a JavaScript type + inheritance relationship or a relationship established via derive. h + must be a hierarchy obtained from make-hierarchy, if not supplied + defaults to the global hierarchy" + ([tag] (ancestors @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:ancestors h) tag)))) + +(defn descendants + "Returns the immediate and indirect children of tag, through a + relationship established via derive. h must be a hierarchy obtained + from make-hierarchy, if not supplied defaults to the global + hierarchy. Note: does not work on JavaScript type inheritance + relationships." + ([tag] (descendants @(get-global-hierarchy) tag)) + ([h tag] (not-empty (get (:descendants h) tag)))) + +(defn derive + "Establishes a parent/child relationship between parent and + tag. Parent must be a namespace-qualified symbol or keyword and + child can be either a namespace-qualified symbol or keyword or a + class. h must be a hierarchy obtained from make-hierarchy, if not + supplied defaults to, and modifies, the global hierarchy." + ([tag parent] + (assert (namespace parent)) + ;; (assert (or (class? tag) (and (instance? cljs.core.Named tag) (namespace tag)))) + (swap-global-hierarchy! derive tag parent) nil) + ([h tag parent] + (assert (not= tag parent)) + ;; (assert (or (class? tag) (instance? clojure.lang.Named tag))) + ;; (assert (instance? clojure.lang.INamed tag)) + ;; (assert (instance? clojure.lang.INamed parent)) + (let [tp (:parents h) + td (:descendants h) + ta (:ancestors h) + tf (fn [m source sources target targets] + (reduce (fn [ret k] + (assoc ret k + (reduce conj (get targets k #{}) (cons target (targets target))))) + m (cons source (sources source))))] + (or + (when-not (contains? (tp tag) parent) + (when (contains? (ta tag) parent) + (throw (js/Error. (str tag "already has" parent "as ancestor")))) + (when (contains? (ta parent) tag) + (throw (js/Error. (str "Cyclic derivation:" parent "has" tag "as ancestor")))) + {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent)) + :ancestors (tf (:ancestors h) tag td parent ta) + :descendants (tf (:descendants h) parent ta tag td)}) + h)))) + +(defn underive + "Removes a parent/child relationship between parent and + tag. h must be a hierarchy obtained from make-hierarchy, if not + supplied defaults to, and modifies, the global hierarchy." + ([tag parent] + (swap-global-hierarchy! underive tag parent) + nil) + ([h tag parent] + (let [parentMap (:parents h) + childsParents (if (parentMap tag) + (disj (parentMap tag) parent) #{}) + newParents (if (not-empty childsParents) + (assoc parentMap tag childsParents) + (dissoc parentMap tag)) + deriv-seq (flatten (map #(cons (first %) (interpose (first %) (second %))) + (seq newParents)))] + (if (contains? (parentMap tag) parent) + (reduce #(apply derive %1 %2) (make-hierarchy) + (partition 2 deriv-seq)) + h)))) + +(defn- reset-cache + [method-cache method-table cached-hierarchy hierarchy] + (swap! method-cache (fn [_] (deref method-table))) + (swap! cached-hierarchy (fn [_] (deref hierarchy)))) + +(defn- prefers* + [x y prefer-table] + (let [xprefs (@prefer-table x)] + (or + (when (and xprefs (xprefs y)) + true) + (loop [ps (parents y)] + (when (pos? (count ps)) + (when (prefers* x (first ps) prefer-table) + true) + (recur (rest ps)))) + (loop [ps (parents x)] + (when (pos? (count ps)) + (when (prefers* (first ps) y prefer-table) + true) + (recur (rest ps)))) + false))) + +(defn- dominates + [x y prefer-table] + (or (prefers* x y prefer-table) (isa? x y))) + +(defn- find-and-cache-best-method + [name dispatch-val hierarchy method-table prefer-table method-cache cached-hierarchy] + (let [best-entry (reduce (fn [be [k _ :as e]] + (if (isa? @hierarchy dispatch-val k) + (let [be2 (if (or (nil? be) (dominates k (first be) prefer-table)) + e + be)] + (when-not (dominates (first be2) k prefer-table) + (throw (js/Error. + (str "Multiple methods in multimethod '" name + "' match dispatch value: " dispatch-val " -> " k + " and " (first be2) ", and neither is preferred")))) + be2) + be)) + nil @method-table)] + (when best-entry + (if (= @cached-hierarchy @hierarchy) + (do + (swap! method-cache assoc dispatch-val (second best-entry)) + (second best-entry)) + (do + (reset-cache method-cache method-table cached-hierarchy hierarchy) + (find-and-cache-best-method name dispatch-val hierarchy method-table prefer-table + method-cache cached-hierarchy)))))) + +(defprotocol IMultiFn + (-reset [mf]) + (-add-method [mf dispatch-val method]) + (-remove-method [mf dispatch-val]) + (-prefer-method [mf dispatch-val dispatch-val-y]) + (-get-method [mf dispatch-val]) + (-methods [mf]) + (-prefers [mf]) + (-dispatch [mf args])) + +(defn- do-dispatch + [mf name dispatch-fn args] + (let [dispatch-val (apply dispatch-fn args) + target-fn (-get-method mf dispatch-val)] + (when-not target-fn + (throw (js/Error. (str "No method in multimethod '" name "' for dispatch value: " dispatch-val)))) + (apply target-fn args))) + +(deftype MultiFn [name dispatch-fn default-dispatch-val hierarchy + method-table prefer-table method-cache cached-hierarchy] + IMultiFn + (-reset [mf] + (swap! method-table (fn [mf] {})) + (swap! method-cache (fn [mf] {})) + (swap! prefer-table (fn [mf] {})) + (swap! cached-hierarchy (fn [mf] nil)) + mf) + + (-add-method [mf dispatch-val method] + (swap! method-table assoc dispatch-val method) + (reset-cache method-cache method-table cached-hierarchy hierarchy) + mf) + + (-remove-method [mf dispatch-val] + (swap! method-table dissoc dispatch-val) + (reset-cache method-cache method-table cached-hierarchy hierarchy) + mf) + + (-get-method [mf dispatch-val] + (when-not (= @cached-hierarchy @hierarchy) + (reset-cache method-cache method-table cached-hierarchy hierarchy)) + (if-let [target-fn (@method-cache dispatch-val)] + target-fn + (if-let [target-fn (find-and-cache-best-method name dispatch-val hierarchy method-table + prefer-table method-cache cached-hierarchy)] + target-fn + (@method-table default-dispatch-val)))) + + (-prefer-method [mf dispatch-val-x dispatch-val-y] + (when (prefers* dispatch-val-x dispatch-val-y prefer-table) + (throw (js/Error. (str "Preference conflict in multimethod '" name "': " dispatch-val-y + " is already preferred to " dispatch-val-x)))) + (swap! prefer-table + (fn [old] + (assoc old dispatch-val-x + (conj (get old dispatch-val-x #{}) + dispatch-val-y)))) + (reset-cache method-cache method-table cached-hierarchy hierarchy)) + + (-methods [mf] @method-table) + (-prefers [mf] @prefer-table) + + (-dispatch [mf args] (do-dispatch mf name dispatch-fn args)) + + IHash + (-hash [this] (goog/getUid this))) + +(set! cljs.core.MultiFn.prototype.call + (fn [_ & args] + (this-as self + (-dispatch self args)))) + +(set! cljs.core.MultiFn.prototype.apply + (fn [_ args] + (this-as self + (-dispatch self args)))) + +(defn remove-all-methods + "Removes all of the methods of multimethod." + [multifn] + (-reset multifn)) + +(defn remove-method + "Removes the method of multimethod associated with dispatch-value." + [multifn dispatch-val] + (-remove-method multifn dispatch-val)) + +(defn prefer-method + "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y + when there is a conflict" + [multifn dispatch-val-x dispatch-val-y] + (-prefer-method multifn dispatch-val-x dispatch-val-y)) + +(defn methods + "Given a multimethod, returns a map of dispatch values -> dispatch fns" + [multifn] (-methods multifn)) + +(defn get-method + "Given a multimethod and a dispatch value, returns the dispatch fn + that would apply to that value, or nil if none apply and no default" + [multifn dispatch-val] (-get-method multifn dispatch-val)) + +(defn prefers + "Given a multimethod, returns a map of preferred value -> set of other values" + [multifn] (-prefers multifn)) + +;; UUID + +(deftype UUID [uuid] + IEquiv + (-equiv [_ other] + (and (instance? UUID other) (identical? uuid (.-uuid other)))) + + IPrintWithWriter + (-pr-writer [_ writer _] + (-write writer (str "#uuid \"" uuid "\""))) + + IHash + (-hash [this] + (goog.string/hashCode (pr-str this)))) + +;;; ExceptionInfo + +(deftype ExceptionInfo [message data cause]) + +;;; ExceptionInfo is a special case, do not emulate this +(set! cljs.core.ExceptionInfo.prototype (js/Error.)) +(set! (.-constructor cljs.core.ExceptionInfo.prototype) ExceptionInfo) + +(defn ex-info + "Alpha - subject to change. + Create an instance of ExceptionInfo, an Error type that carries a + map of additional data." + ([msg map] + (ExceptionInfo. msg map nil)) + ([msg map cause] + (ExceptionInfo. msg map cause))) + +(defn ex-data + "Alpha - subject to change. + Returns exception data (a map) if ex is an ExceptionInfo. + Otherwise returns nil." + [ex] + (when (instance? ExceptionInfo ex) + (.-data ex))) + +(defn ex-message + "Alpha - subject to change. + Returns the message attached to the given Error / ExceptionInfo object. + For non-Errors returns nil." + [ex] + (when (instance? js/Error ex) + (.-message ex))) + +(defn ex-cause + "Alpha - subject to change. + Returns exception cause (an Error / ExceptionInfo) if ex is an + ExceptionInfo. + Otherwise returns nil." + [ex] + (when (instance? ExceptionInfo ex) + (.-cause ex))) + +(defn comparator + "Returns an JavaScript compatible comparator based upon pred." + [pred] + (fn [x y] + (cond (pred x y) -1 (pred y x) 1 :else 0))) + +(defn ^boolean special-symbol? [x] + (contains? + '#{if def fn* do let* loop* letfn* throw try + recur new set! ns deftype* defrecord* . js* & quote} + x)) diff --git a/repl/cljs/core.js b/repl/cljs/core.js new file mode 100644 index 0000000..c080626 --- /dev/null +++ b/repl/cljs/core.js @@ -0,0 +1,18804 @@ +// Compiled by ClojureScript 0.0-2173 +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_clojurescript_version_STAR_ = "0.0-2173"; +cljs.core._STAR_unchecked_if_STAR_ = false; +/** +* Each runtime environment provides a different way to print output. +* Whatever function *print-fn* is bound to will be passed any +* Strings which should be printed. +*/ +cljs.core._STAR_print_fn_STAR_ = (function _STAR_print_fn_STAR_(_){throw (new Error("No *print-fn* fn set for evaluation environment")); +}); +/** +* Set *print-fn* to f. +*/ +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); +}); +/** +* Set *print-fn* to console.log +*/ +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__6049__delegate = function (args){return console.log.apply(console,cljs.core.into_array.call(null,args)); +}; +var G__6049 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6049__delegate.call(this,args);}; +G__6049.cljs$lang$maxFixedArity = 0; +G__6049.cljs$lang$applyTo = (function (arglist__6050){ +var args = cljs.core.seq(arglist__6050); +return G__6049__delegate(args); +}); +G__6049.cljs$core$IFn$_invoke$arity$variadic = G__6049__delegate; +return G__6049; +})() +; +}); +/** +* Internal - do not use! +*/ +cljs.core.truth_ = (function truth_(x){return (x != null && x !== false); +}); +cljs.core.not_native = null; +/** +* Tests if 2 arguments are the same object +*/ +cljs.core.identical_QMARK_ = (function identical_QMARK_(x,y){return (x === y); +}); +/** +* Returns true if x is nil, false otherwise. +*/ +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'; +}); +/** +* Returns true if x is logical false, false otherwise. +*/ +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); +}); +/** +* Internal - do not use! +*/ +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); +}); +/** +* When compiled for a command-line target, whatever +* function *main-fn* is set to will be called with the command-line +* argv as arguments +*/ +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__3528__auto__ = ty;if(cljs.core.truth_(and__3528__auto__)) +{return ty.cljs$lang$type; +} else +{return and__3528__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; +})() +; +/** +* Returns a javascript array, cloned from the passed in array +*/ +cljs.core.aclone = (function aclone(arr){var len = arr.length;var new_arr = (new Array(len));var n__4388__auto___6057 = len;var i_6058 = 0;while(true){ +if((i_6058 < n__4388__auto___6057)) +{(new_arr[i_6058] = (arr[i_6058])); +{ +var G__6059 = (i_6058 + 1); +i_6058 = G__6059; +continue; +} +} else +{} +break; +} +return new_arr; +}); +/** +* Creates a new javascript array. +* @param {...*} var_args +*/ +cljs.core.array = (function array(var_args){return Array.prototype.slice.call(arguments); +}); +/** +* Returns the value at the index. +* @param {...*} var_args +*/ +cljs.core.aget = (function() { +var aget = null; +var aget__2 = (function (array,i){return (array[i]); +}); +var aget__3 = (function() { +var G__6060__delegate = function (array,i,idxs){return cljs.core.apply.call(null,aget,aget.call(null,array,i),idxs); +}; +var G__6060 = 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__6060__delegate.call(this,array,i,idxs);}; +G__6060.cljs$lang$maxFixedArity = 2; +G__6060.cljs$lang$applyTo = (function (arglist__6061){ +var array = cljs.core.first(arglist__6061); +arglist__6061 = cljs.core.next(arglist__6061); +var i = cljs.core.first(arglist__6061); +var idxs = cljs.core.rest(arglist__6061); +return G__6060__delegate(array,i,idxs); +}); +G__6060.cljs$core$IFn$_invoke$arity$variadic = G__6060__delegate; +return G__6060; +})() +; +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; +})() +; +/** +* Sets the value at the index. +* @param {...*} var_args +*/ +cljs.core.aset = (function() { +var aset = null; +var aset__3 = (function (array,i,val){return (array[i] = val); +}); +var aset__4 = (function() { +var G__6064__delegate = function (array,idx,idx2,idxv){return cljs.core.apply.call(null,aset,(array[idx]),idx2,idxv); +}; +var G__6064 = 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__6064__delegate.call(this,array,idx,idx2,idxv);}; +G__6064.cljs$lang$maxFixedArity = 3; +G__6064.cljs$lang$applyTo = (function (arglist__6065){ +var array = cljs.core.first(arglist__6065); +arglist__6065 = cljs.core.next(arglist__6065); +var idx = cljs.core.first(arglist__6065); +arglist__6065 = cljs.core.next(arglist__6065); +var idx2 = cljs.core.first(arglist__6065); +var idxv = cljs.core.rest(arglist__6065); +return G__6064__delegate(array,idx,idx2,idxv); +}); +G__6064.cljs$core$IFn$_invoke$arity$variadic = G__6064__delegate; +return G__6064; +})() +; +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; +})() +; +/** +* Returns the length of the array. Works on arrays of all types. +*/ +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 obj6074 = {};return obj6074; +})(); +cljs.core.IFn = (function (){var obj6077 = {};return obj6077; +})(); +cljs.core._invoke = (function() { +var _invoke = null; +var _invoke__1 = (function (this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$2(this$,a); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$3(this$,a,b); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$4(this$,a,b,c); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$5; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$5(this$,a,b,c,d); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$6; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$6(this$,a,b,c,d,e); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$7; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$7(this$,a,b,c,d,e,f); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$8; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$8(this$,a,b,c,d,e,f,g); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$9; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$9(this$,a,b,c,d,e,f,g,h); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$10; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$10(this$,a,b,c,d,e,f,g,h,i); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$11; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$11(this$,a,b,c,d,e,f,g,h,i,j); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$12; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IFn$_invoke$arity$12(this$,a,b,c,d,e,f,g,h,i,j,k); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$13; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$14; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$15; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(or__3540__auto____$1) +{return or__3540__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(cljs.core.truth_((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IFn$_invoke$arity$16; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__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(cljs.core.truth_((function (){var and__3528__auto__ = this$;if(cljs.core.truth_(and__3528__auto__)) +{return this$.cljs$core$IFn$_invoke$arity$17; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__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(cljs.core.truth_((function (){var and__3528__auto__ = this$;if(cljs.core.truth_(and__3528__auto__)) +{return this$.cljs$core$IFn$_invoke$arity$18; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__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(cljs.core.truth_((function (){var and__3528__auto__ = this$;if(cljs.core.truth_(and__3528__auto__)) +{return this$.cljs$core$IFn$_invoke$arity$19; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__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(cljs.core.truth_((function (){var and__3528__auto__ = this$;if(cljs.core.truth_(and__3528__auto__)) +{return this$.cljs$core$IFn$_invoke$arity$20; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__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(cljs.core.truth_((function (){var and__3528__auto__ = this$;if(cljs.core.truth_(and__3528__auto__)) +{return this$.cljs$core$IFn$_invoke$arity$21; +} else +{return and__3528__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__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._invoke[goog.typeOf(x__4167__auto__)]);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._invoke["_"]);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__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.ICloneable = (function (){var obj6240 = {};return obj6240; +})(); +cljs.core._clone = (function _clone(value){if((function (){var and__3528__auto__ = value;if(and__3528__auto__) +{return value.cljs$core$ICloneable$_clone$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return value.cljs$core$ICloneable$_clone$arity$1(value); +} else +{var x__4167__auto__ = (((value == null))?null:value);return (function (){var or__3540__auto__ = (cljs.core._clone[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._clone["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICloneable.-clone",value); +} +} +})().call(null,value); +} +}); +cljs.core.ICounted = (function (){var obj6242 = {};return obj6242; +})(); +cljs.core._count = (function _count(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ICounted$_count$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ICounted$_count$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._count[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._count["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICounted.-count",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IEmptyableCollection = (function (){var obj6250 = {};return obj6250; +})(); +cljs.core._empty = (function _empty(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IEmptyableCollection$_empty$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._empty[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._empty["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEmptyableCollection.-empty",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ICollection = (function (){var obj6258 = {};return obj6258; +})(); +cljs.core._conj = (function _conj(coll,o){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ICollection$_conj$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ICollection$_conj$arity$2(coll,o); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._conj[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._conj["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICollection.-conj",coll); +} +} +})().call(null,coll,o); +} +}); +cljs.core.IIndexed = (function (){var obj6267 = {};return obj6267; +})(); +cljs.core._nth = (function() { +var _nth = null; +var _nth__2 = (function (coll,n){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IIndexed$_nth$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IIndexed$_nth$arity$2(coll,n); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._nth[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._nth["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IIndexed$_nth$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IIndexed$_nth$arity$3(coll,n,not_found); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._nth[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._nth["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj6294 = {};return obj6294; +})(); +cljs.core.ISeq = (function (){var obj6297 = {};return obj6297; +})(); +cljs.core._first = (function _first(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISeq$_first$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISeq$_first$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._first[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._first["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISeq$_rest$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISeq$_rest$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._rest[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._rest["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISeq.-rest",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.INext = (function (){var obj6331 = {};return obj6331; +})(); +cljs.core._next = (function _next(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$INext$_next$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$INext$_next$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._next[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._next["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"INext.-next",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ILookup = (function (){var obj6351 = {};return obj6351; +})(); +cljs.core._lookup = (function() { +var _lookup = null; +var _lookup__2 = (function (o,k){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ILookup$_lookup$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ILookup$_lookup$arity$2(o,k); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._lookup[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._lookup["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ILookup$_lookup$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ILookup$_lookup$arity$3(o,k,not_found); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._lookup[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._lookup["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj6384 = {};return obj6384; +})(); +cljs.core._contains_key_QMARK_ = (function _contains_key_QMARK_(coll,k){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll,k); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._contains_key_QMARK_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._contains_key_QMARK_["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IAssociative$_assoc$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IAssociative$_assoc$arity$3(coll,k,v); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._assoc[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IAssociative.-assoc",coll); +} +} +})().call(null,coll,k,v); +} +}); +cljs.core.IMap = (function (){var obj6426 = {};return obj6426; +})(); +cljs.core._dissoc = (function _dissoc(coll,k){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IMap$_dissoc$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IMap$_dissoc$arity$2(coll,k); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._dissoc[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._dissoc["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IMap.-dissoc",coll); +} +} +})().call(null,coll,k); +} +}); +cljs.core.IMapEntry = (function (){var obj6450 = {};return obj6450; +})(); +cljs.core._key = (function _key(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IMapEntry$_key$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IMapEntry$_key$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._key[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._key["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IMapEntry$_val$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IMapEntry$_val$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._val[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._val["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IMapEntry.-val",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ISet = (function (){var obj6460 = {};return obj6460; +})(); +cljs.core._disjoin = (function _disjoin(coll,v){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISet$_disjoin$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISet$_disjoin$arity$2(coll,v); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._disjoin[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._disjoin["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISet.-disjoin",coll); +} +} +})().call(null,coll,v); +} +}); +cljs.core.IStack = (function (){var obj6466 = {};return obj6466; +})(); +cljs.core._peek = (function _peek(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IStack$_peek$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IStack$_peek$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._peek[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._peek["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IStack$_pop$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IStack$_pop$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._pop[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._pop["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IStack.-pop",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IVector = (function (){var obj6476 = {};return obj6476; +})(); +cljs.core._assoc_n = (function _assoc_n(coll,n,val){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IVector$_assoc_n$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IVector$_assoc_n$arity$3(coll,n,val); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._assoc_n[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc_n["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IVector.-assoc-n",coll); +} +} +})().call(null,coll,n,val); +} +}); +cljs.core.IDeref = (function (){var obj6482 = {};return obj6482; +})(); +cljs.core._deref = (function _deref(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IDeref$_deref$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IDeref$_deref$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._deref[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._deref["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IDeref.-deref",o); +} +} +})().call(null,o); +} +}); +cljs.core.IDerefWithTimeout = (function (){var obj6488 = {};return obj6488; +})(); +cljs.core._deref_with_timeout = (function _deref_with_timeout(o,msec,timeout_val){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o,msec,timeout_val); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._deref_with_timeout[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._deref_with_timeout["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj6494 = {};return obj6494; +})(); +cljs.core._meta = (function _meta(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IMeta$_meta$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IMeta$_meta$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._meta[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._meta["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IMeta.-meta",o); +} +} +})().call(null,o); +} +}); +cljs.core.IWithMeta = (function (){var obj6500 = {};return obj6500; +})(); +cljs.core._with_meta = (function _with_meta(o,meta){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IWithMeta$_with_meta$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IWithMeta$_with_meta$arity$2(o,meta); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._with_meta[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._with_meta["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IWithMeta.-with-meta",o); +} +} +})().call(null,o,meta); +} +}); +cljs.core.IReduce = (function (){var obj6506 = {};return obj6506; +})(); +cljs.core._reduce = (function() { +var _reduce = null; +var _reduce__2 = (function (coll,f){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IReduce$_reduce$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IReduce$_reduce$arity$2(coll,f); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._reduce[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reduce["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IReduce$_reduce$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IReduce$_reduce$arity$3(coll,f,start); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._reduce[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reduce["_"]);if(or__3540__auto____$1) +{return or__3540__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 obj6508 = {};return obj6508; +})(); +cljs.core._kv_reduce = (function _kv_reduce(coll,f,init){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IKVReduce$_kv_reduce$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll,f,init); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._kv_reduce[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._kv_reduce["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IKVReduce.-kv-reduce",coll); +} +} +})().call(null,coll,f,init); +} +}); +cljs.core.IEquiv = (function (){var obj6510 = {};return obj6510; +})(); +cljs.core._equiv = (function _equiv(o,other){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IEquiv$_equiv$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IEquiv$_equiv$arity$2(o,other); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._equiv[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._equiv["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEquiv.-equiv",o); +} +} +})().call(null,o,other); +} +}); +cljs.core.IHash = (function (){var obj6512 = {};return obj6512; +})(); +cljs.core._hash = (function _hash(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IHash$_hash$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IHash$_hash$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._hash[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._hash["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IHash.-hash",o); +} +} +})().call(null,o); +} +}); +cljs.core.ISeqable = (function (){var obj6514 = {};return obj6514; +})(); +cljs.core._seq = (function _seq(o){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISeqable$_seq$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISeqable$_seq$arity$1(o); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._seq[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._seq["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISeqable.-seq",o); +} +} +})().call(null,o); +} +}); +cljs.core.ISequential = (function (){var obj6516 = {};return obj6516; +})(); +cljs.core.IList = (function (){var obj6518 = {};return obj6518; +})(); +cljs.core.IRecord = (function (){var obj6520 = {};return obj6520; +})(); +cljs.core.IReversible = (function (){var obj6522 = {};return obj6522; +})(); +cljs.core._rseq = (function _rseq(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IReversible$_rseq$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IReversible$_rseq$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._rseq[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._rseq["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IReversible.-rseq",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ISorted = (function (){var obj6524 = {};return obj6524; +})(); +cljs.core._sorted_seq = (function _sorted_seq(coll,ascending_QMARK_){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_sorted_seq$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll,ascending_QMARK_); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._sorted_seq[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._sorted_seq["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_sorted_seq_from$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll,k,ascending_QMARK_); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._sorted_seq_from[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._sorted_seq_from["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_entry_key$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_entry_key$arity$2(coll,entry); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._entry_key[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._entry_key["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$ISorted$_comparator$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$ISorted$_comparator$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._comparator[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._comparator["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISorted.-comparator",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IWriter = (function (){var obj6526 = {};return obj6526; +})(); +cljs.core._write = (function _write(writer,s){if((function (){var and__3528__auto__ = writer;if(and__3528__auto__) +{return writer.cljs$core$IWriter$_write$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return writer.cljs$core$IWriter$_write$arity$2(writer,s); +} else +{var x__4167__auto__ = (((writer == null))?null:writer);return (function (){var or__3540__auto__ = (cljs.core._write[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._write["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = writer;if(and__3528__auto__) +{return writer.cljs$core$IWriter$_flush$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return writer.cljs$core$IWriter$_flush$arity$1(writer); +} else +{var x__4167__auto__ = (((writer == null))?null:writer);return (function (){var or__3540__auto__ = (cljs.core._flush[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._flush["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IWriter.-flush",writer); +} +} +})().call(null,writer); +} +}); +cljs.core.IPrintWithWriter = (function (){var obj6528 = {};return obj6528; +})(); +cljs.core._pr_writer = (function _pr_writer(o,writer,opts){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o,writer,opts); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._pr_writer[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._pr_writer["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IPrintWithWriter.-pr-writer",o); +} +} +})().call(null,o,writer,opts); +} +}); +cljs.core.IPending = (function (){var obj6530 = {};return obj6530; +})(); +cljs.core._realized_QMARK_ = (function _realized_QMARK_(d){if((function (){var and__3528__auto__ = d;if(and__3528__auto__) +{return d.cljs$core$IPending$_realized_QMARK_$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return d.cljs$core$IPending$_realized_QMARK_$arity$1(d); +} else +{var x__4167__auto__ = (((d == null))?null:d);return (function (){var or__3540__auto__ = (cljs.core._realized_QMARK_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._realized_QMARK_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IPending.-realized?",d); +} +} +})().call(null,d); +} +}); +cljs.core.IWatchable = (function (){var obj6532 = {};return obj6532; +})(); +cljs.core._notify_watches = (function _notify_watches(this$,oldval,newval){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IWatchable$_notify_watches$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$,oldval,newval); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._notify_watches[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._notify_watches["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IWatchable$_add_watch$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IWatchable$_add_watch$arity$3(this$,key,f); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._add_watch[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._add_watch["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = this$;if(and__3528__auto__) +{return this$.cljs$core$IWatchable$_remove_watch$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$,key); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (cljs.core._remove_watch[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._remove_watch["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IWatchable.-remove-watch",this$); +} +} +})().call(null,this$,key); +} +}); +cljs.core.IEditableCollection = (function (){var obj6534 = {};return obj6534; +})(); +cljs.core._as_transient = (function _as_transient(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IEditableCollection$_as_transient$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._as_transient[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._as_transient["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEditableCollection.-as-transient",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.ITransientCollection = (function (){var obj6536 = {};return obj6536; +})(); +cljs.core._conj_BANG_ = (function _conj_BANG_(tcoll,val){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll,val); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._conj_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._conj_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._persistent_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._persistent_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientCollection.-persistent!",tcoll); +} +} +})().call(null,tcoll); +} +}); +cljs.core.ITransientAssociative = (function (){var obj6538 = {};return obj6538; +})(); +cljs.core._assoc_BANG_ = (function _assoc_BANG_(tcoll,key,val){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll,key,val); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._assoc_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientAssociative.-assoc!",tcoll); +} +} +})().call(null,tcoll,key,val); +} +}); +cljs.core.ITransientMap = (function (){var obj6540 = {};return obj6540; +})(); +cljs.core._dissoc_BANG_ = (function _dissoc_BANG_(tcoll,key){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll,key); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._dissoc_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._dissoc_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientMap.-dissoc!",tcoll); +} +} +})().call(null,tcoll,key); +} +}); +cljs.core.ITransientVector = (function (){var obj6542 = {};return obj6542; +})(); +cljs.core._assoc_n_BANG_ = (function _assoc_n_BANG_(tcoll,n,val){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll,n,val); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._assoc_n_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._assoc_n_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._pop_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._pop_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientVector.-pop!",tcoll); +} +} +})().call(null,tcoll); +} +}); +cljs.core.ITransientSet = (function (){var obj6544 = {};return obj6544; +})(); +cljs.core._disjoin_BANG_ = (function _disjoin_BANG_(tcoll,v){if((function (){var and__3528__auto__ = tcoll;if(and__3528__auto__) +{return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll,v); +} else +{var x__4167__auto__ = (((tcoll == null))?null:tcoll);return (function (){var or__3540__auto__ = (cljs.core._disjoin_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._disjoin_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ITransientSet.-disjoin!",tcoll); +} +} +})().call(null,tcoll,v); +} +}); +cljs.core.IComparable = (function (){var obj6546 = {};return obj6546; +})(); +cljs.core._compare = (function _compare(x,y){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IComparable$_compare$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IComparable$_compare$arity$2(x,y); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._compare[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._compare["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IComparable.-compare",x); +} +} +})().call(null,x,y); +} +}); +cljs.core.IChunk = (function (){var obj6548 = {};return obj6548; +})(); +cljs.core._drop_first = (function _drop_first(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunk$_drop_first$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunk$_drop_first$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._drop_first[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._drop_first["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IChunk.-drop-first",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IChunkedSeq = (function (){var obj6550 = {};return obj6550; +})(); +cljs.core._chunked_first = (function _chunked_first(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._chunked_first[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._chunked_first["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._chunked_rest[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._chunked_rest["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IChunkedSeq.-chunked-rest",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.IChunkedNext = (function (){var obj6552 = {};return obj6552; +})(); +cljs.core._chunked_next = (function _chunked_next(coll){if((function (){var and__3528__auto__ = coll;if(and__3528__auto__) +{return coll.cljs$core$IChunkedNext$_chunked_next$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll); +} else +{var x__4167__auto__ = (((coll == null))?null:coll);return (function (){var or__3540__auto__ = (cljs.core._chunked_next[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._chunked_next["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IChunkedNext.-chunked-next",coll); +} +} +})().call(null,coll); +} +}); +cljs.core.INamed = (function (){var obj6554 = {};return obj6554; +})(); +cljs.core._name = (function _name(x){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$INamed$_name$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$INamed$_name$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._name[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._name["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$INamed$_namespace$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$INamed$_namespace$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._namespace[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._namespace["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"INamed.-namespace",x); +} +} +})().call(null,x); +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); +/** +* Support so that collections can implement toString without +* loading all the printing machinery. +*/ +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__3528__auto__ = cljs.core.not.call(null,a.ns);if(and__3528__auto__) +{return b.ns; +} else +{return and__3528__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; +} +} +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__._hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_symbol.call(null,sym__$1);self__._hash = h__3951__auto____$1; +return h__3951__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__6556 = null; +var G__6556__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__6556__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__6556 = function(self__,coll,not_found){ +switch(arguments.length){ +case 2: +return G__6556__2.call(this,self__,coll); +case 3: +return G__6556__3.call(this,self__,coll,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__6556; +})() +; +cljs.core.Symbol.prototype.apply = (function (self__,args6555){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args6555))); +}); +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.clone = (function clone(value){return cljs.core._clone.call(null,value); +}); +cljs.core.cloneable_QMARK_ = (function cloneable_QMARK_(value){var G__6558 = value;if(G__6558) +{var bit__4190__auto__ = (G__6558.cljs$lang$protocol_mask$partition1$ & 8192);if((bit__4190__auto__) || (G__6558.cljs$core$ICloneable$)) +{return true; +} else +{if((!G__6558.cljs$lang$protocol_mask$partition1$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICloneable,G__6558); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICloneable,G__6558); +} +}); +/** +* Returns a seq on the collection. If the collection is +* empty, returns nil. (seq nil) returns nil. seq also works on +* Strings. +*/ +cljs.core.seq = (function seq(coll){if((coll == null)) +{return null; +} else +{if((function (){var G__6560 = coll;if(G__6560) +{var bit__4183__auto__ = (G__6560.cljs$lang$protocol_mask$partition0$ & 8388608);if((bit__4183__auto__) || (G__6560.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; +} +} +} +} +} +} +}); +/** +* Returns the first item in the collection. Calls seq on its +* argument. If coll is nil, returns nil. +*/ +cljs.core.first = (function first(coll){if((coll == null)) +{return null; +} else +{if((function (){var G__6562 = coll;if(G__6562) +{var bit__4183__auto__ = (G__6562.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4183__auto__) || (G__6562.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); +} +} +} +}); +/** +* Returns a possibly empty seq of the items after the first. Calls seq on its +* argument. +*/ +cljs.core.rest = (function rest(coll){if(!((coll == null))) +{if((function (){var G__6564 = coll;if(G__6564) +{var bit__4183__auto__ = (G__6564.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4183__auto__) || (G__6564.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; +} +}); +/** +* Returns a seq of the items after the first. Calls seq on its +* argument. If there are no more items, returns nil +*/ +cljs.core.next = (function next(coll){if((coll == null)) +{return null; +} else +{if((function (){var G__6566 = coll;if(G__6566) +{var bit__4183__auto__ = (G__6566.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4183__auto__) || (G__6566.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)); +} +} +}); +/** +* Equality. Returns true if x equals y, false if not. Compares +* numbers and collections in a type-independent manner. Clojure's immutable data +* structures define -equiv (and thus =) as a value, not an identity, +* comparison. +* @param {...*} var_args +*/ +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__6567__delegate = function (x,y,more){while(true){ +if(_EQ_.call(null,x,y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__6568 = y; +var G__6569 = cljs.core.first.call(null,more); +var G__6570 = cljs.core.next.call(null,more); +x = G__6568; +y = G__6569; +more = G__6570; +continue; +} +} else +{return _EQ_.call(null,y,cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__6567 = 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__6567__delegate.call(this,x,y,more);}; +G__6567.cljs$lang$maxFixedArity = 2; +G__6567.cljs$lang$applyTo = (function (arglist__6571){ +var x = cljs.core.first(arglist__6571); +arglist__6571 = cljs.core.next(arglist__6571); +var y = cljs.core.first(arglist__6571); +var more = cljs.core.rest(arglist__6571); +return G__6567__delegate(x,y,more); +}); +G__6567.cljs$core$IFn$_invoke$arity$variadic = G__6567__delegate; +return G__6567; +})() +; +_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); +})); +/** +* Returns a number one greater than num. +*/ +cljs.core.inc = (function inc(x){return (x + 1); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); +/** +* Wraps x in a way such that a reduce will terminate with the value x +*/ +cljs.core.reduced = (function reduced(x){return (new cljs.core.Reduced(x)); +}); +/** +* Returns true if x is the result of a call to reduced +*/ +cljs.core.reduced_QMARK_ = (function reduced_QMARK_(r){return (r instanceof cljs.core.Reduced); +}); +/** +* Accepts any collection which satisfies the ICount and IIndexed protocols and +* reduces them without incurring seq initialization +*/ +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__6572 = nval; +var G__6573 = (n + 1); +val = G__6572; +n = G__6573; +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__6574 = nval; +var G__6575 = (n + 1); +val__$1 = G__6574; +n = G__6575; +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__6576 = nval; +var G__6577 = (n + 1); +val__$1 = G__6576; +n = G__6577; +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__6578 = nval; +var G__6579 = (n + 1); +val = G__6578; +n = G__6579; +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__6580 = nval; +var G__6581 = (n + 1); +val__$1 = G__6580; +n = G__6581; +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__6582 = nval; +var G__6583 = (n + 1); +val__$1 = G__6582; +n = G__6583; +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; +})() +; +/** +* Returns true if coll implements count in constant time +*/ +cljs.core.counted_QMARK_ = (function counted_QMARK_(x){var G__6585 = x;if(G__6585) +{var bit__4190__auto__ = (G__6585.cljs$lang$protocol_mask$partition0$ & 2);if((bit__4190__auto__) || (G__6585.cljs$core$ICounted$)) +{return true; +} else +{if((!G__6585.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICounted,G__6585); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICounted,G__6585); +} +}); +/** +* Returns true if coll implements nth in constant time +*/ +cljs.core.indexed_QMARK_ = (function indexed_QMARK_(x){var G__6587 = x;if(G__6587) +{var bit__4190__auto__ = (G__6587.cljs$lang$protocol_mask$partition0$ & 16);if((bit__4190__auto__) || (G__6587.cljs$core$IIndexed$)) +{return true; +} else +{if((!G__6587.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IIndexed,G__6587); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IIndexed,G__6587); +} +}); + +/** +* @constructor +*/ +cljs.core.IndexedSeq = (function (arr,i){ +this.arr = arr; +this.i = i; +this.cljs$lang$protocol_mask$partition0$ = 166199550; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.IndexedSeq.cljs$lang$type = true; +cljs.core.IndexedSeq.cljs$lang$ctorStr = "cljs.core/IndexedSeq"; +cljs.core.IndexedSeq.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.IndexedSeq(self__.arr,self__.i)); +}); +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; +})() +; + +/** +* @constructor +*/ +cljs.core.RSeq = (function (ci,i,meta){ +this.ci = ci; +this.i = i; +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 32374862; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.RSeq.cljs$lang$type = true; +cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq"; +cljs.core.RSeq.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.RSeq(self__.ci,self__.i,self__.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)); +}); +/** +* Same as (first (next x)) +*/ +cljs.core.second = (function second(coll){return cljs.core.first.call(null,cljs.core.next.call(null,coll)); +}); +/** +* Same as (first (first x)) +*/ +cljs.core.ffirst = (function ffirst(coll){return cljs.core.first.call(null,cljs.core.first.call(null,coll)); +}); +/** +* Same as (next (first x)) +*/ +cljs.core.nfirst = (function nfirst(coll){return cljs.core.next.call(null,cljs.core.first.call(null,coll)); +}); +/** +* Same as (first (next x)) +*/ +cljs.core.fnext = (function fnext(coll){return cljs.core.first.call(null,cljs.core.next.call(null,coll)); +}); +/** +* Same as (next (next x)) +*/ +cljs.core.nnext = (function nnext(coll){return cljs.core.next.call(null,cljs.core.next.call(null,coll)); +}); +/** +* Return the last item in coll, in linear time +*/ +cljs.core.last = (function last(s){while(true){ +var sn = cljs.core.next.call(null,s);if(!((sn == null))) +{{ +var G__6588 = sn; +s = G__6588; +continue; +} +} else +{return cljs.core.first.call(null,s); +} +break; +} +}); +(cljs.core.IEquiv["_"] = true); +(cljs.core._equiv["_"] = (function (x,o){return (x === o); +})); +/** +* conj[oin]. Returns a new collection with the xs +* 'added'. (conj nil item) returns (item). The 'addition' may +* happen at different 'places' depending on the concrete type. +* @param {...*} var_args +*/ +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__6589__delegate = function (coll,x,xs){while(true){ +if(cljs.core.truth_(xs)) +{{ +var G__6590 = conj.call(null,coll,x); +var G__6591 = cljs.core.first.call(null,xs); +var G__6592 = cljs.core.next.call(null,xs); +coll = G__6590; +x = G__6591; +xs = G__6592; +continue; +} +} else +{return conj.call(null,coll,x); +} +break; +} +}; +var G__6589 = 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__6589__delegate.call(this,coll,x,xs);}; +G__6589.cljs$lang$maxFixedArity = 2; +G__6589.cljs$lang$applyTo = (function (arglist__6593){ +var coll = cljs.core.first(arglist__6593); +arglist__6593 = cljs.core.next(arglist__6593); +var x = cljs.core.first(arglist__6593); +var xs = cljs.core.rest(arglist__6593); +return G__6589__delegate(coll,x,xs); +}); +G__6589.cljs$core$IFn$_invoke$arity$variadic = G__6589__delegate; +return G__6589; +})() +; +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; +})() +; +/** +* Returns an empty collection of the same category as coll, or nil +*/ +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__6594 = cljs.core.next.call(null,s); +var G__6595 = (acc + 1); +s = G__6594; +acc = G__6595; +continue; +} +} +break; +} +}); +/** +* Returns the number of items in the collection. (count nil) returns +* 0. Also works on strings, arrays, and Maps +*/ +cljs.core.count = (function count(coll){if(!((coll == null))) +{if((function (){var G__6597 = coll;if(G__6597) +{var bit__4183__auto__ = (G__6597.cljs$lang$protocol_mask$partition0$ & 2);if((bit__4183__auto__) || (G__6597.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__6598 = cljs.core.next.call(null,coll); +var G__6599 = (n - 1); +coll = G__6598; +n = G__6599; +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__6600 = cljs.core.next.call(null,coll); +var G__6601 = (n - 1); +var G__6602 = not_found; +coll = G__6600; +n = G__6601; +not_found = G__6602; +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; +})() +; +/** +* Returns the value at the index. get returns nil if index out of +* bounds, nth throws an exception unless not-found is supplied. nth +* also works for strings, arrays, regex Matchers and Lists, and, +* in O(n) time, for sequences. +*/ +cljs.core.nth = (function() { +var nth = null; +var nth__2 = (function (coll,n){if((coll == null)) +{return null; +} else +{if((function (){var G__6607 = coll;if(G__6607) +{var bit__4183__auto__ = (G__6607.cljs$lang$protocol_mask$partition0$ & 16);if((bit__4183__auto__) || (G__6607.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__6608 = coll;if(G__6608) +{var bit__4190__auto__ = (G__6608.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4190__auto__) || (G__6608.cljs$core$ISeq$)) +{return true; +} else +{if((!G__6608.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__6608); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__6608); +} +})()) +{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__6609 = coll;if(G__6609) +{var bit__4183__auto__ = (G__6609.cljs$lang$protocol_mask$partition0$ & 16);if((bit__4183__auto__) || (G__6609.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__6610 = coll;if(G__6610) +{var bit__4190__auto__ = (G__6610.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4190__auto__) || (G__6610.cljs$core$ISeq$)) +{return true; +} else +{if((!G__6610.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__6610); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__6610); +} +})()) +{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; +})() +; +/** +* Returns the value mapped to key, not-found or nil if key not present. +*/ +cljs.core.get = (function() { +var get = null; +var get__2 = (function (o,k){if((o == null)) +{return null; +} else +{if((function (){var G__6613 = o;if(G__6613) +{var bit__4183__auto__ = (G__6613.cljs$lang$protocol_mask$partition0$ & 256);if((bit__4183__auto__) || (G__6613.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__6614 = o;if(G__6614) +{var bit__4183__auto__ = (G__6614.cljs$lang$protocol_mask$partition0$ & 256);if((bit__4183__auto__) || (G__6614.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; +})() +; +/** +* assoc[iate]. When applied to a map, returns a new map of the +* same (hashed/sorted) type, that contains the mapping of key(s) to +* val(s). When applied to a vector, returns a new vector that +* contains val at index. +* @param {...*} var_args +*/ +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__6615__delegate = function (coll,k,v,kvs){while(true){ +var ret = assoc.call(null,coll,k,v);if(cljs.core.truth_(kvs)) +{{ +var G__6616 = ret; +var G__6617 = cljs.core.first.call(null,kvs); +var G__6618 = cljs.core.second.call(null,kvs); +var G__6619 = cljs.core.nnext.call(null,kvs); +coll = G__6616; +k = G__6617; +v = G__6618; +kvs = G__6619; +continue; +} +} else +{return ret; +} +break; +} +}; +var G__6615 = 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__6615__delegate.call(this,coll,k,v,kvs);}; +G__6615.cljs$lang$maxFixedArity = 3; +G__6615.cljs$lang$applyTo = (function (arglist__6620){ +var coll = cljs.core.first(arglist__6620); +arglist__6620 = cljs.core.next(arglist__6620); +var k = cljs.core.first(arglist__6620); +arglist__6620 = cljs.core.next(arglist__6620); +var v = cljs.core.first(arglist__6620); +var kvs = cljs.core.rest(arglist__6620); +return G__6615__delegate(coll,k,v,kvs); +}); +G__6615.cljs$core$IFn$_invoke$arity$variadic = G__6615__delegate; +return G__6615; +})() +; +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; +})() +; +/** +* dissoc[iate]. Returns a new map of the same (hashed/sorted) type, +* that does not contain a mapping for key(s). +* @param {...*} var_args +*/ +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__6621__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__6622 = ret; +var G__6623 = cljs.core.first.call(null,ks); +var G__6624 = cljs.core.next.call(null,ks); +coll = G__6622; +k = G__6623; +ks = G__6624; +continue; +} +} else +{return ret; +} +} +break; +} +}; +var G__6621 = 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__6621__delegate.call(this,coll,k,ks);}; +G__6621.cljs$lang$maxFixedArity = 2; +G__6621.cljs$lang$applyTo = (function (arglist__6625){ +var coll = cljs.core.first(arglist__6625); +arglist__6625 = cljs.core.next(arglist__6625); +var k = cljs.core.first(arglist__6625); +var ks = cljs.core.rest(arglist__6625); +return G__6621__delegate(coll,k,ks); +}); +G__6621.cljs$core$IFn$_invoke$arity$variadic = G__6621__delegate; +return G__6621; +})() +; +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__3540__auto__ = goog.isFunction(f);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var G__6629 = f;if(G__6629) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto____$1 = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return G__6629.cljs$core$Fn$; +} +})())) +{return true; +} else +{if((!G__6629.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.Fn,G__6629); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.Fn,G__6629); +} +} +}); +/** +* Returns an object of the same type and value as obj, with +* map m as its metadata. +*/ +cljs.core.with_meta = (function with_meta(o,meta){if((cljs.core.fn_QMARK_.call(null,o)) && (!((function (){var G__6637 = o;if(G__6637) +{var bit__4190__auto__ = (G__6637.cljs$lang$protocol_mask$partition0$ & 262144);if((bit__4190__auto__) || (G__6637.cljs$core$IWithMeta$)) +{return true; +} else +{if((!G__6637.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IWithMeta,G__6637); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IWithMeta,G__6637); +} +})()))) +{return with_meta.call(null,(function (){if(typeof cljs.core.t6638 !== 'undefined') +{} else +{ +/** +* @constructor +*/ +cljs.core.t6638 = (function (meta,o,with_meta,meta6639){ +this.meta = meta; +this.o = o; +this.with_meta = with_meta; +this.meta6639 = meta6639; +this.cljs$lang$protocol_mask$partition1$ = 0; +this.cljs$lang$protocol_mask$partition0$ = 393217; +}) +cljs.core.t6638.cljs$lang$type = true; +cljs.core.t6638.cljs$lang$ctorStr = "cljs.core/t6638"; +cljs.core.t6638.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__auto__,"cljs.core/t6638"); +}); +cljs.core.t6638.prototype.call = (function() { +var G__6642__delegate = function (self__,args){var self____$1 = this;var _ = self____$1;return cljs.core.apply.call(null,self__.o,args); +}; +var G__6642 = 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__6642__delegate.call(this,self__,args);}; +G__6642.cljs$lang$maxFixedArity = 1; +G__6642.cljs$lang$applyTo = (function (arglist__6643){ +var self__ = cljs.core.first(arglist__6643); +var args = cljs.core.rest(arglist__6643); +return G__6642__delegate(self__,args); +}); +G__6642.cljs$core$IFn$_invoke$arity$variadic = G__6642__delegate; +return G__6642; +})() +; +cljs.core.t6638.prototype.apply = (function (self__,args6641){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args6641))); +}); +cljs.core.t6638.prototype.cljs$core$IFn$_invoke$arity$2 = (function() { +var G__6644__delegate = function (args){var _ = this;return cljs.core.apply.call(null,self__.o,args); +}; +var G__6644 = 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__6644__delegate.call(this,args);}; +G__6644.cljs$lang$maxFixedArity = 0; +G__6644.cljs$lang$applyTo = (function (arglist__6645){ +var args = cljs.core.seq(arglist__6645); +return G__6644__delegate(args); +}); +G__6644.cljs$core$IFn$_invoke$arity$variadic = G__6644__delegate; +return G__6644; +})() +; +cljs.core.t6638.prototype.cljs$core$Fn$ = true; +cljs.core.t6638.prototype.cljs$core$IMeta$_meta$arity$1 = (function (_6640){var self__ = this; +var _6640__$1 = this;return self__.meta6639; +}); +cljs.core.t6638.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = (function (_6640,meta6639__$1){var self__ = this; +var _6640__$1 = this;return (new cljs.core.t6638(self__.meta,self__.o,self__.with_meta,meta6639__$1)); +}); +cljs.core.__GT_t6638 = (function __GT_t6638(meta__$1,o__$1,with_meta__$1,meta6639){return (new cljs.core.t6638(meta__$1,o__$1,with_meta__$1,meta6639)); +}); +} +return (new cljs.core.t6638(meta,o,with_meta,null)); +})(),meta); +} else +{if((o == null)) +{return null; +} else +{return cljs.core._with_meta.call(null,o,meta); +} +} +}); +/** +* Returns the metadata of obj, returns nil if there is no metadata. +*/ +cljs.core.meta = (function meta(o){if((function (){var and__3528__auto__ = !((o == null));if(and__3528__auto__) +{var G__6649 = o;if(G__6649) +{var bit__4190__auto__ = (G__6649.cljs$lang$protocol_mask$partition0$ & 131072);if((bit__4190__auto__) || (G__6649.cljs$core$IMeta$)) +{return true; +} else +{if((!G__6649.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__6649); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__6649); +} +} else +{return and__3528__auto__; +} +})()) +{return cljs.core._meta.call(null,o); +} else +{return null; +} +}); +/** +* For a list or queue, same as first, for a vector, same as, but much +* more efficient than, last. If the collection is empty, returns nil. +*/ +cljs.core.peek = (function peek(coll){if((coll == null)) +{return null; +} else +{return cljs.core._peek.call(null,coll); +} +}); +/** +* For a list or queue, returns a new list/queue without the first +* item, for a vector, returns a new vector without the last item. +* Note - not the same as next/butlast. +*/ +cljs.core.pop = (function pop(coll){if((coll == null)) +{return null; +} else +{return cljs.core._pop.call(null,coll); +} +}); +/** +* disj[oin]. Returns a new set of the same (hashed/sorted) type, that +* does not contain key(s). +* @param {...*} var_args +*/ +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__6650__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__6651 = ret; +var G__6652 = cljs.core.first.call(null,ks); +var G__6653 = cljs.core.next.call(null,ks); +coll = G__6651; +k = G__6652; +ks = G__6653; +continue; +} +} else +{return ret; +} +} +break; +} +}; +var G__6650 = 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__6650__delegate.call(this,coll,k,ks);}; +G__6650.cljs$lang$maxFixedArity = 2; +G__6650.cljs$lang$applyTo = (function (arglist__6654){ +var coll = cljs.core.first(arglist__6654); +arglist__6654 = cljs.core.next(arglist__6654); +var k = cljs.core.first(arglist__6654); +var ks = cljs.core.rest(arglist__6654); +return G__6650__delegate(coll,k,ks); +}); +G__6650.cljs$core$IFn$_invoke$arity$variadic = G__6650__delegate; +return G__6650; +})() +; +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 obj6656 = {};return obj6656; +})(); +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 obj6660 = {};return obj6660; +})(); +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__6662 = o;if(G__6662) +{var bit__4183__auto__ = (G__6662.cljs$lang$protocol_mask$partition0$ & 4194304);if((bit__4183__auto__) || (G__6662.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; +} +} +} +} +} +} +} +}); +/** +* Returns true if coll has no items - same as (not (seq coll)). +* Please use the idiom (seq x) rather than (not (empty? x)) +*/ +cljs.core.empty_QMARK_ = (function empty_QMARK_(coll){return ((coll == null)) || (cljs.core.not.call(null,cljs.core.seq.call(null,coll))); +}); +/** +* Returns true if x satisfies ICollection +*/ +cljs.core.coll_QMARK_ = (function coll_QMARK_(x){if((x == null)) +{return false; +} else +{var G__6664 = x;if(G__6664) +{var bit__4190__auto__ = (G__6664.cljs$lang$protocol_mask$partition0$ & 8);if((bit__4190__auto__) || (G__6664.cljs$core$ICollection$)) +{return true; +} else +{if((!G__6664.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICollection,G__6664); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ICollection,G__6664); +} +} +}); +/** +* Returns true if x satisfies ISet +*/ +cljs.core.set_QMARK_ = (function set_QMARK_(x){if((x == null)) +{return false; +} else +{var G__6666 = x;if(G__6666) +{var bit__4190__auto__ = (G__6666.cljs$lang$protocol_mask$partition0$ & 4096);if((bit__4190__auto__) || (G__6666.cljs$core$ISet$)) +{return true; +} else +{if((!G__6666.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISet,G__6666); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISet,G__6666); +} +} +}); +/** +* Returns true if coll implements Associative +*/ +cljs.core.associative_QMARK_ = (function associative_QMARK_(x){var G__6668 = x;if(G__6668) +{var bit__4190__auto__ = (G__6668.cljs$lang$protocol_mask$partition0$ & 512);if((bit__4190__auto__) || (G__6668.cljs$core$IAssociative$)) +{return true; +} else +{if((!G__6668.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IAssociative,G__6668); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IAssociative,G__6668); +} +}); +/** +* Returns true if coll satisfies ISequential +*/ +cljs.core.sequential_QMARK_ = (function sequential_QMARK_(x){var G__6670 = x;if(G__6670) +{var bit__4190__auto__ = (G__6670.cljs$lang$protocol_mask$partition0$ & 16777216);if((bit__4190__auto__) || (G__6670.cljs$core$ISequential$)) +{return true; +} else +{if((!G__6670.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISequential,G__6670); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISequential,G__6670); +} +}); +/** +* Returns true if coll satisfies ISorted +*/ +cljs.core.sorted_QMARK_ = (function sorted_QMARK_(x){var G__6672 = x;if(G__6672) +{var bit__4190__auto__ = (G__6672.cljs$lang$protocol_mask$partition0$ & 268435456);if((bit__4190__auto__) || (G__6672.cljs$core$ISorted$)) +{return true; +} else +{if((!G__6672.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISorted,G__6672); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISorted,G__6672); +} +}); +/** +* Returns true if coll satisfies IReduce +*/ +cljs.core.reduceable_QMARK_ = (function reduceable_QMARK_(x){var G__6674 = x;if(G__6674) +{var bit__4190__auto__ = (G__6674.cljs$lang$protocol_mask$partition0$ & 524288);if((bit__4190__auto__) || (G__6674.cljs$core$IReduce$)) +{return true; +} else +{if((!G__6674.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReduce,G__6674); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReduce,G__6674); +} +}); +/** +* Return true if x satisfies IMap +*/ +cljs.core.map_QMARK_ = (function map_QMARK_(x){if((x == null)) +{return false; +} else +{var G__6676 = x;if(G__6676) +{var bit__4190__auto__ = (G__6676.cljs$lang$protocol_mask$partition0$ & 1024);if((bit__4190__auto__) || (G__6676.cljs$core$IMap$)) +{return true; +} else +{if((!G__6676.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMap,G__6676); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMap,G__6676); +} +} +}); +/** +* Return true if x satisfies IVector +*/ +cljs.core.vector_QMARK_ = (function vector_QMARK_(x){var G__6678 = x;if(G__6678) +{var bit__4190__auto__ = (G__6678.cljs$lang$protocol_mask$partition0$ & 16384);if((bit__4190__auto__) || (G__6678.cljs$core$IVector$)) +{return true; +} else +{if((!G__6678.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IVector,G__6678); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IVector,G__6678); +} +}); +cljs.core.chunked_seq_QMARK_ = (function chunked_seq_QMARK_(x){var G__6680 = x;if(G__6680) +{var bit__4183__auto__ = (G__6680.cljs$lang$protocol_mask$partition1$ & 512);if((bit__4183__auto__) || (G__6680.cljs$core$IChunkedSeq$)) +{return true; +} else +{return false; +} +} else +{return false; +} +}); +/** +* @param {...*} var_args +*/ +cljs.core.js_obj = (function() { +var js_obj = null; +var js_obj__0 = (function (){var obj6684 = {};return obj6684; +}); +var js_obj__1 = (function() { +var G__6685__delegate = function (keyvals){return cljs.core.apply.call(null,goog.object.create,keyvals); +}; +var G__6685 = function (var_args){ +var keyvals = null;if (arguments.length > 0) { + keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6685__delegate.call(this,keyvals);}; +G__6685.cljs$lang$maxFixedArity = 0; +G__6685.cljs$lang$applyTo = (function (arglist__6686){ +var keyvals = cljs.core.seq(arglist__6686); +return G__6685__delegate(keyvals); +}); +G__6685.cljs$core$IFn$_invoke$arity$variadic = G__6685__delegate; +return G__6685; +})() +; +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__6687 = (i__$1 + 1); +var G__6688 = (j__$1 + 1); +var G__6689 = (len__$1 - 1); +i__$1 = G__6687; +j__$1 = G__6688; +len__$1 = G__6689; +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__6690 = (i__$1 - 1); +var G__6691 = (j__$1 - 1); +var G__6692 = (len__$1 - 1); +i__$1 = G__6690; +j__$1 = G__6691; +len__$1 = G__6692; +continue; +} +} +break; +} +}); +cljs.core.lookup_sentinel = (function (){var obj6694 = {};return obj6694; +})(); +/** +* Returns true if x is the value false, false otherwise. +*/ +cljs.core.false_QMARK_ = (function false_QMARK_(x){return x === false; +}); +/** +* Returns true if x is the value true, false otherwise. +*/ +cljs.core.true_QMARK_ = (function true_QMARK_(x){return x === true; +}); +cljs.core.undefined_QMARK_ = (function undefined_QMARK_(x){return (void 0 === x); +}); +/** +* Return true if s satisfies ISeq +*/ +cljs.core.seq_QMARK_ = (function seq_QMARK_(s){if((s == null)) +{return false; +} else +{var G__6696 = s;if(G__6696) +{var bit__4190__auto__ = (G__6696.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4190__auto__) || (G__6696.cljs$core$ISeq$)) +{return true; +} else +{if((!G__6696.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__6696); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeq,G__6696); +} +} +}); +/** +* Return true if s satisfies ISeqable +*/ +cljs.core.seqable_QMARK_ = (function seqable_QMARK_(s){var G__6698 = s;if(G__6698) +{var bit__4190__auto__ = (G__6698.cljs$lang$protocol_mask$partition0$ & 8388608);if((bit__4190__auto__) || (G__6698.cljs$core$ISeqable$)) +{return true; +} else +{if((!G__6698.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeqable,G__6698); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ISeqable,G__6698); +} +}); +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__3540__auto__ = cljs.core.fn_QMARK_.call(null,f);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var G__6702 = f;if(G__6702) +{var bit__4190__auto__ = (G__6702.cljs$lang$protocol_mask$partition0$ & 1);if((bit__4190__auto__) || (G__6702.cljs$core$IFn$)) +{return true; +} else +{if((!G__6702.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IFn,G__6702); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IFn,G__6702); +} +} +}); +/** +* Returns true if n is an integer. +*/ +cljs.core.integer_QMARK_ = (function integer_QMARK_(n){return (typeof n === 'number') && (!(isNaN(n))) && (!((n === Infinity))) && ((parseFloat(n) === parseInt(n,10))); +}); +/** +* Returns true if key is present in the given collection, otherwise +* returns false. Note that for numerically indexed collections like +* vectors and arrays, this tests if the numeric key is within the +* range of indexes. 'contains?' operates constant or logarithmic time; +* it will not perform a linear search for a value. See also 'some'. +*/ +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; +} +}); +/** +* Returns the map entry for key, or nil if key not present. +*/ +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; +} +}); +/** +* Returns true if no two of the arguments are = +* @param {...*} var_args +*/ +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__6703__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__6704 = cljs.core.conj.call(null,s,x__$1); +var G__6705 = etc; +s = G__6704; +xs = G__6705; +continue; +} +} +} else +{return true; +} +break; +} +} else +{return false; +} +}; +var G__6703 = 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__6703__delegate.call(this,x,y,more);}; +G__6703.cljs$lang$maxFixedArity = 2; +G__6703.cljs$lang$applyTo = (function (arglist__6706){ +var x = cljs.core.first(arglist__6706); +arglist__6706 = cljs.core.next(arglist__6706); +var y = cljs.core.first(arglist__6706); +var more = cljs.core.rest(arglist__6706); +return G__6703__delegate(x,y,more); +}); +G__6703.cljs$core$IFn$_invoke$arity$variadic = G__6703__delegate; +return G__6703; +})() +; +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_; +})() +; +/** +* Coerces coll to a (possibly empty) sequence, if it is not already +* one. Will not force a lazy seq. (sequence nil) yields () +*/ +cljs.core.sequence = (function sequence(coll){if(cljs.core.seq_QMARK_.call(null,coll)) +{return coll; +} else +{var or__3540__auto__ = cljs.core.seq.call(null,coll);if(or__3540__auto__) +{return or__3540__auto__; +} else +{return cljs.core.List.EMPTY; +} +} +}); +/** +* Comparator. Returns a negative number, zero, or a positive number +* when x is logically 'less than', 'equal to', or 'greater than' +* y. Uses IComparable if available and google.array.defaultCompare for objects +* of the same type and special-cases nil to be less than any other object. +*/ +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__6708 = x;if(G__6708) +{var bit__4183__auto__ = (G__6708.cljs$lang$protocol_mask$partition1$ & 2048);if((bit__4183__auto__) || (G__6708.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; +} +} +} +} +} +}); +/** +* Compare indexed collection. +*/ +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__6709 = xs; +var G__6710 = ys; +var G__6711 = len; +var G__6712 = (n + 1); +xs = G__6709; +ys = G__6710; +len = G__6711; +n = G__6712; +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; +})() +; +/** +* Given a fn that might be boolean valued or a comparator, +* return a fn that is a comparator. +*/ +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; +} +} +} +}); +} +}); +/** +* Returns a sorted sequence of the items in coll. Comp can be +* boolean-valued comparison funcion, or a -/0/+ valued comparator. +* Comp defaults to compare. +*/ +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; +})() +; +/** +* Returns a sorted sequence of the items in coll, where the sort +* order is determined by comparing (keyfn item). Comp can be +* boolean-valued comparison funcion, or a -/0/+ valued comparator. +* Comp defaults to compare. +*/ +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__6713 = nval; +var G__6714 = cljs.core.next.call(null,coll__$1); +val__$1 = G__6713; +coll__$1 = G__6714; +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; +})() +; +/** +* Return a random permutation of coll +*/ +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); +}); +/** +* f should be a function of 2 arguments. If val is not supplied, +* returns the result of applying f to the first 2 items in coll, then +* applying f to that result and the 3rd item, etc. If coll contains no +* items, f must accept no arguments as well, and reduce returns the +* result of calling f with no arguments. If coll has only 1 item, it +* is returned and f is not called. If val is supplied, returns the +* result of applying f to val and the first item in coll, then +* applying f to that result and the 2nd item, etc. If coll contains no +* items, returns val and f is not called. +*/ +cljs.core.reduce = (function() { +var reduce = null; +var reduce__2 = (function (f,coll){if((function (){var G__6717 = coll;if(G__6717) +{var bit__4183__auto__ = (G__6717.cljs$lang$protocol_mask$partition0$ & 524288);if((bit__4183__auto__) || (G__6717.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__6718 = coll;if(G__6718) +{var bit__4183__auto__ = (G__6718.cljs$lang$protocol_mask$partition0$ & 524288);if((bit__4183__auto__) || (G__6718.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; +})() +; +/** +* Reduces an associative collection. f should be a function of 3 +* arguments. Returns the result of applying f to init, the first key +* and the first value in coll, then applying f to that result and the +* 2nd key and value, etc. If coll contains no entries, returns init +* and f is not called. Note that reduce-kv is supported on vectors, +* where the keys will be the ordinals. +*/ +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; +} +}); +/** +* Returns the sum of nums. (+) returns 0. +* @param {...*} var_args +*/ +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__6719__delegate = function (x,y,more){return cljs.core.reduce.call(null,_PLUS_,(x + y),more); +}; +var G__6719 = 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__6719__delegate.call(this,x,y,more);}; +G__6719.cljs$lang$maxFixedArity = 2; +G__6719.cljs$lang$applyTo = (function (arglist__6720){ +var x = cljs.core.first(arglist__6720); +arglist__6720 = cljs.core.next(arglist__6720); +var y = cljs.core.first(arglist__6720); +var more = cljs.core.rest(arglist__6720); +return G__6719__delegate(x,y,more); +}); +G__6719.cljs$core$IFn$_invoke$arity$variadic = G__6719__delegate; +return G__6719; +})() +; +_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_; +})() +; +/** +* If no ys are supplied, returns the negation of x, else subtracts +* the ys from x and returns the result. +* @param {...*} var_args +*/ +cljs.core._ = (function() { +var _ = null; +var ___1 = (function (x){return (- x); +}); +var ___2 = (function (x,y){return (x - y); +}); +var ___3 = (function() { +var G__6721__delegate = function (x,y,more){return cljs.core.reduce.call(null,_,(x - y),more); +}; +var G__6721 = 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__6721__delegate.call(this,x,y,more);}; +G__6721.cljs$lang$maxFixedArity = 2; +G__6721.cljs$lang$applyTo = (function (arglist__6722){ +var x = cljs.core.first(arglist__6722); +arglist__6722 = cljs.core.next(arglist__6722); +var y = cljs.core.first(arglist__6722); +var more = cljs.core.rest(arglist__6722); +return G__6721__delegate(x,y,more); +}); +G__6721.cljs$core$IFn$_invoke$arity$variadic = G__6721__delegate; +return G__6721; +})() +; +_ = 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 _; +})() +; +/** +* Returns the product of nums. (*) returns 1. +* @param {...*} var_args +*/ +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__6723__delegate = function (x,y,more){return cljs.core.reduce.call(null,_STAR_,(x * y),more); +}; +var G__6723 = 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__6723__delegate.call(this,x,y,more);}; +G__6723.cljs$lang$maxFixedArity = 2; +G__6723.cljs$lang$applyTo = (function (arglist__6724){ +var x = cljs.core.first(arglist__6724); +arglist__6724 = cljs.core.next(arglist__6724); +var y = cljs.core.first(arglist__6724); +var more = cljs.core.rest(arglist__6724); +return G__6723__delegate(x,y,more); +}); +G__6723.cljs$core$IFn$_invoke$arity$variadic = G__6723__delegate; +return G__6723; +})() +; +_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_; +})() +; +/** +* If no denominators are supplied, returns 1/numerator, +* else returns numerator divided by all of the denominators. +* @param {...*} var_args +*/ +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__6725__delegate = function (x,y,more){return cljs.core.reduce.call(null,_SLASH_,_SLASH_.call(null,x,y),more); +}; +var G__6725 = 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__6725__delegate.call(this,x,y,more);}; +G__6725.cljs$lang$maxFixedArity = 2; +G__6725.cljs$lang$applyTo = (function (arglist__6726){ +var x = cljs.core.first(arglist__6726); +arglist__6726 = cljs.core.next(arglist__6726); +var y = cljs.core.first(arglist__6726); +var more = cljs.core.rest(arglist__6726); +return G__6725__delegate(x,y,more); +}); +G__6725.cljs$core$IFn$_invoke$arity$variadic = G__6725__delegate; +return G__6725; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically increasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__6727__delegate = function (x,y,more){while(true){ +if((x < y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__6728 = y; +var G__6729 = cljs.core.first.call(null,more); +var G__6730 = cljs.core.next.call(null,more); +x = G__6728; +y = G__6729; +more = G__6730; +continue; +} +} else +{return (y < cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__6727 = 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__6727__delegate.call(this,x,y,more);}; +G__6727.cljs$lang$maxFixedArity = 2; +G__6727.cljs$lang$applyTo = (function (arglist__6731){ +var x = cljs.core.first(arglist__6731); +arglist__6731 = cljs.core.next(arglist__6731); +var y = cljs.core.first(arglist__6731); +var more = cljs.core.rest(arglist__6731); +return G__6727__delegate(x,y,more); +}); +G__6727.cljs$core$IFn$_invoke$arity$variadic = G__6727__delegate; +return G__6727; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically non-decreasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__6732__delegate = function (x,y,more){while(true){ +if((x <= y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__6733 = y; +var G__6734 = cljs.core.first.call(null,more); +var G__6735 = cljs.core.next.call(null,more); +x = G__6733; +y = G__6734; +more = G__6735; +continue; +} +} else +{return (y <= cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__6732 = 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__6732__delegate.call(this,x,y,more);}; +G__6732.cljs$lang$maxFixedArity = 2; +G__6732.cljs$lang$applyTo = (function (arglist__6736){ +var x = cljs.core.first(arglist__6736); +arglist__6736 = cljs.core.next(arglist__6736); +var y = cljs.core.first(arglist__6736); +var more = cljs.core.rest(arglist__6736); +return G__6732__delegate(x,y,more); +}); +G__6732.cljs$core$IFn$_invoke$arity$variadic = G__6732__delegate; +return G__6732; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically decreasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__6737__delegate = function (x,y,more){while(true){ +if((x > y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__6738 = y; +var G__6739 = cljs.core.first.call(null,more); +var G__6740 = cljs.core.next.call(null,more); +x = G__6738; +y = G__6739; +more = G__6740; +continue; +} +} else +{return (y > cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__6737 = 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__6737__delegate.call(this,x,y,more);}; +G__6737.cljs$lang$maxFixedArity = 2; +G__6737.cljs$lang$applyTo = (function (arglist__6741){ +var x = cljs.core.first(arglist__6741); +arglist__6741 = cljs.core.next(arglist__6741); +var y = cljs.core.first(arglist__6741); +var more = cljs.core.rest(arglist__6741); +return G__6737__delegate(x,y,more); +}); +G__6737.cljs$core$IFn$_invoke$arity$variadic = G__6737__delegate; +return G__6737; +})() +; +_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_; +})() +; +/** +* Returns non-nil if nums are in monotonically non-increasing order, +* otherwise false. +* @param {...*} var_args +*/ +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__6742__delegate = function (x,y,more){while(true){ +if((x >= y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__6743 = y; +var G__6744 = cljs.core.first.call(null,more); +var G__6745 = cljs.core.next.call(null,more); +x = G__6743; +y = G__6744; +more = G__6745; +continue; +} +} else +{return (y >= cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__6742 = 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__6742__delegate.call(this,x,y,more);}; +G__6742.cljs$lang$maxFixedArity = 2; +G__6742.cljs$lang$applyTo = (function (arglist__6746){ +var x = cljs.core.first(arglist__6746); +arglist__6746 = cljs.core.next(arglist__6746); +var y = cljs.core.first(arglist__6746); +var more = cljs.core.rest(arglist__6746); +return G__6742__delegate(x,y,more); +}); +G__6742.cljs$core$IFn$_invoke$arity$variadic = G__6742__delegate; +return G__6742; +})() +; +_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_; +})() +; +/** +* Returns a number one less than num. +*/ +cljs.core.dec = (function dec(x){return (x - 1); +}); +/** +* Returns the greatest of the nums. +* @param {...*} var_args +*/ +cljs.core.max = (function() { +var max = null; +var max__1 = (function (x){return x; +}); +var max__2 = (function (x,y){var x__3847__auto__ = x;var y__3848__auto__ = y;return ((x__3847__auto__ > y__3848__auto__) ? x__3847__auto__ : y__3848__auto__); +}); +var max__3 = (function() { +var G__6747__delegate = function (x,y,more){return cljs.core.reduce.call(null,max,(function (){var x__3847__auto__ = x;var y__3848__auto__ = y;return ((x__3847__auto__ > y__3848__auto__) ? x__3847__auto__ : y__3848__auto__); +})(),more); +}; +var G__6747 = 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__6747__delegate.call(this,x,y,more);}; +G__6747.cljs$lang$maxFixedArity = 2; +G__6747.cljs$lang$applyTo = (function (arglist__6748){ +var x = cljs.core.first(arglist__6748); +arglist__6748 = cljs.core.next(arglist__6748); +var y = cljs.core.first(arglist__6748); +var more = cljs.core.rest(arglist__6748); +return G__6747__delegate(x,y,more); +}); +G__6747.cljs$core$IFn$_invoke$arity$variadic = G__6747__delegate; +return G__6747; +})() +; +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; +})() +; +/** +* Returns the least of the nums. +* @param {...*} var_args +*/ +cljs.core.min = (function() { +var min = null; +var min__1 = (function (x){return x; +}); +var min__2 = (function (x,y){var x__3854__auto__ = x;var y__3855__auto__ = y;return ((x__3854__auto__ < y__3855__auto__) ? x__3854__auto__ : y__3855__auto__); +}); +var min__3 = (function() { +var G__6749__delegate = function (x,y,more){return cljs.core.reduce.call(null,min,(function (){var x__3854__auto__ = x;var y__3855__auto__ = y;return ((x__3854__auto__ < y__3855__auto__) ? x__3854__auto__ : y__3855__auto__); +})(),more); +}; +var G__6749 = 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__6749__delegate.call(this,x,y,more);}; +G__6749.cljs$lang$maxFixedArity = 2; +G__6749.cljs$lang$applyTo = (function (arglist__6750){ +var x = cljs.core.first(arglist__6750); +arglist__6750 = cljs.core.next(arglist__6750); +var y = cljs.core.first(arglist__6750); +var more = cljs.core.rest(arglist__6750); +return G__6749__delegate(x,y,more); +}); +G__6749.cljs$core$IFn$_invoke$arity$variadic = G__6749__delegate; +return G__6749; +})() +; +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; +}); +/** +* Coerce to char +*/ +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; +}); +/** +* Returns the sum of nums. (+) returns 0. +* @param {...*} var_args +*/ +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__6751__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_add,(x + y),more); +}; +var G__6751 = 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__6751__delegate.call(this,x,y,more);}; +G__6751.cljs$lang$maxFixedArity = 2; +G__6751.cljs$lang$applyTo = (function (arglist__6752){ +var x = cljs.core.first(arglist__6752); +arglist__6752 = cljs.core.next(arglist__6752); +var y = cljs.core.first(arglist__6752); +var more = cljs.core.rest(arglist__6752); +return G__6751__delegate(x,y,more); +}); +G__6751.cljs$core$IFn$_invoke$arity$variadic = G__6751__delegate; +return G__6751; +})() +; +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; +})() +; +/** +* Returns the sum of nums. (+) returns 0. +* @param {...*} var_args +*/ +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__6753__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_add_int,(x + y),more); +}; +var G__6753 = 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__6753__delegate.call(this,x,y,more);}; +G__6753.cljs$lang$maxFixedArity = 2; +G__6753.cljs$lang$applyTo = (function (arglist__6754){ +var x = cljs.core.first(arglist__6754); +arglist__6754 = cljs.core.next(arglist__6754); +var y = cljs.core.first(arglist__6754); +var more = cljs.core.rest(arglist__6754); +return G__6753__delegate(x,y,more); +}); +G__6753.cljs$core$IFn$_invoke$arity$variadic = G__6753__delegate; +return G__6753; +})() +; +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); +}); +/** +* If no denominators are supplied, returns 1/numerator, +* else returns numerator divided by all of the denominators. +* @param {...*} var_args +*/ +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__6755__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_divide_int,unchecked_divide_int.call(null,x,y),more); +}; +var G__6755 = 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__6755__delegate.call(this,x,y,more);}; +G__6755.cljs$lang$maxFixedArity = 2; +G__6755.cljs$lang$applyTo = (function (arglist__6756){ +var x = cljs.core.first(arglist__6756); +arglist__6756 = cljs.core.next(arglist__6756); +var y = cljs.core.first(arglist__6756); +var more = cljs.core.rest(arglist__6756); +return G__6755__delegate(x,y,more); +}); +G__6755.cljs$core$IFn$_invoke$arity$variadic = G__6755__delegate; +return G__6755; +})() +; +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); +}); +/** +* Returns the product of nums. (*) returns 1. +* @param {...*} var_args +*/ +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__6757__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_multiply,(x * y),more); +}; +var G__6757 = 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__6757__delegate.call(this,x,y,more);}; +G__6757.cljs$lang$maxFixedArity = 2; +G__6757.cljs$lang$applyTo = (function (arglist__6758){ +var x = cljs.core.first(arglist__6758); +arglist__6758 = cljs.core.next(arglist__6758); +var y = cljs.core.first(arglist__6758); +var more = cljs.core.rest(arglist__6758); +return G__6757__delegate(x,y,more); +}); +G__6757.cljs$core$IFn$_invoke$arity$variadic = G__6757__delegate; +return G__6757; +})() +; +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; +})() +; +/** +* Returns the product of nums. (*) returns 1. +* @param {...*} var_args +*/ +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__6759__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_multiply_int,(x * y),more); +}; +var G__6759 = 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__6759__delegate.call(this,x,y,more);}; +G__6759.cljs$lang$maxFixedArity = 2; +G__6759.cljs$lang$applyTo = (function (arglist__6760){ +var x = cljs.core.first(arglist__6760); +arglist__6760 = cljs.core.next(arglist__6760); +var y = cljs.core.first(arglist__6760); +var more = cljs.core.rest(arglist__6760); +return G__6759__delegate(x,y,more); +}); +G__6759.cljs$core$IFn$_invoke$arity$variadic = G__6759__delegate; +return G__6759; +})() +; +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); +}); +/** +* If no ys are supplied, returns the negation of x, else subtracts +* the ys from x and returns the result. +* @param {...*} var_args +*/ +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__6761__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_substract,(x - y),more); +}; +var G__6761 = 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__6761__delegate.call(this,x,y,more);}; +G__6761.cljs$lang$maxFixedArity = 2; +G__6761.cljs$lang$applyTo = (function (arglist__6762){ +var x = cljs.core.first(arglist__6762); +arglist__6762 = cljs.core.next(arglist__6762); +var y = cljs.core.first(arglist__6762); +var more = cljs.core.rest(arglist__6762); +return G__6761__delegate(x,y,more); +}); +G__6761.cljs$core$IFn$_invoke$arity$variadic = G__6761__delegate; +return G__6761; +})() +; +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; +})() +; +/** +* If no ys are supplied, returns the negation of x, else subtracts +* the ys from x and returns the result. +* @param {...*} var_args +*/ +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__6763__delegate = function (x,y,more){return cljs.core.reduce.call(null,unchecked_substract_int,(x - y),more); +}; +var G__6763 = 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__6763__delegate.call(this,x,y,more);}; +G__6763.cljs$lang$maxFixedArity = 2; +G__6763.cljs$lang$applyTo = (function (arglist__6764){ +var x = cljs.core.first(arglist__6764); +arglist__6764 = cljs.core.next(arglist__6764); +var y = cljs.core.first(arglist__6764); +var more = cljs.core.rest(arglist__6764); +return G__6763__delegate(x,y,more); +}); +G__6763.cljs$core$IFn$_invoke$arity$variadic = G__6763__delegate; +return G__6763; +})() +; +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); +} +}); +/** +* Coerce to int by stripping decimal places. +*/ +cljs.core.int$ = (function int$(x){return (x | 0); +}); +/** +* Coerce to int by stripping decimal places. +*/ +cljs.core.unchecked_int = (function unchecked_int(x){return cljs.core.fix.call(null,x); +}); +/** +* Coerce to long by stripping decimal places. Identical to `int'. +*/ +cljs.core.long$ = (function long$(x){return cljs.core.fix.call(null,x); +}); +/** +* Coerce to long by stripping decimal places. Identical to `int'. +*/ +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; +}); +/** +* Modulus of num and div with original javascript behavior. i.e. bug for negative numbers +*/ +cljs.core.js_mod = (function js_mod(n,d){return (n % d); +}); +/** +* Modulus of num and div. Truncates toward negative infinity. +*/ +cljs.core.mod = (function mod(n,d){return (((n % d) + d) % d); +}); +/** +* quot[ient] of dividing numerator by denominator. +*/ +cljs.core.quot = (function quot(n,d){var rem = (n % d);return cljs.core.fix.call(null,((n - rem) / d)); +}); +/** +* remainder of dividing numerator by denominator. +*/ +cljs.core.rem = (function rem(n,d){var q = cljs.core.quot.call(null,n,d);return (n - (d * q)); +}); +/** +* Returns a random floating point number between 0 (inclusive) and n (default 1) (exclusive). +*/ +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; +})() +; +/** +* Returns a random integer between 0 (inclusive) and n (exclusive). +*/ +cljs.core.rand_int = (function rand_int(n){return cljs.core.fix.call(null,cljs.core.rand.call(null,n)); +}); +/** +* Bitwise exclusive or +*/ +cljs.core.bit_xor = (function bit_xor(x,y){return (x ^ y); +}); +/** +* Bitwise and +*/ +cljs.core.bit_and = (function bit_and(x,y){return (x & y); +}); +/** +* Bitwise or +*/ +cljs.core.bit_or = (function bit_or(x,y){return (x | y); +}); +/** +* Bitwise and +*/ +cljs.core.bit_and_not = (function bit_and_not(x,y){return (x & ~y); +}); +/** +* Clear bit at index n +*/ +cljs.core.bit_clear = (function bit_clear(x,n){return (x & ~(1 << n)); +}); +/** +* Flip bit at index n +*/ +cljs.core.bit_flip = (function bit_flip(x,n){return (x ^ (1 << n)); +}); +/** +* Bitwise complement +*/ +cljs.core.bit_not = (function bit_not(x){return (~ x); +}); +/** +* Set bit at index n +*/ +cljs.core.bit_set = (function bit_set(x,n){return (x | (1 << n)); +}); +/** +* Test bit at index n +*/ +cljs.core.bit_test = (function bit_test(x,n){return ((x & (1 << n)) != 0); +}); +/** +* Bitwise shift left +*/ +cljs.core.bit_shift_left = (function bit_shift_left(x,n){return (x << n); +}); +/** +* Bitwise shift right +*/ +cljs.core.bit_shift_right = (function bit_shift_right(x,n){return (x >> n); +}); +/** +* DEPRECATED: Bitwise shift right with zero fill +*/ +cljs.core.bit_shift_right_zero_fill = (function bit_shift_right_zero_fill(x,n){return (x >>> n); +}); +/** +* Bitwise shift right with zero fill +*/ +cljs.core.unsigned_bit_shift_right = (function unsigned_bit_shift_right(x,n){return (x >>> n); +}); +/** +* Counts the number of bits set in 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); +}); +/** +* Returns non-nil if nums all have the equivalent +* value, otherwise false. Behavior on non nums is +* undefined. +* @param {...*} var_args +*/ +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__6765__delegate = function (x,y,more){while(true){ +if(_EQ__EQ_.call(null,x,y)) +{if(cljs.core.next.call(null,more)) +{{ +var G__6766 = y; +var G__6767 = cljs.core.first.call(null,more); +var G__6768 = cljs.core.next.call(null,more); +x = G__6766; +y = G__6767; +more = G__6768; +continue; +} +} else +{return _EQ__EQ_.call(null,y,cljs.core.first.call(null,more)); +} +} else +{return false; +} +break; +} +}; +var G__6765 = 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__6765__delegate.call(this,x,y,more);}; +G__6765.cljs$lang$maxFixedArity = 2; +G__6765.cljs$lang$applyTo = (function (arglist__6769){ +var x = cljs.core.first(arglist__6769); +arglist__6769 = cljs.core.next(arglist__6769); +var y = cljs.core.first(arglist__6769); +var more = cljs.core.rest(arglist__6769); +return G__6765__delegate(x,y,more); +}); +G__6765.cljs$core$IFn$_invoke$arity$variadic = G__6765__delegate; +return G__6765; +})() +; +_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_; +})() +; +/** +* Returns true if num is greater than zero, else false +*/ +cljs.core.pos_QMARK_ = (function pos_QMARK_(n){return (n > 0); +}); +cljs.core.zero_QMARK_ = (function zero_QMARK_(n){return (n === 0); +}); +/** +* Returns true if num is less than zero, else false +*/ +cljs.core.neg_QMARK_ = (function neg_QMARK_(x){return (x < 0); +}); +/** +* Returns the nth next of coll, (seq coll) when n is 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__6770 = (n__$1 - 1); +var G__6771 = cljs.core.next.call(null,xs); +n__$1 = G__6770; +xs = G__6771; +continue; +} +} else +{return xs; +} +break; +} +}); +/** +* With no args, returns the empty string. With one arg x, returns +* x.toString(). (str nil) returns the empty string. With more than +* one arg, returns the concatenation of the str values of the args. +* @param {...*} var_args +*/ +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__6772__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__6773 = sb.append(str.call(null,cljs.core.first.call(null,more))); +var G__6774 = cljs.core.next.call(null,more); +sb = G__6773; +more = G__6774; +continue; +} +} else +{return sb.toString(); +} +break; +} +}; +var G__6772 = 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__6772__delegate.call(this,x,ys);}; +G__6772.cljs$lang$maxFixedArity = 1; +G__6772.cljs$lang$applyTo = (function (arglist__6775){ +var x = cljs.core.first(arglist__6775); +var ys = cljs.core.rest(arglist__6775); +return G__6772__delegate(x,ys); +}); +G__6772.cljs$core$IFn$_invoke$arity$variadic = G__6772__delegate; +return G__6772; +})() +; +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; +})() +; +/** +* Returns the substring of s beginning at start inclusive, and ending +* at end (defaults to length of string), exclusive. +*/ +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; +})() +; +/** +* Assumes x is sequential. Returns true if x equals y, otherwise +* returns false. +*/ +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__6776 = cljs.core.next.call(null,xs); +var G__6777 = cljs.core.next.call(null,ys); +xs = G__6776; +ys = G__6777; +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__6778 = cljs.core.hash_combine.call(null,res,cljs.core.hash.call(null,cljs.core.first.call(null,s))); +var G__6779 = cljs.core.next.call(null,s); +res = G__6778; +s = G__6779; +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__6780 = ((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__6781 = cljs.core.next.call(null,s); +h = G__6780; +s = G__6781; +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__6782 = ((h + cljs.core.hash.call(null,e)) % 4503599627370496); +var G__6783 = cljs.core.next.call(null,s__$1); +h = G__6782; +s__$1 = G__6783; +continue; +} +} else +{return h; +} +break; +} +}); +/** +* Takes a JavaScript object and a map of names to functions and +* attaches said functions as methods on the object. Any references to +* JavaScript's implict this (via the this-as macro) will resolve to the +* object that the function is attached. +*/ +cljs.core.extend_object_BANG_ = (function extend_object_BANG_(obj,fn_map){var seq__6790_6796 = cljs.core.seq.call(null,fn_map);var chunk__6791_6797 = null;var count__6792_6798 = 0;var i__6793_6799 = 0;while(true){ +if((i__6793_6799 < count__6792_6798)) +{var vec__6794_6800 = cljs.core._nth.call(null,chunk__6791_6797,i__6793_6799);var key_name_6801 = cljs.core.nth.call(null,vec__6794_6800,0,null);var f_6802 = cljs.core.nth.call(null,vec__6794_6800,1,null);var str_name_6803 = cljs.core.name.call(null,key_name_6801);(obj[str_name_6803] = f_6802); +{ +var G__6804 = seq__6790_6796; +var G__6805 = chunk__6791_6797; +var G__6806 = count__6792_6798; +var G__6807 = (i__6793_6799 + 1); +seq__6790_6796 = G__6804; +chunk__6791_6797 = G__6805; +count__6792_6798 = G__6806; +i__6793_6799 = G__6807; +continue; +} +} else +{var temp__4092__auto___6808 = cljs.core.seq.call(null,seq__6790_6796);if(temp__4092__auto___6808) +{var seq__6790_6809__$1 = temp__4092__auto___6808;if(cljs.core.chunked_seq_QMARK_.call(null,seq__6790_6809__$1)) +{var c__4288__auto___6810 = cljs.core.chunk_first.call(null,seq__6790_6809__$1);{ +var G__6811 = cljs.core.chunk_rest.call(null,seq__6790_6809__$1); +var G__6812 = c__4288__auto___6810; +var G__6813 = cljs.core.count.call(null,c__4288__auto___6810); +var G__6814 = 0; +seq__6790_6796 = G__6811; +chunk__6791_6797 = G__6812; +count__6792_6798 = G__6813; +i__6793_6799 = G__6814; +continue; +} +} else +{var vec__6795_6815 = cljs.core.first.call(null,seq__6790_6809__$1);var key_name_6816 = cljs.core.nth.call(null,vec__6795_6815,0,null);var f_6817 = cljs.core.nth.call(null,vec__6795_6815,1,null);var str_name_6818 = cljs.core.name.call(null,key_name_6816);(obj[str_name_6818] = f_6817); +{ +var G__6819 = cljs.core.next.call(null,seq__6790_6809__$1); +var G__6820 = null; +var G__6821 = 0; +var G__6822 = 0; +seq__6790_6796 = G__6819; +chunk__6791_6797 = G__6820; +count__6792_6798 = G__6821; +i__6793_6799 = G__6822; +continue; +} +} +} else +{} +} +break; +} +return obj; +}); + +/** +* @constructor +*/ +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$partition0$ = 65937646; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.List.cljs$lang$type = true; +cljs.core.List.cljs$lang$ctorStr = "cljs.core/List"; +cljs.core.List.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.List(self__.meta,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)); +}); + +/** +* @constructor +*/ +cljs.core.EmptyList = (function (meta){ +this.meta = meta; +this.cljs$lang$protocol_mask$partition0$ = 65937614; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.EmptyList.cljs$lang$type = true; +cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList"; +cljs.core.EmptyList.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.EmptyList(self__.meta)); +}); +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__6824 = coll;if(G__6824) +{var bit__4190__auto__ = (G__6824.cljs$lang$protocol_mask$partition0$ & 134217728);if((bit__4190__auto__) || (G__6824.cljs$core$IReversible$)) +{return true; +} else +{if((!G__6824.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReversible,G__6824); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IReversible,G__6824); +} +}); +cljs.core.rseq = (function rseq(coll){return cljs.core._rseq.call(null,coll); +}); +/** +* Returns a seq of the items in coll in reverse order. Not lazy. +*/ +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); +} +}); +/** +* @param {...*} var_args +*/ +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__6825 = cljs.core._next.call(null,xs__$1); +xs__$1 = G__6825; +continue; +} +} else +{return arr; +} +break; +} +})());var i = arr.length;var r = cljs.core.List.EMPTY;while(true){ +if((i > 0)) +{{ +var G__6826 = (i - 1); +var G__6827 = cljs.core._conj.call(null,r,(arr[(i - 1)])); +i = G__6826; +r = G__6827; +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__6828){ +var xs = cljs.core.seq(arglist__6828); +return list__delegate(xs); +}); +list.cljs$core$IFn$_invoke$arity$variadic = list__delegate; +return list; +})() +; + +/** +* @constructor +*/ +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$partition0$ = 65929452; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.Cons.cljs$lang$type = true; +cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons"; +cljs.core.Cons.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.Cons(self__.meta,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)); +}); +/** +* Returns a new seq where x is the first element and seq is the rest. +*/ +cljs.core.cons = (function cons(x,coll){if((function (){var or__3540__auto__ = (coll == null);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var G__6832 = coll;if(G__6832) +{var bit__4183__auto__ = (G__6832.cljs$lang$protocol_mask$partition0$ & 64);if((bit__4183__auto__) || (G__6832.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__6834 = x;if(G__6834) +{var bit__4190__auto__ = (G__6834.cljs$lang$protocol_mask$partition0$ & 33554432);if((bit__4190__auto__) || (G__6834.cljs$core$IList$)) +{return true; +} else +{if((!G__6834.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IList,G__6834); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IList,G__6834); +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__6836 = null; +var G__6836__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__6836__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__6836 = function(self__,coll,not_found){ +switch(arguments.length){ +case 2: +return G__6836__2.call(this,self__,coll); +case 3: +return G__6836__3.call(this,self__,coll,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__6836; +})() +; +cljs.core.Keyword.prototype.apply = (function (self__,args6835){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args6835))); +}); +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; +} +} +}); +/** +* Returns the namespace String of a symbol or keyword, or nil if not present. +*/ +cljs.core.namespace = (function namespace(x){if((function (){var G__6838 = x;if(G__6838) +{var bit__4183__auto__ = (G__6838.cljs$lang$protocol_mask$partition1$ & 4096);if((bit__4183__auto__) || (G__6838.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(''))); +} +}); +/** +* Returns a Keyword with the given namespace and name. Do not use : +* in the keyword strings, it will be added automatically. +*/ +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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__6839 = ls.sval(); +ls = G__6839; +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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__6841 = s;if(G__6841) +{var bit__4183__auto__ = (G__6841.cljs$lang$protocol_mask$partition1$ & 1024);if((bit__4183__auto__) || (G__6841.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)); +} +}); +/** +* Naive impl of to-array as a start. +*/ +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__6842 = cljs.core.next.call(null,s__$1); +s__$1 = G__6842; +continue; +} +} else +{return ary; +} +break; +} +}); +/** +* Returns a (potentially-ragged) 2-dimensional array +* containing the contents of coll. +*/ +cljs.core.to_array_2d = (function to_array_2d(coll){var ret = (new Array(cljs.core.count.call(null,coll)));var i_6843 = 0;var xs_6844 = cljs.core.seq.call(null,coll);while(true){ +if(xs_6844) +{(ret[i_6843] = cljs.core.to_array.call(null,cljs.core.first.call(null,xs_6844))); +{ +var G__6845 = (i_6843 + 1); +var G__6846 = cljs.core.next.call(null,xs_6844); +i_6843 = G__6845; +xs_6844 = G__6846; +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__6847 = (i + 1); +var G__6848 = cljs.core.next.call(null,s__$1); +i = G__6847; +s__$1 = G__6848; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___6849 = size;var i_6850 = 0;while(true){ +if((i_6850 < n__4388__auto___6849)) +{(a[i_6850] = init_val_or_seq); +{ +var G__6851 = (i_6850 + 1); +i_6850 = G__6851; +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__6852 = (i + 1); +var G__6853 = cljs.core.next.call(null,s__$1); +i = G__6852; +s__$1 = G__6853; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___6854 = size;var i_6855 = 0;while(true){ +if((i_6855 < n__4388__auto___6854)) +{(a[i_6855] = init_val_or_seq); +{ +var G__6856 = (i_6855 + 1); +i_6855 = G__6856; +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__6857 = (i + 1); +var G__6858 = cljs.core.next.call(null,s__$1); +i = G__6857; +s__$1 = G__6858; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___6859 = size;var i_6860 = 0;while(true){ +if((i_6860 < n__4388__auto___6859)) +{(a[i_6860] = init_val_or_seq); +{ +var G__6861 = (i_6860 + 1); +i_6860 = G__6861; +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__6862 = (i + 1); +var G__6863 = cljs.core.next.call(null,s__$1); +i = G__6862; +s__$1 = G__6863; +continue; +} +} else +{return a; +} +break; +} +} else +{var n__4388__auto___6864 = size;var i_6865 = 0;while(true){ +if((i_6865 < n__4388__auto___6864)) +{(a[i_6865] = init_val_or_seq); +{ +var G__6866 = (i_6865 + 1); +i_6865 = G__6866; +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__6867 = cljs.core.next.call(null,s__$1); +var G__6868 = (i - 1); +var G__6869 = (sum + 1); +s__$1 = G__6867; +i = G__6868; +sum = G__6869; +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; +} +} +} +}); +/** +* Returns a lazy seq representing the concatenation of the elements in the supplied colls. +* @param {...*} var_args +*/ +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__6870__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__6870 = 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__6870__delegate.call(this,x,y,zs);}; +G__6870.cljs$lang$maxFixedArity = 2; +G__6870.cljs$lang$applyTo = (function (arglist__6871){ +var x = cljs.core.first(arglist__6871); +arglist__6871 = cljs.core.next(arglist__6871); +var y = cljs.core.first(arglist__6871); +var zs = cljs.core.rest(arglist__6871); +return G__6870__delegate(x,y,zs); +}); +G__6870.cljs$core$IFn$_invoke$arity$variadic = G__6870__delegate; +return G__6870; +})() +; +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; +})() +; +/** +* Creates a new list containing the items prepended to the rest, the +* last of which will be treated as a sequence. +* @param {...*} var_args +*/ +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__6872__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__6872 = 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__6872__delegate.call(this,a,b,c,d,more);}; +G__6872.cljs$lang$maxFixedArity = 4; +G__6872.cljs$lang$applyTo = (function (arglist__6873){ +var a = cljs.core.first(arglist__6873); +arglist__6873 = cljs.core.next(arglist__6873); +var b = cljs.core.first(arglist__6873); +arglist__6873 = cljs.core.next(arglist__6873); +var c = cljs.core.first(arglist__6873); +arglist__6873 = cljs.core.next(arglist__6873); +var d = cljs.core.first(arglist__6873); +var more = cljs.core.rest(arglist__6873); +return G__6872__delegate(a,b,c,d,more); +}); +G__6872.cljs$core$IFn$_invoke$arity$variadic = G__6872__delegate; +return G__6872; +})() +; +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_; +})() +; +/** +* Returns a new, transient version of the collection, in constant time. +*/ +cljs.core.transient$ = (function transient$(coll){return cljs.core._as_transient.call(null,coll); +}); +/** +* Returns a new, persistent version of the transient collection, in +* constant time. The transient collection cannot be used after this +* call, any such use will throw an exception. +*/ +cljs.core.persistent_BANG_ = (function persistent_BANG_(tcoll){return cljs.core._persistent_BANG_.call(null,tcoll); +}); +/** +* Adds x to the transient collection, and return coll. The 'addition' +* may happen at different 'places' depending on the concrete type. +* @param {...*} var_args +*/ +cljs.core.conj_BANG_ = (function() { +var conj_BANG_ = null; +var conj_BANG___2 = (function (tcoll,val){return cljs.core._conj_BANG_.call(null,tcoll,val); +}); +var conj_BANG___3 = (function() { +var G__6874__delegate = function (tcoll,val,vals){while(true){ +var ntcoll = cljs.core._conj_BANG_.call(null,tcoll,val);if(cljs.core.truth_(vals)) +{{ +var G__6875 = ntcoll; +var G__6876 = cljs.core.first.call(null,vals); +var G__6877 = cljs.core.next.call(null,vals); +tcoll = G__6875; +val = G__6876; +vals = G__6877; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__6874 = function (tcoll,val,var_args){ +var vals = null;if (arguments.length > 2) { + vals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2),0);} +return G__6874__delegate.call(this,tcoll,val,vals);}; +G__6874.cljs$lang$maxFixedArity = 2; +G__6874.cljs$lang$applyTo = (function (arglist__6878){ +var tcoll = cljs.core.first(arglist__6878); +arglist__6878 = cljs.core.next(arglist__6878); +var val = cljs.core.first(arglist__6878); +var vals = cljs.core.rest(arglist__6878); +return G__6874__delegate(tcoll,val,vals); +}); +G__6874.cljs$core$IFn$_invoke$arity$variadic = G__6874__delegate; +return G__6874; +})() +; +conj_BANG_ = function(tcoll,val,var_args){ +var vals = var_args; +switch(arguments.length){ +case 2: +return conj_BANG___2.call(this,tcoll,val); +default: +return conj_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll,val, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +conj_BANG_.cljs$lang$maxFixedArity = 2; +conj_BANG_.cljs$lang$applyTo = conj_BANG___3.cljs$lang$applyTo; +conj_BANG_.cljs$core$IFn$_invoke$arity$2 = conj_BANG___2; +conj_BANG_.cljs$core$IFn$_invoke$arity$variadic = conj_BANG___3.cljs$core$IFn$_invoke$arity$variadic; +return conj_BANG_; +})() +; +/** +* When applied to a transient map, adds mapping of key(s) to +* val(s). When applied to a transient vector, sets the val at index. +* Note - index must be <= (count vector). Returns coll. +* @param {...*} var_args +*/ +cljs.core.assoc_BANG_ = (function() { +var assoc_BANG_ = null; +var assoc_BANG___3 = (function (tcoll,key,val){return cljs.core._assoc_BANG_.call(null,tcoll,key,val); +}); +var assoc_BANG___4 = (function() { +var G__6879__delegate = function (tcoll,key,val,kvs){while(true){ +var ntcoll = cljs.core._assoc_BANG_.call(null,tcoll,key,val);if(cljs.core.truth_(kvs)) +{{ +var G__6880 = ntcoll; +var G__6881 = cljs.core.first.call(null,kvs); +var G__6882 = cljs.core.second.call(null,kvs); +var G__6883 = cljs.core.nnext.call(null,kvs); +tcoll = G__6880; +key = G__6881; +val = G__6882; +kvs = G__6883; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__6879 = function (tcoll,key,val,var_args){ +var kvs = null;if (arguments.length > 3) { + kvs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3),0);} +return G__6879__delegate.call(this,tcoll,key,val,kvs);}; +G__6879.cljs$lang$maxFixedArity = 3; +G__6879.cljs$lang$applyTo = (function (arglist__6884){ +var tcoll = cljs.core.first(arglist__6884); +arglist__6884 = cljs.core.next(arglist__6884); +var key = cljs.core.first(arglist__6884); +arglist__6884 = cljs.core.next(arglist__6884); +var val = cljs.core.first(arglist__6884); +var kvs = cljs.core.rest(arglist__6884); +return G__6879__delegate(tcoll,key,val,kvs); +}); +G__6879.cljs$core$IFn$_invoke$arity$variadic = G__6879__delegate; +return G__6879; +})() +; +assoc_BANG_ = function(tcoll,key,val,var_args){ +var kvs = var_args; +switch(arguments.length){ +case 3: +return assoc_BANG___3.call(this,tcoll,key,val); +default: +return assoc_BANG___4.cljs$core$IFn$_invoke$arity$variadic(tcoll,key,val, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +assoc_BANG_.cljs$lang$maxFixedArity = 3; +assoc_BANG_.cljs$lang$applyTo = assoc_BANG___4.cljs$lang$applyTo; +assoc_BANG_.cljs$core$IFn$_invoke$arity$3 = assoc_BANG___3; +assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = assoc_BANG___4.cljs$core$IFn$_invoke$arity$variadic; +return assoc_BANG_; +})() +; +/** +* Returns a transient map that doesn't contain a mapping for key(s). +* @param {...*} var_args +*/ +cljs.core.dissoc_BANG_ = (function() { +var dissoc_BANG_ = null; +var dissoc_BANG___2 = (function (tcoll,key){return cljs.core._dissoc_BANG_.call(null,tcoll,key); +}); +var dissoc_BANG___3 = (function() { +var G__6885__delegate = function (tcoll,key,ks){while(true){ +var ntcoll = cljs.core._dissoc_BANG_.call(null,tcoll,key);if(cljs.core.truth_(ks)) +{{ +var G__6886 = ntcoll; +var G__6887 = cljs.core.first.call(null,ks); +var G__6888 = cljs.core.next.call(null,ks); +tcoll = G__6886; +key = G__6887; +ks = G__6888; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__6885 = function (tcoll,key,var_args){ +var ks = null;if (arguments.length > 2) { + ks = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2),0);} +return G__6885__delegate.call(this,tcoll,key,ks);}; +G__6885.cljs$lang$maxFixedArity = 2; +G__6885.cljs$lang$applyTo = (function (arglist__6889){ +var tcoll = cljs.core.first(arglist__6889); +arglist__6889 = cljs.core.next(arglist__6889); +var key = cljs.core.first(arglist__6889); +var ks = cljs.core.rest(arglist__6889); +return G__6885__delegate(tcoll,key,ks); +}); +G__6885.cljs$core$IFn$_invoke$arity$variadic = G__6885__delegate; +return G__6885; +})() +; +dissoc_BANG_ = function(tcoll,key,var_args){ +var ks = var_args; +switch(arguments.length){ +case 2: +return dissoc_BANG___2.call(this,tcoll,key); +default: +return dissoc_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll,key, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +dissoc_BANG_.cljs$lang$maxFixedArity = 2; +dissoc_BANG_.cljs$lang$applyTo = dissoc_BANG___3.cljs$lang$applyTo; +dissoc_BANG_.cljs$core$IFn$_invoke$arity$2 = dissoc_BANG___2; +dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = dissoc_BANG___3.cljs$core$IFn$_invoke$arity$variadic; +return dissoc_BANG_; +})() +; +/** +* Removes the last item from a transient vector. If +* the collection is empty, throws an exception. Returns coll +*/ +cljs.core.pop_BANG_ = (function pop_BANG_(tcoll){return cljs.core._pop_BANG_.call(null,tcoll); +}); +/** +* disj[oin]. Returns a transient set of the same (hashed/sorted) type, that +* does not contain key(s). +* @param {...*} var_args +*/ +cljs.core.disj_BANG_ = (function() { +var disj_BANG_ = null; +var disj_BANG___2 = (function (tcoll,val){return cljs.core._disjoin_BANG_.call(null,tcoll,val); +}); +var disj_BANG___3 = (function() { +var G__6890__delegate = function (tcoll,val,vals){while(true){ +var ntcoll = cljs.core._disjoin_BANG_.call(null,tcoll,val);if(cljs.core.truth_(vals)) +{{ +var G__6891 = ntcoll; +var G__6892 = cljs.core.first.call(null,vals); +var G__6893 = cljs.core.next.call(null,vals); +tcoll = G__6891; +val = G__6892; +vals = G__6893; +continue; +} +} else +{return ntcoll; +} +break; +} +}; +var G__6890 = function (tcoll,val,var_args){ +var vals = null;if (arguments.length > 2) { + vals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2),0);} +return G__6890__delegate.call(this,tcoll,val,vals);}; +G__6890.cljs$lang$maxFixedArity = 2; +G__6890.cljs$lang$applyTo = (function (arglist__6894){ +var tcoll = cljs.core.first(arglist__6894); +arglist__6894 = cljs.core.next(arglist__6894); +var val = cljs.core.first(arglist__6894); +var vals = cljs.core.rest(arglist__6894); +return G__6890__delegate(tcoll,val,vals); +}); +G__6890.cljs$core$IFn$_invoke$arity$variadic = G__6890__delegate; +return G__6890; +})() +; +disj_BANG_ = function(tcoll,val,var_args){ +var vals = var_args; +switch(arguments.length){ +case 2: +return disj_BANG___2.call(this,tcoll,val); +default: +return disj_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll,val, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +disj_BANG_.cljs$lang$maxFixedArity = 2; +disj_BANG_.cljs$lang$applyTo = disj_BANG___3.cljs$lang$applyTo; +disj_BANG_.cljs$core$IFn$_invoke$arity$2 = disj_BANG___2; +disj_BANG_.cljs$core$IFn$_invoke$arity$variadic = disj_BANG___3.cljs$core$IFn$_invoke$arity$variadic; +return disj_BANG_; +})() +; +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")); +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +} +}); +/** +* Applies fn f to the argument list formed by prepending intervening arguments to args. +* First cut. Not lazy. Needs to use emitted toApply. +* @param {...*} var_args +*/ +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__6895__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__6895 = 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__6895__delegate.call(this,f,a,b,c,d,args);}; +G__6895.cljs$lang$maxFixedArity = 5; +G__6895.cljs$lang$applyTo = (function (arglist__6896){ +var f = cljs.core.first(arglist__6896); +arglist__6896 = cljs.core.next(arglist__6896); +var a = cljs.core.first(arglist__6896); +arglist__6896 = cljs.core.next(arglist__6896); +var b = cljs.core.first(arglist__6896); +arglist__6896 = cljs.core.next(arglist__6896); +var c = cljs.core.first(arglist__6896); +arglist__6896 = cljs.core.next(arglist__6896); +var d = cljs.core.first(arglist__6896); +var args = cljs.core.rest(arglist__6896); +return G__6895__delegate(f,a,b,c,d,args); +}); +G__6895.cljs$core$IFn$_invoke$arity$variadic = G__6895__delegate; +return G__6895; +})() +; +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; +})() +; +/** +* Returns an object of the same type and value as obj, with +* (apply f (meta obj) args) as its metadata. +* @param {...*} var_args +*/ +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__6897__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__6897 = 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__6897__delegate.call(this,obj,f,a,b,c,d,args);}; +G__6897.cljs$lang$maxFixedArity = 6; +G__6897.cljs$lang$applyTo = (function (arglist__6898){ +var obj = cljs.core.first(arglist__6898); +arglist__6898 = cljs.core.next(arglist__6898); +var f = cljs.core.first(arglist__6898); +arglist__6898 = cljs.core.next(arglist__6898); +var a = cljs.core.first(arglist__6898); +arglist__6898 = cljs.core.next(arglist__6898); +var b = cljs.core.first(arglist__6898); +arglist__6898 = cljs.core.next(arglist__6898); +var c = cljs.core.first(arglist__6898); +arglist__6898 = cljs.core.next(arglist__6898); +var d = cljs.core.first(arglist__6898); +var args = cljs.core.rest(arglist__6898); +return G__6897__delegate(obj,f,a,b,c,d,args); +}); +G__6897.cljs$core$IFn$_invoke$arity$variadic = G__6897__delegate; +return G__6897; +})() +; +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; +})() +; +/** +* Same as (not (= obj1 obj2)) +* @param {...*} var_args +*/ +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__6899__delegate = function (x,y,more){return cljs.core.not.call(null,cljs.core.apply.call(null,cljs.core._EQ_,x,y,more)); +}; +var G__6899 = 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__6899__delegate.call(this,x,y,more);}; +G__6899.cljs$lang$maxFixedArity = 2; +G__6899.cljs$lang$applyTo = (function (arglist__6900){ +var x = cljs.core.first(arglist__6900); +arglist__6900 = cljs.core.next(arglist__6900); +var y = cljs.core.first(arglist__6900); +var more = cljs.core.rest(arglist__6900); +return G__6899__delegate(x,y,more); +}); +G__6899.cljs$core$IFn$_invoke$arity$variadic = G__6899__delegate; +return G__6899; +})() +; +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_; +})() +; +/** +* If coll is empty, returns nil, else coll +*/ +cljs.core.not_empty = (function not_empty(coll){if(cljs.core.seq.call(null,coll)) +{return coll; +} else +{return null; +} +}); +/** +* Returns true if (pred x) is logical true for every x in coll, else +* false. +*/ +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__6901 = pred; +var G__6902 = cljs.core.next.call(null,coll); +pred = G__6901; +coll = G__6902; +continue; +} +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{return false; +} else +{return null; +} +} +} +break; +} +}); +/** +* Returns false if (pred x) is logical true for every x in +* coll, else true. +*/ +cljs.core.not_every_QMARK_ = (function not_every_QMARK_(pred,coll){return !(cljs.core.every_QMARK_.call(null,pred,coll)); +}); +/** +* Returns the first logical true value of (pred x) for any x in coll, +* else nil. One common idiom is to use a set as pred, for example +* this will return :fred if :fred is in the sequence, otherwise nil: +* (some #{:fred} coll) +*/ +cljs.core.some = (function some(pred,coll){while(true){ +if(cljs.core.seq.call(null,coll)) +{var or__3540__auto__ = pred.call(null,cljs.core.first.call(null,coll));if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{{ +var G__6903 = pred; +var G__6904 = cljs.core.next.call(null,coll); +pred = G__6903; +coll = G__6904; +continue; +} +} +} else +{return null; +} +break; +} +}); +/** +* Returns false if (pred x) is logical true for any x in coll, +* else true. +*/ +cljs.core.not_any_QMARK_ = (function not_any_QMARK_(pred,coll){return cljs.core.not.call(null,cljs.core.some.call(null,pred,coll)); +}); +/** +* Returns true if n is even, throws an exception if n is not an integer +*/ +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(''))); +} +}); +/** +* Returns true if n is odd, throws an exception if n is not an integer +*/ +cljs.core.odd_QMARK_ = (function odd_QMARK_(n){return !(cljs.core.even_QMARK_.call(null,n)); +}); +cljs.core.identity = (function identity(x){return x; +}); +/** +* Takes a fn f and returns a fn that takes the same arguments as f, +* has the same effects, if any, and returns the opposite truth value. +*/ +cljs.core.complement = (function complement(f){return (function() { +var G__6905 = null; +var G__6905__0 = (function (){return cljs.core.not.call(null,f.call(null)); +}); +var G__6905__1 = (function (x){return cljs.core.not.call(null,f.call(null,x)); +}); +var G__6905__2 = (function (x,y){return cljs.core.not.call(null,f.call(null,x,y)); +}); +var G__6905__3 = (function() { +var G__6906__delegate = function (x,y,zs){return cljs.core.not.call(null,cljs.core.apply.call(null,f,x,y,zs)); +}; +var G__6906 = 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__6906__delegate.call(this,x,y,zs);}; +G__6906.cljs$lang$maxFixedArity = 2; +G__6906.cljs$lang$applyTo = (function (arglist__6907){ +var x = cljs.core.first(arglist__6907); +arglist__6907 = cljs.core.next(arglist__6907); +var y = cljs.core.first(arglist__6907); +var zs = cljs.core.rest(arglist__6907); +return G__6906__delegate(x,y,zs); +}); +G__6906.cljs$core$IFn$_invoke$arity$variadic = G__6906__delegate; +return G__6906; +})() +; +G__6905 = function(x,y,var_args){ +var zs = var_args; +switch(arguments.length){ +case 0: +return G__6905__0.call(this); +case 1: +return G__6905__1.call(this,x); +case 2: +return G__6905__2.call(this,x,y); +default: +return G__6905__3.cljs$core$IFn$_invoke$arity$variadic(x,y, cljs.core.array_seq(arguments, 2)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__6905.cljs$lang$maxFixedArity = 2; +G__6905.cljs$lang$applyTo = G__6905__3.cljs$lang$applyTo; +return G__6905; +})() +}); +/** +* Returns a function that takes any number of arguments and returns x. +*/ +cljs.core.constantly = (function constantly(x){return (function() { +var G__6908__delegate = function (args){return x; +}; +var G__6908 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6908__delegate.call(this,args);}; +G__6908.cljs$lang$maxFixedArity = 0; +G__6908.cljs$lang$applyTo = (function (arglist__6909){ +var args = cljs.core.seq(arglist__6909); +return G__6908__delegate(args); +}); +G__6908.cljs$core$IFn$_invoke$arity$variadic = G__6908__delegate; +return G__6908; +})() +; +}); +/** +* Takes a set of functions and returns a fn that is the composition +* of those fns. The returned fn takes a variable number of args, +* applies the rightmost of fns to the args, the next +* fn (right-to-left) to the result, etc. +* @param {...*} var_args +*/ +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__6910 = null; +var G__6910__0 = (function (){return f.call(null,g.call(null)); +}); +var G__6910__1 = (function (x){return f.call(null,g.call(null,x)); +}); +var G__6910__2 = (function (x,y){return f.call(null,g.call(null,x,y)); +}); +var G__6910__3 = (function (x,y,z){return f.call(null,g.call(null,x,y,z)); +}); +var G__6910__4 = (function() { +var G__6911__delegate = function (x,y,z,args){return f.call(null,cljs.core.apply.call(null,g,x,y,z,args)); +}; +var G__6911 = 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__6911__delegate.call(this,x,y,z,args);}; +G__6911.cljs$lang$maxFixedArity = 3; +G__6911.cljs$lang$applyTo = (function (arglist__6912){ +var x = cljs.core.first(arglist__6912); +arglist__6912 = cljs.core.next(arglist__6912); +var y = cljs.core.first(arglist__6912); +arglist__6912 = cljs.core.next(arglist__6912); +var z = cljs.core.first(arglist__6912); +var args = cljs.core.rest(arglist__6912); +return G__6911__delegate(x,y,z,args); +}); +G__6911.cljs$core$IFn$_invoke$arity$variadic = G__6911__delegate; +return G__6911; +})() +; +G__6910 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__6910__0.call(this); +case 1: +return G__6910__1.call(this,x); +case 2: +return G__6910__2.call(this,x,y); +case 3: +return G__6910__3.call(this,x,y,z); +default: +return G__6910__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__6910.cljs$lang$maxFixedArity = 3; +G__6910.cljs$lang$applyTo = G__6910__4.cljs$lang$applyTo; +return G__6910; +})() +}); +var comp__3 = (function (f,g,h){return (function() { +var G__6913 = null; +var G__6913__0 = (function (){return f.call(null,g.call(null,h.call(null))); +}); +var G__6913__1 = (function (x){return f.call(null,g.call(null,h.call(null,x))); +}); +var G__6913__2 = (function (x,y){return f.call(null,g.call(null,h.call(null,x,y))); +}); +var G__6913__3 = (function (x,y,z){return f.call(null,g.call(null,h.call(null,x,y,z))); +}); +var G__6913__4 = (function() { +var G__6914__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__6914 = 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__6914__delegate.call(this,x,y,z,args);}; +G__6914.cljs$lang$maxFixedArity = 3; +G__6914.cljs$lang$applyTo = (function (arglist__6915){ +var x = cljs.core.first(arglist__6915); +arglist__6915 = cljs.core.next(arglist__6915); +var y = cljs.core.first(arglist__6915); +arglist__6915 = cljs.core.next(arglist__6915); +var z = cljs.core.first(arglist__6915); +var args = cljs.core.rest(arglist__6915); +return G__6914__delegate(x,y,z,args); +}); +G__6914.cljs$core$IFn$_invoke$arity$variadic = G__6914__delegate; +return G__6914; +})() +; +G__6913 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__6913__0.call(this); +case 1: +return G__6913__1.call(this,x); +case 2: +return G__6913__2.call(this,x,y); +case 3: +return G__6913__3.call(this,x,y,z); +default: +return G__6913__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__6913.cljs$lang$maxFixedArity = 3; +G__6913.cljs$lang$applyTo = G__6913__4.cljs$lang$applyTo; +return G__6913; +})() +}); +var comp__4 = (function() { +var G__6916__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__6917__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__6918 = cljs.core.first.call(null,fs__$2).call(null,ret); +var G__6919 = cljs.core.next.call(null,fs__$2); +ret = G__6918; +fs__$2 = G__6919; +continue; +} +} else +{return ret; +} +break; +} +}; +var G__6917 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6917__delegate.call(this,args);}; +G__6917.cljs$lang$maxFixedArity = 0; +G__6917.cljs$lang$applyTo = (function (arglist__6920){ +var args = cljs.core.seq(arglist__6920); +return G__6917__delegate(args); +}); +G__6917.cljs$core$IFn$_invoke$arity$variadic = G__6917__delegate; +return G__6917; +})() +; +}; +var G__6916 = 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__6916__delegate.call(this,f1,f2,f3,fs);}; +G__6916.cljs$lang$maxFixedArity = 3; +G__6916.cljs$lang$applyTo = (function (arglist__6921){ +var f1 = cljs.core.first(arglist__6921); +arglist__6921 = cljs.core.next(arglist__6921); +var f2 = cljs.core.first(arglist__6921); +arglist__6921 = cljs.core.next(arglist__6921); +var f3 = cljs.core.first(arglist__6921); +var fs = cljs.core.rest(arglist__6921); +return G__6916__delegate(f1,f2,f3,fs); +}); +G__6916.cljs$core$IFn$_invoke$arity$variadic = G__6916__delegate; +return G__6916; +})() +; +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; +})() +; +/** +* Takes a function f and fewer than the normal arguments to f, and +* returns a fn that takes a variable number of additional args. When +* called, the returned function calls f with args + additional args. +* @param {...*} var_args +*/ +cljs.core.partial = (function() { +var partial = null; +var partial__1 = (function (f){return f; +}); +var partial__2 = (function (f,arg1){return (function() { +var G__6922__delegate = function (args){return cljs.core.apply.call(null,f,arg1,args); +}; +var G__6922 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6922__delegate.call(this,args);}; +G__6922.cljs$lang$maxFixedArity = 0; +G__6922.cljs$lang$applyTo = (function (arglist__6923){ +var args = cljs.core.seq(arglist__6923); +return G__6922__delegate(args); +}); +G__6922.cljs$core$IFn$_invoke$arity$variadic = G__6922__delegate; +return G__6922; +})() +; +}); +var partial__3 = (function (f,arg1,arg2){return (function() { +var G__6924__delegate = function (args){return cljs.core.apply.call(null,f,arg1,arg2,args); +}; +var G__6924 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6924__delegate.call(this,args);}; +G__6924.cljs$lang$maxFixedArity = 0; +G__6924.cljs$lang$applyTo = (function (arglist__6925){ +var args = cljs.core.seq(arglist__6925); +return G__6924__delegate(args); +}); +G__6924.cljs$core$IFn$_invoke$arity$variadic = G__6924__delegate; +return G__6924; +})() +; +}); +var partial__4 = (function (f,arg1,arg2,arg3){return (function() { +var G__6926__delegate = function (args){return cljs.core.apply.call(null,f,arg1,arg2,arg3,args); +}; +var G__6926 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6926__delegate.call(this,args);}; +G__6926.cljs$lang$maxFixedArity = 0; +G__6926.cljs$lang$applyTo = (function (arglist__6927){ +var args = cljs.core.seq(arglist__6927); +return G__6926__delegate(args); +}); +G__6926.cljs$core$IFn$_invoke$arity$variadic = G__6926__delegate; +return G__6926; +})() +; +}); +var partial__5 = (function() { +var G__6928__delegate = function (f,arg1,arg2,arg3,more){return (function() { +var G__6929__delegate = function (args){return cljs.core.apply.call(null,f,arg1,arg2,arg3,cljs.core.concat.call(null,more,args)); +}; +var G__6929 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__6929__delegate.call(this,args);}; +G__6929.cljs$lang$maxFixedArity = 0; +G__6929.cljs$lang$applyTo = (function (arglist__6930){ +var args = cljs.core.seq(arglist__6930); +return G__6929__delegate(args); +}); +G__6929.cljs$core$IFn$_invoke$arity$variadic = G__6929__delegate; +return G__6929; +})() +; +}; +var G__6928 = 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__6928__delegate.call(this,f,arg1,arg2,arg3,more);}; +G__6928.cljs$lang$maxFixedArity = 4; +G__6928.cljs$lang$applyTo = (function (arglist__6931){ +var f = cljs.core.first(arglist__6931); +arglist__6931 = cljs.core.next(arglist__6931); +var arg1 = cljs.core.first(arglist__6931); +arglist__6931 = cljs.core.next(arglist__6931); +var arg2 = cljs.core.first(arglist__6931); +arglist__6931 = cljs.core.next(arglist__6931); +var arg3 = cljs.core.first(arglist__6931); +var more = cljs.core.rest(arglist__6931); +return G__6928__delegate(f,arg1,arg2,arg3,more); +}); +G__6928.cljs$core$IFn$_invoke$arity$variadic = G__6928__delegate; +return G__6928; +})() +; +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; +})() +; +/** +* Takes a function f, and returns a function that calls f, replacing +* a nil first argument to f with the supplied value x. Higher arity +* versions can replace arguments in the second and third +* positions (y, z). Note that the function f can take any number of +* arguments, not just the one(s) being nil-patched. +*/ +cljs.core.fnil = (function() { +var fnil = null; +var fnil__2 = (function (f,x){return (function() { +var G__6932 = null; +var G__6932__1 = (function (a){return f.call(null,(((a == null))?x:a)); +}); +var G__6932__2 = (function (a,b){return f.call(null,(((a == null))?x:a),b); +}); +var G__6932__3 = (function (a,b,c){return f.call(null,(((a == null))?x:a),b,c); +}); +var G__6932__4 = (function() { +var G__6933__delegate = function (a,b,c,ds){return cljs.core.apply.call(null,f,(((a == null))?x:a),b,c,ds); +}; +var G__6933 = 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__6933__delegate.call(this,a,b,c,ds);}; +G__6933.cljs$lang$maxFixedArity = 3; +G__6933.cljs$lang$applyTo = (function (arglist__6934){ +var a = cljs.core.first(arglist__6934); +arglist__6934 = cljs.core.next(arglist__6934); +var b = cljs.core.first(arglist__6934); +arglist__6934 = cljs.core.next(arglist__6934); +var c = cljs.core.first(arglist__6934); +var ds = cljs.core.rest(arglist__6934); +return G__6933__delegate(a,b,c,ds); +}); +G__6933.cljs$core$IFn$_invoke$arity$variadic = G__6933__delegate; +return G__6933; +})() +; +G__6932 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 1: +return G__6932__1.call(this,a); +case 2: +return G__6932__2.call(this,a,b); +case 3: +return G__6932__3.call(this,a,b,c); +default: +return G__6932__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__6932.cljs$lang$maxFixedArity = 3; +G__6932.cljs$lang$applyTo = G__6932__4.cljs$lang$applyTo; +return G__6932; +})() +}); +var fnil__3 = (function (f,x,y){return (function() { +var G__6935 = null; +var G__6935__2 = (function (a,b){return f.call(null,(((a == null))?x:a),(((b == null))?y:b)); +}); +var G__6935__3 = (function (a,b,c){return f.call(null,(((a == null))?x:a),(((b == null))?y:b),c); +}); +var G__6935__4 = (function() { +var G__6936__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__6936 = 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__6936__delegate.call(this,a,b,c,ds);}; +G__6936.cljs$lang$maxFixedArity = 3; +G__6936.cljs$lang$applyTo = (function (arglist__6937){ +var a = cljs.core.first(arglist__6937); +arglist__6937 = cljs.core.next(arglist__6937); +var b = cljs.core.first(arglist__6937); +arglist__6937 = cljs.core.next(arglist__6937); +var c = cljs.core.first(arglist__6937); +var ds = cljs.core.rest(arglist__6937); +return G__6936__delegate(a,b,c,ds); +}); +G__6936.cljs$core$IFn$_invoke$arity$variadic = G__6936__delegate; +return G__6936; +})() +; +G__6935 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 2: +return G__6935__2.call(this,a,b); +case 3: +return G__6935__3.call(this,a,b,c); +default: +return G__6935__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__6935.cljs$lang$maxFixedArity = 3; +G__6935.cljs$lang$applyTo = G__6935__4.cljs$lang$applyTo; +return G__6935; +})() +}); +var fnil__4 = (function (f,x,y,z){return (function() { +var G__6938 = null; +var G__6938__2 = (function (a,b){return f.call(null,(((a == null))?x:a),(((b == null))?y:b)); +}); +var G__6938__3 = (function (a,b,c){return f.call(null,(((a == null))?x:a),(((b == null))?y:b),(((c == null))?z:c)); +}); +var G__6938__4 = (function() { +var G__6939__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__6939 = 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__6939__delegate.call(this,a,b,c,ds);}; +G__6939.cljs$lang$maxFixedArity = 3; +G__6939.cljs$lang$applyTo = (function (arglist__6940){ +var a = cljs.core.first(arglist__6940); +arglist__6940 = cljs.core.next(arglist__6940); +var b = cljs.core.first(arglist__6940); +arglist__6940 = cljs.core.next(arglist__6940); +var c = cljs.core.first(arglist__6940); +var ds = cljs.core.rest(arglist__6940); +return G__6939__delegate(a,b,c,ds); +}); +G__6939.cljs$core$IFn$_invoke$arity$variadic = G__6939__delegate; +return G__6939; +})() +; +G__6938 = function(a,b,c,var_args){ +var ds = var_args; +switch(arguments.length){ +case 2: +return G__6938__2.call(this,a,b); +case 3: +return G__6938__3.call(this,a,b,c); +default: +return G__6938__4.cljs$core$IFn$_invoke$arity$variadic(a,b,c, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__6938.cljs$lang$maxFixedArity = 3; +G__6938.cljs$lang$applyTo = G__6938__4.cljs$lang$applyTo; +return G__6938; +})() +}); +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; +})() +; +/** +* Returns a lazy sequence consisting of the result of applying f to 0 +* and the first item of coll, followed by applying f to 1 and the second +* item in coll, etc, until coll is exhausted. Thus function f should +* accept 2 arguments, index and item. +*/ +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__4388__auto___6941 = size;var i_6942 = 0;while(true){ +if((i_6942 < n__4388__auto___6941)) +{cljs.core.chunk_append.call(null,b,f.call(null,(idx + i_6942),cljs.core._nth.call(null,c,i_6942))); +{ +var G__6943 = (i_6942 + 1); +i_6942 = G__6943; +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); +}); +/** +* Returns a lazy sequence of the non-nil results of (f item). Note, +* this means false return values will be included. f must be free of +* side-effects. +*/ +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__4388__auto___6944 = size;var i_6945 = 0;while(true){ +if((i_6945 < n__4388__auto___6944)) +{var x_6946 = f.call(null,cljs.core._nth.call(null,c,i_6945));if((x_6946 == null)) +{} else +{cljs.core.chunk_append.call(null,b,x_6946); +} +{ +var G__6947 = (i_6945 + 1); +i_6945 = G__6947; +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)); +}); +/** +* Returns a lazy sequence of the non-nil results of (f index item). Note, +* this means false return values will be included. f must be free of +* side-effects. +*/ +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__4388__auto___6948 = size;var i_6949 = 0;while(true){ +if((i_6949 < n__4388__auto___6948)) +{var x_6950 = f.call(null,(idx + i_6949),cljs.core._nth.call(null,c,i_6949));if((x_6950 == null)) +{} else +{cljs.core.chunk_append.call(null,b,x_6950); +} +{ +var G__6951 = (i_6949 + 1); +i_6949 = G__6951; +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); +}); +/** +* Takes a set of predicates and returns a function f that returns true if all of its +* composing predicates return a logical true value against all of its arguments, else it returns +* false. Note that f is short-circuiting in that it will stop execution on the first +* argument that triggers a logical false result against the original predicates. +* @param {...*} var_args +*/ +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__3528__auto__ = p.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{return p.call(null,y); +} else +{return and__3528__auto__; +} +})()); +}); +var ep1__3 = (function (x,y,z){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{return p.call(null,z); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep1__4 = (function() { +var G__6958__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__6958 = 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__6958__delegate.call(this,x,y,z,args);}; +G__6958.cljs$lang$maxFixedArity = 3; +G__6958.cljs$lang$applyTo = (function (arglist__6959){ +var x = cljs.core.first(arglist__6959); +arglist__6959 = cljs.core.next(arglist__6959); +var y = cljs.core.first(arglist__6959); +arglist__6959 = cljs.core.next(arglist__6959); +var z = cljs.core.first(arglist__6959); +var args = cljs.core.rest(arglist__6959); +return G__6958__delegate(x,y,z,args); +}); +G__6958.cljs$core$IFn$_invoke$arity$variadic = G__6958__delegate; +return G__6958; +})() +; +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__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{return p2.call(null,x); +} else +{return and__3528__auto__; +} +})()); +}); +var ep2__2 = (function (x,y){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$2)) +{return p2.call(null,y); +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep2__3 = (function (x,y,z){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p1.call(null,z);if(cljs.core.truth_(and__3528__auto____$2)) +{var and__3528__auto____$3 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$3)) +{var and__3528__auto____$4 = p2.call(null,y);if(cljs.core.truth_(and__3528__auto____$4)) +{return p2.call(null,z); +} else +{return and__3528__auto____$4; +} +} else +{return and__3528__auto____$3; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep2__4 = (function() { +var G__6960__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__6952_SHARP_){var and__3528__auto__ = p1.call(null,p1__6952_SHARP_);if(cljs.core.truth_(and__3528__auto__)) +{return p2.call(null,p1__6952_SHARP_); +} else +{return and__3528__auto__; +} +}),args))); +}; +var G__6960 = 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__6960__delegate.call(this,x,y,z,args);}; +G__6960.cljs$lang$maxFixedArity = 3; +G__6960.cljs$lang$applyTo = (function (arglist__6961){ +var x = cljs.core.first(arglist__6961); +arglist__6961 = cljs.core.next(arglist__6961); +var y = cljs.core.first(arglist__6961); +arglist__6961 = cljs.core.next(arglist__6961); +var z = cljs.core.first(arglist__6961); +var args = cljs.core.rest(arglist__6961); +return G__6960__delegate(x,y,z,args); +}); +G__6960.cljs$core$IFn$_invoke$arity$variadic = G__6960__delegate; +return G__6960; +})() +; +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__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$1)) +{return p3.call(null,x); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep3__2 = (function (x,y){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p3.call(null,x);if(cljs.core.truth_(and__3528__auto____$2)) +{var and__3528__auto____$3 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$3)) +{var and__3528__auto____$4 = p2.call(null,y);if(cljs.core.truth_(and__3528__auto____$4)) +{return p3.call(null,y); +} else +{return and__3528__auto____$4; +} +} else +{return and__3528__auto____$3; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep3__3 = (function (x,y,z){return cljs.core.boolean$.call(null,(function (){var and__3528__auto__ = p1.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,x);if(cljs.core.truth_(and__3528__auto____$1)) +{var and__3528__auto____$2 = p3.call(null,x);if(cljs.core.truth_(and__3528__auto____$2)) +{var and__3528__auto____$3 = p1.call(null,y);if(cljs.core.truth_(and__3528__auto____$3)) +{var and__3528__auto____$4 = p2.call(null,y);if(cljs.core.truth_(and__3528__auto____$4)) +{var and__3528__auto____$5 = p3.call(null,y);if(cljs.core.truth_(and__3528__auto____$5)) +{var and__3528__auto____$6 = p1.call(null,z);if(cljs.core.truth_(and__3528__auto____$6)) +{var and__3528__auto____$7 = p2.call(null,z);if(cljs.core.truth_(and__3528__auto____$7)) +{return p3.call(null,z); +} else +{return and__3528__auto____$7; +} +} else +{return and__3528__auto____$6; +} +} else +{return and__3528__auto____$5; +} +} else +{return and__3528__auto____$4; +} +} else +{return and__3528__auto____$3; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +})()); +}); +var ep3__4 = (function() { +var G__6962__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__6953_SHARP_){var and__3528__auto__ = p1.call(null,p1__6953_SHARP_);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p2.call(null,p1__6953_SHARP_);if(cljs.core.truth_(and__3528__auto____$1)) +{return p3.call(null,p1__6953_SHARP_); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +}),args))); +}; +var G__6962 = 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__6962__delegate.call(this,x,y,z,args);}; +G__6962.cljs$lang$maxFixedArity = 3; +G__6962.cljs$lang$applyTo = (function (arglist__6963){ +var x = cljs.core.first(arglist__6963); +arglist__6963 = cljs.core.next(arglist__6963); +var y = cljs.core.first(arglist__6963); +arglist__6963 = cljs.core.next(arglist__6963); +var z = cljs.core.first(arglist__6963); +var args = cljs.core.rest(arglist__6963); +return G__6962__delegate(x,y,z,args); +}); +G__6962.cljs$core$IFn$_invoke$arity$variadic = G__6962__delegate; +return G__6962; +})() +; +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__6964__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__6954_SHARP_){return p1__6954_SHARP_.call(null,x); +}),ps__$1); +}); +var epn__2 = (function (x,y){return cljs.core.every_QMARK_.call(null,(function (p1__6955_SHARP_){var and__3528__auto__ = p1__6955_SHARP_.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{return p1__6955_SHARP_.call(null,y); +} else +{return and__3528__auto__; +} +}),ps__$1); +}); +var epn__3 = (function (x,y,z){return cljs.core.every_QMARK_.call(null,(function (p1__6956_SHARP_){var and__3528__auto__ = p1__6956_SHARP_.call(null,x);if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = p1__6956_SHARP_.call(null,y);if(cljs.core.truth_(and__3528__auto____$1)) +{return p1__6956_SHARP_.call(null,z); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__auto__; +} +}),ps__$1); +}); +var epn__4 = (function() { +var G__6965__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__6957_SHARP_){return cljs.core.every_QMARK_.call(null,p1__6957_SHARP_,args); +}),ps__$1))); +}; +var G__6965 = 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__6965__delegate.call(this,x,y,z,args);}; +G__6965.cljs$lang$maxFixedArity = 3; +G__6965.cljs$lang$applyTo = (function (arglist__6966){ +var x = cljs.core.first(arglist__6966); +arglist__6966 = cljs.core.next(arglist__6966); +var y = cljs.core.first(arglist__6966); +arglist__6966 = cljs.core.next(arglist__6966); +var z = cljs.core.first(arglist__6966); +var args = cljs.core.rest(arglist__6966); +return G__6965__delegate(x,y,z,args); +}); +G__6965.cljs$core$IFn$_invoke$arity$variadic = G__6965__delegate; +return G__6965; +})() +; +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__6964 = 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__6964__delegate.call(this,p1,p2,p3,ps);}; +G__6964.cljs$lang$maxFixedArity = 3; +G__6964.cljs$lang$applyTo = (function (arglist__6967){ +var p1 = cljs.core.first(arglist__6967); +arglist__6967 = cljs.core.next(arglist__6967); +var p2 = cljs.core.first(arglist__6967); +arglist__6967 = cljs.core.next(arglist__6967); +var p3 = cljs.core.first(arglist__6967); +var ps = cljs.core.rest(arglist__6967); +return G__6964__delegate(p1,p2,p3,ps); +}); +G__6964.cljs$core$IFn$_invoke$arity$variadic = G__6964__delegate; +return G__6964; +})() +; +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; +})() +; +/** +* Takes a set of predicates and returns a function f that returns the first logical true value +* returned by one of its composing predicates against any of its arguments, else it returns +* logical false. Note that f is short-circuiting in that it will stop execution on the first +* argument that triggers a logical true result against the original predicates. +* @param {...*} var_args +*/ +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__3540__auto__ = p.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return p.call(null,y); +} +}); +var sp1__3 = (function (x,y,z){var or__3540__auto__ = p.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p.call(null,z); +} +} +}); +var sp1__4 = (function() { +var G__6974__delegate = function (x,y,z,args){var or__3540__auto__ = sp1.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,p,args); +} +}; +var G__6974 = 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__6974__delegate.call(this,x,y,z,args);}; +G__6974.cljs$lang$maxFixedArity = 3; +G__6974.cljs$lang$applyTo = (function (arglist__6975){ +var x = cljs.core.first(arglist__6975); +arglist__6975 = cljs.core.next(arglist__6975); +var y = cljs.core.first(arglist__6975); +arglist__6975 = cljs.core.next(arglist__6975); +var z = cljs.core.first(arglist__6975); +var args = cljs.core.rest(arglist__6975); +return G__6974__delegate(x,y,z,args); +}); +G__6974.cljs$core$IFn$_invoke$arity$variadic = G__6974__delegate; +return G__6974; +})() +; +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__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return p2.call(null,x); +} +}); +var sp2__2 = (function (x,y){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{return p2.call(null,y); +} +} +} +}); +var sp2__3 = (function (x,y,z){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p1.call(null,z);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{var or__3540__auto____$3 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$3)) +{return or__3540__auto____$3; +} else +{var or__3540__auto____$4 = p2.call(null,y);if(cljs.core.truth_(or__3540__auto____$4)) +{return or__3540__auto____$4; +} else +{return p2.call(null,z); +} +} +} +} +} +}); +var sp2__4 = (function() { +var G__6976__delegate = function (x,y,z,args){var or__3540__auto__ = sp2.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,(function (p1__6968_SHARP_){var or__3540__auto____$1 = p1.call(null,p1__6968_SHARP_);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p2.call(null,p1__6968_SHARP_); +} +}),args); +} +}; +var G__6976 = 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__6976__delegate.call(this,x,y,z,args);}; +G__6976.cljs$lang$maxFixedArity = 3; +G__6976.cljs$lang$applyTo = (function (arglist__6977){ +var x = cljs.core.first(arglist__6977); +arglist__6977 = cljs.core.next(arglist__6977); +var y = cljs.core.first(arglist__6977); +arglist__6977 = cljs.core.next(arglist__6977); +var z = cljs.core.first(arglist__6977); +var args = cljs.core.rest(arglist__6977); +return G__6976__delegate(x,y,z,args); +}); +G__6976.cljs$core$IFn$_invoke$arity$variadic = G__6976__delegate; +return G__6976; +})() +; +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__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p3.call(null,x); +} +} +}); +var sp3__2 = (function (x,y){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p3.call(null,x);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{var or__3540__auto____$3 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$3)) +{return or__3540__auto____$3; +} else +{var or__3540__auto____$4 = p2.call(null,y);if(cljs.core.truth_(or__3540__auto____$4)) +{return or__3540__auto____$4; +} else +{return p3.call(null,y); +} +} +} +} +} +}); +var sp3__3 = (function (x,y,z){var or__3540__auto__ = p1.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p2.call(null,x);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p3.call(null,x);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{var or__3540__auto____$3 = p1.call(null,y);if(cljs.core.truth_(or__3540__auto____$3)) +{return or__3540__auto____$3; +} else +{var or__3540__auto____$4 = p2.call(null,y);if(cljs.core.truth_(or__3540__auto____$4)) +{return or__3540__auto____$4; +} else +{var or__3540__auto____$5 = p3.call(null,y);if(cljs.core.truth_(or__3540__auto____$5)) +{return or__3540__auto____$5; +} else +{var or__3540__auto____$6 = p1.call(null,z);if(cljs.core.truth_(or__3540__auto____$6)) +{return or__3540__auto____$6; +} else +{var or__3540__auto____$7 = p2.call(null,z);if(cljs.core.truth_(or__3540__auto____$7)) +{return or__3540__auto____$7; +} else +{return p3.call(null,z); +} +} +} +} +} +} +} +} +}); +var sp3__4 = (function() { +var G__6978__delegate = function (x,y,z,args){var or__3540__auto__ = sp3.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,(function (p1__6969_SHARP_){var or__3540__auto____$1 = p1.call(null,p1__6969_SHARP_);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__auto____$2 = p2.call(null,p1__6969_SHARP_);if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{return p3.call(null,p1__6969_SHARP_); +} +} +}),args); +} +}; +var G__6978 = 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__6978__delegate.call(this,x,y,z,args);}; +G__6978.cljs$lang$maxFixedArity = 3; +G__6978.cljs$lang$applyTo = (function (arglist__6979){ +var x = cljs.core.first(arglist__6979); +arglist__6979 = cljs.core.next(arglist__6979); +var y = cljs.core.first(arglist__6979); +arglist__6979 = cljs.core.next(arglist__6979); +var z = cljs.core.first(arglist__6979); +var args = cljs.core.rest(arglist__6979); +return G__6978__delegate(x,y,z,args); +}); +G__6978.cljs$core$IFn$_invoke$arity$variadic = G__6978__delegate; +return G__6978; +})() +; +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__6980__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__6970_SHARP_){return p1__6970_SHARP_.call(null,x); +}),ps__$1); +}); +var spn__2 = (function (x,y){return cljs.core.some.call(null,(function (p1__6971_SHARP_){var or__3540__auto__ = p1__6971_SHARP_.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return p1__6971_SHARP_.call(null,y); +} +}),ps__$1); +}); +var spn__3 = (function (x,y,z){return cljs.core.some.call(null,(function (p1__6972_SHARP_){var or__3540__auto__ = p1__6972_SHARP_.call(null,x);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = p1__6972_SHARP_.call(null,y);if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{return p1__6972_SHARP_.call(null,z); +} +} +}),ps__$1); +}); +var spn__4 = (function() { +var G__6981__delegate = function (x,y,z,args){var or__3540__auto__ = spn.call(null,x,y,z);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.some.call(null,(function (p1__6973_SHARP_){return cljs.core.some.call(null,p1__6973_SHARP_,args); +}),ps__$1); +} +}; +var G__6981 = 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__6981__delegate.call(this,x,y,z,args);}; +G__6981.cljs$lang$maxFixedArity = 3; +G__6981.cljs$lang$applyTo = (function (arglist__6982){ +var x = cljs.core.first(arglist__6982); +arglist__6982 = cljs.core.next(arglist__6982); +var y = cljs.core.first(arglist__6982); +arglist__6982 = cljs.core.next(arglist__6982); +var z = cljs.core.first(arglist__6982); +var args = cljs.core.rest(arglist__6982); +return G__6981__delegate(x,y,z,args); +}); +G__6981.cljs$core$IFn$_invoke$arity$variadic = G__6981__delegate; +return G__6981; +})() +; +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__6980 = 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__6980__delegate.call(this,p1,p2,p3,ps);}; +G__6980.cljs$lang$maxFixedArity = 3; +G__6980.cljs$lang$applyTo = (function (arglist__6983){ +var p1 = cljs.core.first(arglist__6983); +arglist__6983 = cljs.core.next(arglist__6983); +var p2 = cljs.core.first(arglist__6983); +arglist__6983 = cljs.core.next(arglist__6983); +var p3 = cljs.core.first(arglist__6983); +var ps = cljs.core.rest(arglist__6983); +return G__6980__delegate(p1,p2,p3,ps); +}); +G__6980.cljs$core$IFn$_invoke$arity$variadic = G__6980__delegate; +return G__6980; +})() +; +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; +})() +; +/** +* Returns a lazy sequence consisting of the result of applying f to the +* set of first items of each coll, followed by applying f to the set +* of second items in each coll, until any one of the colls is +* exhausted. Any remaining items in other colls are ignored. Function +* f should accept number-of-colls arguments. +* @param {...*} var_args +*/ +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__4388__auto___6985 = size;var i_6986 = 0;while(true){ +if((i_6986 < n__4388__auto___6985)) +{cljs.core.chunk_append.call(null,b,f.call(null,cljs.core._nth.call(null,c,i_6986))); +{ +var G__6987 = (i_6986 + 1); +i_6986 = G__6987; +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__6988__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__6984_SHARP_){return cljs.core.apply.call(null,f,p1__6984_SHARP_); +}),step.call(null,cljs.core.conj.call(null,colls,c3,c2,c1))); +}; +var G__6988 = 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__6988__delegate.call(this,f,c1,c2,c3,colls);}; +G__6988.cljs$lang$maxFixedArity = 4; +G__6988.cljs$lang$applyTo = (function (arglist__6989){ +var f = cljs.core.first(arglist__6989); +arglist__6989 = cljs.core.next(arglist__6989); +var c1 = cljs.core.first(arglist__6989); +arglist__6989 = cljs.core.next(arglist__6989); +var c2 = cljs.core.first(arglist__6989); +arglist__6989 = cljs.core.next(arglist__6989); +var c3 = cljs.core.first(arglist__6989); +var colls = cljs.core.rest(arglist__6989); +return G__6988__delegate(f,c1,c2,c3,colls); +}); +G__6988.cljs$core$IFn$_invoke$arity$variadic = G__6988__delegate; +return G__6988; +})() +; +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; +})() +; +/** +* Returns a lazy sequence of the first n items in coll, or all items if +* there are fewer than n. +*/ +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)); +}); +/** +* Returns a lazy sequence of all but the first n items in coll. +*/ +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__6990 = (n__$1 - 1); +var G__6991 = cljs.core.rest.call(null,s); +n__$1 = G__6990; +coll__$1 = G__6991; +continue; +} +} else +{return s; +} +break; +} +});return (new cljs.core.LazySeq(null,(function (){return step.call(null,n,coll); +}),null,null)); +}); +/** +* Return a lazy sequence of all but the last n (default 1) items in coll +*/ +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; +})() +; +/** +* Returns a seq of the last n items in coll. Depending on the type +* of coll may be no better than linear time. For vectors, see also subvec. +*/ +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__6992 = cljs.core.next.call(null,s); +var G__6993 = cljs.core.next.call(null,lead); +s = G__6992; +lead = G__6993; +continue; +} +} else +{return s; +} +break; +} +}); +/** +* Returns a lazy sequence of the items in coll starting from the first +* item for which (pred item) returns nil. +*/ +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__3528__auto__ = s;if(and__3528__auto__) +{return pred__$1.call(null,cljs.core.first.call(null,s)); +} else +{return and__3528__auto__; +} +})())) +{{ +var G__6994 = pred__$1; +var G__6995 = cljs.core.rest.call(null,s); +pred__$1 = G__6994; +coll__$1 = G__6995; +continue; +} +} else +{return s; +} +break; +} +});return (new cljs.core.LazySeq(null,(function (){return step.call(null,pred,coll); +}),null,null)); +}); +/** +* Returns a lazy (infinite!) sequence of repetitions of the items in coll. +*/ +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)); +}); +/** +* Returns a vector of [(take n coll) (drop n coll)] +*/ +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); +}); +/** +* Returns a lazy (infinite!, or length n if supplied) sequence of xs. +*/ +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; +})() +; +/** +* Returns a lazy seq of n xs. +*/ +cljs.core.replicate = (function replicate(n,x){return cljs.core.take.call(null,n,cljs.core.repeat.call(null,x)); +}); +/** +* Takes a function of no args, presumably with side effects, and +* returns an infinite (or length n if supplied) lazy sequence of calls +* to it +*/ +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; +})() +; +/** +* Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects +*/ +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))); +}); +/** +* Returns a lazy seq of the first item in each coll, then the second etc. +* @param {...*} var_args +*/ +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__6996__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__6996 = 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__6996__delegate.call(this,c1,c2,colls);}; +G__6996.cljs$lang$maxFixedArity = 2; +G__6996.cljs$lang$applyTo = (function (arglist__6997){ +var c1 = cljs.core.first(arglist__6997); +arglist__6997 = cljs.core.next(arglist__6997); +var c2 = cljs.core.first(arglist__6997); +var colls = cljs.core.rest(arglist__6997); +return G__6996__delegate(c1,c2,colls); +}); +G__6996.cljs$core$IFn$_invoke$arity$variadic = G__6996__delegate; +return G__6996; +})() +; +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; +})() +; +/** +* Returns a lazy seq of the elements of coll separated by sep +*/ +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)); +}); +/** +* Take a collection of collections, and return a lazy seq +* of items from the inner collection +*/ +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); +}); +/** +* Returns the result of applying concat to the result of applying map +* to f and colls. Thus function f should return a collection. +* @param {...*} var_args +*/ +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__6998__delegate = function (f,coll,colls){return cljs.core.flatten1.call(null,cljs.core.apply.call(null,cljs.core.map,f,coll,colls)); +}; +var G__6998 = 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__6998__delegate.call(this,f,coll,colls);}; +G__6998.cljs$lang$maxFixedArity = 2; +G__6998.cljs$lang$applyTo = (function (arglist__6999){ +var f = cljs.core.first(arglist__6999); +arglist__6999 = cljs.core.next(arglist__6999); +var coll = cljs.core.first(arglist__6999); +var colls = cljs.core.rest(arglist__6999); +return G__6998__delegate(f,coll,colls); +}); +G__6998.cljs$core$IFn$_invoke$arity$variadic = G__6998__delegate; +return G__6998; +})() +; +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; +})() +; +/** +* Returns a lazy sequence of the items in coll for which +* (pred item) returns true. pred must be free of side-effects. +*/ +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__4388__auto___7000 = size;var i_7001 = 0;while(true){ +if((i_7001 < n__4388__auto___7000)) +{if(cljs.core.truth_(pred.call(null,cljs.core._nth.call(null,c,i_7001)))) +{cljs.core.chunk_append.call(null,b,cljs.core._nth.call(null,c,i_7001)); +} else +{} +{ +var G__7002 = (i_7001 + 1); +i_7001 = G__7002; +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)); +}); +/** +* Returns a lazy sequence of the items in coll for which +* (pred item) returns false. pred must be free of side-effects. +*/ +cljs.core.remove = (function remove(pred,coll){return cljs.core.filter.call(null,cljs.core.complement.call(null,pred),coll); +}); +/** +* Returns a lazy sequence of the nodes in a tree, via a depth-first walk. +* branch? must be a fn of one arg that returns true if passed a node +* that can have children (but may not). children must be a fn of one +* arg that returns a sequence of the children. Will only be called on +* nodes for which branch? returns true. Root is the root node of the +* tree. +*/ +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); +}); +/** +* Takes any nested combination of sequential things (lists, vectors, +* etc.) and returns their contents as a single, flat sequence. +* (flatten nil) returns nil. +*/ +cljs.core.flatten = (function flatten(x){return cljs.core.filter.call(null,(function (p1__7003_SHARP_){return !(cljs.core.sequential_QMARK_.call(null,p1__7003_SHARP_)); +}),cljs.core.rest.call(null,cljs.core.tree_seq.call(null,cljs.core.sequential_QMARK_,cljs.core.seq,x))); +}); +/** +* Returns a new coll consisting of to-coll with all of the items of +* from-coll conjoined. +*/ +cljs.core.into = (function into(to,from){if(!((to == null))) +{if((function (){var G__7005 = to;if(G__7005) +{var bit__4183__auto__ = (G__7005.cljs$lang$protocol_mask$partition1$ & 4);if((bit__4183__auto__) || (G__7005.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); +} +}); +/** +* Returns a vector consisting of the result of applying f to the +* set of first items of each coll, followed by applying f to the set +* of second items in each coll, until any one of the colls is +* exhausted. Any remaining items in other colls are ignored. Function +* f should accept number-of-colls arguments. +* @param {...*} var_args +*/ +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__7006__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__7006 = 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__7006__delegate.call(this,f,c1,c2,c3,colls);}; +G__7006.cljs$lang$maxFixedArity = 4; +G__7006.cljs$lang$applyTo = (function (arglist__7007){ +var f = cljs.core.first(arglist__7007); +arglist__7007 = cljs.core.next(arglist__7007); +var c1 = cljs.core.first(arglist__7007); +arglist__7007 = cljs.core.next(arglist__7007); +var c2 = cljs.core.first(arglist__7007); +arglist__7007 = cljs.core.next(arglist__7007); +var c3 = cljs.core.first(arglist__7007); +var colls = cljs.core.rest(arglist__7007); +return G__7006__delegate(f,c1,c2,c3,colls); +}); +G__7006.cljs$core$IFn$_invoke$arity$variadic = G__7006__delegate; +return G__7006; +})() +; +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; +})() +; +/** +* Returns a vector of the items in coll for which +* (pred item) returns true. pred must be free of side-effects. +*/ +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)); +}); +/** +* Returns a lazy sequence of lists of n items each, at offsets step +* apart. If step is not supplied, defaults to n, i.e. the partitions +* do not overlap. If a pad collection is supplied, use its elements as +* necessary to complete last partition upto n items. In case there are +* not enough padding elements, return a partition with less than n items. +*/ +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; +})() +; +/** +* Returns the value in a nested associative structure, +* where ks is a sequence of keys. Returns nil if the key is not present, +* or the not-found value if supplied. +*/ +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__7009 = m__$1;if(G__7009) +{var bit__4190__auto__ = (G__7009.cljs$lang$protocol_mask$partition0$ & 256);if((bit__4190__auto__) || (G__7009.cljs$core$ILookup$)) +{return true; +} else +{if((!G__7009.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ILookup,G__7009); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.ILookup,G__7009); +} +})())) +{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__7010 = sentinel; +var G__7011 = m__$2; +var G__7012 = cljs.core.next.call(null,ks__$1); +sentinel = G__7010; +m__$1 = G__7011; +ks__$1 = G__7012; +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; +})() +; +/** +* Associates a value in a nested associative structure, where ks is a +* sequence of keys and v is the new value and returns a new nested structure. +* If any levels do not exist, hash-maps will be created. +*/ +cljs.core.assoc_in = (function assoc_in(m,p__7013,v){var vec__7015 = p__7013;var k = cljs.core.nth.call(null,vec__7015,0,null);var ks = cljs.core.nthnext.call(null,vec__7015,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); +} +}); +/** +* 'Updates' a value in a nested associative structure, where ks is a +* sequence of keys and f is a function that will take the old value +* and any supplied args and return the new value, and returns a new +* nested structure. If any levels do not exist, hash-maps will be +* created. +* @param {...*} var_args +*/ +cljs.core.update_in = (function() { +var update_in = null; +var update_in__3 = (function (m,p__7016,f){var vec__7026 = p__7016;var k = cljs.core.nth.call(null,vec__7026,0,null);var ks = cljs.core.nthnext.call(null,vec__7026,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__7017,f,a){var vec__7027 = p__7017;var k = cljs.core.nth.call(null,vec__7027,0,null);var ks = cljs.core.nthnext.call(null,vec__7027,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__7018,f,a,b){var vec__7028 = p__7018;var k = cljs.core.nth.call(null,vec__7028,0,null);var ks = cljs.core.nthnext.call(null,vec__7028,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__7019,f,a,b,c){var vec__7029 = p__7019;var k = cljs.core.nth.call(null,vec__7029,0,null);var ks = cljs.core.nthnext.call(null,vec__7029,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__7031__delegate = function (m,p__7020,f,a,b,c,args){var vec__7030 = p__7020;var k = cljs.core.nth.call(null,vec__7030,0,null);var ks = cljs.core.nthnext.call(null,vec__7030,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__7031 = function (m,p__7020,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__7031__delegate.call(this,m,p__7020,f,a,b,c,args);}; +G__7031.cljs$lang$maxFixedArity = 6; +G__7031.cljs$lang$applyTo = (function (arglist__7032){ +var m = cljs.core.first(arglist__7032); +arglist__7032 = cljs.core.next(arglist__7032); +var p__7020 = cljs.core.first(arglist__7032); +arglist__7032 = cljs.core.next(arglist__7032); +var f = cljs.core.first(arglist__7032); +arglist__7032 = cljs.core.next(arglist__7032); +var a = cljs.core.first(arglist__7032); +arglist__7032 = cljs.core.next(arglist__7032); +var b = cljs.core.first(arglist__7032); +arglist__7032 = cljs.core.next(arglist__7032); +var c = cljs.core.first(arglist__7032); +var args = cljs.core.rest(arglist__7032); +return G__7031__delegate(m,p__7020,f,a,b,c,args); +}); +G__7031.cljs$core$IFn$_invoke$arity$variadic = G__7031__delegate; +return G__7031; +})() +; +update_in = function(m,p__7020,f,a,b,c,var_args){ +var args = var_args; +switch(arguments.length){ +case 3: +return update_in__3.call(this,m,p__7020,f); +case 4: +return update_in__4.call(this,m,p__7020,f,a); +case 5: +return update_in__5.call(this,m,p__7020,f,a,b); +case 6: +return update_in__6.call(this,m,p__7020,f,a,b,c); +default: +return update_in__7.cljs$core$IFn$_invoke$arity$variadic(m,p__7020,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; +})() +; + +/** +* @constructor +*/ +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__4110__auto__,writer__4111__auto__,opts__4112__auto__){return cljs.core._write.call(null,writer__4111__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__7033 = (ll - 5); +var G__7034 = r; +ll = G__7033; +ret = G__7034; +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__7035 = cljs.core.pv_aget.call(null,node,((i >>> level) & 31)); +var G__7036 = (level - 5); +node = G__7035; +level = G__7036; +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; +} +} +} +}); + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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(typeof k === 'number') +{return cljs.core._assoc_n.call(null,coll__$1,k,v); +} else +{throw (new Error("Vector's key for assoc must be a number.")); +} +}); +cljs.core.PersistentVector.prototype.call = (function() { +var G__7038 = null; +var G__7038__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__7038__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__7038 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7038__2.call(this,self__,k); +case 3: +return G__7038__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7038; +})() +; +cljs.core.PersistentVector.prototype.apply = (function (self__,args7037){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7037))); +}); +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__7039 = (j + 1); +var G__7040 = init__$2; +j = G__7039; +init__$1 = G__7040; +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__7041 = (i + (step_init[0])); +i = G__7041; +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__4388__auto___7042 = len;var i_7043 = 0;while(true){ +if((i_7043 < n__4388__auto___7042)) +{(new_tail[i_7043] = (self__.tail[i_7043])); +{ +var G__7044 = (i_7043 + 1); +i_7043 = G__7044; +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;if(((0 <= n)) && ((n < self__.cnt))) +{if((cljs.core.tail_off.call(null,coll__$1) <= n)) +{var new_tail = cljs.core.aclone.call(null,self__.tail);(new_tail[(n & 31)] = val); +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,n,val),self__.tail,null)); +} +} else +{if((n === self__.cnt)) +{return cljs.core._conj.call(null,coll__$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 [0,"),cljs.core.str(self__.cnt),cljs.core.str("]")].join(''))); +} else +{return null; +} +} +} +}); +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentVector(self__.meta,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__7045 = (i + 1); +var G__7046 = cljs.core.conj_BANG_.call(null,out,(xs__$1[i])); +i = G__7045; +out = G__7046; +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)); +}); +/** +* @param {...*} var_args +*/ +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__7047){ +var args = cljs.core.seq(arglist__7047); +return vector__delegate(args); +}); +vector.cljs$core$IFn$_invoke$arity$variadic = vector__delegate; +return vector; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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; +})() +; + +/** +* @constructor +*/ +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$partition0$ = 166617887; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.Subvec.cljs$lang$type = true; +cljs.core.Subvec.cljs$lang$ctorStr = "cljs.core/Subvec"; +cljs.core.Subvec.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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;if(typeof key === 'number') +{return cljs.core._assoc_n.call(null,coll__$1,key,val); +} else +{throw (new Error("Subvec's key for assoc must be a number.")); +} +}); +cljs.core.Subvec.prototype.call = (function() { +var G__7049 = null; +var G__7049__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__7049__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__7049 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7049__2.call(this,self__,k); +case 3: +return G__7049__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7049; +})() +; +cljs.core.Subvec.prototype.apply = (function (self__,args7048){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7048))); +}); +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.cljs$core$IReversible$_rseq$arity$1 = (function (coll){var self__ = this; +var coll__$1 = this;if(!((self__.start === self__.end))) +{return (new cljs.core.RSeq(coll__$1,((self__.end - self__.start) - 1),null)); +} else +{return 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;var v_pos = (self__.start + n);return cljs.core.build_subvec.call(null,self__.meta,cljs.core.assoc.call(null,self__.v,v_pos,val),self__.start,(function (){var x__3847__auto__ = self__.end;var y__3848__auto__ = (v_pos + 1);return ((x__3847__auto__ > y__3848__auto__) ? x__3847__auto__ : y__3848__auto__); +})(),null); +}); +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.Subvec(self__.meta,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__7050 = meta; +var G__7051 = v.v; +var G__7052 = (v.start + start); +var G__7053 = (v.start + end); +var G__7054 = __hash; +meta = G__7050; +v = G__7051; +start = G__7052; +end = G__7053; +__hash = G__7054; +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; +} +}); +/** +* Returns a persistent vector of the items in vector from +* start (inclusive) to end (exclusive). If end is not supplied, +* defaults to (count vector). This operation is O(1) and very fast, as +* the resulting vector shares structure with the original and no +* trimming is done. +*/ +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 obj7058 = {};return obj7058; +})(),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__7059 = cljs.core.tv_ensure_editable.call(null,root.edit,cljs.core.pv_aget.call(null,node,((i >>> level) & 31))); +var G__7060 = (level - 5); +node = G__7059; +level = G__7060; +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(''))); +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__auto__,"cljs.core/TransientVector"); +}); +cljs.core.TransientVector.prototype.call = (function() { +var G__7062 = null; +var G__7062__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__7062__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__7062 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7062__2.call(this,self__,k); +case 3: +return G__7062__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7062; +})() +; +cljs.core.TransientVector.prototype.apply = (function (self__,args7061){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7061))); +}); +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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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)); +}); + +/** +* @constructor +*/ +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$partition0$ = 31858766; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.PersistentQueue.cljs$lang$type = true; +cljs.core.PersistentQueue.cljs$lang$ctorStr = "cljs.core/PersistentQueue"; +cljs.core.PersistentQueue.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__3540__auto__ = self__.rear;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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__3540__auto__ = self__.front;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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$ICloneable$_clone$arity$1 = (function (coll){var self__ = this; +var coll__$1 = this;return (new cljs.core.PersistentQueue(self__.meta,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)); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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()); +/** +* Assumes y is a map. Returns true if x equals y, otherwise returns +* false. +*/ +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__7063 = (i + incr); +i = G__7063; +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__7064 = (i + 1); +var G__7065 = cljs.core.assoc_BANG_.call(null,out,k__$1,(so[k__$1])); +i = G__7064; +out = G__7065; +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 obj7069 = {};return obj7069; +})();var l = ks.length;var i_7070 = 0;while(true){ +if((i_7070 < l)) +{var k_7071 = (ks[i_7070]);(new_obj[k_7071] = (obj[k_7071])); +{ +var G__7072 = (i_7070 + 1); +i_7070 = G__7072; +continue; +} +} else +{} +break; +} +return new_obj; +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7075 = null; +var G__7075__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__7075__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__7075 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7075__2.call(this,self__,k); +case 3: +return G__7075__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7075; +})() +; +cljs.core.ObjMap.prototype.apply = (function (self__,args7074){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7074))); +}); +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__7076 = cljs.core.rest.call(null,keys__$1); +var G__7077 = init__$2; +keys__$1 = G__7076; +init__$1 = G__7077; +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__7073_SHARP_){return (new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[p1__7073_SHARP_,(self__.strobj[p1__7073_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 obj7079 = {};return obj7079; +})(),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__7080 = (i + 2); +i = G__7080; +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__7081 = (i + 2); +i = G__7081; +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__7082 = (i + 2); +i = G__7082; +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__7083 = (i + 2); +i = G__7083; +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__7084 = (i + 2); +i = G__7084; +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_7085 = 0;while(true){ +if((i_7085 < l)) +{(narr[i_7085] = (arr[i_7085])); +{ +var G__7086 = (i_7085 + 1); +i_7085 = G__7086; +continue; +} +} else +{} +break; +} +(narr[l] = k); +(narr[(l + 1)] = v); +return narr; +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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; +} +}); + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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 obj7089 = {};return obj7089; +})(),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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7090 = cljs.core.aclone.call(null,self__.arr);(G__7090[(idx + 1)] = v); +return G__7090; +})();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__7091 = null; +var G__7091__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__7091__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__7091 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7091__2.call(this,self__,k); +case 3: +return G__7091__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7091; +})() +; +cljs.core.PersistentArrayMap.prototype.apply = (function (self__,args7087){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7087))); +}); +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__7092 = (i + 2); +var G__7093 = init__$2; +i = G__7092; +init__$1 = G__7093; +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentArrayMap(self__.meta,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__7094 = (s + 2); +var G__7095 = d; +s = G__7094; +d = G__7095; +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__7096 = (s + 2); +var G__7097 = (d + 2); +s = G__7096; +d = G__7097; +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__7098 = (i + 2); +var G__7099 = cljs.core._assoc_BANG_.call(null,ret,(arr__$1[i]),(arr__$1[(i + 1)])); +i = G__7098; +ret = G__7099; +continue; +} +} else +{return cljs.core._persistent_BANG_.call(null,ret); +} +break; +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7100_7102 = self__.arr;G__7100_7102.pop(); +G__7100_7102.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__7101 = o;if(G__7101) +{var bit__4190__auto__ = (G__7101.cljs$lang$protocol_mask$partition0$ & 2048);if((bit__4190__auto__) || (G__7101.cljs$core$IMapEntry$)) +{return true; +} else +{if((!G__7101.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__7101); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__7101); +} +})()) +{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__7103 = cljs.core.next.call(null,es); +var G__7104 = cljs.core._assoc_BANG_.call(null,tcoll__$2,cljs.core.key.call(null,e),cljs.core.val.call(null,e)); +es = G__7103; +tcoll__$2 = G__7104; +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__7105 = cljs.core.assoc_BANG_.call(null,out,(arr[i]),(arr[(i + 1)])); +var G__7106 = (i + 2); +out = G__7105; +i = G__7106; +continue; +} +} else +{return out; +} +break; +} +}); + +/** +* @constructor +*/ +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__4110__auto__,writer__4111__auto__,opts__4112__auto__){return cljs.core._write.call(null,writer__4111__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__7109 = cljs.core.aclone.call(null,arr);(G__7109[i] = a); +return G__7109; +}); +var clone_and_set__5 = (function (arr,i,a,j,b){var G__7110 = cljs.core.aclone.call(null,arr);(G__7110[i] = a); +(G__7110[j] = b); +return G__7110; +}); +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) & 0x01f)); +}); +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__7111 = (i + 2); +var G__7112 = init__$2; +i = G__7111; +init__$1 = G__7112; +continue; +} +} +} else +{return init__$1; +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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) & 0x01f));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) & 0x01f);(nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + 5),hash,key,val,added_leaf_QMARK_)); +var i_7113 = 0;var j_7114 = 0;while(true){ +if((i_7113 < 32)) +{if((((self__.bitmap >>> i_7113) & 1) === 0)) +{{ +var G__7115 = (i_7113 + 1); +var G__7116 = j_7114; +i_7113 = G__7115; +j_7114 = G__7116; +continue; +} +} else +{(nodes[i_7113] = ((!(((self__.arr[j_7114]) == null)))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1,(shift + 5),cljs.core.hash.call(null,(self__.arr[j_7114])),(self__.arr[j_7114]),(self__.arr[(j_7114 + 1)]),added_leaf_QMARK_):(self__.arr[(j_7114 + 1)]))); +{ +var G__7117 = (i_7113 + 1); +var G__7118 = (j_7114 + 2); +i_7113 = G__7117; +j_7114 = G__7118; +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) & 0x01f));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) & 0x01f));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) & 0x01f));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) & 0x01f));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) & 0x01f);(nodes[jdx] = cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + 5),hash,key,val,added_leaf_QMARK_)); +var i_7119 = 0;var j_7120 = 0;while(true){ +if((i_7119 < 32)) +{if((((self__.bitmap >>> i_7119) & 1) === 0)) +{{ +var G__7121 = (i_7119 + 1); +var G__7122 = j_7120; +i_7119 = G__7121; +j_7120 = G__7122; +continue; +} +} else +{(nodes[i_7119] = ((!(((self__.arr[j_7120]) == null)))?cljs.core.BitmapIndexedNode.EMPTY.inode_assoc((shift + 5),cljs.core.hash.call(null,(self__.arr[j_7120])),(self__.arr[j_7120]),(self__.arr[(j_7120 + 1)]),added_leaf_QMARK_):(self__.arr[(j_7120 + 1)]))); +{ +var G__7123 = (i_7119 + 1); +var G__7124 = (j_7120 + 2); +i_7119 = G__7123; +j_7120 = G__7124; +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) & 0x01f));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__7125 = (i + 1); +var G__7126 = (j + 2); +var G__7127 = (bitmap | (1 << i)); +i = G__7125; +j = G__7126; +bitmap = G__7127; +continue; +} +} else +{{ +var G__7128 = (i + 1); +var G__7129 = j; +var G__7130 = bitmap; +i = G__7128; +j = G__7129; +bitmap = G__7130; +continue; +} +} +} else +{return (new cljs.core.BitmapIndexedNode(edit,bitmap,new_arr)); +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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) & 0x01f);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) & 0x01f);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__7131 = (i + 1); +var G__7132 = init__$2; +i = G__7131; +init__$1 = G__7132; +continue; +} +} +} else +{{ +var G__7133 = (i + 1); +var G__7134 = init__$1; +i = G__7133; +init__$1 = G__7134; +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) & 0x01f);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) & 0x01f);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) & 0x01f);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) & 0x01f);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__7135 = (i + 2); +i = G__7135; +continue; +} +} +} else +{return -1; +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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) & 0x01f)),[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) & 0x01f)),[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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7136 = (j + 2); +j = G__7136; +continue; +} +} +} else +{{ +var G__7137 = (j + 2); +j = G__7137; +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; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7138 = (j + 1); +j = G__7138; +continue; +} +} +} else +{{ +var G__7139 = (j + 1); +j = G__7139; +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; +})() +; + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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 obj7142 = {};return obj7142; +})(),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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7143 = null; +var G__7143__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__7143__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__7143 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7143__2.call(this,self__,k); +case 3: +return G__7143__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7143; +})() +; +cljs.core.PersistentHashMap.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.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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentHashMap(self__.meta,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__7144 = (i + 1); +var G__7145 = cljs.core._assoc_BANG_.call(null,out,(ks[i]),(vs[i])); +i = G__7144; +out = G__7145; +continue; +} +} else +{return cljs.core.persistent_BANG_.call(null,out); +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7146 = o;if(G__7146) +{var bit__4190__auto__ = (G__7146.cljs$lang$protocol_mask$partition0$ & 2048);if((bit__4190__auto__) || (G__7146.cljs$core$IMapEntry$)) +{return true; +} else +{if((!G__7146.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__7146); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMapEntry,G__7146); +} +})()) +{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__7147 = cljs.core.next.call(null,es); +var G__7148 = tcoll__$1.assoc_BANG_(cljs.core.key.call(null,e),cljs.core.val.call(null,e)); +es = G__7147; +tcoll__$1 = G__7148; +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__7149 = ((ascending_QMARK_)?t.left:t.right); +var G__7150 = cljs.core.conj.call(null,stack__$1,t); +t = G__7149; +stack__$1 = G__7150; +continue; +} +} else +{return stack__$1; +} +break; +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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; +} +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7152 = null; +var G__7152__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__7152__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__7152 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7152__2.call(this,self__,k); +case 3: +return G__7152__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7152; +})() +; +cljs.core.BlackNode.prototype.apply = (function (self__,args7151){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7151))); +}); +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)); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7154 = null; +var G__7154__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__7154__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__7154 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7154__2.call(this,self__,k); +case 3: +return G__7154__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7154; +})() +; +cljs.core.RedNode.prototype.apply = (function (self__,args7153){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7153))); +}); +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; +} +} +} +}); + +/** +* @constructor +*/ +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$partition0$ = 418776847; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.PersistentTreeMap.cljs$lang$type = true; +cljs.core.PersistentTreeMap.cljs$lang$ctorStr = "cljs.core/PersistentTreeMap"; +cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_imap.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7156 = null; +var G__7156__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__7156__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__7156 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7156__2.call(this,self__,k); +case 3: +return G__7156__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7156; +})() +; +cljs.core.PersistentTreeMap.prototype.apply = (function (self__,args7155){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7155))); +}); +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.toString = (function (){var self__ = this; +var coll = this;return cljs.core.pr_str_STAR_.call(null,coll); +}); +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__7157 = t.left; +t = G__7157; +continue; +} +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{{ +var G__7158 = t.right; +t = G__7158; +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__7159 = cljs.core.conj.call(null,stack,t); +var G__7160 = t.left; +stack = G__7159; +t = G__7160; +continue; +} +} else +{{ +var G__7161 = stack; +var G__7162 = t.right; +stack = G__7161; +t = G__7162; +continue; +} +} +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{if((c > 0)) +{{ +var G__7163 = cljs.core.conj.call(null,stack,t); +var G__7164 = t.right; +stack = G__7163; +t = G__7164; +continue; +} +} else +{{ +var G__7165 = stack; +var G__7166 = t.left; +stack = G__7165; +t = G__7166; +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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentTreeMap(self__.comp,self__.tree,self__.cnt,self__.meta,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)); +/** +* keyval => key val +* Returns a new hash map with supplied mappings. +* @param {...*} var_args +*/ +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__7167 = cljs.core.nnext.call(null,in$); +var G__7168 = cljs.core.assoc_BANG_.call(null,out,cljs.core.first.call(null,in$),cljs.core.second.call(null,in$)); +in$ = G__7167; +out = G__7168; +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__7169){ +var keyvals = cljs.core.seq(arglist__7169); +return hash_map__delegate(keyvals); +}); +hash_map.cljs$core$IFn$_invoke$arity$variadic = hash_map__delegate; +return hash_map; +})() +; +/** +* keyval => key val +* Returns a new array map with supplied mappings. +* @param {...*} var_args +*/ +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__7170){ +var keyvals = cljs.core.seq(arglist__7170); +return array_map__delegate(keyvals); +}); +array_map.cljs$core$IFn$_invoke$arity$variadic = array_map__delegate; +return array_map; +})() +; +/** +* keyval => key val +* Returns a new object map with supplied mappings. +* @param {...*} var_args +*/ +cljs.core.obj_map = (function() { +var obj_map__delegate = function (keyvals){var ks = [];var obj = (function (){var obj7174 = {};return obj7174; +})();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__7175 = cljs.core.nnext.call(null,kvs); +kvs = G__7175; +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__7176){ +var keyvals = cljs.core.seq(arglist__7176); +return obj_map__delegate(keyvals); +}); +obj_map.cljs$core$IFn$_invoke$arity$variadic = obj_map__delegate; +return obj_map; +})() +; +/** +* keyval => key val +* Returns a new sorted map with supplied mappings. +* @param {...*} var_args +*/ +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__7177 = cljs.core.nnext.call(null,in$); +var G__7178 = cljs.core.assoc.call(null,out,cljs.core.first.call(null,in$),cljs.core.second.call(null,in$)); +in$ = G__7177; +out = G__7178; +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__7179){ +var keyvals = cljs.core.seq(arglist__7179); +return sorted_map__delegate(keyvals); +}); +sorted_map.cljs$core$IFn$_invoke$arity$variadic = sorted_map__delegate; +return sorted_map; +})() +; +/** +* keyval => key val +* Returns a new sorted map with supplied mappings, using the supplied comparator. +* @param {...*} var_args +*/ +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__7180 = cljs.core.nnext.call(null,in$); +var G__7181 = cljs.core.assoc.call(null,out,cljs.core.first.call(null,in$),cljs.core.second.call(null,in$)); +in$ = G__7180; +out = G__7181; +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__7182){ +var comparator = cljs.core.first(arglist__7182); +var keyvals = cljs.core.rest(arglist__7182); +return sorted_map_by__delegate(comparator,keyvals); +}); +sorted_map_by.cljs$core$IFn$_invoke$arity$variadic = sorted_map_by__delegate; +return sorted_map_by; +})() +; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7183 = self__.mseq;if(G__7183) +{var bit__4190__auto__ = (G__7183.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__7183.cljs$core$INext$)) +{return true; +} else +{if((!G__7183.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7183); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7183); +} +})())?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__7184 = self__.mseq;if(G__7184) +{var bit__4190__auto__ = (G__7184.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__7184.cljs$core$INext$)) +{return true; +} else +{if((!G__7184.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7184); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7184); +} +})())?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)); +}); +/** +* Returns a sequence of the map's keys. +*/ +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; +} +}); +/** +* Returns the key of the map entry. +*/ +cljs.core.key = (function key(map_entry){return cljs.core._key.call(null,map_entry); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7185 = self__.mseq;if(G__7185) +{var bit__4190__auto__ = (G__7185.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__7185.cljs$core$INext$)) +{return true; +} else +{if((!G__7185.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7185); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7185); +} +})())?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__7186 = self__.mseq;if(G__7186) +{var bit__4190__auto__ = (G__7186.cljs$lang$protocol_mask$partition0$ & 128);if((bit__4190__auto__) || (G__7186.cljs$core$INext$)) +{return true; +} else +{if((!G__7186.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7186); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.INext,G__7186); +} +})())?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)); +}); +/** +* Returns a sequence of the map's values. +*/ +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; +} +}); +/** +* Returns the value in the map entry. +*/ +cljs.core.val = (function val(map_entry){return cljs.core._val.call(null,map_entry); +}); +/** +* Returns a map that consists of the rest of the maps conj-ed onto +* the first. If a key occurs in more than one map, the mapping from +* the latter (left-to-right) will be the mapping in the result. +* @param {...*} var_args +*/ +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__7187_SHARP_,p2__7188_SHARP_){return cljs.core.conj.call(null,(function (){var or__3540__auto__ = p1__7187_SHARP_;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return cljs.core.PersistentArrayMap.EMPTY; +} +})(),p2__7188_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__7189){ +var maps = cljs.core.seq(arglist__7189); +return merge__delegate(maps); +}); +merge.cljs$core$IFn$_invoke$arity$variadic = merge__delegate; +return merge; +})() +; +/** +* Returns a map that consists of the rest of the maps conj-ed onto +* the first. If a key occurs in more than one map, the mapping(s) +* from the latter (left-to-right) will be combined with the mapping in +* the result by calling (f val-in-result val-in-latter). +* @param {...*} var_args +*/ +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__3540__auto__ = m1;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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__7190){ +var f = cljs.core.first(arglist__7190); +var maps = cljs.core.rest(arglist__7190); +return merge_with__delegate(f,maps); +}); +merge_with.cljs$core$IFn$_invoke$arity$variadic = merge_with__delegate; +return merge_with; +})() +; +/** +* Returns a map containing only those entries in map whose key is in keys +*/ +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__7191 = ((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__7192 = cljs.core.next.call(null,keys); +ret = G__7191; +keys = G__7192; +continue; +} +} else +{return ret; +} +break; +} +}); + +/** +* @constructor +*/ +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$ = 8196; +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_iset.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7195 = null; +var G__7195__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__7195__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__7195 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7195__2.call(this,self__,k); +case 3: +return G__7195__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7195; +})() +; +cljs.core.PersistentHashSet.prototype.apply = (function (self__,args7194){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7194))); +}); +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__7193_SHARP_){return cljs.core.contains_QMARK_.call(null,coll__$1,p1__7193_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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentHashSet(self__.meta,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__7196 = (i + 1); +var G__7197 = cljs.core._assoc_BANG_.call(null,out,(items[i]),null); +i = G__7196; +out = G__7197; +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__7198 = (i + 1); +var G__7199 = cljs.core._conj_BANG_.call(null,out,(items[i])); +i = G__7198; +out = G__7199; +continue; +} +} else +{return cljs.core._persistent_BANG_.call(null,out); +} +break; +} +} +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__auto__,"cljs.core/TransientHashSet"); +}); +cljs.core.TransientHashSet.prototype.call = (function() { +var G__7201 = null; +var G__7201__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__7201__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__7201 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7201__2.call(this,self__,k); +case 3: +return G__7201__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7201; +})() +; +cljs.core.TransientHashSet.prototype.apply = (function (self__,args7200){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7200))); +}); +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)); +}); + +/** +* @constructor +*/ +cljs.core.PersistentTreeSet = (function (meta,tree_map,__hash){ +this.meta = meta; +this.tree_map = tree_map; +this.__hash = __hash; +this.cljs$lang$protocol_mask$partition0$ = 417730831; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.PersistentTreeSet.cljs$lang$type = true; +cljs.core.PersistentTreeSet.cljs$lang$ctorStr = "cljs.core/PersistentTreeSet"; +cljs.core.PersistentTreeSet.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_iset.call(null,coll__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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__7204 = null; +var G__7204__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__7204__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__7204 = function(self__,k,not_found){ +switch(arguments.length){ +case 2: +return G__7204__2.call(this,self__,k); +case 3: +return G__7204__3.call(this,self__,k,not_found); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +return G__7204; +})() +; +cljs.core.PersistentTreeSet.prototype.apply = (function (self__,args7203){var self__ = this; +var self____$1 = this;return self____$1.call.apply(self____$1,[self____$1].concat(cljs.core.aclone.call(null,args7203))); +}); +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__7202_SHARP_){return cljs.core.contains_QMARK_.call(null,coll__$1,p1__7202_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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.PersistentTreeSet(self__.meta,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__4382__auto__ = arr;var i = 0;var res = cljs.core._as_transient.call(null,cljs.core.PersistentHashSet.EMPTY);while(true){ +if((i < a__4382__auto__.length)) +{{ +var G__7205 = (i + 1); +var G__7206 = cljs.core._conj_BANG_.call(null,res,(arr[i])); +i = G__7205; +res = G__7206; +continue; +} +} else +{return res; +} +break; +} +})();return cljs.core._persistent_BANG_.call(null,ret); +}); +/** +* Returns a set of the distinct elements of coll. +*/ +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__7207 = cljs.core._next.call(null,in$__$1); +var G__7208 = cljs.core._conj_BANG_.call(null,out,cljs.core._first.call(null,in$__$1)); +in$__$1 = G__7207; +out = G__7208; +continue; +} +} else +{return cljs.core._persistent_BANG_.call(null,out); +} +break; +} +} else +{return null; +} +} +} +}); +/** +* @param {...*} var_args +*/ +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__7209__delegate = function (keys){return cljs.core.set.call(null,keys); +}; +var G__7209 = function (var_args){ +var keys = null;if (arguments.length > 0) { + keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__7209__delegate.call(this,keys);}; +G__7209.cljs$lang$maxFixedArity = 0; +G__7209.cljs$lang$applyTo = (function (arglist__7210){ +var keys = cljs.core.seq(arglist__7210); +return G__7209__delegate(keys); +}); +G__7209.cljs$core$IFn$_invoke$arity$variadic = G__7209__delegate; +return G__7209; +})() +; +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; +})() +; +/** +* Returns a new sorted set with supplied keys. +* @param {...*} var_args +*/ +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__7211){ +var keys = cljs.core.seq(arglist__7211); +return sorted_set__delegate(keys); +}); +sorted_set.cljs$core$IFn$_invoke$arity$variadic = sorted_set__delegate; +return sorted_set; +})() +; +/** +* Returns a new sorted set with supplied keys, using the supplied comparator. +* @param {...*} var_args +*/ +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__7212){ +var comparator = cljs.core.first(arglist__7212); +var keys = cljs.core.rest(arglist__7212); +return sorted_set_by__delegate(comparator,keys); +}); +sorted_set_by.cljs$core$IFn$_invoke$arity$variadic = sorted_set_by__delegate; +return sorted_set_by; +})() +; +/** +* Given a map of replacement pairs and a vector/collection, returns a +* vector/seq with any elements = a key in smap replaced with the +* corresponding val in smap +*/ +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__7213_SHARP_){var temp__4090__auto__ = cljs.core.find.call(null,smap,p1__7213_SHARP_);if(cljs.core.truth_(temp__4090__auto__)) +{var e = temp__4090__auto__;return cljs.core.second.call(null,e); +} else +{return p1__7213_SHARP_; +} +}),coll); +} +}); +/** +* Returns a lazy sequence of the elements of coll with duplicates removed +*/ +cljs.core.distinct = (function distinct(coll){var step = (function step(xs,seen){return (new cljs.core.LazySeq(null,(function (){return (function (p__7220,seen__$1){while(true){ +var vec__7221 = p__7220;var f = cljs.core.nth.call(null,vec__7221,0,null);var xs__$1 = vec__7221;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__7222 = cljs.core.rest.call(null,s); +var G__7223 = seen__$1; +p__7220 = G__7222; +seen__$1 = G__7223; +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__7224 = cljs.core.conj.call(null,ret,cljs.core.first.call(null,s__$1)); +var G__7225 = cljs.core.next.call(null,s__$1); +ret = G__7224; +s__$1 = G__7225; +continue; +} +} else +{return cljs.core.seq.call(null,ret); +} +break; +} +}); +/** +* Returns the name String of a string, symbol or keyword. +*/ +cljs.core.name = (function name(x){if((function (){var G__7227 = x;if(G__7227) +{var bit__4183__auto__ = (G__7227.cljs$lang$protocol_mask$partition1$ & 4096);if((bit__4183__auto__) || (G__7227.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(''))); +} +} +}); +/** +* Returns a map with the keys mapped to the corresponding vals. +*/ +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__7228 = cljs.core.assoc_BANG_.call(null,map,cljs.core.first.call(null,ks),cljs.core.first.call(null,vs)); +var G__7229 = cljs.core.next.call(null,ks); +var G__7230 = cljs.core.next.call(null,vs); +map = G__7228; +ks = G__7229; +vs = G__7230; +continue; +} +} else +{return cljs.core.persistent_BANG_.call(null,map); +} +break; +} +}); +/** +* Returns the x for which (k x), a number, is greatest. +* @param {...*} var_args +*/ +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__7233__delegate = function (k,x,y,more){return cljs.core.reduce.call(null,(function (p1__7231_SHARP_,p2__7232_SHARP_){return max_key.call(null,k,p1__7231_SHARP_,p2__7232_SHARP_); +}),max_key.call(null,k,x,y),more); +}; +var G__7233 = 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__7233__delegate.call(this,k,x,y,more);}; +G__7233.cljs$lang$maxFixedArity = 3; +G__7233.cljs$lang$applyTo = (function (arglist__7234){ +var k = cljs.core.first(arglist__7234); +arglist__7234 = cljs.core.next(arglist__7234); +var x = cljs.core.first(arglist__7234); +arglist__7234 = cljs.core.next(arglist__7234); +var y = cljs.core.first(arglist__7234); +var more = cljs.core.rest(arglist__7234); +return G__7233__delegate(k,x,y,more); +}); +G__7233.cljs$core$IFn$_invoke$arity$variadic = G__7233__delegate; +return G__7233; +})() +; +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; +})() +; +/** +* Returns the x for which (k x), a number, is least. +* @param {...*} var_args +*/ +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__7237__delegate = function (k,x,y,more){return cljs.core.reduce.call(null,(function (p1__7235_SHARP_,p2__7236_SHARP_){return min_key.call(null,k,p1__7235_SHARP_,p2__7236_SHARP_); +}),min_key.call(null,k,x,y),more); +}; +var G__7237 = 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__7237__delegate.call(this,k,x,y,more);}; +G__7237.cljs$lang$maxFixedArity = 3; +G__7237.cljs$lang$applyTo = (function (arglist__7238){ +var k = cljs.core.first(arglist__7238); +arglist__7238 = cljs.core.next(arglist__7238); +var x = cljs.core.first(arglist__7238); +arglist__7238 = cljs.core.next(arglist__7238); +var y = cljs.core.first(arglist__7238); +var more = cljs.core.rest(arglist__7238); +return G__7237__delegate(k,x,y,more); +}); +G__7237.cljs$core$IFn$_invoke$arity$variadic = G__7237__delegate; +return G__7237; +})() +; +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; +})() +; +/** +* Returns a lazy sequence of lists like partition, but may include +* partitions with fewer than n items at the end. +*/ +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; +})() +; +/** +* Returns a lazy sequence of successive items from coll while +* (pred item) returns true. pred must be free of side-effects. +*/ +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); +}); +}); +/** +* sc must be a sorted collection, test(s) one of <, <=, > or +* >=. Returns a seq of those entries with keys ek for +* which (test (.. sc comparator (compare ek key)) 0) is true +*/ +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__7241 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__7241,0,null);var s = vec__7241;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__7242 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__7242,0,null);var s = vec__7242;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; +})() +; +/** +* sc must be a sorted collection, test(s) one of <, <=, > or +* >=. Returns a reverse seq of those entries with keys ek for +* which (test (.. sc comparator (compare ek key)) 0) is true +*/ +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__7245 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__7245,0,null);var s = vec__7245;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__7246 = temp__4092__auto__;var e = cljs.core.nth.call(null,vec__7246,0,null);var s = vec__7246;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; +})() +; + +/** +* @constructor +*/ +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$partition0$ = 32375006; +this.cljs$lang$protocol_mask$partition1$ = 8192; +}) +cljs.core.Range.cljs$lang$type = true; +cljs.core.Range.cljs$lang$ctorStr = "cljs.core/Range"; +cljs.core.Range.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__3951__auto__ = self__.__hash;if(!((h__3951__auto__ == null))) +{return h__3951__auto__; +} else +{var h__3951__auto____$1 = cljs.core.hash_coll.call(null,rng__$1);self__.__hash = h__3951__auto____$1; +return h__3951__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$ICloneable$_clone$arity$1 = (function (_){var self__ = this; +var ___$1 = this;return (new cljs.core.Range(self__.meta,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)); +}); +/** +* Returns a lazy seq of nums from start (inclusive) to end +* (exclusive), by step, where start defaults to 0, step to 1, +* and end to infinity. +*/ +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; +})() +; +/** +* Returns a lazy seq of every nth item in coll. +*/ +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)); +}); +/** +* Returns a vector of [(take-while pred coll) (drop-while pred coll)] +*/ +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); +}); +/** +* Applies f to each value in coll, splitting it each time f returns +* a new value. Returns a lazy seq of partitions. +*/ +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__7247_SHARP_){return cljs.core._EQ_.call(null,fv,f.call(null,p1__7247_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)); +}); +/** +* Returns a map from distinct items in coll to the number of times +* they appear. +*/ +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)); +}); +/** +* Returns a lazy seq of the intermediate values of the reduction (as +* per reduce) of coll by f, starting with init. +*/ +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; +})() +; +/** +* Takes a set of functions and returns a fn that is the juxtaposition +* of those fns. The returned fn takes a variable number of args, and +* returns a vector containing the result of applying each fn to the +* args (left-to-right). +* ((juxt a b c) x) => [(a x) (b x) (c x)] +* @param {...*} var_args +*/ +cljs.core.juxt = (function() { +var juxt = null; +var juxt__1 = (function (f){return (function() { +var G__7258 = null; +var G__7258__0 = (function (){return (new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[f.call(null)],null)); +}); +var G__7258__1 = (function (x){return (new cljs.core.PersistentVector(null,1,5,cljs.core.PersistentVector.EMPTY_NODE,[f.call(null,x)],null)); +}); +var G__7258__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__7258__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__7258__4 = (function() { +var G__7259__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__7259 = 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__7259__delegate.call(this,x,y,z,args);}; +G__7259.cljs$lang$maxFixedArity = 3; +G__7259.cljs$lang$applyTo = (function (arglist__7260){ +var x = cljs.core.first(arglist__7260); +arglist__7260 = cljs.core.next(arglist__7260); +var y = cljs.core.first(arglist__7260); +arglist__7260 = cljs.core.next(arglist__7260); +var z = cljs.core.first(arglist__7260); +var args = cljs.core.rest(arglist__7260); +return G__7259__delegate(x,y,z,args); +}); +G__7259.cljs$core$IFn$_invoke$arity$variadic = G__7259__delegate; +return G__7259; +})() +; +G__7258 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__7258__0.call(this); +case 1: +return G__7258__1.call(this,x); +case 2: +return G__7258__2.call(this,x,y); +case 3: +return G__7258__3.call(this,x,y,z); +default: +return G__7258__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__7258.cljs$lang$maxFixedArity = 3; +G__7258.cljs$lang$applyTo = G__7258__4.cljs$lang$applyTo; +return G__7258; +})() +}); +var juxt__2 = (function (f,g){return (function() { +var G__7261 = null; +var G__7261__0 = (function (){return (new cljs.core.PersistentVector(null,2,5,cljs.core.PersistentVector.EMPTY_NODE,[f.call(null),g.call(null)],null)); +}); +var G__7261__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__7261__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__7261__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__7261__4 = (function() { +var G__7262__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__7262 = 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__7262__delegate.call(this,x,y,z,args);}; +G__7262.cljs$lang$maxFixedArity = 3; +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); +arglist__7263 = cljs.core.next(arglist__7263); +var z = cljs.core.first(arglist__7263); +var args = cljs.core.rest(arglist__7263); +return G__7262__delegate(x,y,z,args); +}); +G__7262.cljs$core$IFn$_invoke$arity$variadic = G__7262__delegate; +return G__7262; +})() +; +G__7261 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__7261__0.call(this); +case 1: +return G__7261__1.call(this,x); +case 2: +return G__7261__2.call(this,x,y); +case 3: +return G__7261__3.call(this,x,y,z); +default: +return G__7261__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__7261.cljs$lang$maxFixedArity = 3; +G__7261.cljs$lang$applyTo = G__7261__4.cljs$lang$applyTo; +return G__7261; +})() +}); +var juxt__3 = (function (f,g,h){return (function() { +var G__7264 = null; +var G__7264__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__7264__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__7264__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__7264__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__7264__4 = (function() { +var G__7265__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__7265 = 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__7265__delegate.call(this,x,y,z,args);}; +G__7265.cljs$lang$maxFixedArity = 3; +G__7265.cljs$lang$applyTo = (function (arglist__7266){ +var x = cljs.core.first(arglist__7266); +arglist__7266 = cljs.core.next(arglist__7266); +var y = cljs.core.first(arglist__7266); +arglist__7266 = cljs.core.next(arglist__7266); +var z = cljs.core.first(arglist__7266); +var args = cljs.core.rest(arglist__7266); +return G__7265__delegate(x,y,z,args); +}); +G__7265.cljs$core$IFn$_invoke$arity$variadic = G__7265__delegate; +return G__7265; +})() +; +G__7264 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__7264__0.call(this); +case 1: +return G__7264__1.call(this,x); +case 2: +return G__7264__2.call(this,x,y); +case 3: +return G__7264__3.call(this,x,y,z); +default: +return G__7264__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__7264.cljs$lang$maxFixedArity = 3; +G__7264.cljs$lang$applyTo = G__7264__4.cljs$lang$applyTo; +return G__7264; +})() +}); +var juxt__4 = (function() { +var G__7267__delegate = function (f,g,h,fs){var fs__$1 = cljs.core.list_STAR_.call(null,f,g,h,fs);return (function() { +var G__7268 = null; +var G__7268__0 = (function (){return cljs.core.reduce.call(null,(function (p1__7248_SHARP_,p2__7249_SHARP_){return cljs.core.conj.call(null,p1__7248_SHARP_,p2__7249_SHARP_.call(null)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__7268__1 = (function (x){return cljs.core.reduce.call(null,(function (p1__7250_SHARP_,p2__7251_SHARP_){return cljs.core.conj.call(null,p1__7250_SHARP_,p2__7251_SHARP_.call(null,x)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__7268__2 = (function (x,y){return cljs.core.reduce.call(null,(function (p1__7252_SHARP_,p2__7253_SHARP_){return cljs.core.conj.call(null,p1__7252_SHARP_,p2__7253_SHARP_.call(null,x,y)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__7268__3 = (function (x,y,z){return cljs.core.reduce.call(null,(function (p1__7254_SHARP_,p2__7255_SHARP_){return cljs.core.conj.call(null,p1__7254_SHARP_,p2__7255_SHARP_.call(null,x,y,z)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}); +var G__7268__4 = (function() { +var G__7269__delegate = function (x,y,z,args){return cljs.core.reduce.call(null,(function (p1__7256_SHARP_,p2__7257_SHARP_){return cljs.core.conj.call(null,p1__7256_SHARP_,cljs.core.apply.call(null,p2__7257_SHARP_,x,y,z,args)); +}),cljs.core.PersistentVector.EMPTY,fs__$1); +}; +var G__7269 = 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__7269__delegate.call(this,x,y,z,args);}; +G__7269.cljs$lang$maxFixedArity = 3; +G__7269.cljs$lang$applyTo = (function (arglist__7270){ +var x = cljs.core.first(arglist__7270); +arglist__7270 = cljs.core.next(arglist__7270); +var y = cljs.core.first(arglist__7270); +arglist__7270 = cljs.core.next(arglist__7270); +var z = cljs.core.first(arglist__7270); +var args = cljs.core.rest(arglist__7270); +return G__7269__delegate(x,y,z,args); +}); +G__7269.cljs$core$IFn$_invoke$arity$variadic = G__7269__delegate; +return G__7269; +})() +; +G__7268 = function(x,y,z,var_args){ +var args = var_args; +switch(arguments.length){ +case 0: +return G__7268__0.call(this); +case 1: +return G__7268__1.call(this,x); +case 2: +return G__7268__2.call(this,x,y); +case 3: +return G__7268__3.call(this,x,y,z); +default: +return G__7268__4.cljs$core$IFn$_invoke$arity$variadic(x,y,z, cljs.core.array_seq(arguments, 3)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +G__7268.cljs$lang$maxFixedArity = 3; +G__7268.cljs$lang$applyTo = G__7268__4.cljs$lang$applyTo; +return G__7268; +})() +}; +var G__7267 = 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__7267__delegate.call(this,f,g,h,fs);}; +G__7267.cljs$lang$maxFixedArity = 3; +G__7267.cljs$lang$applyTo = (function (arglist__7271){ +var f = cljs.core.first(arglist__7271); +arglist__7271 = cljs.core.next(arglist__7271); +var g = cljs.core.first(arglist__7271); +arglist__7271 = cljs.core.next(arglist__7271); +var h = cljs.core.first(arglist__7271); +var fs = cljs.core.rest(arglist__7271); +return G__7267__delegate(f,g,h,fs); +}); +G__7267.cljs$core$IFn$_invoke$arity$variadic = G__7267__delegate; +return G__7267; +})() +; +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; +})() +; +/** +* When lazy sequences are produced via functions that have side +* effects, any effects other than those needed to produce the first +* element in the seq do not occur until the seq is consumed. dorun can +* be used to force any effects. Walks through the successive nexts of +* the seq, does not retain the head and returns nil. +*/ +cljs.core.dorun = (function() { +var dorun = null; +var dorun__1 = (function (coll){while(true){ +if(cljs.core.seq.call(null,coll)) +{{ +var G__7272 = cljs.core.next.call(null,coll); +coll = G__7272; +continue; +} +} else +{return null; +} +break; +} +}); +var dorun__2 = (function (n,coll){while(true){ +if((cljs.core.seq.call(null,coll)) && ((n > 0))) +{{ +var G__7273 = (n - 1); +var G__7274 = cljs.core.next.call(null,coll); +n = G__7273; +coll = G__7274; +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; +})() +; +/** +* When lazy sequences are produced via functions that have side +* effects, any effects other than those needed to produce the first +* element in the seq do not occur until the seq is consumed. doall can +* be used to force any effects. Walks through the successive nexts of +* the seq, retains the head and returns it, thus causing the entire +* seq to reside in memory at one time. +*/ +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); +}); +/** +* Returns the result of (re-find re s) if re fully matches s. +*/ +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; +} +}); +/** +* Returns the first regex match, if any, of s to re, using +* re.exec(s). Returns a vector, containing first the matching +* substring, then any capturing groups if the regular expression contains +* capturing groups. +*/ +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); +} +} +}); +/** +* Returns a lazy sequence of successive matches of re in s. +*/ +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; +} +}); +/** +* Returns an instance of RegExp which has compiled the provided string. +*/ +cljs.core.re_pattern = (function re_pattern(s){var vec__7276 = cljs.core.re_find.call(null,/^(?:\(\?([idmsux]*)\))?(.*)/,s);var _ = cljs.core.nth.call(null,vec__7276,0,null);var flags = cljs.core.nth.call(null,vec__7276,1,null);var pattern = cljs.core.nth.call(null,vec__7276,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_7278 = 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_7279__$1 = cljs.core.next.call(null,coll);var n_7280 = new cljs.core.Keyword(null,"print-length","print-length",3960797560).cljs$core$IFn$_invoke$arity$1(opts);while(true){ +if((coll_7279__$1) && (((n_7280 == null)) || (!((n_7280 === 0))))) +{cljs.core._write.call(null,writer,sep); +print_one.call(null,cljs.core.first.call(null,coll_7279__$1),writer,opts); +{ +var G__7281 = cljs.core.next.call(null,coll_7279__$1); +var G__7282 = (n_7280 - 1); +coll_7279__$1 = G__7281; +n_7280 = G__7282; +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_7278; +}}); +/** +* @param {...*} var_args +*/ +cljs.core.write_all = (function() { +var write_all__delegate = function (writer,ss){var seq__7287 = cljs.core.seq.call(null,ss);var chunk__7288 = null;var count__7289 = 0;var i__7290 = 0;while(true){ +if((i__7290 < count__7289)) +{var s = cljs.core._nth.call(null,chunk__7288,i__7290);cljs.core._write.call(null,writer,s); +{ +var G__7291 = seq__7287; +var G__7292 = chunk__7288; +var G__7293 = count__7289; +var G__7294 = (i__7290 + 1); +seq__7287 = G__7291; +chunk__7288 = G__7292; +count__7289 = G__7293; +i__7290 = G__7294; +continue; +} +} else +{var temp__4092__auto__ = cljs.core.seq.call(null,seq__7287);if(temp__4092__auto__) +{var seq__7287__$1 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,seq__7287__$1)) +{var c__4288__auto__ = cljs.core.chunk_first.call(null,seq__7287__$1);{ +var G__7295 = cljs.core.chunk_rest.call(null,seq__7287__$1); +var G__7296 = c__4288__auto__; +var G__7297 = cljs.core.count.call(null,c__4288__auto__); +var G__7298 = 0; +seq__7287 = G__7295; +chunk__7288 = G__7296; +count__7289 = G__7297; +i__7290 = G__7298; +continue; +} +} else +{var s = cljs.core.first.call(null,seq__7287__$1);cljs.core._write.call(null,writer,s); +{ +var G__7299 = cljs.core.next.call(null,seq__7287__$1); +var G__7300 = null; +var G__7301 = 0; +var G__7302 = 0; +seq__7287 = G__7299; +chunk__7288 = G__7300; +count__7289 = G__7301; +i__7290 = G__7302; +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__7303){ +var writer = cljs.core.first(arglist__7303); +var ss = cljs.core.rest(arglist__7303); +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 obj7305 = {"\"":"\\\"","\\":"\\\\","\b":"\\b","\f":"\\f","\n":"\\n","\r":"\\r","\t":"\\t"};return obj7305; +})(); +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(''); +}); +/** +* Prefer this to pr-seq, because it makes the printing function +* configurable, allowing efficient implementations such as appending +* to a StringBuffer. +*/ +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,"#"); +} else +{if(new cljs.core.Keyword(null,"else","else",1017020587)) +{if(cljs.core.truth_((function (){var and__3528__auto__ = cljs.core.get.call(null,opts,new cljs.core.Keyword(null,"meta","meta",1017252215));if(cljs.core.truth_(and__3528__auto__)) +{var and__3528__auto____$1 = (function (){var G__7311 = obj;if(G__7311) +{var bit__4190__auto__ = (G__7311.cljs$lang$protocol_mask$partition0$ & 131072);if((bit__4190__auto__) || (G__7311.cljs$core$IMeta$)) +{return true; +} else +{if((!G__7311.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__7311); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IMeta,G__7311); +} +})();if(and__3528__auto____$1) +{return cljs.core.meta.call(null,obj); +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__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__7312 = obj;if(G__7312) +{var bit__4183__auto__ = (G__7312.cljs$lang$protocol_mask$partition0$ & 2147483648);if((bit__4183__auto__) || (G__7312.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,"#<",[cljs.core.str(obj)].join(''),">"); +} else +{if((obj instanceof Date)) +{var normalize = (function (n,len){var ns = [cljs.core.str(n)].join('');while(true){ +if((cljs.core.count.call(null,ns) < len)) +{{ +var G__7314 = [cljs.core.str("0"),cljs.core.str(ns)].join(''); +ns = G__7314; +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__7313 = obj;if(G__7313) +{var bit__4190__auto__ = (G__7313.cljs$lang$protocol_mask$partition0$ & 2147483648);if((bit__4190__auto__) || (G__7313.cljs$core$IPrintWithWriter$)) +{return true; +} else +{if((!G__7313.cljs$lang$protocol_mask$partition0$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IPrintWithWriter,G__7313); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IPrintWithWriter,G__7313); +} +})()) +{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,"#<",[cljs.core.str(obj)].join(''),">"); +} else +{return null; +} +} +} +} +} +} +} +} +} +} +} +} +} else +{return null; +} +} +} +}); +cljs.core.pr_seq_writer = (function pr_seq_writer(objs,writer,opts){cljs.core.pr_writer.call(null,cljs.core.first.call(null,objs),writer,opts); +var seq__7319 = cljs.core.seq.call(null,cljs.core.next.call(null,objs));var chunk__7320 = null;var count__7321 = 0;var i__7322 = 0;while(true){ +if((i__7322 < count__7321)) +{var obj = cljs.core._nth.call(null,chunk__7320,i__7322);cljs.core._write.call(null,writer," "); +cljs.core.pr_writer.call(null,obj,writer,opts); +{ +var G__7323 = seq__7319; +var G__7324 = chunk__7320; +var G__7325 = count__7321; +var G__7326 = (i__7322 + 1); +seq__7319 = G__7323; +chunk__7320 = G__7324; +count__7321 = G__7325; +i__7322 = G__7326; +continue; +} +} else +{var temp__4092__auto__ = cljs.core.seq.call(null,seq__7319);if(temp__4092__auto__) +{var seq__7319__$1 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,seq__7319__$1)) +{var c__4288__auto__ = cljs.core.chunk_first.call(null,seq__7319__$1);{ +var G__7327 = cljs.core.chunk_rest.call(null,seq__7319__$1); +var G__7328 = c__4288__auto__; +var G__7329 = cljs.core.count.call(null,c__4288__auto__); +var G__7330 = 0; +seq__7319 = G__7327; +chunk__7320 = G__7328; +count__7321 = G__7329; +i__7322 = G__7330; +continue; +} +} else +{var obj = cljs.core.first.call(null,seq__7319__$1);cljs.core._write.call(null,writer," "); +cljs.core.pr_writer.call(null,obj,writer,opts); +{ +var G__7331 = cljs.core.next.call(null,seq__7319__$1); +var G__7332 = null; +var G__7333 = 0; +var G__7334 = 0; +seq__7319 = G__7331; +chunk__7320 = G__7332; +count__7321 = G__7333; +i__7322 = G__7334; +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; +}); +/** +* Prints a sequence of objects to a string, observing all the +* options given in opts +*/ +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(''); +} +}); +/** +* Same as pr-str-with-opts followed by (newline) +*/ +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(''); +} +}); +/** +* Prints a sequence of objects using string-print, observing all +* the options given in opts +*/ +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; +} +}); +/** +* pr to a string, returning it. Fundamental entrypoint to IPrintWithWriter. +* @param {...*} var_args +*/ +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__7335){ +var objs = cljs.core.seq(arglist__7335); +return pr_str__delegate(objs); +}); +pr_str.cljs$core$IFn$_invoke$arity$variadic = pr_str__delegate; +return pr_str; +})() +; +/** +* Same as pr-str followed by (newline) +* @param {...*} var_args +*/ +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__7336){ +var objs = cljs.core.seq(arglist__7336); +return prn_str__delegate(objs); +}); +prn_str.cljs$core$IFn$_invoke$arity$variadic = prn_str__delegate; +return prn_str; +})() +; +/** +* Prints the object(s) using string-print. Prints the +* object(s), separated by spaces if there is more than one. +* By default, pr and prn print in a way that objects can be +* read by the reader +* @param {...*} var_args +*/ +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__7337){ +var objs = cljs.core.seq(arglist__7337); +return pr__delegate(objs); +}); +pr.cljs$core$IFn$_invoke$arity$variadic = pr__delegate; +return pr; +})() +; +/** +* Prints the object(s) using string-print. +* print and println produce output for human consumption. +* @param {...*} var_args +*/ +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__7338){ +var objs = cljs.core.seq(arglist__7338); +return cljs_core_print__delegate(objs); +}); +cljs_core_print.cljs$core$IFn$_invoke$arity$variadic = cljs_core_print__delegate; +return cljs_core_print; +})() +; +/** +* print to a string, returning it +* @param {...*} var_args +*/ +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__7339){ +var objs = cljs.core.seq(arglist__7339); +return print_str__delegate(objs); +}); +print_str.cljs$core$IFn$_invoke$arity$variadic = print_str__delegate; +return print_str; +})() +; +/** +* Same as print followed by (newline) +* @param {...*} var_args +*/ +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__7340){ +var objs = cljs.core.seq(arglist__7340); +return println__delegate(objs); +}); +println.cljs$core$IFn$_invoke$arity$variadic = println__delegate; +return println; +})() +; +/** +* println to a string, returning it +* @param {...*} var_args +*/ +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__7341){ +var objs = cljs.core.seq(arglist__7341); +return println_str__delegate(objs); +}); +println_str.cljs$core$IFn$_invoke$arity$variadic = println_str__delegate; +return println_str; +})() +; +/** +* Same as pr followed by (newline). +* @param {...*} var_args +*/ +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__7342){ +var objs = cljs.core.seq(arglist__7342); +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.IAtom = (function (){var obj7344 = {};return obj7344; +})(); +cljs.core.IReset = (function (){var obj7346 = {};return obj7346; +})(); +cljs.core._reset_BANG_ = (function _reset_BANG_(o,new_value){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$IReset$_reset_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$IReset$_reset_BANG_$arity$2(o,new_value); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._reset_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reset_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IReset.-reset!",o); +} +} +})().call(null,o,new_value); +} +}); +cljs.core.ISwap = (function (){var obj7348 = {};return obj7348; +})(); +cljs.core._swap_BANG_ = (function() { +var _swap_BANG_ = null; +var _swap_BANG___2 = (function (o,f){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$2(o,f); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f); +} +}); +var _swap_BANG___3 = (function (o,f,a){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$3(o,f,a); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f,a); +} +}); +var _swap_BANG___4 = (function (o,f,a,b){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$4(o,f,a,b); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f,a,b); +} +}); +var _swap_BANG___5 = (function (o,f,a,b,xs){if((function (){var and__3528__auto__ = o;if(and__3528__auto__) +{return o.cljs$core$ISwap$_swap_BANG_$arity$5; +} else +{return and__3528__auto__; +} +})()) +{return o.cljs$core$ISwap$_swap_BANG_$arity$5(o,f,a,b,xs); +} else +{var x__4167__auto__ = (((o == null))?null:o);return (function (){var or__3540__auto__ = (cljs.core._swap_BANG_[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._swap_BANG_["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ISwap.-swap!",o); +} +} +})().call(null,o,f,a,b,xs); +} +}); +_swap_BANG_ = function(o,f,a,b,xs){ +switch(arguments.length){ +case 2: +return _swap_BANG___2.call(this,o,f); +case 3: +return _swap_BANG___3.call(this,o,f,a); +case 4: +return _swap_BANG___4.call(this,o,f,a,b); +case 5: +return _swap_BANG___5.call(this,o,f,a,b,xs); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +_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; +return _swap_BANG_; +})() +; + +/** +* @constructor +*/ +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$ = 16386; +}) +cljs.core.Atom.cljs$lang$type = true; +cljs.core.Atom.cljs$lang$ctorStr = "cljs.core/Atom"; +cljs.core.Atom.cljs$lang$ctorPrWriter = (function (this__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7349 = cljs.core.seq.call(null,self__.watches);var chunk__7350 = null;var count__7351 = 0;var i__7352 = 0;while(true){ +if((i__7352 < count__7351)) +{var vec__7353 = cljs.core._nth.call(null,chunk__7350,i__7352);var key = cljs.core.nth.call(null,vec__7353,0,null);var f = cljs.core.nth.call(null,vec__7353,1,null);f.call(null,key,this$__$1,oldval,newval); +{ +var G__7355 = seq__7349; +var G__7356 = chunk__7350; +var G__7357 = count__7351; +var G__7358 = (i__7352 + 1); +seq__7349 = G__7355; +chunk__7350 = G__7356; +count__7351 = G__7357; +i__7352 = G__7358; +continue; +} +} else +{var temp__4092__auto__ = cljs.core.seq.call(null,seq__7349);if(temp__4092__auto__) +{var seq__7349__$1 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,seq__7349__$1)) +{var c__4288__auto__ = cljs.core.chunk_first.call(null,seq__7349__$1);{ +var G__7359 = cljs.core.chunk_rest.call(null,seq__7349__$1); +var G__7360 = c__4288__auto__; +var G__7361 = cljs.core.count.call(null,c__4288__auto__); +var G__7362 = 0; +seq__7349 = G__7359; +chunk__7350 = G__7360; +count__7351 = G__7361; +i__7352 = G__7362; +continue; +} +} else +{var vec__7354 = cljs.core.first.call(null,seq__7349__$1);var key = cljs.core.nth.call(null,vec__7354,0,null);var f = cljs.core.nth.call(null,vec__7354,1,null);f.call(null,key,this$__$1,oldval,newval); +{ +var G__7363 = cljs.core.next.call(null,seq__7349__$1); +var G__7364 = null; +var G__7365 = 0; +var G__7366 = 0; +seq__7349 = G__7363; +chunk__7350 = G__7364; +count__7351 = G__7365; +i__7352 = G__7366; +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,"#"); +}); +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)); +}); +/** +* Creates and returns an Atom with an initial value of x and zero or +* more options (in any order): +* +* :meta metadata-map +* +* :validator validate-fn +* +* If metadata-map is supplied, it will be come the metadata on the +* atom. validate-fn must be nil or a side-effect-free fn of one +* argument, which will be passed the intended new state on any state +* change. If the new state is unacceptable, the validate-fn should +* return false or throw an Error. If either of these error conditions +* occur, then the value of the atom will not change. +* @param {...*} var_args +*/ +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__7370__delegate = function (x,p__7367){var map__7369 = p__7367;var map__7369__$1 = ((cljs.core.seq_QMARK_.call(null,map__7369))?cljs.core.apply.call(null,cljs.core.hash_map,map__7369):map__7369);var validator = cljs.core.get.call(null,map__7369__$1,new cljs.core.Keyword(null,"validator","validator",4199087812));var meta = cljs.core.get.call(null,map__7369__$1,new cljs.core.Keyword(null,"meta","meta",1017252215));return (new cljs.core.Atom(x,meta,validator,null)); +}; +var G__7370 = function (x,var_args){ +var p__7367 = null;if (arguments.length > 1) { + p__7367 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1),0);} +return G__7370__delegate.call(this,x,p__7367);}; +G__7370.cljs$lang$maxFixedArity = 1; +G__7370.cljs$lang$applyTo = (function (arglist__7371){ +var x = cljs.core.first(arglist__7371); +var p__7367 = cljs.core.rest(arglist__7371); +return G__7370__delegate(x,p__7367); +}); +G__7370.cljs$core$IFn$_invoke$arity$variadic = G__7370__delegate; +return G__7370; +})() +; +atom = function(x,var_args){ +var p__7367 = 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; +})() +; +/** +* Sets the value of atom to newval without regard for the +* current value. Returns newval. +*/ +cljs.core.reset_BANG_ = (function reset_BANG_(a,new_value){if((a instanceof cljs.core.Atom)) +{var validate = a.validator;if((validate == null)) +{} else +{if(cljs.core.truth_(validate.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 = a.state;a.state = new_value; +if((a.watches == null)) +{} else +{cljs.core._notify_watches.call(null,a,old_value,new_value); +} +return new_value; +} else +{return cljs.core._reset_BANG_.call(null,a,new_value); +} +}); +cljs.core.deref = (function deref(o){return cljs.core._deref.call(null,o); +}); +/** +* Atomically swaps the value of atom to be: +* (apply f current-value-of-atom args). Note that f may be called +* multiple times, and thus should be free of side effects. Returns +* the value that was swapped in. +* @param {...*} var_args +*/ +cljs.core.swap_BANG_ = (function() { +var swap_BANG_ = null; +var swap_BANG___2 = (function (a,f){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,f.call(null,a.state)); +} else +{return cljs.core._swap_BANG_.call(null,a,f); +} +}); +var swap_BANG___3 = (function (a,f,x){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,f.call(null,a.state,x)); +} else +{return cljs.core._swap_BANG_.call(null,a,f,x); +} +}); +var swap_BANG___4 = (function (a,f,x,y){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,f.call(null,a.state,x,y)); +} else +{return cljs.core._swap_BANG_.call(null,a,f,x,y); +} +}); +var swap_BANG___5 = (function() { +var G__7372__delegate = function (a,f,x,y,more){if((a instanceof cljs.core.Atom)) +{return cljs.core.reset_BANG_.call(null,a,cljs.core.apply.call(null,f,a.state,x,y,more)); +} else +{return cljs.core._swap_BANG_.call(null,a,f,x,y,more); +} +}; +var G__7372 = function (a,f,x,y,var_args){ +var more = null;if (arguments.length > 4) { + more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4),0);} +return G__7372__delegate.call(this,a,f,x,y,more);}; +G__7372.cljs$lang$maxFixedArity = 4; +G__7372.cljs$lang$applyTo = (function (arglist__7373){ +var a = cljs.core.first(arglist__7373); +arglist__7373 = cljs.core.next(arglist__7373); +var f = cljs.core.first(arglist__7373); +arglist__7373 = cljs.core.next(arglist__7373); +var x = cljs.core.first(arglist__7373); +arglist__7373 = cljs.core.next(arglist__7373); +var y = cljs.core.first(arglist__7373); +var more = cljs.core.rest(arglist__7373); +return G__7372__delegate(a,f,x,y,more); +}); +G__7372.cljs$core$IFn$_invoke$arity$variadic = G__7372__delegate; +return G__7372; +})() +; +swap_BANG_ = function(a,f,x,y,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); +default: +return swap_BANG___5.cljs$core$IFn$_invoke$arity$variadic(a,f,x,y, cljs.core.array_seq(arguments, 4)); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +swap_BANG_.cljs$lang$maxFixedArity = 4; +swap_BANG_.cljs$lang$applyTo = swap_BANG___5.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$variadic = swap_BANG___5.cljs$core$IFn$_invoke$arity$variadic; +return swap_BANG_; +})() +; +/** +* Atomically sets the value of atom to newval if and only if the +* current value of the atom is identical to oldval. Returns true if +* set happened, else false. +*/ +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; +} +}); +/** +* Sets the validator-fn for an atom. validator-fn must be nil or a +* side-effect-free fn of one argument, which will be passed the intended +* new state on any state change. If the new state is unacceptable, the +* validator-fn should return false or throw an Error. If the current state +* is not acceptable to the new validator, an Error will be thrown and the +* validator will not be changed. +*/ +cljs.core.set_validator_BANG_ = (function set_validator_BANG_(iref,val){return iref.validator = val; +}); +/** +* Gets the validator-fn for a var/ref/agent/atom. +*/ +cljs.core.get_validator = (function get_validator(iref){return iref.validator; +}); +/** +* Atomically sets the metadata for a namespace/var/ref/agent/atom to be: +* +* (apply f its-current-meta args) +* +* f must be free of side-effects +* @param {...*} var_args +*/ +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__7374){ +var iref = cljs.core.first(arglist__7374); +arglist__7374 = cljs.core.next(arglist__7374); +var f = cljs.core.first(arglist__7374); +var args = cljs.core.rest(arglist__7374); +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_; +})() +; +/** +* Atomically resets the metadata for an atom +*/ +cljs.core.reset_meta_BANG_ = (function reset_meta_BANG_(iref,m){return iref.meta = m; +}); +/** +* Alpha - subject to change. +* +* Adds a watch function to an atom reference. The watch fn must be a +* fn of 4 args: a key, the reference, its old-state, its +* new-state. Whenever the reference's state might have been changed, +* any registered watches will have their functions called. The watch +* fn will be called synchronously. Note that an atom's state +* may have changed again prior to the fn call, so use old/new-state +* rather than derefing the reference. Keys must be unique per +* reference, and can be used to remove the watch with remove-watch, +* but are otherwise considered opaque by the watch mechanism. Bear in +* mind that regardless of the result or action of the watch fns the +* atom's value will change. Example: +* +* (def a (atom 0)) +* (add-watch a :inc (fn [k r o n] (assert (== 0 n)))) +* (swap! a inc) +* ;; Assertion Error +* (deref a) +* ;=> 1 +*/ +cljs.core.add_watch = (function add_watch(iref,key,f){return cljs.core._add_watch.call(null,iref,key,f); +}); +/** +* Alpha - subject to change. +* +* Removes a watch (set by add-watch) from a reference +*/ +cljs.core.remove_watch = (function remove_watch(iref,key){return cljs.core._remove_watch.call(null,iref,key); +}); +cljs.core.gensym_counter = null; +/** +* Returns a new symbol with a unique name. If a prefix string is +* supplied, the name is prefix# where # is some unique number. If +* prefix is not supplied, the prefix is 'G__'. +*/ +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; + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7375){var map__7376 = p__7375;var map__7376__$1 = ((cljs.core.seq_QMARK_.call(null,map__7376))?cljs.core.apply.call(null,cljs.core.hash_map,map__7376):map__7376);var curr_state = map__7376__$1;var done = cljs.core.get.call(null,map__7376__$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)); +}); +/** +* returns true if x is a Delay created with delay +*/ +cljs.core.delay_QMARK_ = (function delay_QMARK_(x){return (x instanceof cljs.core.Delay); +}); +/** +* If x is a Delay, returns the (possibly cached) value of its expression, else returns x +*/ +cljs.core.force = (function force(x){if(cljs.core.delay_QMARK_.call(null,x)) +{return cljs.core.deref.call(null,x); +} else +{return x; +} +}); +/** +* Returns true if a value has been produced for a promise, delay, future or lazy sequence. +*/ +cljs.core.realized_QMARK_ = (function realized_QMARK_(d){return cljs.core._realized_QMARK_.call(null,d); +}); +cljs.core.IEncodeJS = (function (){var obj7378 = {};return obj7378; +})(); +cljs.core._clj__GT_js = (function _clj__GT_js(x){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._clj__GT_js[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._clj__GT_js["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEncodeJS.-clj->js",x); +} +} +})().call(null,x); +} +}); +cljs.core._key__GT_js = (function _key__GT_js(x){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IEncodeJS$_key__GT_js$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._key__GT_js[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._key__GT_js["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEncodeJS.-key->js",x); +} +} +})().call(null,x); +} +}); +cljs.core.key__GT_js = (function key__GT_js(k){if((function (){var G__7380 = k;if(G__7380) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto__ = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return G__7380.cljs$core$IEncodeJS$; +} +})())) +{return true; +} else +{if((!G__7380.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__7380); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__7380); +} +})()) +{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); +} +} +}); +/** +* Recursively transforms ClojureScript values to JavaScript. +* sets/vectors/lists become Arrays, Keywords and Symbol become Strings, +* Maps become Objects. Arbitrary keys are encoded to by key->js. +*/ +cljs.core.clj__GT_js = (function clj__GT_js(x){if((x == null)) +{return null; +} else +{if((function (){var G__7394 = x;if(G__7394) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto__ = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return G__7394.cljs$core$IEncodeJS$; +} +})())) +{return true; +} else +{if((!G__7394.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__7394); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeJS,G__7394); +} +})()) +{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 obj7396 = {};return obj7396; +})();var seq__7397_7407 = cljs.core.seq.call(null,x);var chunk__7398_7408 = null;var count__7399_7409 = 0;var i__7400_7410 = 0;while(true){ +if((i__7400_7410 < count__7399_7409)) +{var vec__7401_7411 = cljs.core._nth.call(null,chunk__7398_7408,i__7400_7410);var k_7412 = cljs.core.nth.call(null,vec__7401_7411,0,null);var v_7413 = cljs.core.nth.call(null,vec__7401_7411,1,null);(m[cljs.core.key__GT_js.call(null,k_7412)] = clj__GT_js.call(null,v_7413)); +{ +var G__7414 = seq__7397_7407; +var G__7415 = chunk__7398_7408; +var G__7416 = count__7399_7409; +var G__7417 = (i__7400_7410 + 1); +seq__7397_7407 = G__7414; +chunk__7398_7408 = G__7415; +count__7399_7409 = G__7416; +i__7400_7410 = G__7417; +continue; +} +} else +{var temp__4092__auto___7418 = cljs.core.seq.call(null,seq__7397_7407);if(temp__4092__auto___7418) +{var seq__7397_7419__$1 = temp__4092__auto___7418;if(cljs.core.chunked_seq_QMARK_.call(null,seq__7397_7419__$1)) +{var c__4288__auto___7420 = cljs.core.chunk_first.call(null,seq__7397_7419__$1);{ +var G__7421 = cljs.core.chunk_rest.call(null,seq__7397_7419__$1); +var G__7422 = c__4288__auto___7420; +var G__7423 = cljs.core.count.call(null,c__4288__auto___7420); +var G__7424 = 0; +seq__7397_7407 = G__7421; +chunk__7398_7408 = G__7422; +count__7399_7409 = G__7423; +i__7400_7410 = G__7424; +continue; +} +} else +{var vec__7402_7425 = cljs.core.first.call(null,seq__7397_7419__$1);var k_7426 = cljs.core.nth.call(null,vec__7402_7425,0,null);var v_7427 = cljs.core.nth.call(null,vec__7402_7425,1,null);(m[cljs.core.key__GT_js.call(null,k_7426)] = clj__GT_js.call(null,v_7427)); +{ +var G__7428 = cljs.core.next.call(null,seq__7397_7419__$1); +var G__7429 = null; +var G__7430 = 0; +var G__7431 = 0; +seq__7397_7407 = G__7428; +chunk__7398_7408 = G__7429; +count__7399_7409 = G__7430; +i__7400_7410 = G__7431; +continue; +} +} +} else +{} +} +break; +} +return m; +} else +{if(cljs.core.coll_QMARK_.call(null,x)) +{var arr = [];var seq__7403_7432 = cljs.core.seq.call(null,cljs.core.map.call(null,clj__GT_js,x));var chunk__7404_7433 = null;var count__7405_7434 = 0;var i__7406_7435 = 0;while(true){ +if((i__7406_7435 < count__7405_7434)) +{var x_7436__$1 = cljs.core._nth.call(null,chunk__7404_7433,i__7406_7435);arr.push(x_7436__$1); +{ +var G__7437 = seq__7403_7432; +var G__7438 = chunk__7404_7433; +var G__7439 = count__7405_7434; +var G__7440 = (i__7406_7435 + 1); +seq__7403_7432 = G__7437; +chunk__7404_7433 = G__7438; +count__7405_7434 = G__7439; +i__7406_7435 = G__7440; +continue; +} +} else +{var temp__4092__auto___7441 = cljs.core.seq.call(null,seq__7403_7432);if(temp__4092__auto___7441) +{var seq__7403_7442__$1 = temp__4092__auto___7441;if(cljs.core.chunked_seq_QMARK_.call(null,seq__7403_7442__$1)) +{var c__4288__auto___7443 = cljs.core.chunk_first.call(null,seq__7403_7442__$1);{ +var G__7444 = cljs.core.chunk_rest.call(null,seq__7403_7442__$1); +var G__7445 = c__4288__auto___7443; +var G__7446 = cljs.core.count.call(null,c__4288__auto___7443); +var G__7447 = 0; +seq__7403_7432 = G__7444; +chunk__7404_7433 = G__7445; +count__7405_7434 = G__7446; +i__7406_7435 = G__7447; +continue; +} +} else +{var x_7448__$1 = cljs.core.first.call(null,seq__7403_7442__$1);arr.push(x_7448__$1); +{ +var G__7449 = cljs.core.next.call(null,seq__7403_7442__$1); +var G__7450 = null; +var G__7451 = 0; +var G__7452 = 0; +seq__7403_7432 = G__7449; +chunk__7404_7433 = G__7450; +count__7405_7434 = G__7451; +i__7406_7435 = G__7452; +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 obj7454 = {};return obj7454; +})(); +cljs.core._js__GT_clj = (function _js__GT_clj(x,options){if((function (){var and__3528__auto__ = x;if(and__3528__auto__) +{return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x,options); +} else +{var x__4167__auto__ = (((x == null))?null:x);return (function (){var or__3540__auto__ = (cljs.core._js__GT_clj[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._js__GT_clj["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IEncodeClojure.-js->clj",x); +} +} +})().call(null,x,options); +} +}); +/** +* Recursively transforms JavaScript arrays into ClojureScript +* vectors, and JavaScript objects into ClojureScript maps. With +* option ':keywordize-keys true' will convert object fields from +* strings to keywords. +* @param {...*} var_args +*/ +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__7475__delegate = function (x,opts){if((function (){var G__7465 = x;if(G__7465) +{var bit__4190__auto__ = null;if(cljs.core.truth_((function (){var or__3540__auto__ = bit__4190__auto__;if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{return G__7465.cljs$core$IEncodeClojure$; +} +})())) +{return true; +} else +{if((!G__7465.cljs$lang$protocol_mask$partition$)) +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeClojure,G__7465); +} else +{return false; +} +} +} else +{return cljs.core.native_satisfies_QMARK_.call(null,cljs.core.IEncodeClojure,G__7465); +} +})()) +{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__7466 = opts;var map__7466__$1 = ((cljs.core.seq_QMARK_.call(null,map__7466))?cljs.core.apply.call(null,cljs.core.hash_map,map__7466):map__7466);var keywordize_keys = cljs.core.get.call(null,map__7466__$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__7466,map__7466__$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__4257__auto__ = ((function (map__7466,map__7466__$1,keywordize_keys,keyfn){ +return (function iter__7471(s__7472){return (new cljs.core.LazySeq(null,((function (map__7466,map__7466__$1,keywordize_keys,keyfn){ +return (function (){var s__7472__$1 = s__7472;while(true){ +var temp__4092__auto__ = cljs.core.seq.call(null,s__7472__$1);if(temp__4092__auto__) +{var s__7472__$2 = temp__4092__auto__;if(cljs.core.chunked_seq_QMARK_.call(null,s__7472__$2)) +{var c__4255__auto__ = cljs.core.chunk_first.call(null,s__7472__$2);var size__4256__auto__ = cljs.core.count.call(null,c__4255__auto__);var b__7474 = cljs.core.chunk_buffer.call(null,size__4256__auto__);if((function (){var i__7473 = 0;while(true){ +if((i__7473 < size__4256__auto__)) +{var k = cljs.core._nth.call(null,c__4255__auto__,i__7473);cljs.core.chunk_append.call(null,b__7474,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__7476 = (i__7473 + 1); +i__7473 = G__7476; +continue; +} +} else +{return true; +} +break; +} +})()) +{return cljs.core.chunk_cons.call(null,cljs.core.chunk.call(null,b__7474),iter__7471.call(null,cljs.core.chunk_rest.call(null,s__7472__$2))); +} else +{return cljs.core.chunk_cons.call(null,cljs.core.chunk.call(null,b__7474),null); +} +} else +{var k = cljs.core.first.call(null,s__7472__$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__7471.call(null,cljs.core.rest.call(null,s__7472__$2))); +} +} else +{return null; +} +break; +} +});})(map__7466,map__7466__$1,keywordize_keys,keyfn)) +,null,null)); +});})(map__7466,map__7466__$1,keywordize_keys,keyfn)) +;return iter__4257__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__7466,map__7466__$1,keywordize_keys,keyfn)) +;return f.call(null,x); +} else +{return null; +} +} +}; +var G__7475 = 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__7475__delegate.call(this,x,opts);}; +G__7475.cljs$lang$maxFixedArity = 1; +G__7475.cljs$lang$applyTo = (function (arglist__7477){ +var x = cljs.core.first(arglist__7477); +var opts = cljs.core.rest(arglist__7477); +return G__7475__delegate(x,opts); +}); +G__7475.cljs$core$IFn$_invoke$arity$variadic = G__7475__delegate; +return G__7475; +})() +; +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; +})() +; +/** +* Returns a memoized version of a referentially transparent function. The +* memoized version of the function keeps a cache of the mapping from arguments +* to results and, when calls with the same arguments are repeated often, has +* higher performance at the expense of higher memory use. +*/ +cljs.core.memoize = (function memoize(f){var mem = cljs.core.atom.call(null,cljs.core.PersistentArrayMap.EMPTY);return (function() { +var G__7478__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__7478 = function (var_args){ +var args = null;if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0),0);} +return G__7478__delegate.call(this,args);}; +G__7478.cljs$lang$maxFixedArity = 0; +G__7478.cljs$lang$applyTo = (function (arglist__7479){ +var args = cljs.core.seq(arglist__7479); +return G__7478__delegate(args); +}); +G__7478.cljs$core$IFn$_invoke$arity$variadic = G__7478__delegate; +return G__7478; +})() +; +}); +/** +* trampoline can be used to convert algorithms requiring mutual +* recursion without stack consumption. Calls f with supplied args, if +* any. If f returns a fn, calls that fn with no arguments, and +* continues to repeat, until the return value is not a fn, then +* returns that non-fn value. Note that if you want to return a fn as a +* final value, you must wrap it in some data structure and unpack it +* after trampoline returns. +* @param {...*} var_args +*/ +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__7480 = ret; +f = G__7480; +continue; +} +} else +{return ret; +} +break; +} +}); +var trampoline__2 = (function() { +var G__7481__delegate = function (f,args){return trampoline.call(null,(function (){return cljs.core.apply.call(null,f,args); +})); +}; +var G__7481 = 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__7481__delegate.call(this,f,args);}; +G__7481.cljs$lang$maxFixedArity = 1; +G__7481.cljs$lang$applyTo = (function (arglist__7482){ +var f = cljs.core.first(arglist__7482); +var args = cljs.core.rest(arglist__7482); +return G__7481__delegate(f,args); +}); +G__7481.cljs$core$IFn$_invoke$arity$variadic = G__7481__delegate; +return G__7481; +})() +; +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; +})() +; +/** +* Returns a random floating point number between 0 (inclusive) and +* n (default 1) (exclusive). +*/ +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; +})() +; +/** +* Returns a random integer between 0 (inclusive) and n (exclusive). +*/ +cljs.core.rand_int = (function rand_int(n){return Math.floor.call(null,(Math.random.call(null) * n)); +}); +/** +* Return a random element of the (sequential) collection. Will have +* the same performance characteristics as nth for the given +* collection. +*/ +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))); +}); +/** +* Returns a map of the elements of coll keyed by the result of +* f on each element. The value at each key will be a vector of the +* corresponding elements, in the order they appeared in 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); +}); +/** +* Creates a hierarchy object for use with derive, isa? etc. +*/ +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; +}); +/** +* @param {...*} var_args +*/ +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__7483){ +var f = cljs.core.first(arglist__7483); +var args = cljs.core.rest(arglist__7483); +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_; +})() +; +/** +* Returns true if (= child parent), or child is directly or indirectly derived from +* parent, either via a JavaScript type inheritance relationship or a +* relationship established via derive. h must be a hierarchy obtained +* from make-hierarchy, if not supplied defaults to the global +* hierarchy +*/ +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__3540__auto__ = cljs.core._EQ_.call(null,child,parent);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__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__3540__auto____$1) +{return or__3540__auto____$1; +} else +{var and__3528__auto__ = cljs.core.vector_QMARK_.call(null,parent);if(and__3528__auto__) +{var and__3528__auto____$1 = cljs.core.vector_QMARK_.call(null,child);if(and__3528__auto____$1) +{var and__3528__auto____$2 = (cljs.core.count.call(null,parent) === cljs.core.count.call(null,child));if(and__3528__auto____$2) +{var ret = true;var i = 0;while(true){ +if((!(ret)) || ((i === cljs.core.count.call(null,parent)))) +{return ret; +} else +{{ +var G__7484 = isa_QMARK_.call(null,h,child.call(null,i),parent.call(null,i)); +var G__7485 = (i + 1); +ret = G__7484; +i = G__7485; +continue; +} +} +break; +} +} else +{return and__3528__auto____$2; +} +} else +{return and__3528__auto____$1; +} +} else +{return and__3528__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_; +})() +; +/** +* Returns the immediate parents of tag, either via a JavaScript type +* inheritance relationship or a relationship established via derive. h +* must be a hierarchy obtained from make-hierarchy, if not supplied +* defaults to the global hierarchy +*/ +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; +})() +; +/** +* Returns the immediate and indirect parents of tag, either via a JavaScript type +* inheritance relationship or a relationship established via derive. h +* must be a hierarchy obtained from make-hierarchy, if not supplied +* defaults to the global hierarchy +*/ +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; +})() +; +/** +* Returns the immediate and indirect children of tag, through a +* relationship established via derive. h must be a hierarchy obtained +* from make-hierarchy, if not supplied defaults to the global +* hierarchy. Note: does not work on JavaScript type inheritance +* relationships. +*/ +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; +})() +; +/** +* Establishes a parent/child relationship between parent and +* tag. Parent must be a namespace-qualified symbol or keyword and +* child can be either a namespace-qualified symbol or keyword or a +* class. h must be a hierarchy obtained from make-hierarchy, if not +* supplied defaults to, and modifies, the global hierarchy. +*/ +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=","not=",-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__3540__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__3540__auto__)) +{return or__3540__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; +})() +; +/** +* Removes a parent/child relationship between parent and +* tag. h must be a hierarchy obtained from make-hierarchy, if not +* supplied defaults to, and modifies, the global hierarchy. +*/ +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__7486_SHARP_){return cljs.core.cons.call(null,cljs.core.first.call(null,p1__7486_SHARP_),cljs.core.interpose.call(null,cljs.core.first.call(null,p1__7486_SHARP_),cljs.core.second.call(null,p1__7486_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__7487_SHARP_,p2__7488_SHARP_){return cljs.core.apply.call(null,cljs.core.derive,p1__7487_SHARP_,p2__7488_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__3540__auto__ = (cljs.core.truth_((function (){var and__3528__auto__ = xprefs;if(cljs.core.truth_(and__3528__auto__)) +{return xprefs.call(null,y); +} else +{return and__3528__auto__; +} +})())?true:null);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__auto__; +} else +{var or__3540__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__7489 = cljs.core.rest.call(null,ps); +ps = G__7489; +continue; +} +} else +{return null; +} +break; +} +})();if(cljs.core.truth_(or__3540__auto____$1)) +{return or__3540__auto____$1; +} else +{var or__3540__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__7490 = cljs.core.rest.call(null,ps); +ps = G__7490; +continue; +} +} else +{return null; +} +break; +} +})();if(cljs.core.truth_(or__3540__auto____$2)) +{return or__3540__auto____$2; +} else +{return false; +} +} +} +}); +cljs.core.dominates = (function dominates(x,y,prefer_table){var or__3540__auto__ = cljs.core.prefers_STAR_.call(null,x,y,prefer_table);if(cljs.core.truth_(or__3540__auto__)) +{return or__3540__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__7493){var vec__7494 = p__7493;var k = cljs.core.nth.call(null,vec__7494,0,null);var _ = cljs.core.nth.call(null,vec__7494,1,null);var e = vec__7494;if(cljs.core.isa_QMARK_.call(null,cljs.core.deref.call(null,hierarchy),dispatch_val,k)) +{var be2 = (cljs.core.truth_((function (){var or__3540__auto__ = (be == null);if(or__3540__auto__) +{return or__3540__auto__; +} else +{return cljs.core.dominates.call(null,k,cljs.core.first.call(null,be),prefer_table); +} +})())?e:be);if(cljs.core.truth_(cljs.core.dominates.call(null,cljs.core.first.call(null,be2),k,prefer_table))) +{} else +{throw (new Error([cljs.core.str("Multiple methods in multimethod '"),cljs.core.str(name),cljs.core.str("' match dispatch value: "),cljs.core.str(dispatch_val),cljs.core.str(" -> "),cljs.core.str(k),cljs.core.str(" and "),cljs.core.str(cljs.core.first.call(null,be2)),cljs.core.str(", and neither is preferred")].join(''))); +} +return be2; +} else +{return be; +} +}),null,cljs.core.deref.call(null,method_table));if(cljs.core.truth_(best_entry)) +{if(cljs.core._EQ_.call(null,cljs.core.deref.call(null,cached_hierarchy),cljs.core.deref.call(null,hierarchy))) +{cljs.core.swap_BANG_.call(null,method_cache,cljs.core.assoc,dispatch_val,cljs.core.second.call(null,best_entry)); +return cljs.core.second.call(null,best_entry); +} else +{cljs.core.reset_cache.call(null,method_cache,method_table,cached_hierarchy,hierarchy); +return find_and_cache_best_method.call(null,name,dispatch_val,hierarchy,method_table,prefer_table,method_cache,cached_hierarchy); +} +} else +{return null; +} +}); +cljs.core.IMultiFn = (function (){var obj7496 = {};return obj7496; +})(); +cljs.core._reset = (function _reset(mf){if((function (){var and__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_reset$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_reset$arity$1(mf); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._reset[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._reset["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_add_method$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_add_method$arity$3(mf,dispatch_val,method); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._add_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._add_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_remove_method$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf,dispatch_val); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._remove_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._remove_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_prefer_method$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf,dispatch_val,dispatch_val_y); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._prefer_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._prefer_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_get_method$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_get_method$arity$2(mf,dispatch_val); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._get_method[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._get_method["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_methods$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_methods$arity$1(mf); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._methods[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._methods["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_prefers$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_prefers$arity$1(mf); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._prefers[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._prefers["_"]);if(or__3540__auto____$1) +{return or__3540__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__3528__auto__ = mf;if(and__3528__auto__) +{return mf.cljs$core$IMultiFn$_dispatch$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return mf.cljs$core$IMultiFn$_dispatch$arity$2(mf,args); +} else +{var x__4167__auto__ = (((mf == null))?null:mf);return (function (){var or__3540__auto__ = (cljs.core._dispatch[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (cljs.core._dispatch["_"]);if(or__3540__auto____$1) +{return or__3540__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); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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__7497__delegate = function (_,args){var self = this;return cljs.core._dispatch.call(null,self,args); +}; +var G__7497 = function (_,var_args){ +var args = null;if (arguments.length > 1) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1),0);} +return G__7497__delegate.call(this,_,args);}; +G__7497.cljs$lang$maxFixedArity = 1; +G__7497.cljs$lang$applyTo = (function (arglist__7498){ +var _ = cljs.core.first(arglist__7498); +var args = cljs.core.rest(arglist__7498); +return G__7497__delegate(_,args); +}); +G__7497.cljs$core$IFn$_invoke$arity$variadic = G__7497__delegate; +return G__7497; +})() +; +cljs.core.MultiFn.prototype.apply = (function (_,args){var self = this;return cljs.core._dispatch.call(null,self,args); +}); +/** +* Removes all of the methods of multimethod. +*/ +cljs.core.remove_all_methods = (function remove_all_methods(multifn){return cljs.core._reset.call(null,multifn); +}); +/** +* Removes the method of multimethod associated with dispatch-value. +*/ +cljs.core.remove_method = (function remove_method(multifn,dispatch_val){return cljs.core._remove_method.call(null,multifn,dispatch_val); +}); +/** +* Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y +* when there is a conflict +*/ +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); +}); +/** +* Given a multimethod, returns a map of dispatch values -> dispatch fns +*/ +cljs.core.methods$ = (function methods$(multifn){return cljs.core._methods.call(null,multifn); +}); +/** +* Given a multimethod and a dispatch value, returns the dispatch fn +* that would apply to that value, or nil if none apply and no default +*/ +cljs.core.get_method = (function get_method(multifn,dispatch_val){return cljs.core._get_method.call(null,multifn,dispatch_val); +}); +/** +* Given a multimethod, returns a map of preferred value -> set of other values +*/ +cljs.core.prefers = (function prefers(multifn){return cljs.core._prefers.call(null,multifn); +}); + +/** +* @constructor +*/ +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__4107__auto__,writer__4108__auto__,opt__4109__auto__){return cljs.core._write.call(null,writer__4108__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)); +}); + +/** +* @constructor +*/ +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__4110__auto__,writer__4111__auto__,opts__4112__auto__){return cljs.core._write.call(null,writer__4111__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; +/** +* Alpha - subject to change. +* Create an instance of ExceptionInfo, an Error type that carries a +* map of additional data. +*/ +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; +})() +; +/** +* Alpha - subject to change. +* Returns exception data (a map) if ex is an ExceptionInfo. +* Otherwise returns nil. +*/ +cljs.core.ex_data = (function ex_data(ex){if((ex instanceof cljs.core.ExceptionInfo)) +{return ex.data; +} else +{return null; +} +}); +/** +* Alpha - subject to change. +* Returns the message attached to the given Error / ExceptionInfo object. +* For non-Errors returns nil. +*/ +cljs.core.ex_message = (function ex_message(ex){if((ex instanceof Error)) +{return ex.message; +} else +{return null; +} +}); +/** +* Alpha - subject to change. +* Returns exception cause (an Error / ExceptionInfo) if ex is an +* ExceptionInfo. +* Otherwise returns nil. +*/ +cljs.core.ex_cause = (function ex_cause(ex){if((ex instanceof cljs.core.ExceptionInfo)) +{return ex.cause; +} else +{return null; +} +}); +/** +* Returns an JavaScript compatible comparator based upon pred. +*/ +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,"&","&",-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); +}); diff --git a/repl/clojure/browser/event.cljs b/repl/clojure/browser/event.cljs new file mode 100644 index 0000000..449ed5b --- /dev/null +++ b/repl/clojure/browser/event.cljs @@ -0,0 +1,100 @@ +;; Copyright (c) Rich Hickey. All rights reserved. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "This namespace contains functions to work with browser +events. It is based on the Google Closure Library event system." + :author "Bobby Calderwood"} + clojure.browser.event + (:require [goog.events :as events] + [goog.events.EventTarget :as gevent-target] + [goog.events.EventType :as gevent-type])) + +(defprotocol EventType + (event-types [this])) + +(extend-protocol EventType + + goog.events.EventTarget + (event-types + [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.events.EventType))))) + + js/Element + (event-types + [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.events.EventType)))))) + +(defn listen + ([src type fn] + (listen src type fn false)) + ([src type fn capture?] + (goog.events/listen src + (get (event-types src) type type) + fn + capture?))) + +(defn listen-once + ([src type fn] + (listen-once src type fn false)) + ([src type fn capture?] + (goog.events/listenOnce src + (get (event-types src) type type) + fn + capture?))) + +(defn unlisten + ([src type fn] + (unlisten src type fn false)) + ([src type fn capture?] + (goog.events/unlisten src + (get (event-types src) type type) + fn + capture?))) + +(defn unlisten-by-key + [key] + (goog.events/unlistenByKey key)) + +(defn dispatch-event + [src event] + (goog.events/dispatchEvent src event)) + +(defn expose [e] + (goog.events/expose e)) + +(defn fire-listeners + [obj type capture event]) + +(defn total-listener-count [] + (goog.events/getTotalListenerCount)) + +;; TODO +(defn get-listener [src type listener opt_capt opt_handler]); ⇒ ?Listener +(defn all-listeners [obj type capture]); ⇒ Array. + +(defn unique-event-id [event-type]); ⇒ string + +(defn has-listener [obj opt_type opt_capture]); ⇒ boolean +;; TODO? (defn listen-with-wrapper [src wrapper listener opt_capt opt_handler]) +;; TODO? (defn protect-browser-event-entry-point [errorHandler]) + +(defn remove-all [opt_obj opt_type opt_capt]); ⇒ number +;; TODO? (defn unlisten-with-wrapper [src wrapper listener opt_capt opt_handler]) + diff --git a/repl/clojure/browser/event.js b/repl/clojure/browser/event.js new file mode 100644 index 0000000..089b42c --- /dev/null +++ b/repl/clojure/browser/event.js @@ -0,0 +1,119 @@ +// Compiled by ClojureScript 0.0-2173 +goog.provide('clojure.browser.event'); +goog.require('cljs.core'); +goog.require('goog.events.EventType'); +goog.require('goog.events.EventType'); +goog.require('goog.events.EventTarget'); +goog.require('goog.events.EventTarget'); +goog.require('goog.events'); +goog.require('goog.events'); +clojure.browser.event.EventType = (function (){var obj7522 = {};return obj7522; +})(); +clojure.browser.event.event_types = (function event_types(this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$event$EventType$event_types$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$event$EventType$event_types$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.event.event_types[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.event.event_types["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"EventType.event-types",this$); +} +} +})().call(null,this$); +} +}); +Element.prototype.clojure$browser$event$EventType$ = true; +Element.prototype.clojure$browser$event$EventType$event_types$arity$1 = (function (this$){var this$__$1 = this;return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__7523){var vec__7524 = p__7523;var k = cljs.core.nth.call(null,vec__7524,0,null);var v = cljs.core.nth.call(null,vec__7524,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.events.EventType)))); +}); +goog.events.EventTarget.prototype.clojure$browser$event$EventType$ = true; +goog.events.EventTarget.prototype.clojure$browser$event$EventType$event_types$arity$1 = (function (this$){var this$__$1 = this;return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__7525){var vec__7526 = p__7525;var k = cljs.core.nth.call(null,vec__7526,0,null);var v = cljs.core.nth.call(null,vec__7526,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.events.EventType)))); +}); +clojure.browser.event.listen = (function() { +var listen = null; +var listen__3 = (function (src,type,fn){return listen.call(null,src,type,fn,false); +}); +var listen__4 = (function (src,type,fn,capture_QMARK_){return goog.events.listen(src,cljs.core.get.call(null,clojure.browser.event.event_types.call(null,src),type,type),fn,capture_QMARK_); +}); +listen = function(src,type,fn,capture_QMARK_){ +switch(arguments.length){ +case 3: +return listen__3.call(this,src,type,fn); +case 4: +return listen__4.call(this,src,type,fn,capture_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +listen.cljs$core$IFn$_invoke$arity$3 = listen__3; +listen.cljs$core$IFn$_invoke$arity$4 = listen__4; +return listen; +})() +; +clojure.browser.event.listen_once = (function() { +var listen_once = null; +var listen_once__3 = (function (src,type,fn){return listen_once.call(null,src,type,fn,false); +}); +var listen_once__4 = (function (src,type,fn,capture_QMARK_){return goog.events.listenOnce(src,cljs.core.get.call(null,clojure.browser.event.event_types.call(null,src),type,type),fn,capture_QMARK_); +}); +listen_once = function(src,type,fn,capture_QMARK_){ +switch(arguments.length){ +case 3: +return listen_once__3.call(this,src,type,fn); +case 4: +return listen_once__4.call(this,src,type,fn,capture_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +listen_once.cljs$core$IFn$_invoke$arity$3 = listen_once__3; +listen_once.cljs$core$IFn$_invoke$arity$4 = listen_once__4; +return listen_once; +})() +; +clojure.browser.event.unlisten = (function() { +var unlisten = null; +var unlisten__3 = (function (src,type,fn){return unlisten.call(null,src,type,fn,false); +}); +var unlisten__4 = (function (src,type,fn,capture_QMARK_){return goog.events.unlisten(src,cljs.core.get.call(null,clojure.browser.event.event_types.call(null,src),type,type),fn,capture_QMARK_); +}); +unlisten = function(src,type,fn,capture_QMARK_){ +switch(arguments.length){ +case 3: +return unlisten__3.call(this,src,type,fn); +case 4: +return unlisten__4.call(this,src,type,fn,capture_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +unlisten.cljs$core$IFn$_invoke$arity$3 = unlisten__3; +unlisten.cljs$core$IFn$_invoke$arity$4 = unlisten__4; +return unlisten; +})() +; +clojure.browser.event.unlisten_by_key = (function unlisten_by_key(key){return goog.events.unlistenByKey(key); +}); +clojure.browser.event.dispatch_event = (function dispatch_event(src,event){return goog.events.dispatchEvent(src,event); +}); +clojure.browser.event.expose = (function expose(e){return goog.events.expose(e); +}); +clojure.browser.event.fire_listeners = (function fire_listeners(obj,type,capture,event){return null; +}); +clojure.browser.event.total_listener_count = (function total_listener_count(){return goog.events.getTotalListenerCount(); +}); +clojure.browser.event.get_listener = (function get_listener(src,type,listener,opt_capt,opt_handler){return null; +}); +clojure.browser.event.all_listeners = (function all_listeners(obj,type,capture){return null; +}); +clojure.browser.event.unique_event_id = (function unique_event_id(event_type){return null; +}); +clojure.browser.event.has_listener = (function has_listener(obj,opt_type,opt_capture){return null; +}); +clojure.browser.event.remove_all = (function remove_all(opt_obj,opt_type,opt_capt){return null; +}); diff --git a/repl/clojure/browser/net.cljs b/repl/clojure/browser/net.cljs new file mode 100644 index 0000000..29769e2 --- /dev/null +++ b/repl/clojure/browser/net.cljs @@ -0,0 +1,183 @@ +;; Copyright (c) Rich Hickey. All rights reserved. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "Network communication library, wrapping goog.net. +Includes a common API over XhrIo, CrossPageChannel, and Websockets." + :author "Bobby Calderwood and Alex Redington"} + clojure.browser.net + (:require [clojure.browser.event :as event] + [goog.net.XhrIo :as gxhrio] + [goog.net.EventType :as gnet-event-type] + [goog.net.xpc.CfgFields :as gxpc-config-fields] + [goog.net.xpc.CrossPageChannel :as xpc] + #_[goog.net.WebSocket :as gwebsocket] + [goog.json :as gjson])) + +(def *timeout* 10000) + +(def event-types + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.net.EventType))))) + +(defprotocol IConnection + (connect + [this] + [this opt1] + [this opt1 opt2] + [this opt1 opt2 opt3]) + (transmit + [this opt] + [this opt opt2] + [this opt opt2 opt3] + [this opt opt2 opt3 opt4] + [this opt opt2 opt3 opt4 opt5]) + (close [this])) + +(extend-type goog.net.XhrIo + + IConnection + (transmit + ([this uri] + (transmit this uri "GET" nil nil *timeout*)) + ([this uri method] + (transmit this uri method nil nil *timeout*)) + ([this uri method content] + (transmit this uri method content nil *timeout*)) + ([this uri method content headers] + (transmit this uri method content headers *timeout*)) + ([this uri method content headers timeout] + (.setTimeoutInterval this timeout) + (.send this uri method content headers))) + + + event/EventType + (event-types [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.net.EventType)))))) + +;; TODO jQuery/sinatra/RestClient style API: (get [uri]), (post [uri payload]), (put [uri payload]), (delete [uri]) + +(def xpc-config-fields + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (js->clj goog.net.xpc.CfgFields)))) + +(defn xhr-connection + "Returns an XhrIo connection" + [] + (goog.net.XhrIo.)) + +(defprotocol ICrossPageChannel + (register-service [this service-name fn] [this service-name fn encode-json?])) + +(extend-type goog.net.xpc.CrossPageChannel + + ICrossPageChannel + (register-service + ([this service-name fn] + (register-service this service-name fn false)) + ([this service-name fn encode-json?] + (.registerService this (name service-name) fn encode-json?))) + + IConnection + (connect + ([this] + (connect this nil)) + ([this on-connect-fn] + (.connect this on-connect-fn)) + ([this on-connect-fn config-iframe-fn] + (connect this on-connect-fn config-iframe-fn (.-body js/document))) + ([this on-connect-fn config-iframe-fn iframe-parent] + (.createPeerIframe this iframe-parent config-iframe-fn) + (.connect this on-connect-fn))) + + (transmit [this service-name payload] + (.send this (name service-name) payload)) + + (close [this] + (.close this ()))) + +(defn xpc-connection + "When passed with a config hash-map, returns a parent + CrossPageChannel object. Keys in the config hash map are downcased + versions of the goog.net.xpc.CfgFields enum keys, + e.g. goog.net.xpc.CfgFields.PEER_URI becomes :peer_uri in the config + hash. + + When passed with no args, creates a child CrossPageChannel object, + and the config is automatically taken from the URL param 'xpc', as + per the CrossPageChannel API." + ([] + (when-let [config (.getParameterValue + (goog.Uri. (.-href (.-location js/window))) + "xpc")] + (goog.net.xpc.CrossPageChannel. (gjson/parse config)))) + ([config] + (goog.net.xpc.CrossPageChannel. + (reduce (fn [sum [k v]] + (if-let [field (get xpc-config-fields k)] + (doto sum (aset field v)) + sum)) + (js-obj) + config)))) + +;; WebSocket is not supported in the 3/23/11 release of Google +;; Closure, but will be included in the next release. + +#_(defprotocol IWebSocket + (open? [this])) + +#_(extend-type goog.net.WebSocket + + IWebSocket + (open? [this] + (.isOpen this ())) + + IConnection + (connect + ([this url] + (connect this url nil)) + ([this url protocol] + (.open this url protocol))) + + (transmit [this message] + (.send this message)) + + (close [this] + (.close this ())) + + event/EventType + (event-types [this] + (into {} + (map + (fn [[k v]] + [(keyword (. k (toLowerCase))) + v]) + (merge + (js->clj goog.net.WebSocket/EventType)))))) + +#_(defn websocket-connection + ([] + (websocket-connection nil nil)) + ([auto-reconnect?] + (websocket-connection auto-reconnect? nil)) + ([auto-reconnect? next-reconnect-fn] + (goog.net.WebSocket. auto-reconnect? next-reconnect-fn))) \ No newline at end of file diff --git a/repl/clojure/browser/net.js b/repl/clojure/browser/net.js new file mode 100644 index 0000000..815c754 --- /dev/null +++ b/repl/clojure/browser/net.js @@ -0,0 +1,409 @@ +// Compiled by ClojureScript 0.0-2173 +goog.provide('clojure.browser.net'); +goog.require('cljs.core'); +goog.require('goog.net.XhrIo'); +goog.require('goog.net.xpc.CrossPageChannel'); +goog.require('clojure.browser.event'); +goog.require('goog.json'); +goog.require('goog.net.xpc.CfgFields'); +goog.require('clojure.browser.event'); +goog.require('goog.net.EventType'); +goog.require('goog.net.EventType'); +goog.require('goog.net.xpc.CrossPageChannel'); +goog.require('goog.json'); +goog.require('goog.net.XhrIo'); +goog.require('goog.net.xpc.CfgFields'); +clojure.browser.net._STAR_timeout_STAR_ = 10000; +clojure.browser.net.event_types = cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__7501){var vec__7502 = p__7501;var k = cljs.core.nth.call(null,vec__7502,0,null);var v = cljs.core.nth.call(null,vec__7502,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.net.EventType)))); +clojure.browser.net.IConnection = (function (){var obj7504 = {};return obj7504; +})(); +clojure.browser.net.connect = (function() { +var connect = null; +var connect__1 = (function (this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$); +} +}); +var connect__2 = (function (this$,opt1){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$2(this$,opt1); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$,opt1); +} +}); +var connect__3 = (function (this$,opt1,opt2){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$3(this$,opt1,opt2); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$,opt1,opt2); +} +}); +var connect__4 = (function (this$,opt1,opt2,opt3){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$connect$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$connect$arity$4(this$,opt1,opt2,opt3); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.connect[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.connect["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.connect",this$); +} +} +})().call(null,this$,opt1,opt2,opt3); +} +}); +connect = function(this$,opt1,opt2,opt3){ +switch(arguments.length){ +case 1: +return connect__1.call(this,this$); +case 2: +return connect__2.call(this,this$,opt1); +case 3: +return connect__3.call(this,this$,opt1,opt2); +case 4: +return connect__4.call(this,this$,opt1,opt2,opt3); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +connect.cljs$core$IFn$_invoke$arity$1 = connect__1; +connect.cljs$core$IFn$_invoke$arity$2 = connect__2; +connect.cljs$core$IFn$_invoke$arity$3 = connect__3; +connect.cljs$core$IFn$_invoke$arity$4 = connect__4; +return connect; +})() +; +clojure.browser.net.transmit = (function() { +var transmit = null; +var transmit__2 = (function (this$,opt){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$2; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$2(this$,opt); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt); +} +}); +var transmit__3 = (function (this$,opt,opt2){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$3(this$,opt,opt2); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2); +} +}); +var transmit__4 = (function (this$,opt,opt2,opt3){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$4(this$,opt,opt2,opt3); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2,opt3); +} +}); +var transmit__5 = (function (this$,opt,opt2,opt3,opt4){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$5; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$5(this$,opt,opt2,opt3,opt4); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2,opt3,opt4); +} +}); +var transmit__6 = (function (this$,opt,opt2,opt3,opt4,opt5){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$transmit$arity$6; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$transmit$arity$6(this$,opt,opt2,opt3,opt4,opt5); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.transmit[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.transmit["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.transmit",this$); +} +} +})().call(null,this$,opt,opt2,opt3,opt4,opt5); +} +}); +transmit = function(this$,opt,opt2,opt3,opt4,opt5){ +switch(arguments.length){ +case 2: +return transmit__2.call(this,this$,opt); +case 3: +return transmit__3.call(this,this$,opt,opt2); +case 4: +return transmit__4.call(this,this$,opt,opt2,opt3); +case 5: +return transmit__5.call(this,this$,opt,opt2,opt3,opt4); +case 6: +return transmit__6.call(this,this$,opt,opt2,opt3,opt4,opt5); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +transmit.cljs$core$IFn$_invoke$arity$2 = transmit__2; +transmit.cljs$core$IFn$_invoke$arity$3 = transmit__3; +transmit.cljs$core$IFn$_invoke$arity$4 = transmit__4; +transmit.cljs$core$IFn$_invoke$arity$5 = transmit__5; +transmit.cljs$core$IFn$_invoke$arity$6 = transmit__6; +return transmit; +})() +; +clojure.browser.net.close = (function close(this$){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$IConnection$close$arity$1; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$IConnection$close$arity$1(this$); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.close[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.close["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"IConnection.close",this$); +} +} +})().call(null,this$); +} +}); +goog.net.XhrIo.prototype.clojure$browser$event$EventType$ = true; +goog.net.XhrIo.prototype.clojure$browser$event$EventType$event_types$arity$1 = (function (this$){var this$__$1 = this;return cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__7505){var vec__7506 = p__7505;var k = cljs.core.nth.call(null,vec__7506,0,null);var v = cljs.core.nth.call(null,vec__7506,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.merge.call(null,cljs.core.js__GT_clj.call(null,goog.net.EventType)))); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$ = true; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$2 = (function (this$,uri){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,"GET",null,null,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$3 = (function (this$,uri,method){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,method,null,null,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$4 = (function (this$,uri,method,content){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,method,content,null,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$5 = (function (this$,uri,method,content,headers){var this$__$1 = this;return clojure.browser.net.transmit.call(null,this$__$1,uri,method,content,headers,clojure.browser.net._STAR_timeout_STAR_); +}); +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$6 = (function (this$,uri,method,content,headers,timeout){var this$__$1 = this;this$__$1.setTimeoutInterval(timeout); +return this$__$1.send(uri,method,content,headers); +}); +clojure.browser.net.xpc_config_fields = cljs.core.into.call(null,cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.call(null,(function (p__7507){var vec__7508 = p__7507;var k = cljs.core.nth.call(null,vec__7508,0,null);var v = cljs.core.nth.call(null,vec__7508,1,null);return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null,k.toLowerCase()),v], null); +}),cljs.core.js__GT_clj.call(null,goog.net.xpc.CfgFields))); +/** +* Returns an XhrIo connection +*/ +clojure.browser.net.xhr_connection = (function xhr_connection(){return (new goog.net.XhrIo()); +}); +clojure.browser.net.ICrossPageChannel = (function (){var obj7510 = {};return obj7510; +})(); +clojure.browser.net.register_service = (function() { +var register_service = null; +var register_service__3 = (function (this$,service_name,fn){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$3; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$3(this$,service_name,fn); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.register_service[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.register_service["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICrossPageChannel.register-service",this$); +} +} +})().call(null,this$,service_name,fn); +} +}); +var register_service__4 = (function (this$,service_name,fn,encode_json_QMARK_){if((function (){var and__3528__auto__ = this$;if(and__3528__auto__) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$4; +} else +{return and__3528__auto__; +} +})()) +{return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$4(this$,service_name,fn,encode_json_QMARK_); +} else +{var x__4167__auto__ = (((this$ == null))?null:this$);return (function (){var or__3540__auto__ = (clojure.browser.net.register_service[goog.typeOf(x__4167__auto__)]);if(or__3540__auto__) +{return or__3540__auto__; +} else +{var or__3540__auto____$1 = (clojure.browser.net.register_service["_"]);if(or__3540__auto____$1) +{return or__3540__auto____$1; +} else +{throw cljs.core.missing_protocol.call(null,"ICrossPageChannel.register-service",this$); +} +} +})().call(null,this$,service_name,fn,encode_json_QMARK_); +} +}); +register_service = function(this$,service_name,fn,encode_json_QMARK_){ +switch(arguments.length){ +case 3: +return register_service__3.call(this,this$,service_name,fn); +case 4: +return register_service__4.call(this,this$,service_name,fn,encode_json_QMARK_); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +register_service.cljs$core$IFn$_invoke$arity$3 = register_service__3; +register_service.cljs$core$IFn$_invoke$arity$4 = register_service__4; +return register_service; +})() +; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$ = true; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$1 = (function (this$){var this$__$1 = this;return clojure.browser.net.connect.call(null,this$__$1,null); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$2 = (function (this$,on_connect_fn){var this$__$1 = this;return this$__$1.connect(on_connect_fn); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$3 = (function (this$,on_connect_fn,config_iframe_fn){var this$__$1 = this;return clojure.browser.net.connect.call(null,this$__$1,on_connect_fn,config_iframe_fn,document.body); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$4 = (function (this$,on_connect_fn,config_iframe_fn,iframe_parent){var this$__$1 = this;this$__$1.createPeerIframe(iframe_parent,config_iframe_fn); +return this$__$1.connect(on_connect_fn); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$transmit$arity$3 = (function (this$,service_name,payload){var this$__$1 = this;return this$__$1.send(cljs.core.name.call(null,service_name),payload); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$close$arity$1 = (function (this$){var this$__$1 = this;return this$__$1.close(cljs.core.List.EMPTY); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$ = true; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$3 = (function (this$,service_name,fn){var this$__$1 = this;return clojure.browser.net.register_service.call(null,this$__$1,service_name,fn,false); +}); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$4 = (function (this$,service_name,fn,encode_json_QMARK_){var this$__$1 = this;return this$__$1.registerService(cljs.core.name.call(null,service_name),fn,encode_json_QMARK_); +}); +/** +* When passed with a config hash-map, returns a parent +* CrossPageChannel object. Keys in the config hash map are downcased +* versions of the goog.net.xpc.CfgFields enum keys, +* e.g. goog.net.xpc.CfgFields.PEER_URI becomes :peer_uri in the config +* hash. +* +* When passed with no args, creates a child CrossPageChannel object, +* and the config is automatically taken from the URL param 'xpc', as +* per the CrossPageChannel API. +*/ +clojure.browser.net.xpc_connection = (function() { +var xpc_connection = null; +var xpc_connection__0 = (function (){var temp__4092__auto__ = (new goog.Uri(window.location.href)).getParameterValue("xpc");if(cljs.core.truth_(temp__4092__auto__)) +{var config = temp__4092__auto__;return (new goog.net.xpc.CrossPageChannel(goog.json.parse(config))); +} else +{return null; +} +}); +var xpc_connection__1 = (function (config){return (new goog.net.xpc.CrossPageChannel(cljs.core.reduce.call(null,(function (sum,p__7516){var vec__7517 = p__7516;var k = cljs.core.nth.call(null,vec__7517,0,null);var v = cljs.core.nth.call(null,vec__7517,1,null);var temp__4090__auto__ = cljs.core.get.call(null,clojure.browser.net.xpc_config_fields,k);if(cljs.core.truth_(temp__4090__auto__)) +{var field = temp__4090__auto__;var G__7518 = sum;(G__7518[field] = v); +return G__7518; +} else +{return sum; +} +}),(function (){var obj7520 = {};return obj7520; +})(),config))); +}); +xpc_connection = function(config){ +switch(arguments.length){ +case 0: +return xpc_connection__0.call(this); +case 1: +return xpc_connection__1.call(this,config); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +xpc_connection.cljs$core$IFn$_invoke$arity$0 = xpc_connection__0; +xpc_connection.cljs$core$IFn$_invoke$arity$1 = xpc_connection__1; +return xpc_connection; +})() +; diff --git a/repl/clojure/browser/repl.cljs b/repl/clojure/browser/repl.cljs new file mode 100644 index 0000000..5038e4a --- /dev/null +++ b/repl/clojure/browser/repl.cljs @@ -0,0 +1,109 @@ +;; Copyright (c) Rich Hickey. All rights reserved. +;; The use and distribution terms for this software are covered by the +;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) +;; which can be found in the file epl-v10.html at the root of this distribution. +;; By using this software in any fashion, you are agreeing to be bound by +;; the terms of this license. +;; You must not remove this notice, or any other, from this software. + +(ns ^{:doc "Receive - Eval - Print - Loop + + Receive a block of JS (presumably generated by a ClojureScript compiler) + Evaluate it naively + Print the result of evaluation to a string + Send the resulting string back to the server Loop!" + + :author "Bobby Calderwood and Alex Redington"} + clojure.browser.repl + (:require [clojure.browser.net :as net] + [clojure.browser.event :as event])) + +(def xpc-connection (atom nil)) + +(defn repl-print [data] + (if-let [conn @xpc-connection] + (net/transmit conn :print (pr-str data)))) + +(defn evaluate-javascript + "Process a single block of JavaScript received from the server" + [conn block] + (let [result (try {:status :success :value (str (js* "eval(~{block})"))} + (catch :default e + {:status :exception :value (pr-str e) + :stacktrace (if (.hasOwnProperty e "stack") + (.-stack e) + "No stacktrace available.")}))] + (pr-str result))) + +(defn send-result [connection url data] + (net/transmit connection url "POST" data nil 0)) + +(defn send-print + "Send data to be printed in the REPL. If there is an error, try again + up to 10 times." + ([url data] + (send-print url data 0)) + ([url data n] + (let [conn (net/xhr-connection)] + (event/listen conn :error + (fn [_] + (if (< n 10) + (send-print url data (inc n)) + (.log js/console (str "Could not send " data " after " n " attempts."))))) + (net/transmit conn url "POST" data nil 0)))) + +(def order (atom 0)) + +(defn wrap-message [t data] + (pr-str {:type t :content data :order (swap! order inc)})) + +(defn start-evaluator + "Start the REPL server connection." + [url] + (if-let [repl-connection (net/xpc-connection)] + (let [connection (net/xhr-connection)] + (event/listen connection + :success + (fn [e] + (net/transmit + repl-connection + :evaluate-javascript + (.getResponseText (.-currentTarget e) + ())))) + + (net/register-service repl-connection + :send-result + (fn [data] + (send-result connection url (wrap-message :result data)))) + + (net/register-service repl-connection + :print + (fn [data] + (send-print url (wrap-message :print data)))) + + (net/connect repl-connection + (constantly nil)) + + (js/setTimeout #(send-result connection url (wrap-message :ready "ready")) 50)) + (js/alert "No 'xpc' param provided to child iframe."))) + +(defn connect + "Connects to a REPL server from an HTML document. After the + connection is made, the REPL will evaluate forms in the context of + the document that called this function." + [repl-server-url] + (let [repl-connection (net/xpc-connection + {:peer_uri repl-server-url})] + (swap! xpc-connection (constantly repl-connection)) + (net/register-service repl-connection + :evaluate-javascript + (fn [js] + (net/transmit + repl-connection + :send-result + (evaluate-javascript repl-connection js)))) + (net/connect repl-connection + (constantly nil) + (fn [iframe] + (set! (.-display (.-style iframe)) + "none"))))) diff --git a/repl/clojure/browser/repl.js b/repl/clojure/browser/repl.js new file mode 100644 index 0000000..056a5dd --- /dev/null +++ b/repl/clojure/browser/repl.js @@ -0,0 +1,84 @@ +// Compiled by ClojureScript 0.0-2173 +goog.provide('clojure.browser.repl'); +goog.require('cljs.core'); +goog.require('clojure.browser.event'); +goog.require('clojure.browser.event'); +goog.require('clojure.browser.net'); +goog.require('clojure.browser.net'); +clojure.browser.repl.xpc_connection = cljs.core.atom.call(null,null); +clojure.browser.repl.repl_print = (function repl_print(data){var temp__4090__auto__ = cljs.core.deref.call(null,clojure.browser.repl.xpc_connection);if(cljs.core.truth_(temp__4090__auto__)) +{var conn = temp__4090__auto__;return clojure.browser.net.transmit.call(null,conn,new cljs.core.Keyword(null,"print","print",1120839199),cljs.core.pr_str.call(null,data)); +} else +{return null; +} +}); +/** +* Process a single block of JavaScript received from the server +*/ +clojure.browser.repl.evaluate_javascript = (function evaluate_javascript(conn,block){var result = (function (){try{return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null,"status","status",4416389988),new cljs.core.Keyword(null,"success","success",3441701749),new cljs.core.Keyword(null,"value","value",1125876963),[cljs.core.str(eval(block))].join('')], null); +}catch (e7500){var e = e7500;return new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"status","status",4416389988),new cljs.core.Keyword(null,"exception","exception",2495529921),new cljs.core.Keyword(null,"value","value",1125876963),cljs.core.pr_str.call(null,e),new cljs.core.Keyword(null,"stacktrace","stacktrace",3069736751),(cljs.core.truth_(e.hasOwnProperty("stack"))?e.stack:"No stacktrace available.")], null); +}})();return cljs.core.pr_str.call(null,result); +}); +clojure.browser.repl.send_result = (function send_result(connection,url,data){return clojure.browser.net.transmit.call(null,connection,url,"POST",data,null,0); +}); +/** +* Send data to be printed in the REPL. If there is an error, try again +* up to 10 times. +*/ +clojure.browser.repl.send_print = (function() { +var send_print = null; +var send_print__2 = (function (url,data){return send_print.call(null,url,data,0); +}); +var send_print__3 = (function (url,data,n){var conn = clojure.browser.net.xhr_connection.call(null);clojure.browser.event.listen.call(null,conn,new cljs.core.Keyword(null,"error","error",1110689146),(function (_){if((n < 10)) +{return send_print.call(null,url,data,(n + 1)); +} else +{return console.log([cljs.core.str("Could not send "),cljs.core.str(data),cljs.core.str(" after "),cljs.core.str(n),cljs.core.str(" attempts.")].join('')); +} +})); +return clojure.browser.net.transmit.call(null,conn,url,"POST",data,null,0); +}); +send_print = function(url,data,n){ +switch(arguments.length){ +case 2: +return send_print__2.call(this,url,data); +case 3: +return send_print__3.call(this,url,data,n); +} +throw(new Error('Invalid arity: ' + arguments.length)); +}; +send_print.cljs$core$IFn$_invoke$arity$2 = send_print__2; +send_print.cljs$core$IFn$_invoke$arity$3 = send_print__3; +return send_print; +})() +; +clojure.browser.repl.order = cljs.core.atom.call(null,0); +clojure.browser.repl.wrap_message = (function wrap_message(t,data){return cljs.core.pr_str.call(null,new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null,"type","type",1017479852),t,new cljs.core.Keyword(null,"content","content",1965434859),data,new cljs.core.Keyword(null,"order","order",1119910592),cljs.core.swap_BANG_.call(null,clojure.browser.repl.order,cljs.core.inc)], null)); +}); +/** +* Start the REPL server connection. +*/ +clojure.browser.repl.start_evaluator = (function start_evaluator(url){var temp__4090__auto__ = clojure.browser.net.xpc_connection.call(null);if(cljs.core.truth_(temp__4090__auto__)) +{var repl_connection = temp__4090__auto__;var connection = clojure.browser.net.xhr_connection.call(null);clojure.browser.event.listen.call(null,connection,new cljs.core.Keyword(null,"success","success",3441701749),(function (e){return clojure.browser.net.transmit.call(null,repl_connection,new cljs.core.Keyword(null,"evaluate-javascript","evaluate-javascript",2953437843),e.currentTarget.getResponseText(cljs.core.List.EMPTY)); +})); +clojure.browser.net.register_service.call(null,repl_connection,new cljs.core.Keyword(null,"send-result","send-result",3729280372),(function (data){return clojure.browser.repl.send_result.call(null,connection,url,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"result","result",4374444943),data)); +})); +clojure.browser.net.register_service.call(null,repl_connection,new cljs.core.Keyword(null,"print","print",1120839199),(function (data){return clojure.browser.repl.send_print.call(null,url,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"print","print",1120839199),data)); +})); +clojure.browser.net.connect.call(null,repl_connection,cljs.core.constantly.call(null,null)); +return setTimeout((function (){return clojure.browser.repl.send_result.call(null,connection,url,clojure.browser.repl.wrap_message.call(null,new cljs.core.Keyword(null,"ready","ready",1122290965),"ready")); +}),50); +} else +{return alert("No 'xpc' param provided to child iframe."); +} +}); +/** +* Connects to a REPL server from an HTML document. After the +* connection is made, the REPL will evaluate forms in the context of +* the document that called this function. +*/ +clojure.browser.repl.connect = (function connect(repl_server_url){var repl_connection = clojure.browser.net.xpc_connection.call(null,new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null,"peer_uri","peer_uri",1083496577),repl_server_url], null));cljs.core.swap_BANG_.call(null,clojure.browser.repl.xpc_connection,cljs.core.constantly.call(null,repl_connection)); +clojure.browser.net.register_service.call(null,repl_connection,new cljs.core.Keyword(null,"evaluate-javascript","evaluate-javascript",2953437843),(function (js){return clojure.browser.net.transmit.call(null,repl_connection,new cljs.core.Keyword(null,"send-result","send-result",3729280372),clojure.browser.repl.evaluate_javascript.call(null,repl_connection,js)); +})); +return clojure.browser.net.connect.call(null,repl_connection,cljs.core.constantly.call(null,null),(function (iframe){return iframe.style.display = "none"; +})); +}); diff --git a/resources/public/css/sudorace.css b/resources/public/css/sudorace.css new file mode 100644 index 0000000..d758781 --- /dev/null +++ b/resources/public/css/sudorace.css @@ -0,0 +1,26 @@ + +.cell { + font-size: 21px; + font-weight: bold; + line-height: 40px; + width:40px; + height:40px; + float: left; + text-align: center; + color: #8a3c65; +} + +.fixed { + color: #555555; + background: #F7F7F7; +} + +.target_cell { + border: 1px solid #8a3c65; + border-collapse:collapse; +} + +.non_target_cell { + border: 1px solid #d9d9d0; + border-collapse:collapse; +} \ No newline at end of file diff --git a/resources/public/js/sudorace.js b/resources/public/js/sudorace.js new file mode 100644 index 0000000..02b7568 --- /dev/null +++ b/resources/public/js/sudorace.js @@ -0,0 +1,36900 @@ +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.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(/([-()\[\]{}+?*.$\^|,:# 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_clojurescript_version_STAR_ = "0.0-2173"; +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__4958__delegate = function(args) { + return console.log.apply(console, cljs.core.into_array.call(null, args)); + }; + var G__4958 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__4958__delegate.call(this, args); + }; + G__4958.cljs$lang$maxFixedArity = 0; + G__4958.cljs$lang$applyTo = function(arglist__4959) { + var args = cljs.core.seq(arglist__4959); + return G__4958__delegate(args); + }; + G__4958.cljs$core$IFn$_invoke$arity$variadic = G__4958__delegate; + return G__4958; + }(); +}; +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__3431__auto__ = ty; + if (cljs.core.truth_(and__3431__auto__)) { + return ty.cljs$lang$type; + } else { + return and__3431__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__4291__auto___4960 = len; + var i_4961 = 0; + while (true) { + if (i_4961 < n__4291__auto___4960) { + new_arr[i_4961] = arr[i_4961]; + var G__4962 = i_4961 + 1; + i_4961 = G__4962; + 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__4963__delegate = function(array, i, idxs) { + return cljs.core.apply.call(null, aget, aget.call(null, array, i), idxs); + }; + var G__4963 = 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__4963__delegate.call(this, array, i, idxs); + }; + G__4963.cljs$lang$maxFixedArity = 2; + G__4963.cljs$lang$applyTo = function(arglist__4964) { + var array = cljs.core.first(arglist__4964); + arglist__4964 = cljs.core.next(arglist__4964); + var i = cljs.core.first(arglist__4964); + var idxs = cljs.core.rest(arglist__4964); + return G__4963__delegate(array, i, idxs); + }; + G__4963.cljs$core$IFn$_invoke$arity$variadic = G__4963__delegate; + return G__4963; + }(); + 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__4965__delegate = function(array, idx, idx2, idxv) { + return cljs.core.apply.call(null, aset, array[idx], idx2, idxv); + }; + var G__4965 = 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__4965__delegate.call(this, array, idx, idx2, idxv); + }; + G__4965.cljs$lang$maxFixedArity = 3; + G__4965.cljs$lang$applyTo = function(arglist__4966) { + var array = cljs.core.first(arglist__4966); + arglist__4966 = cljs.core.next(arglist__4966); + var idx = cljs.core.first(arglist__4966); + arglist__4966 = cljs.core.next(arglist__4966); + var idx2 = cljs.core.first(arglist__4966); + var idxv = cljs.core.rest(arglist__4966); + return G__4965__delegate(array, idx, idx2, idxv); + }; + G__4965.cljs$core$IFn$_invoke$arity$variadic = G__4965__delegate; + return G__4965; + }(); + 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 obj4968 = {}; + return obj4968; +}(); +cljs.core.IFn = function() { + var obj4970 = {}; + return obj4970; +}(); +cljs.core._invoke = function() { + var _invoke = null; + var _invoke__1 = function(this$) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$1(this$); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$2(this$, a); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$3(this$, a, b); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$4; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$4(this$, a, b, c); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$5; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$5(this$, a, b, c, d); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$6; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$6(this$, a, b, c, d, e); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$7; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$7(this$, a, b, c, d, e, f); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$8; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$8(this$, a, b, c, d, e, f, g); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$9; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$9(this$, a, b, c, d, e, f, g, h); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$10; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$10(this$, a, b, c, d, e, f, g, h, i); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$11; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$11(this$, a, b, c, d, e, f, g, h, i, j); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$12; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IFn$_invoke$arity$12(this$, a, b, c, d, e, f, g, h, i, j, k); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$13; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$14; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$15; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$16; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$17; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$18; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$19; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$20; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IFn$_invoke$arity$21; + } else { + return and__3431__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__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._invoke[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._invoke["_"]; + if (or__3443__auto____$1) { + return or__3443__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.ICloneable = function() { + var obj4972 = {}; + return obj4972; +}(); +cljs.core._clone = function _clone(value) { + if (function() { + var and__3431__auto__ = value; + if (and__3431__auto__) { + return value.cljs$core$ICloneable$_clone$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return value.cljs$core$ICloneable$_clone$arity$1(value); + } else { + var x__4070__auto__ = value == null ? null : value; + return function() { + var or__3443__auto__ = cljs.core._clone[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._clone["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ICloneable.-clone", value); + } + } + }().call(null, value); + } +}; +cljs.core.ICounted = function() { + var obj4974 = {}; + return obj4974; +}(); +cljs.core._count = function _count(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ICounted$_count$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ICounted$_count$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._count[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._count["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ICounted.-count", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.IEmptyableCollection = function() { + var obj4976 = {}; + return obj4976; +}(); +cljs.core._empty = function _empty(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IEmptyableCollection$_empty$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IEmptyableCollection$_empty$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._empty[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._empty["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IEmptyableCollection.-empty", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.ICollection = function() { + var obj4978 = {}; + return obj4978; +}(); +cljs.core._conj = function _conj(coll, o) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ICollection$_conj$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ICollection$_conj$arity$2(coll, o); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._conj[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._conj["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ICollection.-conj", coll); + } + } + }().call(null, coll, o); + } +}; +cljs.core.IIndexed = function() { + var obj4980 = {}; + return obj4980; +}(); +cljs.core._nth = function() { + var _nth = null; + var _nth__2 = function(coll, n) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IIndexed$_nth$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IIndexed$_nth$arity$2(coll, n); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._nth[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._nth["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IIndexed$_nth$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IIndexed$_nth$arity$3(coll, n, not_found); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._nth[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._nth["_"]; + if (or__3443__auto____$1) { + return or__3443__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 obj4982 = {}; + return obj4982; +}(); +cljs.core.ISeq = function() { + var obj4984 = {}; + return obj4984; +}(); +cljs.core._first = function _first(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISeq$_first$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISeq$_first$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._first[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._first["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISeq$_rest$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISeq$_rest$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._rest[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._rest["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISeq.-rest", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.INext = function() { + var obj4986 = {}; + return obj4986; +}(); +cljs.core._next = function _next(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$INext$_next$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$INext$_next$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._next[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._next["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "INext.-next", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.ILookup = function() { + var obj4988 = {}; + return obj4988; +}(); +cljs.core._lookup = function() { + var _lookup = null; + var _lookup__2 = function(o, k) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ILookup$_lookup$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ILookup$_lookup$arity$2(o, k); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._lookup[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._lookup["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ILookup$_lookup$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ILookup$_lookup$arity$3(o, k, not_found); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._lookup[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._lookup["_"]; + if (or__3443__auto____$1) { + return or__3443__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 obj4990 = {}; + return obj4990; +}(); +cljs.core._contains_key_QMARK_ = function _contains_key_QMARK_(coll, k) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IAssociative$_contains_key_QMARK_$arity$2(coll, k); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._contains_key_QMARK_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._contains_key_QMARK_["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IAssociative$_assoc$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IAssociative$_assoc$arity$3(coll, k, v); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._assoc[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._assoc["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IAssociative.-assoc", coll); + } + } + }().call(null, coll, k, v); + } +}; +cljs.core.IMap = function() { + var obj4992 = {}; + return obj4992; +}(); +cljs.core._dissoc = function _dissoc(coll, k) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IMap$_dissoc$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IMap$_dissoc$arity$2(coll, k); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._dissoc[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._dissoc["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IMap.-dissoc", coll); + } + } + }().call(null, coll, k); + } +}; +cljs.core.IMapEntry = function() { + var obj4994 = {}; + return obj4994; +}(); +cljs.core._key = function _key(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IMapEntry$_key$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IMapEntry$_key$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._key[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._key["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IMapEntry$_val$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IMapEntry$_val$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._val[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._val["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IMapEntry.-val", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.ISet = function() { + var obj4996 = {}; + return obj4996; +}(); +cljs.core._disjoin = function _disjoin(coll, v) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISet$_disjoin$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISet$_disjoin$arity$2(coll, v); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._disjoin[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._disjoin["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISet.-disjoin", coll); + } + } + }().call(null, coll, v); + } +}; +cljs.core.IStack = function() { + var obj4998 = {}; + return obj4998; +}(); +cljs.core._peek = function _peek(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IStack$_peek$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IStack$_peek$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._peek[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._peek["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IStack$_pop$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IStack$_pop$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._pop[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._pop["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IStack.-pop", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.IVector = function() { + var obj5000 = {}; + return obj5000; +}(); +cljs.core._assoc_n = function _assoc_n(coll, n, val) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IVector$_assoc_n$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IVector$_assoc_n$arity$3(coll, n, val); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._assoc_n[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._assoc_n["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IVector.-assoc-n", coll); + } + } + }().call(null, coll, n, val); + } +}; +cljs.core.IDeref = function() { + var obj5002 = {}; + return obj5002; +}(); +cljs.core._deref = function _deref(o) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IDeref$_deref$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IDeref$_deref$arity$1(o); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._deref[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._deref["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IDeref.-deref", o); + } + } + }().call(null, o); + } +}; +cljs.core.IDerefWithTimeout = function() { + var obj5004 = {}; + return obj5004; +}(); +cljs.core._deref_with_timeout = function _deref_with_timeout(o, msec, timeout_val) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IDerefWithTimeout$_deref_with_timeout$arity$3(o, msec, timeout_val); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._deref_with_timeout[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._deref_with_timeout["_"]; + if (or__3443__auto____$1) { + return or__3443__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 obj5006 = {}; + return obj5006; +}(); +cljs.core._meta = function _meta(o) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IMeta$_meta$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IMeta$_meta$arity$1(o); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._meta[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._meta["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IMeta.-meta", o); + } + } + }().call(null, o); + } +}; +cljs.core.IWithMeta = function() { + var obj5008 = {}; + return obj5008; +}(); +cljs.core._with_meta = function _with_meta(o, meta) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IWithMeta$_with_meta$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IWithMeta$_with_meta$arity$2(o, meta); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._with_meta[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._with_meta["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IWithMeta.-with-meta", o); + } + } + }().call(null, o, meta); + } +}; +cljs.core.IReduce = function() { + var obj5010 = {}; + return obj5010; +}(); +cljs.core._reduce = function() { + var _reduce = null; + var _reduce__2 = function(coll, f) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IReduce$_reduce$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IReduce$_reduce$arity$2(coll, f); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._reduce[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._reduce["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IReduce$_reduce$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IReduce$_reduce$arity$3(coll, f, start); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._reduce[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._reduce["_"]; + if (or__3443__auto____$1) { + return or__3443__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 obj5012 = {}; + return obj5012; +}(); +cljs.core._kv_reduce = function _kv_reduce(coll, f, init) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IKVReduce$_kv_reduce$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IKVReduce$_kv_reduce$arity$3(coll, f, init); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._kv_reduce[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._kv_reduce["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IKVReduce.-kv-reduce", coll); + } + } + }().call(null, coll, f, init); + } +}; +cljs.core.IEquiv = function() { + var obj5014 = {}; + return obj5014; +}(); +cljs.core._equiv = function _equiv(o, other) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IEquiv$_equiv$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IEquiv$_equiv$arity$2(o, other); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._equiv[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._equiv["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IEquiv.-equiv", o); + } + } + }().call(null, o, other); + } +}; +cljs.core.IHash = function() { + var obj5016 = {}; + return obj5016; +}(); +cljs.core._hash = function _hash(o) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IHash$_hash$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IHash$_hash$arity$1(o); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._hash[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._hash["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IHash.-hash", o); + } + } + }().call(null, o); + } +}; +cljs.core.ISeqable = function() { + var obj5018 = {}; + return obj5018; +}(); +cljs.core._seq = function _seq(o) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ISeqable$_seq$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ISeqable$_seq$arity$1(o); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._seq[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._seq["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISeqable.-seq", o); + } + } + }().call(null, o); + } +}; +cljs.core.ISequential = function() { + var obj5020 = {}; + return obj5020; +}(); +cljs.core.IList = function() { + var obj5022 = {}; + return obj5022; +}(); +cljs.core.IRecord = function() { + var obj5024 = {}; + return obj5024; +}(); +cljs.core.IReversible = function() { + var obj5026 = {}; + return obj5026; +}(); +cljs.core._rseq = function _rseq(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IReversible$_rseq$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IReversible$_rseq$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._rseq[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._rseq["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IReversible.-rseq", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.ISorted = function() { + var obj5028 = {}; + return obj5028; +}(); +cljs.core._sorted_seq = function _sorted_seq(coll, ascending_QMARK_) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISorted$_sorted_seq$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISorted$_sorted_seq$arity$2(coll, ascending_QMARK_); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._sorted_seq[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._sorted_seq["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISorted$_sorted_seq_from$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISorted$_sorted_seq_from$arity$3(coll, k, ascending_QMARK_); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._sorted_seq_from[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._sorted_seq_from["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISorted$_entry_key$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISorted$_entry_key$arity$2(coll, entry); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._entry_key[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._entry_key["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$ISorted$_comparator$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$ISorted$_comparator$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._comparator[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._comparator["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISorted.-comparator", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.IWriter = function() { + var obj5030 = {}; + return obj5030; +}(); +cljs.core._write = function _write(writer, s) { + if (function() { + var and__3431__auto__ = writer; + if (and__3431__auto__) { + return writer.cljs$core$IWriter$_write$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return writer.cljs$core$IWriter$_write$arity$2(writer, s); + } else { + var x__4070__auto__ = writer == null ? null : writer; + return function() { + var or__3443__auto__ = cljs.core._write[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._write["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = writer; + if (and__3431__auto__) { + return writer.cljs$core$IWriter$_flush$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return writer.cljs$core$IWriter$_flush$arity$1(writer); + } else { + var x__4070__auto__ = writer == null ? null : writer; + return function() { + var or__3443__auto__ = cljs.core._flush[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._flush["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IWriter.-flush", writer); + } + } + }().call(null, writer); + } +}; +cljs.core.IPrintWithWriter = function() { + var obj5032 = {}; + return obj5032; +}(); +cljs.core._pr_writer = function _pr_writer(o, writer, opts) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IPrintWithWriter$_pr_writer$arity$3(o, writer, opts); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._pr_writer[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._pr_writer["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IPrintWithWriter.-pr-writer", o); + } + } + }().call(null, o, writer, opts); + } +}; +cljs.core.IPending = function() { + var obj5034 = {}; + return obj5034; +}(); +cljs.core._realized_QMARK_ = function _realized_QMARK_(d) { + if (function() { + var and__3431__auto__ = d; + if (and__3431__auto__) { + return d.cljs$core$IPending$_realized_QMARK_$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return d.cljs$core$IPending$_realized_QMARK_$arity$1(d); + } else { + var x__4070__auto__ = d == null ? null : d; + return function() { + var or__3443__auto__ = cljs.core._realized_QMARK_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._realized_QMARK_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IPending.-realized?", d); + } + } + }().call(null, d); + } +}; +cljs.core.IWatchable = function() { + var obj5036 = {}; + return obj5036; +}(); +cljs.core._notify_watches = function _notify_watches(this$, oldval, newval) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IWatchable$_notify_watches$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IWatchable$_notify_watches$arity$3(this$, oldval, newval); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._notify_watches[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._notify_watches["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IWatchable$_add_watch$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IWatchable$_add_watch$arity$3(this$, key, f); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._add_watch[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._add_watch["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.cljs$core$IWatchable$_remove_watch$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return this$.cljs$core$IWatchable$_remove_watch$arity$2(this$, key); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = cljs.core._remove_watch[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._remove_watch["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IWatchable.-remove-watch", this$); + } + } + }().call(null, this$, key); + } +}; +cljs.core.IEditableCollection = function() { + var obj5038 = {}; + return obj5038; +}(); +cljs.core._as_transient = function _as_transient(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IEditableCollection$_as_transient$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IEditableCollection$_as_transient$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._as_transient[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._as_transient["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IEditableCollection.-as-transient", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.ITransientCollection = function() { + var obj5040 = {}; + return obj5040; +}(); +cljs.core._conj_BANG_ = function _conj_BANG_(tcoll, val) { + if (function() { + var and__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientCollection$_conj_BANG_$arity$2(tcoll, val); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._conj_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._conj_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientCollection$_persistent_BANG_$arity$1(tcoll); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._persistent_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._persistent_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ITransientCollection.-persistent!", tcoll); + } + } + }().call(null, tcoll); + } +}; +cljs.core.ITransientAssociative = function() { + var obj5042 = {}; + return obj5042; +}(); +cljs.core._assoc_BANG_ = function _assoc_BANG_(tcoll, key, val) { + if (function() { + var and__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientAssociative$_assoc_BANG_$arity$3(tcoll, key, val); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._assoc_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._assoc_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ITransientAssociative.-assoc!", tcoll); + } + } + }().call(null, tcoll, key, val); + } +}; +cljs.core.ITransientMap = function() { + var obj5044 = {}; + return obj5044; +}(); +cljs.core._dissoc_BANG_ = function _dissoc_BANG_(tcoll, key) { + if (function() { + var and__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientMap$_dissoc_BANG_$arity$2(tcoll, key); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._dissoc_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._dissoc_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ITransientMap.-dissoc!", tcoll); + } + } + }().call(null, tcoll, key); + } +}; +cljs.core.ITransientVector = function() { + var obj5046 = {}; + return obj5046; +}(); +cljs.core._assoc_n_BANG_ = function _assoc_n_BANG_(tcoll, n, val) { + if (function() { + var and__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientVector$_assoc_n_BANG_$arity$3(tcoll, n, val); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._assoc_n_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._assoc_n_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientVector$_pop_BANG_$arity$1(tcoll); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._pop_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._pop_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ITransientVector.-pop!", tcoll); + } + } + }().call(null, tcoll); + } +}; +cljs.core.ITransientSet = function() { + var obj5048 = {}; + return obj5048; +}(); +cljs.core._disjoin_BANG_ = function _disjoin_BANG_(tcoll, v) { + if (function() { + var and__3431__auto__ = tcoll; + if (and__3431__auto__) { + return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return tcoll.cljs$core$ITransientSet$_disjoin_BANG_$arity$2(tcoll, v); + } else { + var x__4070__auto__ = tcoll == null ? null : tcoll; + return function() { + var or__3443__auto__ = cljs.core._disjoin_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._disjoin_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ITransientSet.-disjoin!", tcoll); + } + } + }().call(null, tcoll, v); + } +}; +cljs.core.IComparable = function() { + var obj5050 = {}; + return obj5050; +}(); +cljs.core._compare = function _compare(x, y) { + if (function() { + var and__3431__auto__ = x; + if (and__3431__auto__) { + return x.cljs$core$IComparable$_compare$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return x.cljs$core$IComparable$_compare$arity$2(x, y); + } else { + var x__4070__auto__ = x == null ? null : x; + return function() { + var or__3443__auto__ = cljs.core._compare[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._compare["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IComparable.-compare", x); + } + } + }().call(null, x, y); + } +}; +cljs.core.IChunk = function() { + var obj5052 = {}; + return obj5052; +}(); +cljs.core._drop_first = function _drop_first(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IChunk$_drop_first$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IChunk$_drop_first$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._drop_first[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._drop_first["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IChunk.-drop-first", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.IChunkedSeq = function() { + var obj5054 = {}; + return obj5054; +}(); +cljs.core._chunked_first = function _chunked_first(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IChunkedSeq$_chunked_first$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._chunked_first[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._chunked_first["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IChunkedSeq$_chunked_rest$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._chunked_rest[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._chunked_rest["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IChunkedSeq.-chunked-rest", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.IChunkedNext = function() { + var obj5056 = {}; + return obj5056; +}(); +cljs.core._chunked_next = function _chunked_next(coll) { + if (function() { + var and__3431__auto__ = coll; + if (and__3431__auto__) { + return coll.cljs$core$IChunkedNext$_chunked_next$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return coll.cljs$core$IChunkedNext$_chunked_next$arity$1(coll); + } else { + var x__4070__auto__ = coll == null ? null : coll; + return function() { + var or__3443__auto__ = cljs.core._chunked_next[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._chunked_next["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IChunkedNext.-chunked-next", coll); + } + } + }().call(null, coll); + } +}; +cljs.core.INamed = function() { + var obj5058 = {}; + return obj5058; +}(); +cljs.core._name = function _name(x) { + if (function() { + var and__3431__auto__ = x; + if (and__3431__auto__) { + return x.cljs$core$INamed$_name$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return x.cljs$core$INamed$_name$arity$1(x); + } else { + var x__4070__auto__ = x == null ? null : x; + return function() { + var or__3443__auto__ = cljs.core._name[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._name["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = x; + if (and__3431__auto__) { + return x.cljs$core$INamed$_namespace$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return x.cljs$core$INamed$_namespace$arity$1(x); + } else { + var x__4070__auto__ = x == null ? null : x; + return function() { + var or__3443__auto__ = cljs.core._namespace[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._namespace["_"]; + if (or__3443__auto____$1) { + return or__3443__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3431__auto__ = cljs.core.not.call(null, a.ns); + if (and__3431__auto__) { + return b.ns; + } else { + return and__3431__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__._hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_symbol.call(null, sym__$1); + self__._hash = h__3854__auto____$1; + return h__3854__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__5060 = null; + var G__5060__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__5060__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__5060 = function(self__, coll, not_found) { + switch(arguments.length) { + case 2: + return G__5060__2.call(this, self__, coll); + case 3: + return G__5060__3.call(this, self__, coll, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5060; +}(); +cljs.core.Symbol.prototype.apply = function(self__, args5059) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5059))); +}; +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.clone = function clone(value) { + return cljs.core._clone.call(null, value); +}; +cljs.core.cloneable_QMARK_ = function cloneable_QMARK_(value) { + var G__5062 = value; + if (G__5062) { + var bit__4093__auto__ = G__5062.cljs$lang$protocol_mask$partition1$ & 8192; + if (bit__4093__auto__ || G__5062.cljs$core$ICloneable$) { + return true; + } else { + if (!G__5062.cljs$lang$protocol_mask$partition1$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICloneable, G__5062); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICloneable, G__5062); + } +}; +cljs.core.seq = function seq(coll) { + if (coll == null) { + return null; + } else { + if (function() { + var G__5064 = coll; + if (G__5064) { + var bit__4086__auto__ = G__5064.cljs$lang$protocol_mask$partition0$ & 8388608; + if (bit__4086__auto__ || G__5064.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__5066 = coll; + if (G__5066) { + var bit__4086__auto__ = G__5066.cljs$lang$protocol_mask$partition0$ & 64; + if (bit__4086__auto__ || G__5066.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__5068 = coll; + if (G__5068) { + var bit__4086__auto__ = G__5068.cljs$lang$protocol_mask$partition0$ & 64; + if (bit__4086__auto__ || G__5068.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__5070 = coll; + if (G__5070) { + var bit__4086__auto__ = G__5070.cljs$lang$protocol_mask$partition0$ & 128; + if (bit__4086__auto__ || G__5070.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__5071__delegate = function(x, y, more) { + while (true) { + if (_EQ_.call(null, x, y)) { + if (cljs.core.next.call(null, more)) { + var G__5072 = y; + var G__5073 = cljs.core.first.call(null, more); + var G__5074 = cljs.core.next.call(null, more); + x = G__5072; + y = G__5073; + more = G__5074; + continue; + } else { + return _EQ_.call(null, y, cljs.core.first.call(null, more)); + } + } else { + return false; + } + break; + } + }; + var G__5071 = 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__5071__delegate.call(this, x, y, more); + }; + G__5071.cljs$lang$maxFixedArity = 2; + G__5071.cljs$lang$applyTo = function(arglist__5075) { + var x = cljs.core.first(arglist__5075); + arglist__5075 = cljs.core.next(arglist__5075); + var y = cljs.core.first(arglist__5075); + var more = cljs.core.rest(arglist__5075); + return G__5071__delegate(x, y, more); + }; + G__5071.cljs$core$IFn$_invoke$arity$variadic = G__5071__delegate; + return G__5071; + }(); + _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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5076 = nval; + var G__5077 = n + 1; + val = G__5076; + n = G__5077; + 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__5078 = nval; + var G__5079 = n + 1; + val__$1 = G__5078; + n = G__5079; + 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__5080 = nval; + var G__5081 = n + 1; + val__$1 = G__5080; + n = G__5081; + 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__5082 = nval; + var G__5083 = n + 1; + val = G__5082; + n = G__5083; + 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__5084 = nval; + var G__5085 = n + 1; + val__$1 = G__5084; + n = G__5085; + 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__5086 = nval; + var G__5087 = n + 1; + val__$1 = G__5086; + n = G__5087; + 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__5089 = x; + if (G__5089) { + var bit__4093__auto__ = G__5089.cljs$lang$protocol_mask$partition0$ & 2; + if (bit__4093__auto__ || G__5089.cljs$core$ICounted$) { + return true; + } else { + if (!G__5089.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, G__5089); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICounted, G__5089); + } +}; +cljs.core.indexed_QMARK_ = function indexed_QMARK_(x) { + var G__5091 = x; + if (G__5091) { + var bit__4093__auto__ = G__5091.cljs$lang$protocol_mask$partition0$ & 16; + if (bit__4093__auto__ || G__5091.cljs$core$IIndexed$) { + return true; + } else { + if (!G__5091.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, G__5091); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IIndexed, G__5091); + } +}; +cljs.core.IndexedSeq = function(arr, i) { + this.arr = arr; + this.i = i; + this.cljs$lang$protocol_mask$partition0$ = 166199550; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.IndexedSeq.cljs$lang$type = true; +cljs.core.IndexedSeq.cljs$lang$ctorStr = "cljs.core/IndexedSeq"; +cljs.core.IndexedSeq.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.IndexedSeq(self__.arr, self__.i); +}; +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$partition0$ = 32374862; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.RSeq.cljs$lang$type = true; +cljs.core.RSeq.cljs$lang$ctorStr = "cljs.core/RSeq"; +cljs.core.RSeq.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.RSeq(self__.ci, self__.i, self__.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__5092 = sn; + s = G__5092; + 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__5093__delegate = function(coll, x, xs) { + while (true) { + if (cljs.core.truth_(xs)) { + var G__5094 = conj.call(null, coll, x); + var G__5095 = cljs.core.first.call(null, xs); + var G__5096 = cljs.core.next.call(null, xs); + coll = G__5094; + x = G__5095; + xs = G__5096; + continue; + } else { + return conj.call(null, coll, x); + } + break; + } + }; + var G__5093 = 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__5093__delegate.call(this, coll, x, xs); + }; + G__5093.cljs$lang$maxFixedArity = 2; + G__5093.cljs$lang$applyTo = function(arglist__5097) { + var coll = cljs.core.first(arglist__5097); + arglist__5097 = cljs.core.next(arglist__5097); + var x = cljs.core.first(arglist__5097); + var xs = cljs.core.rest(arglist__5097); + return G__5093__delegate(coll, x, xs); + }; + G__5093.cljs$core$IFn$_invoke$arity$variadic = G__5093__delegate; + return G__5093; + }(); + 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__5098 = cljs.core.next.call(null, s); + var G__5099 = acc + 1; + s = G__5098; + acc = G__5099; + continue; + } + break; + } +}; +cljs.core.count = function count(coll) { + if (!(coll == null)) { + if (function() { + var G__5101 = coll; + if (G__5101) { + var bit__4086__auto__ = G__5101.cljs$lang$protocol_mask$partition0$ & 2; + if (bit__4086__auto__ || G__5101.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__5102 = cljs.core.next.call(null, coll); + var G__5103 = n - 1; + coll = G__5102; + n = G__5103; + 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__5104 = cljs.core.next.call(null, coll); + var G__5105 = n - 1; + var G__5106 = not_found; + coll = G__5104; + n = G__5105; + not_found = G__5106; + 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__5111 = coll; + if (G__5111) { + var bit__4086__auto__ = G__5111.cljs$lang$protocol_mask$partition0$ & 16; + if (bit__4086__auto__ || G__5111.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__5112 = coll; + if (G__5112) { + var bit__4093__auto__ = G__5112.cljs$lang$protocol_mask$partition0$ & 64; + if (bit__4093__auto__ || G__5112.cljs$core$ISeq$) { + return true; + } else { + if (!G__5112.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__5112); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__5112); + } + }()) { + 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__5113 = coll; + if (G__5113) { + var bit__4086__auto__ = G__5113.cljs$lang$protocol_mask$partition0$ & 16; + if (bit__4086__auto__ || G__5113.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__5114 = coll; + if (G__5114) { + var bit__4093__auto__ = G__5114.cljs$lang$protocol_mask$partition0$ & 64; + if (bit__4093__auto__ || G__5114.cljs$core$ISeq$) { + return true; + } else { + if (!G__5114.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__5114); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__5114); + } + }()) { + 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__5117 = o; + if (G__5117) { + var bit__4086__auto__ = G__5117.cljs$lang$protocol_mask$partition0$ & 256; + if (bit__4086__auto__ || G__5117.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__5118 = o; + if (G__5118) { + var bit__4086__auto__ = G__5118.cljs$lang$protocol_mask$partition0$ & 256; + if (bit__4086__auto__ || G__5118.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__5119__delegate = function(coll, k, v, kvs) { + while (true) { + var ret = assoc.call(null, coll, k, v); + if (cljs.core.truth_(kvs)) { + var G__5120 = ret; + var G__5121 = cljs.core.first.call(null, kvs); + var G__5122 = cljs.core.second.call(null, kvs); + var G__5123 = cljs.core.nnext.call(null, kvs); + coll = G__5120; + k = G__5121; + v = G__5122; + kvs = G__5123; + continue; + } else { + return ret; + } + break; + } + }; + var G__5119 = 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__5119__delegate.call(this, coll, k, v, kvs); + }; + G__5119.cljs$lang$maxFixedArity = 3; + G__5119.cljs$lang$applyTo = function(arglist__5124) { + var coll = cljs.core.first(arglist__5124); + arglist__5124 = cljs.core.next(arglist__5124); + var k = cljs.core.first(arglist__5124); + arglist__5124 = cljs.core.next(arglist__5124); + var v = cljs.core.first(arglist__5124); + var kvs = cljs.core.rest(arglist__5124); + return G__5119__delegate(coll, k, v, kvs); + }; + G__5119.cljs$core$IFn$_invoke$arity$variadic = G__5119__delegate; + return G__5119; + }(); + 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__5125__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__5126 = ret; + var G__5127 = cljs.core.first.call(null, ks); + var G__5128 = cljs.core.next.call(null, ks); + coll = G__5126; + k = G__5127; + ks = G__5128; + continue; + } else { + return ret; + } + } + break; + } + }; + var G__5125 = 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__5125__delegate.call(this, coll, k, ks); + }; + G__5125.cljs$lang$maxFixedArity = 2; + G__5125.cljs$lang$applyTo = function(arglist__5129) { + var coll = cljs.core.first(arglist__5129); + arglist__5129 = cljs.core.next(arglist__5129); + var k = cljs.core.first(arglist__5129); + var ks = cljs.core.rest(arglist__5129); + return G__5125__delegate(coll, k, ks); + }; + G__5125.cljs$core$IFn$_invoke$arity$variadic = G__5125__delegate; + return G__5125; + }(); + 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__3443__auto__ = goog.isFunction(f); + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var G__5133 = f; + if (G__5133) { + var bit__4093__auto__ = null; + if (cljs.core.truth_(function() { + var or__3443__auto____$1 = bit__4093__auto__; + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + return G__5133.cljs$core$Fn$; + } + }())) { + return true; + } else { + if (!G__5133.cljs$lang$protocol_mask$partition$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.Fn, G__5133); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.Fn, G__5133); + } + } +}; +cljs.core.with_meta = function with_meta(o, meta) { + if (cljs.core.fn_QMARK_.call(null, o) && !function() { + var G__5141 = o; + if (G__5141) { + var bit__4093__auto__ = G__5141.cljs$lang$protocol_mask$partition0$ & 262144; + if (bit__4093__auto__ || G__5141.cljs$core$IWithMeta$) { + return true; + } else { + if (!G__5141.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IWithMeta, G__5141); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IWithMeta, G__5141); + } + }()) { + return with_meta.call(null, function() { + if (typeof cljs.core.t5142 !== "undefined") { + } else { + cljs.core.t5142 = function(meta, o, with_meta, meta5143) { + this.meta = meta; + this.o = o; + this.with_meta = with_meta; + this.meta5143 = meta5143; + this.cljs$lang$protocol_mask$partition1$ = 0; + this.cljs$lang$protocol_mask$partition0$ = 393217; + }; + cljs.core.t5142.cljs$lang$type = true; + cljs.core.t5142.cljs$lang$ctorStr = "cljs.core/t5142"; + cljs.core.t5142.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__auto__, "cljs.core/t5142"); + }; + cljs.core.t5142.prototype.call = function() { + var G__5146__delegate = function(self__, args) { + var self____$1 = this; + var _ = self____$1; + return cljs.core.apply.call(null, self__.o, args); + }; + var G__5146 = 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__5146__delegate.call(this, self__, args); + }; + G__5146.cljs$lang$maxFixedArity = 1; + G__5146.cljs$lang$applyTo = function(arglist__5147) { + var self__ = cljs.core.first(arglist__5147); + var args = cljs.core.rest(arglist__5147); + return G__5146__delegate(self__, args); + }; + G__5146.cljs$core$IFn$_invoke$arity$variadic = G__5146__delegate; + return G__5146; + }(); + cljs.core.t5142.prototype.apply = function(self__, args5145) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5145))); + }; + cljs.core.t5142.prototype.cljs$core$IFn$_invoke$arity$2 = function() { + var G__5148__delegate = function(args) { + var _ = this; + return cljs.core.apply.call(null, self__.o, args); + }; + var G__5148 = 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__5148__delegate.call(this, args); + }; + G__5148.cljs$lang$maxFixedArity = 0; + G__5148.cljs$lang$applyTo = function(arglist__5149) { + var args = cljs.core.seq(arglist__5149); + return G__5148__delegate(args); + }; + G__5148.cljs$core$IFn$_invoke$arity$variadic = G__5148__delegate; + return G__5148; + }(); + cljs.core.t5142.prototype.cljs$core$Fn$ = true; + cljs.core.t5142.prototype.cljs$core$IMeta$_meta$arity$1 = function(_5144) { + var self__ = this; + var _5144__$1 = this; + return self__.meta5143; + }; + cljs.core.t5142.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_5144, meta5143__$1) { + var self__ = this; + var _5144__$1 = this; + return new cljs.core.t5142(self__.meta, self__.o, self__.with_meta, meta5143__$1); + }; + cljs.core.__GT_t5142 = function __GT_t5142(meta__$1, o__$1, with_meta__$1, meta5143) { + return new cljs.core.t5142(meta__$1, o__$1, with_meta__$1, meta5143); + }; + } + return new cljs.core.t5142(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__3431__auto__ = !(o == null); + if (and__3431__auto__) { + var G__5153 = o; + if (G__5153) { + var bit__4093__auto__ = G__5153.cljs$lang$protocol_mask$partition0$ & 131072; + if (bit__4093__auto__ || G__5153.cljs$core$IMeta$) { + return true; + } else { + if (!G__5153.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__5153); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__5153); + } + } else { + return and__3431__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__5154__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__5155 = ret; + var G__5156 = cljs.core.first.call(null, ks); + var G__5157 = cljs.core.next.call(null, ks); + coll = G__5155; + k = G__5156; + ks = G__5157; + continue; + } else { + return ret; + } + } + break; + } + }; + var G__5154 = 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__5154__delegate.call(this, coll, k, ks); + }; + G__5154.cljs$lang$maxFixedArity = 2; + G__5154.cljs$lang$applyTo = function(arglist__5158) { + var coll = cljs.core.first(arglist__5158); + arglist__5158 = cljs.core.next(arglist__5158); + var k = cljs.core.first(arglist__5158); + var ks = cljs.core.rest(arglist__5158); + return G__5154__delegate(coll, k, ks); + }; + G__5154.cljs$core$IFn$_invoke$arity$variadic = G__5154__delegate; + return G__5154; + }(); + 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 obj5160 = {}; + return obj5160; +}(); +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 obj5164 = {}; + return obj5164; + }(); + 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__5166 = o; + if (G__5166) { + var bit__4086__auto__ = G__5166.cljs$lang$protocol_mask$partition0$ & 4194304; + if (bit__4086__auto__ || G__5166.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__5168 = x; + if (G__5168) { + var bit__4093__auto__ = G__5168.cljs$lang$protocol_mask$partition0$ & 8; + if (bit__4093__auto__ || G__5168.cljs$core$ICollection$) { + return true; + } else { + if (!G__5168.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICollection, G__5168); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ICollection, G__5168); + } + } +}; +cljs.core.set_QMARK_ = function set_QMARK_(x) { + if (x == null) { + return false; + } else { + var G__5170 = x; + if (G__5170) { + var bit__4093__auto__ = G__5170.cljs$lang$protocol_mask$partition0$ & 4096; + if (bit__4093__auto__ || G__5170.cljs$core$ISet$) { + return true; + } else { + if (!G__5170.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISet, G__5170); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISet, G__5170); + } + } +}; +cljs.core.associative_QMARK_ = function associative_QMARK_(x) { + var G__5172 = x; + if (G__5172) { + var bit__4093__auto__ = G__5172.cljs$lang$protocol_mask$partition0$ & 512; + if (bit__4093__auto__ || G__5172.cljs$core$IAssociative$) { + return true; + } else { + if (!G__5172.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IAssociative, G__5172); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IAssociative, G__5172); + } +}; +cljs.core.sequential_QMARK_ = function sequential_QMARK_(x) { + var G__5174 = x; + if (G__5174) { + var bit__4093__auto__ = G__5174.cljs$lang$protocol_mask$partition0$ & 16777216; + if (bit__4093__auto__ || G__5174.cljs$core$ISequential$) { + return true; + } else { + if (!G__5174.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISequential, G__5174); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISequential, G__5174); + } +}; +cljs.core.sorted_QMARK_ = function sorted_QMARK_(x) { + var G__5176 = x; + if (G__5176) { + var bit__4093__auto__ = G__5176.cljs$lang$protocol_mask$partition0$ & 268435456; + if (bit__4093__auto__ || G__5176.cljs$core$ISorted$) { + return true; + } else { + if (!G__5176.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISorted, G__5176); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISorted, G__5176); + } +}; +cljs.core.reduceable_QMARK_ = function reduceable_QMARK_(x) { + var G__5178 = x; + if (G__5178) { + var bit__4093__auto__ = G__5178.cljs$lang$protocol_mask$partition0$ & 524288; + if (bit__4093__auto__ || G__5178.cljs$core$IReduce$) { + return true; + } else { + if (!G__5178.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, G__5178); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReduce, G__5178); + } +}; +cljs.core.map_QMARK_ = function map_QMARK_(x) { + if (x == null) { + return false; + } else { + var G__5180 = x; + if (G__5180) { + var bit__4093__auto__ = G__5180.cljs$lang$protocol_mask$partition0$ & 1024; + if (bit__4093__auto__ || G__5180.cljs$core$IMap$) { + return true; + } else { + if (!G__5180.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMap, G__5180); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMap, G__5180); + } + } +}; +cljs.core.vector_QMARK_ = function vector_QMARK_(x) { + var G__5182 = x; + if (G__5182) { + var bit__4093__auto__ = G__5182.cljs$lang$protocol_mask$partition0$ & 16384; + if (bit__4093__auto__ || G__5182.cljs$core$IVector$) { + return true; + } else { + if (!G__5182.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IVector, G__5182); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IVector, G__5182); + } +}; +cljs.core.chunked_seq_QMARK_ = function chunked_seq_QMARK_(x) { + var G__5184 = x; + if (G__5184) { + var bit__4086__auto__ = G__5184.cljs$lang$protocol_mask$partition1$ & 512; + if (bit__4086__auto__ || G__5184.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 obj5188 = {}; + return obj5188; + }; + var js_obj__1 = function() { + var G__5189__delegate = function(keyvals) { + return cljs.core.apply.call(null, goog.object.create, keyvals); + }; + var G__5189 = function(var_args) { + var keyvals = null; + if (arguments.length > 0) { + keyvals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5189__delegate.call(this, keyvals); + }; + G__5189.cljs$lang$maxFixedArity = 0; + G__5189.cljs$lang$applyTo = function(arglist__5190) { + var keyvals = cljs.core.seq(arglist__5190); + return G__5189__delegate(keyvals); + }; + G__5189.cljs$core$IFn$_invoke$arity$variadic = G__5189__delegate; + return G__5189; + }(); + 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__5191 = i__$1 + 1; + var G__5192 = j__$1 + 1; + var G__5193 = len__$1 - 1; + i__$1 = G__5191; + j__$1 = G__5192; + len__$1 = G__5193; + 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__5194 = i__$1 - 1; + var G__5195 = j__$1 - 1; + var G__5196 = len__$1 - 1; + i__$1 = G__5194; + j__$1 = G__5195; + len__$1 = G__5196; + continue; + } + break; + } +}; +cljs.core.lookup_sentinel = function() { + var obj5198 = {}; + return obj5198; +}(); +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__5200 = s; + if (G__5200) { + var bit__4093__auto__ = G__5200.cljs$lang$protocol_mask$partition0$ & 64; + if (bit__4093__auto__ || G__5200.cljs$core$ISeq$) { + return true; + } else { + if (!G__5200.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__5200); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeq, G__5200); + } + } +}; +cljs.core.seqable_QMARK_ = function seqable_QMARK_(s) { + var G__5202 = s; + if (G__5202) { + var bit__4093__auto__ = G__5202.cljs$lang$protocol_mask$partition0$ & 8388608; + if (bit__4093__auto__ || G__5202.cljs$core$ISeqable$) { + return true; + } else { + if (!G__5202.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__5202); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__5202); + } +}; +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__3443__auto__ = cljs.core.fn_QMARK_.call(null, f); + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var G__5206 = f; + if (G__5206) { + var bit__4093__auto__ = G__5206.cljs$lang$protocol_mask$partition0$ & 1; + if (bit__4093__auto__ || G__5206.cljs$core$IFn$) { + return true; + } else { + if (!G__5206.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IFn, G__5206); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IFn, G__5206); + } + } +}; +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__5207__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__5208 = cljs.core.conj.call(null, s, x__$1); + var G__5209 = etc; + s = G__5208; + xs = G__5209; + continue; + } + } else { + return true; + } + break; + } + } else { + return false; + } + }; + var G__5207 = 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__5207__delegate.call(this, x, y, more); + }; + G__5207.cljs$lang$maxFixedArity = 2; + G__5207.cljs$lang$applyTo = function(arglist__5210) { + var x = cljs.core.first(arglist__5210); + arglist__5210 = cljs.core.next(arglist__5210); + var y = cljs.core.first(arglist__5210); + var more = cljs.core.rest(arglist__5210); + return G__5207__delegate(x, y, more); + }; + G__5207.cljs$core$IFn$_invoke$arity$variadic = G__5207__delegate; + return G__5207; + }(); + 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__3443__auto__ = cljs.core.seq.call(null, coll); + if (or__3443__auto__) { + return or__3443__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__5212 = x; + if (G__5212) { + var bit__4086__auto__ = G__5212.cljs$lang$protocol_mask$partition1$ & 2048; + if (bit__4086__auto__ || G__5212.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__5213 = xs; + var G__5214 = ys; + var G__5215 = len; + var G__5216 = n + 1; + xs = G__5213; + ys = G__5214; + len = G__5215; + n = G__5216; + 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__5217 = nval; + var G__5218 = cljs.core.next.call(null, coll__$1); + val__$1 = G__5217; + coll__$1 = G__5218; + 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__5221 = coll; + if (G__5221) { + var bit__4086__auto__ = G__5221.cljs$lang$protocol_mask$partition0$ & 524288; + if (bit__4086__auto__ || G__5221.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__5222 = coll; + if (G__5222) { + var bit__4086__auto__ = G__5222.cljs$lang$protocol_mask$partition0$ & 524288; + if (bit__4086__auto__ || G__5222.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__5223__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, _PLUS_, x + y, more); + }; + var G__5223 = 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__5223__delegate.call(this, x, y, more); + }; + G__5223.cljs$lang$maxFixedArity = 2; + G__5223.cljs$lang$applyTo = function(arglist__5224) { + var x = cljs.core.first(arglist__5224); + arglist__5224 = cljs.core.next(arglist__5224); + var y = cljs.core.first(arglist__5224); + var more = cljs.core.rest(arglist__5224); + return G__5223__delegate(x, y, more); + }; + G__5223.cljs$core$IFn$_invoke$arity$variadic = G__5223__delegate; + return G__5223; + }(); + _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__5225__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, _, x - y, more); + }; + var G__5225 = 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__5225__delegate.call(this, x, y, more); + }; + G__5225.cljs$lang$maxFixedArity = 2; + G__5225.cljs$lang$applyTo = function(arglist__5226) { + var x = cljs.core.first(arglist__5226); + arglist__5226 = cljs.core.next(arglist__5226); + var y = cljs.core.first(arglist__5226); + var more = cljs.core.rest(arglist__5226); + return G__5225__delegate(x, y, more); + }; + G__5225.cljs$core$IFn$_invoke$arity$variadic = G__5225__delegate; + return G__5225; + }(); + _ = 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__5227__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, _STAR_, x * y, more); + }; + var G__5227 = 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__5227__delegate.call(this, x, y, more); + }; + G__5227.cljs$lang$maxFixedArity = 2; + G__5227.cljs$lang$applyTo = function(arglist__5228) { + var x = cljs.core.first(arglist__5228); + arglist__5228 = cljs.core.next(arglist__5228); + var y = cljs.core.first(arglist__5228); + var more = cljs.core.rest(arglist__5228); + return G__5227__delegate(x, y, more); + }; + G__5227.cljs$core$IFn$_invoke$arity$variadic = G__5227__delegate; + return G__5227; + }(); + _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__5229__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, _SLASH_, _SLASH_.call(null, x, y), more); + }; + var G__5229 = 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__5229__delegate.call(this, x, y, more); + }; + G__5229.cljs$lang$maxFixedArity = 2; + G__5229.cljs$lang$applyTo = function(arglist__5230) { + var x = cljs.core.first(arglist__5230); + arglist__5230 = cljs.core.next(arglist__5230); + var y = cljs.core.first(arglist__5230); + var more = cljs.core.rest(arglist__5230); + return G__5229__delegate(x, y, more); + }; + G__5229.cljs$core$IFn$_invoke$arity$variadic = G__5229__delegate; + return G__5229; + }(); + _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__5231__delegate = function(x, y, more) { + while (true) { + if (x < y) { + if (cljs.core.next.call(null, more)) { + var G__5232 = y; + var G__5233 = cljs.core.first.call(null, more); + var G__5234 = cljs.core.next.call(null, more); + x = G__5232; + y = G__5233; + more = G__5234; + continue; + } else { + return y < cljs.core.first.call(null, more); + } + } else { + return false; + } + break; + } + }; + var G__5231 = 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__5231__delegate.call(this, x, y, more); + }; + G__5231.cljs$lang$maxFixedArity = 2; + G__5231.cljs$lang$applyTo = function(arglist__5235) { + var x = cljs.core.first(arglist__5235); + arglist__5235 = cljs.core.next(arglist__5235); + var y = cljs.core.first(arglist__5235); + var more = cljs.core.rest(arglist__5235); + return G__5231__delegate(x, y, more); + }; + G__5231.cljs$core$IFn$_invoke$arity$variadic = G__5231__delegate; + return G__5231; + }(); + _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__5236__delegate = function(x, y, more) { + while (true) { + if (x <= y) { + if (cljs.core.next.call(null, more)) { + var G__5237 = y; + var G__5238 = cljs.core.first.call(null, more); + var G__5239 = cljs.core.next.call(null, more); + x = G__5237; + y = G__5238; + more = G__5239; + continue; + } else { + return y <= cljs.core.first.call(null, more); + } + } else { + return false; + } + break; + } + }; + var G__5236 = 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__5236__delegate.call(this, x, y, more); + }; + G__5236.cljs$lang$maxFixedArity = 2; + G__5236.cljs$lang$applyTo = function(arglist__5240) { + var x = cljs.core.first(arglist__5240); + arglist__5240 = cljs.core.next(arglist__5240); + var y = cljs.core.first(arglist__5240); + var more = cljs.core.rest(arglist__5240); + return G__5236__delegate(x, y, more); + }; + G__5236.cljs$core$IFn$_invoke$arity$variadic = G__5236__delegate; + return G__5236; + }(); + _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__5241__delegate = function(x, y, more) { + while (true) { + if (x > y) { + if (cljs.core.next.call(null, more)) { + var G__5242 = y; + var G__5243 = cljs.core.first.call(null, more); + var G__5244 = cljs.core.next.call(null, more); + x = G__5242; + y = G__5243; + more = G__5244; + continue; + } else { + return y > cljs.core.first.call(null, more); + } + } else { + return false; + } + break; + } + }; + var G__5241 = 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__5241__delegate.call(this, x, y, more); + }; + G__5241.cljs$lang$maxFixedArity = 2; + G__5241.cljs$lang$applyTo = function(arglist__5245) { + var x = cljs.core.first(arglist__5245); + arglist__5245 = cljs.core.next(arglist__5245); + var y = cljs.core.first(arglist__5245); + var more = cljs.core.rest(arglist__5245); + return G__5241__delegate(x, y, more); + }; + G__5241.cljs$core$IFn$_invoke$arity$variadic = G__5241__delegate; + return G__5241; + }(); + _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__5246__delegate = function(x, y, more) { + while (true) { + if (x >= y) { + if (cljs.core.next.call(null, more)) { + var G__5247 = y; + var G__5248 = cljs.core.first.call(null, more); + var G__5249 = cljs.core.next.call(null, more); + x = G__5247; + y = G__5248; + more = G__5249; + continue; + } else { + return y >= cljs.core.first.call(null, more); + } + } else { + return false; + } + break; + } + }; + var G__5246 = 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__5246__delegate.call(this, x, y, more); + }; + G__5246.cljs$lang$maxFixedArity = 2; + G__5246.cljs$lang$applyTo = function(arglist__5250) { + var x = cljs.core.first(arglist__5250); + arglist__5250 = cljs.core.next(arglist__5250); + var y = cljs.core.first(arglist__5250); + var more = cljs.core.rest(arglist__5250); + return G__5246__delegate(x, y, more); + }; + G__5246.cljs$core$IFn$_invoke$arity$variadic = G__5246__delegate; + return G__5246; + }(); + _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__3750__auto__ = x; + var y__3751__auto__ = y; + return x__3750__auto__ > y__3751__auto__ ? x__3750__auto__ : y__3751__auto__; + }; + var max__3 = function() { + var G__5251__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, max, function() { + var x__3750__auto__ = x; + var y__3751__auto__ = y; + return x__3750__auto__ > y__3751__auto__ ? x__3750__auto__ : y__3751__auto__; + }(), more); + }; + var G__5251 = 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__5251__delegate.call(this, x, y, more); + }; + G__5251.cljs$lang$maxFixedArity = 2; + G__5251.cljs$lang$applyTo = function(arglist__5252) { + var x = cljs.core.first(arglist__5252); + arglist__5252 = cljs.core.next(arglist__5252); + var y = cljs.core.first(arglist__5252); + var more = cljs.core.rest(arglist__5252); + return G__5251__delegate(x, y, more); + }; + G__5251.cljs$core$IFn$_invoke$arity$variadic = G__5251__delegate; + return G__5251; + }(); + 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__3757__auto__ = x; + var y__3758__auto__ = y; + return x__3757__auto__ < y__3758__auto__ ? x__3757__auto__ : y__3758__auto__; + }; + var min__3 = function() { + var G__5253__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, min, function() { + var x__3757__auto__ = x; + var y__3758__auto__ = y; + return x__3757__auto__ < y__3758__auto__ ? x__3757__auto__ : y__3758__auto__; + }(), more); + }; + var G__5253 = 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__5253__delegate.call(this, x, y, more); + }; + G__5253.cljs$lang$maxFixedArity = 2; + G__5253.cljs$lang$applyTo = function(arglist__5254) { + var x = cljs.core.first(arglist__5254); + arglist__5254 = cljs.core.next(arglist__5254); + var y = cljs.core.first(arglist__5254); + var more = cljs.core.rest(arglist__5254); + return G__5253__delegate(x, y, more); + }; + G__5253.cljs$core$IFn$_invoke$arity$variadic = G__5253__delegate; + return G__5253; + }(); + 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__5255__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_add, x + y, more); + }; + var G__5255 = 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__5255__delegate.call(this, x, y, more); + }; + G__5255.cljs$lang$maxFixedArity = 2; + G__5255.cljs$lang$applyTo = function(arglist__5256) { + var x = cljs.core.first(arglist__5256); + arglist__5256 = cljs.core.next(arglist__5256); + var y = cljs.core.first(arglist__5256); + var more = cljs.core.rest(arglist__5256); + return G__5255__delegate(x, y, more); + }; + G__5255.cljs$core$IFn$_invoke$arity$variadic = G__5255__delegate; + return G__5255; + }(); + 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__5257__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_add_int, x + y, more); + }; + var G__5257 = 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__5257__delegate.call(this, x, y, more); + }; + G__5257.cljs$lang$maxFixedArity = 2; + G__5257.cljs$lang$applyTo = function(arglist__5258) { + var x = cljs.core.first(arglist__5258); + arglist__5258 = cljs.core.next(arglist__5258); + var y = cljs.core.first(arglist__5258); + var more = cljs.core.rest(arglist__5258); + return G__5257__delegate(x, y, more); + }; + G__5257.cljs$core$IFn$_invoke$arity$variadic = G__5257__delegate; + return G__5257; + }(); + 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__5259__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_divide_int, unchecked_divide_int.call(null, x, y), more); + }; + var G__5259 = 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__5259__delegate.call(this, x, y, more); + }; + G__5259.cljs$lang$maxFixedArity = 2; + G__5259.cljs$lang$applyTo = function(arglist__5260) { + var x = cljs.core.first(arglist__5260); + arglist__5260 = cljs.core.next(arglist__5260); + var y = cljs.core.first(arglist__5260); + var more = cljs.core.rest(arglist__5260); + return G__5259__delegate(x, y, more); + }; + G__5259.cljs$core$IFn$_invoke$arity$variadic = G__5259__delegate; + return G__5259; + }(); + 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__5261__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_multiply, x * y, more); + }; + var G__5261 = 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__5261__delegate.call(this, x, y, more); + }; + G__5261.cljs$lang$maxFixedArity = 2; + G__5261.cljs$lang$applyTo = function(arglist__5262) { + var x = cljs.core.first(arglist__5262); + arglist__5262 = cljs.core.next(arglist__5262); + var y = cljs.core.first(arglist__5262); + var more = cljs.core.rest(arglist__5262); + return G__5261__delegate(x, y, more); + }; + G__5261.cljs$core$IFn$_invoke$arity$variadic = G__5261__delegate; + return G__5261; + }(); + 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__5263__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_multiply_int, x * y, more); + }; + var G__5263 = 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__5263__delegate.call(this, x, y, more); + }; + G__5263.cljs$lang$maxFixedArity = 2; + G__5263.cljs$lang$applyTo = function(arglist__5264) { + var x = cljs.core.first(arglist__5264); + arglist__5264 = cljs.core.next(arglist__5264); + var y = cljs.core.first(arglist__5264); + var more = cljs.core.rest(arglist__5264); + return G__5263__delegate(x, y, more); + }; + G__5263.cljs$core$IFn$_invoke$arity$variadic = G__5263__delegate; + return G__5263; + }(); + 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__5265__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_substract, x - y, more); + }; + var G__5265 = 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__5265__delegate.call(this, x, y, more); + }; + G__5265.cljs$lang$maxFixedArity = 2; + G__5265.cljs$lang$applyTo = function(arglist__5266) { + var x = cljs.core.first(arglist__5266); + arglist__5266 = cljs.core.next(arglist__5266); + var y = cljs.core.first(arglist__5266); + var more = cljs.core.rest(arglist__5266); + return G__5265__delegate(x, y, more); + }; + G__5265.cljs$core$IFn$_invoke$arity$variadic = G__5265__delegate; + return G__5265; + }(); + 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__5267__delegate = function(x, y, more) { + return cljs.core.reduce.call(null, unchecked_substract_int, x - y, more); + }; + var G__5267 = 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__5267__delegate.call(this, x, y, more); + }; + G__5267.cljs$lang$maxFixedArity = 2; + G__5267.cljs$lang$applyTo = function(arglist__5268) { + var x = cljs.core.first(arglist__5268); + arglist__5268 = cljs.core.next(arglist__5268); + var y = cljs.core.first(arglist__5268); + var more = cljs.core.rest(arglist__5268); + return G__5267__delegate(x, y, more); + }; + G__5267.cljs$core$IFn$_invoke$arity$variadic = G__5267__delegate; + return G__5267; + }(); + 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__5269__delegate = function(x, y, more) { + while (true) { + if (_EQ__EQ_.call(null, x, y)) { + if (cljs.core.next.call(null, more)) { + var G__5270 = y; + var G__5271 = cljs.core.first.call(null, more); + var G__5272 = cljs.core.next.call(null, more); + x = G__5270; + y = G__5271; + more = G__5272; + continue; + } else { + return _EQ__EQ_.call(null, y, cljs.core.first.call(null, more)); + } + } else { + return false; + } + break; + } + }; + var G__5269 = 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__5269__delegate.call(this, x, y, more); + }; + G__5269.cljs$lang$maxFixedArity = 2; + G__5269.cljs$lang$applyTo = function(arglist__5273) { + var x = cljs.core.first(arglist__5273); + arglist__5273 = cljs.core.next(arglist__5273); + var y = cljs.core.first(arglist__5273); + var more = cljs.core.rest(arglist__5273); + return G__5269__delegate(x, y, more); + }; + G__5269.cljs$core$IFn$_invoke$arity$variadic = G__5269__delegate; + return G__5269; + }(); + _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__5274 = n__$1 - 1; + var G__5275 = cljs.core.next.call(null, xs); + n__$1 = G__5274; + xs = G__5275; + 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__5276__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__5277 = sb.append(str.call(null, cljs.core.first.call(null, more))); + var G__5278 = cljs.core.next.call(null, more); + sb = G__5277; + more = G__5278; + continue; + } else { + return sb.toString(); + } + break; + } + }; + var G__5276 = 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__5276__delegate.call(this, x, ys); + }; + G__5276.cljs$lang$maxFixedArity = 1; + G__5276.cljs$lang$applyTo = function(arglist__5279) { + var x = cljs.core.first(arglist__5279); + var ys = cljs.core.rest(arglist__5279); + return G__5276__delegate(x, ys); + }; + G__5276.cljs$core$IFn$_invoke$arity$variadic = G__5276__delegate; + return G__5276; + }(); + 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__5280 = cljs.core.next.call(null, xs); + var G__5281 = cljs.core.next.call(null, ys); + xs = G__5280; + ys = G__5281; + 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__5282 = cljs.core.hash_combine.call(null, res, cljs.core.hash.call(null, cljs.core.first.call(null, s))); + var G__5283 = cljs.core.next.call(null, s); + res = G__5282; + s = G__5283; + 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__5284 = (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__5285 = cljs.core.next.call(null, s); + h = G__5284; + s = G__5285; + 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__5286 = (h + cljs.core.hash.call(null, e)) % 4503599627370496; + var G__5287 = cljs.core.next.call(null, s__$1); + h = G__5286; + s__$1 = G__5287; + continue; + } else { + return h; + } + break; + } +}; +cljs.core.extend_object_BANG_ = function extend_object_BANG_(obj, fn_map) { + var seq__5294_5300 = cljs.core.seq.call(null, fn_map); + var chunk__5295_5301 = null; + var count__5296_5302 = 0; + var i__5297_5303 = 0; + while (true) { + if (i__5297_5303 < count__5296_5302) { + var vec__5298_5304 = cljs.core._nth.call(null, chunk__5295_5301, i__5297_5303); + var key_name_5305 = cljs.core.nth.call(null, vec__5298_5304, 0, null); + var f_5306 = cljs.core.nth.call(null, vec__5298_5304, 1, null); + var str_name_5307 = cljs.core.name.call(null, key_name_5305); + obj[str_name_5307] = f_5306; + var G__5308 = seq__5294_5300; + var G__5309 = chunk__5295_5301; + var G__5310 = count__5296_5302; + var G__5311 = i__5297_5303 + 1; + seq__5294_5300 = G__5308; + chunk__5295_5301 = G__5309; + count__5296_5302 = G__5310; + i__5297_5303 = G__5311; + continue; + } else { + var temp__4092__auto___5312 = cljs.core.seq.call(null, seq__5294_5300); + if (temp__4092__auto___5312) { + var seq__5294_5313__$1 = temp__4092__auto___5312; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__5294_5313__$1)) { + var c__4191__auto___5314 = cljs.core.chunk_first.call(null, seq__5294_5313__$1); + var G__5315 = cljs.core.chunk_rest.call(null, seq__5294_5313__$1); + var G__5316 = c__4191__auto___5314; + var G__5317 = cljs.core.count.call(null, c__4191__auto___5314); + var G__5318 = 0; + seq__5294_5300 = G__5315; + chunk__5295_5301 = G__5316; + count__5296_5302 = G__5317; + i__5297_5303 = G__5318; + continue; + } else { + var vec__5299_5319 = cljs.core.first.call(null, seq__5294_5313__$1); + var key_name_5320 = cljs.core.nth.call(null, vec__5299_5319, 0, null); + var f_5321 = cljs.core.nth.call(null, vec__5299_5319, 1, null); + var str_name_5322 = cljs.core.name.call(null, key_name_5320); + obj[str_name_5322] = f_5321; + var G__5323 = cljs.core.next.call(null, seq__5294_5313__$1); + var G__5324 = null; + var G__5325 = 0; + var G__5326 = 0; + seq__5294_5300 = G__5323; + chunk__5295_5301 = G__5324; + count__5296_5302 = G__5325; + i__5297_5303 = G__5326; + 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$partition0$ = 65937646; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.List.cljs$lang$type = true; +cljs.core.List.cljs$lang$ctorStr = "cljs.core/List"; +cljs.core.List.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.List(self__.meta, 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$partition0$ = 65937614; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.EmptyList.cljs$lang$type = true; +cljs.core.EmptyList.cljs$lang$ctorStr = "cljs.core/EmptyList"; +cljs.core.EmptyList.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.EmptyList(self__.meta); +}; +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__5328 = coll; + if (G__5328) { + var bit__4093__auto__ = G__5328.cljs$lang$protocol_mask$partition0$ & 134217728; + if (bit__4093__auto__ || G__5328.cljs$core$IReversible$) { + return true; + } else { + if (!G__5328.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReversible, G__5328); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IReversible, G__5328); + } +}; +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__5329 = cljs.core._next.call(null, xs__$1); + xs__$1 = G__5329; + continue; + } else { + return arr; + } + break; + } + }(); + var i = arr.length; + var r = cljs.core.List.EMPTY; + while (true) { + if (i > 0) { + var G__5330 = i - 1; + var G__5331 = cljs.core._conj.call(null, r, arr[i - 1]); + i = G__5330; + r = G__5331; + 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__5332) { + var xs = cljs.core.seq(arglist__5332); + 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$partition0$ = 65929452; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.Cons.cljs$lang$type = true; +cljs.core.Cons.cljs$lang$ctorStr = "cljs.core/Cons"; +cljs.core.Cons.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.Cons(self__.meta, 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__3443__auto__ = coll == null; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var G__5336 = coll; + if (G__5336) { + var bit__4086__auto__ = G__5336.cljs$lang$protocol_mask$partition0$ & 64; + if (bit__4086__auto__ || G__5336.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__5338 = x; + if (G__5338) { + var bit__4093__auto__ = G__5338.cljs$lang$protocol_mask$partition0$ & 33554432; + if (bit__4093__auto__ || G__5338.cljs$core$IList$) { + return true; + } else { + if (!G__5338.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IList, G__5338); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IList, G__5338); + } +}; +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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5340 = null; + var G__5340__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__5340__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__5340 = function(self__, coll, not_found) { + switch(arguments.length) { + case 2: + return G__5340__2.call(this, self__, coll); + case 3: + return G__5340__3.call(this, self__, coll, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5340; +}(); +cljs.core.Keyword.prototype.apply = function(self__, args5339) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5339))); +}; +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__5342 = x; + if (G__5342) { + var bit__4086__auto__ = G__5342.cljs$lang$protocol_mask$partition1$ & 4096; + if (bit__4086__auto__ || G__5342.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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5343 = ls.sval(); + ls = G__5343; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5345 = s; + if (G__5345) { + var bit__4086__auto__ = G__5345.cljs$lang$protocol_mask$partition1$ & 1024; + if (bit__4086__auto__ || G__5345.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__5346 = cljs.core.next.call(null, s__$1); + s__$1 = G__5346; + 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_5347 = 0; + var xs_5348 = cljs.core.seq.call(null, coll); + while (true) { + if (xs_5348) { + ret[i_5347] = cljs.core.to_array.call(null, cljs.core.first.call(null, xs_5348)); + var G__5349 = i_5347 + 1; + var G__5350 = cljs.core.next.call(null, xs_5348); + i_5347 = G__5349; + xs_5348 = G__5350; + 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__5351 = i + 1; + var G__5352 = cljs.core.next.call(null, s__$1); + i = G__5351; + s__$1 = G__5352; + continue; + } else { + return a; + } + break; + } + } else { + var n__4291__auto___5353 = size; + var i_5354 = 0; + while (true) { + if (i_5354 < n__4291__auto___5353) { + a[i_5354] = init_val_or_seq; + var G__5355 = i_5354 + 1; + i_5354 = G__5355; + 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__5356 = i + 1; + var G__5357 = cljs.core.next.call(null, s__$1); + i = G__5356; + s__$1 = G__5357; + continue; + } else { + return a; + } + break; + } + } else { + var n__4291__auto___5358 = size; + var i_5359 = 0; + while (true) { + if (i_5359 < n__4291__auto___5358) { + a[i_5359] = init_val_or_seq; + var G__5360 = i_5359 + 1; + i_5359 = G__5360; + 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__5361 = i + 1; + var G__5362 = cljs.core.next.call(null, s__$1); + i = G__5361; + s__$1 = G__5362; + continue; + } else { + return a; + } + break; + } + } else { + var n__4291__auto___5363 = size; + var i_5364 = 0; + while (true) { + if (i_5364 < n__4291__auto___5363) { + a[i_5364] = init_val_or_seq; + var G__5365 = i_5364 + 1; + i_5364 = G__5365; + 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__5366 = i + 1; + var G__5367 = cljs.core.next.call(null, s__$1); + i = G__5366; + s__$1 = G__5367; + continue; + } else { + return a; + } + break; + } + } else { + var n__4291__auto___5368 = size; + var i_5369 = 0; + while (true) { + if (i_5369 < n__4291__auto___5368) { + a[i_5369] = init_val_or_seq; + var G__5370 = i_5369 + 1; + i_5369 = G__5370; + 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__5371 = cljs.core.next.call(null, s__$1); + var G__5372 = i - 1; + var G__5373 = sum + 1; + s__$1 = G__5371; + i = G__5372; + sum = G__5373; + 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__5374__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__5374 = 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__5374__delegate.call(this, x, y, zs); + }; + G__5374.cljs$lang$maxFixedArity = 2; + G__5374.cljs$lang$applyTo = function(arglist__5375) { + var x = cljs.core.first(arglist__5375); + arglist__5375 = cljs.core.next(arglist__5375); + var y = cljs.core.first(arglist__5375); + var zs = cljs.core.rest(arglist__5375); + return G__5374__delegate(x, y, zs); + }; + G__5374.cljs$core$IFn$_invoke$arity$variadic = G__5374__delegate; + return G__5374; + }(); + 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__5376__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__5376 = 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__5376__delegate.call(this, a, b, c, d, more); + }; + G__5376.cljs$lang$maxFixedArity = 4; + G__5376.cljs$lang$applyTo = function(arglist__5377) { + var a = cljs.core.first(arglist__5377); + arglist__5377 = cljs.core.next(arglist__5377); + var b = cljs.core.first(arglist__5377); + arglist__5377 = cljs.core.next(arglist__5377); + var c = cljs.core.first(arglist__5377); + arglist__5377 = cljs.core.next(arglist__5377); + var d = cljs.core.first(arglist__5377); + var more = cljs.core.rest(arglist__5377); + return G__5376__delegate(a, b, c, d, more); + }; + G__5376.cljs$core$IFn$_invoke$arity$variadic = G__5376__delegate; + return G__5376; + }(); + 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() { + var conj_BANG_ = null; + var conj_BANG___2 = function(tcoll, val) { + return cljs.core._conj_BANG_.call(null, tcoll, val); + }; + var conj_BANG___3 = function() { + var G__5378__delegate = function(tcoll, val, vals) { + while (true) { + var ntcoll = cljs.core._conj_BANG_.call(null, tcoll, val); + if (cljs.core.truth_(vals)) { + var G__5379 = ntcoll; + var G__5380 = cljs.core.first.call(null, vals); + var G__5381 = cljs.core.next.call(null, vals); + tcoll = G__5379; + val = G__5380; + vals = G__5381; + continue; + } else { + return ntcoll; + } + break; + } + }; + var G__5378 = function(tcoll, val, var_args) { + var vals = null; + if (arguments.length > 2) { + vals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0); + } + return G__5378__delegate.call(this, tcoll, val, vals); + }; + G__5378.cljs$lang$maxFixedArity = 2; + G__5378.cljs$lang$applyTo = function(arglist__5382) { + var tcoll = cljs.core.first(arglist__5382); + arglist__5382 = cljs.core.next(arglist__5382); + var val = cljs.core.first(arglist__5382); + var vals = cljs.core.rest(arglist__5382); + return G__5378__delegate(tcoll, val, vals); + }; + G__5378.cljs$core$IFn$_invoke$arity$variadic = G__5378__delegate; + return G__5378; + }(); + conj_BANG_ = function(tcoll, val, var_args) { + var vals = var_args; + switch(arguments.length) { + case 2: + return conj_BANG___2.call(this, tcoll, val); + default: + return conj_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll, val, cljs.core.array_seq(arguments, 2)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + conj_BANG_.cljs$lang$maxFixedArity = 2; + conj_BANG_.cljs$lang$applyTo = conj_BANG___3.cljs$lang$applyTo; + conj_BANG_.cljs$core$IFn$_invoke$arity$2 = conj_BANG___2; + conj_BANG_.cljs$core$IFn$_invoke$arity$variadic = conj_BANG___3.cljs$core$IFn$_invoke$arity$variadic; + return conj_BANG_; +}(); +cljs.core.assoc_BANG_ = function() { + var assoc_BANG_ = null; + var assoc_BANG___3 = function(tcoll, key, val) { + return cljs.core._assoc_BANG_.call(null, tcoll, key, val); + }; + var assoc_BANG___4 = function() { + var G__5383__delegate = function(tcoll, key, val, kvs) { + while (true) { + var ntcoll = cljs.core._assoc_BANG_.call(null, tcoll, key, val); + if (cljs.core.truth_(kvs)) { + var G__5384 = ntcoll; + var G__5385 = cljs.core.first.call(null, kvs); + var G__5386 = cljs.core.second.call(null, kvs); + var G__5387 = cljs.core.nnext.call(null, kvs); + tcoll = G__5384; + key = G__5385; + val = G__5386; + kvs = G__5387; + continue; + } else { + return ntcoll; + } + break; + } + }; + var G__5383 = function(tcoll, key, val, var_args) { + var kvs = null; + if (arguments.length > 3) { + kvs = cljs.core.array_seq(Array.prototype.slice.call(arguments, 3), 0); + } + return G__5383__delegate.call(this, tcoll, key, val, kvs); + }; + G__5383.cljs$lang$maxFixedArity = 3; + G__5383.cljs$lang$applyTo = function(arglist__5388) { + var tcoll = cljs.core.first(arglist__5388); + arglist__5388 = cljs.core.next(arglist__5388); + var key = cljs.core.first(arglist__5388); + arglist__5388 = cljs.core.next(arglist__5388); + var val = cljs.core.first(arglist__5388); + var kvs = cljs.core.rest(arglist__5388); + return G__5383__delegate(tcoll, key, val, kvs); + }; + G__5383.cljs$core$IFn$_invoke$arity$variadic = G__5383__delegate; + return G__5383; + }(); + assoc_BANG_ = function(tcoll, key, val, var_args) { + var kvs = var_args; + switch(arguments.length) { + case 3: + return assoc_BANG___3.call(this, tcoll, key, val); + default: + return assoc_BANG___4.cljs$core$IFn$_invoke$arity$variadic(tcoll, key, val, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + assoc_BANG_.cljs$lang$maxFixedArity = 3; + assoc_BANG_.cljs$lang$applyTo = assoc_BANG___4.cljs$lang$applyTo; + assoc_BANG_.cljs$core$IFn$_invoke$arity$3 = assoc_BANG___3; + assoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = assoc_BANG___4.cljs$core$IFn$_invoke$arity$variadic; + return assoc_BANG_; +}(); +cljs.core.dissoc_BANG_ = function() { + var dissoc_BANG_ = null; + var dissoc_BANG___2 = function(tcoll, key) { + return cljs.core._dissoc_BANG_.call(null, tcoll, key); + }; + var dissoc_BANG___3 = function() { + var G__5389__delegate = function(tcoll, key, ks) { + while (true) { + var ntcoll = cljs.core._dissoc_BANG_.call(null, tcoll, key); + if (cljs.core.truth_(ks)) { + var G__5390 = ntcoll; + var G__5391 = cljs.core.first.call(null, ks); + var G__5392 = cljs.core.next.call(null, ks); + tcoll = G__5390; + key = G__5391; + ks = G__5392; + continue; + } else { + return ntcoll; + } + break; + } + }; + var G__5389 = function(tcoll, key, var_args) { + var ks = null; + if (arguments.length > 2) { + ks = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0); + } + return G__5389__delegate.call(this, tcoll, key, ks); + }; + G__5389.cljs$lang$maxFixedArity = 2; + G__5389.cljs$lang$applyTo = function(arglist__5393) { + var tcoll = cljs.core.first(arglist__5393); + arglist__5393 = cljs.core.next(arglist__5393); + var key = cljs.core.first(arglist__5393); + var ks = cljs.core.rest(arglist__5393); + return G__5389__delegate(tcoll, key, ks); + }; + G__5389.cljs$core$IFn$_invoke$arity$variadic = G__5389__delegate; + return G__5389; + }(); + dissoc_BANG_ = function(tcoll, key, var_args) { + var ks = var_args; + switch(arguments.length) { + case 2: + return dissoc_BANG___2.call(this, tcoll, key); + default: + return dissoc_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll, key, cljs.core.array_seq(arguments, 2)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + dissoc_BANG_.cljs$lang$maxFixedArity = 2; + dissoc_BANG_.cljs$lang$applyTo = dissoc_BANG___3.cljs$lang$applyTo; + dissoc_BANG_.cljs$core$IFn$_invoke$arity$2 = dissoc_BANG___2; + dissoc_BANG_.cljs$core$IFn$_invoke$arity$variadic = dissoc_BANG___3.cljs$core$IFn$_invoke$arity$variadic; + return dissoc_BANG_; +}(); +cljs.core.pop_BANG_ = function pop_BANG_(tcoll) { + return cljs.core._pop_BANG_.call(null, tcoll); +}; +cljs.core.disj_BANG_ = function() { + var disj_BANG_ = null; + var disj_BANG___2 = function(tcoll, val) { + return cljs.core._disjoin_BANG_.call(null, tcoll, val); + }; + var disj_BANG___3 = function() { + var G__5394__delegate = function(tcoll, val, vals) { + while (true) { + var ntcoll = cljs.core._disjoin_BANG_.call(null, tcoll, val); + if (cljs.core.truth_(vals)) { + var G__5395 = ntcoll; + var G__5396 = cljs.core.first.call(null, vals); + var G__5397 = cljs.core.next.call(null, vals); + tcoll = G__5395; + val = G__5396; + vals = G__5397; + continue; + } else { + return ntcoll; + } + break; + } + }; + var G__5394 = function(tcoll, val, var_args) { + var vals = null; + if (arguments.length > 2) { + vals = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0); + } + return G__5394__delegate.call(this, tcoll, val, vals); + }; + G__5394.cljs$lang$maxFixedArity = 2; + G__5394.cljs$lang$applyTo = function(arglist__5398) { + var tcoll = cljs.core.first(arglist__5398); + arglist__5398 = cljs.core.next(arglist__5398); + var val = cljs.core.first(arglist__5398); + var vals = cljs.core.rest(arglist__5398); + return G__5394__delegate(tcoll, val, vals); + }; + G__5394.cljs$core$IFn$_invoke$arity$variadic = G__5394__delegate; + return G__5394; + }(); + disj_BANG_ = function(tcoll, val, var_args) { + var vals = var_args; + switch(arguments.length) { + case 2: + return disj_BANG___2.call(this, tcoll, val); + default: + return disj_BANG___3.cljs$core$IFn$_invoke$arity$variadic(tcoll, val, cljs.core.array_seq(arguments, 2)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + disj_BANG_.cljs$lang$maxFixedArity = 2; + disj_BANG_.cljs$lang$applyTo = disj_BANG___3.cljs$lang$applyTo; + disj_BANG_.cljs$core$IFn$_invoke$arity$2 = disj_BANG___2; + disj_BANG_.cljs$core$IFn$_invoke$arity$variadic = disj_BANG___3.cljs$core$IFn$_invoke$arity$variadic; + return disj_BANG_; +}(); +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__5399__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__5399 = 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__5399__delegate.call(this, f, a, b, c, d, args); + }; + G__5399.cljs$lang$maxFixedArity = 5; + G__5399.cljs$lang$applyTo = function(arglist__5400) { + var f = cljs.core.first(arglist__5400); + arglist__5400 = cljs.core.next(arglist__5400); + var a = cljs.core.first(arglist__5400); + arglist__5400 = cljs.core.next(arglist__5400); + var b = cljs.core.first(arglist__5400); + arglist__5400 = cljs.core.next(arglist__5400); + var c = cljs.core.first(arglist__5400); + arglist__5400 = cljs.core.next(arglist__5400); + var d = cljs.core.first(arglist__5400); + var args = cljs.core.rest(arglist__5400); + return G__5399__delegate(f, a, b, c, d, args); + }; + G__5399.cljs$core$IFn$_invoke$arity$variadic = G__5399__delegate; + return G__5399; + }(); + 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__5401__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__5401 = 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__5401__delegate.call(this, obj, f, a, b, c, d, args); + }; + G__5401.cljs$lang$maxFixedArity = 6; + G__5401.cljs$lang$applyTo = function(arglist__5402) { + var obj = cljs.core.first(arglist__5402); + arglist__5402 = cljs.core.next(arglist__5402); + var f = cljs.core.first(arglist__5402); + arglist__5402 = cljs.core.next(arglist__5402); + var a = cljs.core.first(arglist__5402); + arglist__5402 = cljs.core.next(arglist__5402); + var b = cljs.core.first(arglist__5402); + arglist__5402 = cljs.core.next(arglist__5402); + var c = cljs.core.first(arglist__5402); + arglist__5402 = cljs.core.next(arglist__5402); + var d = cljs.core.first(arglist__5402); + var args = cljs.core.rest(arglist__5402); + return G__5401__delegate(obj, f, a, b, c, d, args); + }; + G__5401.cljs$core$IFn$_invoke$arity$variadic = G__5401__delegate; + return G__5401; + }(); + 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__5403__delegate = function(x, y, more) { + return cljs.core.not.call(null, cljs.core.apply.call(null, cljs.core._EQ_, x, y, more)); + }; + var G__5403 = 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__5403__delegate.call(this, x, y, more); + }; + G__5403.cljs$lang$maxFixedArity = 2; + G__5403.cljs$lang$applyTo = function(arglist__5404) { + var x = cljs.core.first(arglist__5404); + arglist__5404 = cljs.core.next(arglist__5404); + var y = cljs.core.first(arglist__5404); + var more = cljs.core.rest(arglist__5404); + return G__5403__delegate(x, y, more); + }; + G__5403.cljs$core$IFn$_invoke$arity$variadic = G__5403__delegate; + return G__5403; + }(); + 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__5405 = pred; + var G__5406 = cljs.core.next.call(null, coll); + pred = G__5405; + coll = G__5406; + 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__3443__auto__ = pred.call(null, cljs.core.first.call(null, coll)); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var G__5407 = pred; + var G__5408 = cljs.core.next.call(null, coll); + pred = G__5407; + coll = G__5408; + 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__5409 = null; + var G__5409__0 = function() { + return cljs.core.not.call(null, f.call(null)); + }; + var G__5409__1 = function(x) { + return cljs.core.not.call(null, f.call(null, x)); + }; + var G__5409__2 = function(x, y) { + return cljs.core.not.call(null, f.call(null, x, y)); + }; + var G__5409__3 = function() { + var G__5410__delegate = function(x, y, zs) { + return cljs.core.not.call(null, cljs.core.apply.call(null, f, x, y, zs)); + }; + var G__5410 = 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__5410__delegate.call(this, x, y, zs); + }; + G__5410.cljs$lang$maxFixedArity = 2; + G__5410.cljs$lang$applyTo = function(arglist__5411) { + var x = cljs.core.first(arglist__5411); + arglist__5411 = cljs.core.next(arglist__5411); + var y = cljs.core.first(arglist__5411); + var zs = cljs.core.rest(arglist__5411); + return G__5410__delegate(x, y, zs); + }; + G__5410.cljs$core$IFn$_invoke$arity$variadic = G__5410__delegate; + return G__5410; + }(); + G__5409 = function(x, y, var_args) { + var zs = var_args; + switch(arguments.length) { + case 0: + return G__5409__0.call(this); + case 1: + return G__5409__1.call(this, x); + case 2: + return G__5409__2.call(this, x, y); + default: + return G__5409__3.cljs$core$IFn$_invoke$arity$variadic(x, y, cljs.core.array_seq(arguments, 2)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5409.cljs$lang$maxFixedArity = 2; + G__5409.cljs$lang$applyTo = G__5409__3.cljs$lang$applyTo; + return G__5409; + }(); +}; +cljs.core.constantly = function constantly(x) { + return function() { + var G__5412__delegate = function(args) { + return x; + }; + var G__5412 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5412__delegate.call(this, args); + }; + G__5412.cljs$lang$maxFixedArity = 0; + G__5412.cljs$lang$applyTo = function(arglist__5413) { + var args = cljs.core.seq(arglist__5413); + return G__5412__delegate(args); + }; + G__5412.cljs$core$IFn$_invoke$arity$variadic = G__5412__delegate; + return G__5412; + }(); +}; +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__5414 = null; + var G__5414__0 = function() { + return f.call(null, g.call(null)); + }; + var G__5414__1 = function(x) { + return f.call(null, g.call(null, x)); + }; + var G__5414__2 = function(x, y) { + return f.call(null, g.call(null, x, y)); + }; + var G__5414__3 = function(x, y, z) { + return f.call(null, g.call(null, x, y, z)); + }; + var G__5414__4 = function() { + var G__5415__delegate = function(x, y, z, args) { + return f.call(null, cljs.core.apply.call(null, g, x, y, z, args)); + }; + var G__5415 = 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__5415__delegate.call(this, x, y, z, args); + }; + G__5415.cljs$lang$maxFixedArity = 3; + G__5415.cljs$lang$applyTo = function(arglist__5416) { + var x = cljs.core.first(arglist__5416); + arglist__5416 = cljs.core.next(arglist__5416); + var y = cljs.core.first(arglist__5416); + arglist__5416 = cljs.core.next(arglist__5416); + var z = cljs.core.first(arglist__5416); + var args = cljs.core.rest(arglist__5416); + return G__5415__delegate(x, y, z, args); + }; + G__5415.cljs$core$IFn$_invoke$arity$variadic = G__5415__delegate; + return G__5415; + }(); + G__5414 = function(x, y, z, var_args) { + var args = var_args; + switch(arguments.length) { + case 0: + return G__5414__0.call(this); + case 1: + return G__5414__1.call(this, x); + case 2: + return G__5414__2.call(this, x, y); + case 3: + return G__5414__3.call(this, x, y, z); + default: + return G__5414__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5414.cljs$lang$maxFixedArity = 3; + G__5414.cljs$lang$applyTo = G__5414__4.cljs$lang$applyTo; + return G__5414; + }(); + }; + var comp__3 = function(f, g, h) { + return function() { + var G__5417 = null; + var G__5417__0 = function() { + return f.call(null, g.call(null, h.call(null))); + }; + var G__5417__1 = function(x) { + return f.call(null, g.call(null, h.call(null, x))); + }; + var G__5417__2 = function(x, y) { + return f.call(null, g.call(null, h.call(null, x, y))); + }; + var G__5417__3 = function(x, y, z) { + return f.call(null, g.call(null, h.call(null, x, y, z))); + }; + var G__5417__4 = function() { + var G__5418__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__5418 = 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__5418__delegate.call(this, x, y, z, args); + }; + G__5418.cljs$lang$maxFixedArity = 3; + G__5418.cljs$lang$applyTo = function(arglist__5419) { + var x = cljs.core.first(arglist__5419); + arglist__5419 = cljs.core.next(arglist__5419); + var y = cljs.core.first(arglist__5419); + arglist__5419 = cljs.core.next(arglist__5419); + var z = cljs.core.first(arglist__5419); + var args = cljs.core.rest(arglist__5419); + return G__5418__delegate(x, y, z, args); + }; + G__5418.cljs$core$IFn$_invoke$arity$variadic = G__5418__delegate; + return G__5418; + }(); + G__5417 = function(x, y, z, var_args) { + var args = var_args; + switch(arguments.length) { + case 0: + return G__5417__0.call(this); + case 1: + return G__5417__1.call(this, x); + case 2: + return G__5417__2.call(this, x, y); + case 3: + return G__5417__3.call(this, x, y, z); + default: + return G__5417__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5417.cljs$lang$maxFixedArity = 3; + G__5417.cljs$lang$applyTo = G__5417__4.cljs$lang$applyTo; + return G__5417; + }(); + }; + var comp__4 = function() { + var G__5420__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__5421__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__5422 = cljs.core.first.call(null, fs__$2).call(null, ret); + var G__5423 = cljs.core.next.call(null, fs__$2); + ret = G__5422; + fs__$2 = G__5423; + continue; + } else { + return ret; + } + break; + } + }; + var G__5421 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5421__delegate.call(this, args); + }; + G__5421.cljs$lang$maxFixedArity = 0; + G__5421.cljs$lang$applyTo = function(arglist__5424) { + var args = cljs.core.seq(arglist__5424); + return G__5421__delegate(args); + }; + G__5421.cljs$core$IFn$_invoke$arity$variadic = G__5421__delegate; + return G__5421; + }(); + }; + var G__5420 = 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__5420__delegate.call(this, f1, f2, f3, fs); + }; + G__5420.cljs$lang$maxFixedArity = 3; + G__5420.cljs$lang$applyTo = function(arglist__5425) { + var f1 = cljs.core.first(arglist__5425); + arglist__5425 = cljs.core.next(arglist__5425); + var f2 = cljs.core.first(arglist__5425); + arglist__5425 = cljs.core.next(arglist__5425); + var f3 = cljs.core.first(arglist__5425); + var fs = cljs.core.rest(arglist__5425); + return G__5420__delegate(f1, f2, f3, fs); + }; + G__5420.cljs$core$IFn$_invoke$arity$variadic = G__5420__delegate; + return G__5420; + }(); + 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__5426__delegate = function(args) { + return cljs.core.apply.call(null, f, arg1, args); + }; + var G__5426 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5426__delegate.call(this, args); + }; + G__5426.cljs$lang$maxFixedArity = 0; + G__5426.cljs$lang$applyTo = function(arglist__5427) { + var args = cljs.core.seq(arglist__5427); + return G__5426__delegate(args); + }; + G__5426.cljs$core$IFn$_invoke$arity$variadic = G__5426__delegate; + return G__5426; + }(); + }; + var partial__3 = function(f, arg1, arg2) { + return function() { + var G__5428__delegate = function(args) { + return cljs.core.apply.call(null, f, arg1, arg2, args); + }; + var G__5428 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5428__delegate.call(this, args); + }; + G__5428.cljs$lang$maxFixedArity = 0; + G__5428.cljs$lang$applyTo = function(arglist__5429) { + var args = cljs.core.seq(arglist__5429); + return G__5428__delegate(args); + }; + G__5428.cljs$core$IFn$_invoke$arity$variadic = G__5428__delegate; + return G__5428; + }(); + }; + var partial__4 = function(f, arg1, arg2, arg3) { + return function() { + var G__5430__delegate = function(args) { + return cljs.core.apply.call(null, f, arg1, arg2, arg3, args); + }; + var G__5430 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5430__delegate.call(this, args); + }; + G__5430.cljs$lang$maxFixedArity = 0; + G__5430.cljs$lang$applyTo = function(arglist__5431) { + var args = cljs.core.seq(arglist__5431); + return G__5430__delegate(args); + }; + G__5430.cljs$core$IFn$_invoke$arity$variadic = G__5430__delegate; + return G__5430; + }(); + }; + var partial__5 = function() { + var G__5432__delegate = function(f, arg1, arg2, arg3, more) { + return function() { + var G__5433__delegate = function(args) { + return cljs.core.apply.call(null, f, arg1, arg2, arg3, cljs.core.concat.call(null, more, args)); + }; + var G__5433 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5433__delegate.call(this, args); + }; + G__5433.cljs$lang$maxFixedArity = 0; + G__5433.cljs$lang$applyTo = function(arglist__5434) { + var args = cljs.core.seq(arglist__5434); + return G__5433__delegate(args); + }; + G__5433.cljs$core$IFn$_invoke$arity$variadic = G__5433__delegate; + return G__5433; + }(); + }; + var G__5432 = 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__5432__delegate.call(this, f, arg1, arg2, arg3, more); + }; + G__5432.cljs$lang$maxFixedArity = 4; + G__5432.cljs$lang$applyTo = function(arglist__5435) { + var f = cljs.core.first(arglist__5435); + arglist__5435 = cljs.core.next(arglist__5435); + var arg1 = cljs.core.first(arglist__5435); + arglist__5435 = cljs.core.next(arglist__5435); + var arg2 = cljs.core.first(arglist__5435); + arglist__5435 = cljs.core.next(arglist__5435); + var arg3 = cljs.core.first(arglist__5435); + var more = cljs.core.rest(arglist__5435); + return G__5432__delegate(f, arg1, arg2, arg3, more); + }; + G__5432.cljs$core$IFn$_invoke$arity$variadic = G__5432__delegate; + return G__5432; + }(); + 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__5436 = null; + var G__5436__1 = function(a) { + return f.call(null, a == null ? x : a); + }; + var G__5436__2 = function(a, b) { + return f.call(null, a == null ? x : a, b); + }; + var G__5436__3 = function(a, b, c) { + return f.call(null, a == null ? x : a, b, c); + }; + var G__5436__4 = function() { + var G__5437__delegate = function(a, b, c, ds) { + return cljs.core.apply.call(null, f, a == null ? x : a, b, c, ds); + }; + var G__5437 = 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__5437__delegate.call(this, a, b, c, ds); + }; + G__5437.cljs$lang$maxFixedArity = 3; + G__5437.cljs$lang$applyTo = function(arglist__5438) { + var a = cljs.core.first(arglist__5438); + arglist__5438 = cljs.core.next(arglist__5438); + var b = cljs.core.first(arglist__5438); + arglist__5438 = cljs.core.next(arglist__5438); + var c = cljs.core.first(arglist__5438); + var ds = cljs.core.rest(arglist__5438); + return G__5437__delegate(a, b, c, ds); + }; + G__5437.cljs$core$IFn$_invoke$arity$variadic = G__5437__delegate; + return G__5437; + }(); + G__5436 = function(a, b, c, var_args) { + var ds = var_args; + switch(arguments.length) { + case 1: + return G__5436__1.call(this, a); + case 2: + return G__5436__2.call(this, a, b); + case 3: + return G__5436__3.call(this, a, b, c); + default: + return G__5436__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5436.cljs$lang$maxFixedArity = 3; + G__5436.cljs$lang$applyTo = G__5436__4.cljs$lang$applyTo; + return G__5436; + }(); + }; + var fnil__3 = function(f, x, y) { + return function() { + var G__5439 = null; + var G__5439__2 = function(a, b) { + return f.call(null, a == null ? x : a, b == null ? y : b); + }; + var G__5439__3 = function(a, b, c) { + return f.call(null, a == null ? x : a, b == null ? y : b, c); + }; + var G__5439__4 = function() { + var G__5440__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__5440 = 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__5440__delegate.call(this, a, b, c, ds); + }; + G__5440.cljs$lang$maxFixedArity = 3; + G__5440.cljs$lang$applyTo = function(arglist__5441) { + var a = cljs.core.first(arglist__5441); + arglist__5441 = cljs.core.next(arglist__5441); + var b = cljs.core.first(arglist__5441); + arglist__5441 = cljs.core.next(arglist__5441); + var c = cljs.core.first(arglist__5441); + var ds = cljs.core.rest(arglist__5441); + return G__5440__delegate(a, b, c, ds); + }; + G__5440.cljs$core$IFn$_invoke$arity$variadic = G__5440__delegate; + return G__5440; + }(); + G__5439 = function(a, b, c, var_args) { + var ds = var_args; + switch(arguments.length) { + case 2: + return G__5439__2.call(this, a, b); + case 3: + return G__5439__3.call(this, a, b, c); + default: + return G__5439__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5439.cljs$lang$maxFixedArity = 3; + G__5439.cljs$lang$applyTo = G__5439__4.cljs$lang$applyTo; + return G__5439; + }(); + }; + var fnil__4 = function(f, x, y, z) { + return function() { + var G__5442 = null; + var G__5442__2 = function(a, b) { + return f.call(null, a == null ? x : a, b == null ? y : b); + }; + var G__5442__3 = function(a, b, c) { + return f.call(null, a == null ? x : a, b == null ? y : b, c == null ? z : c); + }; + var G__5442__4 = function() { + var G__5443__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__5443 = 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__5443__delegate.call(this, a, b, c, ds); + }; + G__5443.cljs$lang$maxFixedArity = 3; + G__5443.cljs$lang$applyTo = function(arglist__5444) { + var a = cljs.core.first(arglist__5444); + arglist__5444 = cljs.core.next(arglist__5444); + var b = cljs.core.first(arglist__5444); + arglist__5444 = cljs.core.next(arglist__5444); + var c = cljs.core.first(arglist__5444); + var ds = cljs.core.rest(arglist__5444); + return G__5443__delegate(a, b, c, ds); + }; + G__5443.cljs$core$IFn$_invoke$arity$variadic = G__5443__delegate; + return G__5443; + }(); + G__5442 = function(a, b, c, var_args) { + var ds = var_args; + switch(arguments.length) { + case 2: + return G__5442__2.call(this, a, b); + case 3: + return G__5442__3.call(this, a, b, c); + default: + return G__5442__4.cljs$core$IFn$_invoke$arity$variadic(a, b, c, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5442.cljs$lang$maxFixedArity = 3; + G__5442.cljs$lang$applyTo = G__5442__4.cljs$lang$applyTo; + return G__5442; + }(); + }; + 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__4291__auto___5445 = size; + var i_5446 = 0; + while (true) { + if (i_5446 < n__4291__auto___5445) { + cljs.core.chunk_append.call(null, b, f.call(null, idx + i_5446, cljs.core._nth.call(null, c, i_5446))); + var G__5447 = i_5446 + 1; + i_5446 = G__5447; + 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__4291__auto___5448 = size; + var i_5449 = 0; + while (true) { + if (i_5449 < n__4291__auto___5448) { + var x_5450 = f.call(null, cljs.core._nth.call(null, c, i_5449)); + if (x_5450 == null) { + } else { + cljs.core.chunk_append.call(null, b, x_5450); + } + var G__5451 = i_5449 + 1; + i_5449 = G__5451; + 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__4291__auto___5452 = size; + var i_5453 = 0; + while (true) { + if (i_5453 < n__4291__auto___5452) { + var x_5454 = f.call(null, idx + i_5453, cljs.core._nth.call(null, c, i_5453)); + if (x_5454 == null) { + } else { + cljs.core.chunk_append.call(null, b, x_5454); + } + var G__5455 = i_5453 + 1; + i_5453 = G__5455; + 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__3431__auto__ = p.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + return p.call(null, y); + } else { + return and__3431__auto__; + } + }()); + }; + var ep1__3 = function(x, y, z) { + return cljs.core.boolean$.call(null, function() { + var and__3431__auto__ = p.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p.call(null, y); + if (cljs.core.truth_(and__3431__auto____$1)) { + return p.call(null, z); + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }()); + }; + var ep1__4 = function() { + var G__5462__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__5462 = 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__5462__delegate.call(this, x, y, z, args); + }; + G__5462.cljs$lang$maxFixedArity = 3; + G__5462.cljs$lang$applyTo = function(arglist__5463) { + var x = cljs.core.first(arglist__5463); + arglist__5463 = cljs.core.next(arglist__5463); + var y = cljs.core.first(arglist__5463); + arglist__5463 = cljs.core.next(arglist__5463); + var z = cljs.core.first(arglist__5463); + var args = cljs.core.rest(arglist__5463); + return G__5462__delegate(x, y, z, args); + }; + G__5462.cljs$core$IFn$_invoke$arity$variadic = G__5462__delegate; + return G__5462; + }(); + 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__3431__auto__ = p1.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + return p2.call(null, x); + } else { + return and__3431__auto__; + } + }()); + }; + var ep2__2 = function(x, y) { + return cljs.core.boolean$.call(null, function() { + var and__3431__auto__ = p1.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p1.call(null, y); + if (cljs.core.truth_(and__3431__auto____$1)) { + var and__3431__auto____$2 = p2.call(null, x); + if (cljs.core.truth_(and__3431__auto____$2)) { + return p2.call(null, y); + } else { + return and__3431__auto____$2; + } + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }()); + }; + var ep2__3 = function(x, y, z) { + return cljs.core.boolean$.call(null, function() { + var and__3431__auto__ = p1.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p1.call(null, y); + if (cljs.core.truth_(and__3431__auto____$1)) { + var and__3431__auto____$2 = p1.call(null, z); + if (cljs.core.truth_(and__3431__auto____$2)) { + var and__3431__auto____$3 = p2.call(null, x); + if (cljs.core.truth_(and__3431__auto____$3)) { + var and__3431__auto____$4 = p2.call(null, y); + if (cljs.core.truth_(and__3431__auto____$4)) { + return p2.call(null, z); + } else { + return and__3431__auto____$4; + } + } else { + return and__3431__auto____$3; + } + } else { + return and__3431__auto____$2; + } + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }()); + }; + var ep2__4 = function() { + var G__5464__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__5456_SHARP_) { + var and__3431__auto__ = p1.call(null, p1__5456_SHARP_); + if (cljs.core.truth_(and__3431__auto__)) { + return p2.call(null, p1__5456_SHARP_); + } else { + return and__3431__auto__; + } + }, args)); + }; + var G__5464 = 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__5464__delegate.call(this, x, y, z, args); + }; + G__5464.cljs$lang$maxFixedArity = 3; + G__5464.cljs$lang$applyTo = function(arglist__5465) { + var x = cljs.core.first(arglist__5465); + arglist__5465 = cljs.core.next(arglist__5465); + var y = cljs.core.first(arglist__5465); + arglist__5465 = cljs.core.next(arglist__5465); + var z = cljs.core.first(arglist__5465); + var args = cljs.core.rest(arglist__5465); + return G__5464__delegate(x, y, z, args); + }; + G__5464.cljs$core$IFn$_invoke$arity$variadic = G__5464__delegate; + return G__5464; + }(); + 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__3431__auto__ = p1.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p2.call(null, x); + if (cljs.core.truth_(and__3431__auto____$1)) { + return p3.call(null, x); + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }()); + }; + var ep3__2 = function(x, y) { + return cljs.core.boolean$.call(null, function() { + var and__3431__auto__ = p1.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p2.call(null, x); + if (cljs.core.truth_(and__3431__auto____$1)) { + var and__3431__auto____$2 = p3.call(null, x); + if (cljs.core.truth_(and__3431__auto____$2)) { + var and__3431__auto____$3 = p1.call(null, y); + if (cljs.core.truth_(and__3431__auto____$3)) { + var and__3431__auto____$4 = p2.call(null, y); + if (cljs.core.truth_(and__3431__auto____$4)) { + return p3.call(null, y); + } else { + return and__3431__auto____$4; + } + } else { + return and__3431__auto____$3; + } + } else { + return and__3431__auto____$2; + } + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }()); + }; + var ep3__3 = function(x, y, z) { + return cljs.core.boolean$.call(null, function() { + var and__3431__auto__ = p1.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p2.call(null, x); + if (cljs.core.truth_(and__3431__auto____$1)) { + var and__3431__auto____$2 = p3.call(null, x); + if (cljs.core.truth_(and__3431__auto____$2)) { + var and__3431__auto____$3 = p1.call(null, y); + if (cljs.core.truth_(and__3431__auto____$3)) { + var and__3431__auto____$4 = p2.call(null, y); + if (cljs.core.truth_(and__3431__auto____$4)) { + var and__3431__auto____$5 = p3.call(null, y); + if (cljs.core.truth_(and__3431__auto____$5)) { + var and__3431__auto____$6 = p1.call(null, z); + if (cljs.core.truth_(and__3431__auto____$6)) { + var and__3431__auto____$7 = p2.call(null, z); + if (cljs.core.truth_(and__3431__auto____$7)) { + return p3.call(null, z); + } else { + return and__3431__auto____$7; + } + } else { + return and__3431__auto____$6; + } + } else { + return and__3431__auto____$5; + } + } else { + return and__3431__auto____$4; + } + } else { + return and__3431__auto____$3; + } + } else { + return and__3431__auto____$2; + } + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }()); + }; + var ep3__4 = function() { + var G__5466__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__5457_SHARP_) { + var and__3431__auto__ = p1.call(null, p1__5457_SHARP_); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p2.call(null, p1__5457_SHARP_); + if (cljs.core.truth_(and__3431__auto____$1)) { + return p3.call(null, p1__5457_SHARP_); + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }, args)); + }; + var G__5466 = 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__5466__delegate.call(this, x, y, z, args); + }; + G__5466.cljs$lang$maxFixedArity = 3; + G__5466.cljs$lang$applyTo = function(arglist__5467) { + var x = cljs.core.first(arglist__5467); + arglist__5467 = cljs.core.next(arglist__5467); + var y = cljs.core.first(arglist__5467); + arglist__5467 = cljs.core.next(arglist__5467); + var z = cljs.core.first(arglist__5467); + var args = cljs.core.rest(arglist__5467); + return G__5466__delegate(x, y, z, args); + }; + G__5466.cljs$core$IFn$_invoke$arity$variadic = G__5466__delegate; + return G__5466; + }(); + 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__5468__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__5458_SHARP_) { + return p1__5458_SHARP_.call(null, x); + }, ps__$1); + }; + var epn__2 = function(x, y) { + return cljs.core.every_QMARK_.call(null, function(p1__5459_SHARP_) { + var and__3431__auto__ = p1__5459_SHARP_.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + return p1__5459_SHARP_.call(null, y); + } else { + return and__3431__auto__; + } + }, ps__$1); + }; + var epn__3 = function(x, y, z) { + return cljs.core.every_QMARK_.call(null, function(p1__5460_SHARP_) { + var and__3431__auto__ = p1__5460_SHARP_.call(null, x); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = p1__5460_SHARP_.call(null, y); + if (cljs.core.truth_(and__3431__auto____$1)) { + return p1__5460_SHARP_.call(null, z); + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }, ps__$1); + }; + var epn__4 = function() { + var G__5469__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__5461_SHARP_) { + return cljs.core.every_QMARK_.call(null, p1__5461_SHARP_, args); + }, ps__$1)); + }; + var G__5469 = 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__5469__delegate.call(this, x, y, z, args); + }; + G__5469.cljs$lang$maxFixedArity = 3; + G__5469.cljs$lang$applyTo = function(arglist__5470) { + var x = cljs.core.first(arglist__5470); + arglist__5470 = cljs.core.next(arglist__5470); + var y = cljs.core.first(arglist__5470); + arglist__5470 = cljs.core.next(arglist__5470); + var z = cljs.core.first(arglist__5470); + var args = cljs.core.rest(arglist__5470); + return G__5469__delegate(x, y, z, args); + }; + G__5469.cljs$core$IFn$_invoke$arity$variadic = G__5469__delegate; + return G__5469; + }(); + 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__5468 = 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__5468__delegate.call(this, p1, p2, p3, ps); + }; + G__5468.cljs$lang$maxFixedArity = 3; + G__5468.cljs$lang$applyTo = function(arglist__5471) { + var p1 = cljs.core.first(arglist__5471); + arglist__5471 = cljs.core.next(arglist__5471); + var p2 = cljs.core.first(arglist__5471); + arglist__5471 = cljs.core.next(arglist__5471); + var p3 = cljs.core.first(arglist__5471); + var ps = cljs.core.rest(arglist__5471); + return G__5468__delegate(p1, p2, p3, ps); + }; + G__5468.cljs$core$IFn$_invoke$arity$variadic = G__5468__delegate; + return G__5468; + }(); + 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__3443__auto__ = p.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return p.call(null, y); + } + }; + var sp1__3 = function(x, y, z) { + var or__3443__auto__ = p.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p.call(null, y); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + return p.call(null, z); + } + } + }; + var sp1__4 = function() { + var G__5478__delegate = function(x, y, z, args) { + var or__3443__auto__ = sp1.call(null, x, y, z); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.some.call(null, p, args); + } + }; + var G__5478 = 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__5478__delegate.call(this, x, y, z, args); + }; + G__5478.cljs$lang$maxFixedArity = 3; + G__5478.cljs$lang$applyTo = function(arglist__5479) { + var x = cljs.core.first(arglist__5479); + arglist__5479 = cljs.core.next(arglist__5479); + var y = cljs.core.first(arglist__5479); + arglist__5479 = cljs.core.next(arglist__5479); + var z = cljs.core.first(arglist__5479); + var args = cljs.core.rest(arglist__5479); + return G__5478__delegate(x, y, z, args); + }; + G__5478.cljs$core$IFn$_invoke$arity$variadic = G__5478__delegate; + return G__5478; + }(); + 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__3443__auto__ = p1.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return p2.call(null, x); + } + }; + var sp2__2 = function(x, y) { + var or__3443__auto__ = p1.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p1.call(null, y); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + var or__3443__auto____$2 = p2.call(null, x); + if (cljs.core.truth_(or__3443__auto____$2)) { + return or__3443__auto____$2; + } else { + return p2.call(null, y); + } + } + } + }; + var sp2__3 = function(x, y, z) { + var or__3443__auto__ = p1.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p1.call(null, y); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + var or__3443__auto____$2 = p1.call(null, z); + if (cljs.core.truth_(or__3443__auto____$2)) { + return or__3443__auto____$2; + } else { + var or__3443__auto____$3 = p2.call(null, x); + if (cljs.core.truth_(or__3443__auto____$3)) { + return or__3443__auto____$3; + } else { + var or__3443__auto____$4 = p2.call(null, y); + if (cljs.core.truth_(or__3443__auto____$4)) { + return or__3443__auto____$4; + } else { + return p2.call(null, z); + } + } + } + } + } + }; + var sp2__4 = function() { + var G__5480__delegate = function(x, y, z, args) { + var or__3443__auto__ = sp2.call(null, x, y, z); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.some.call(null, function(p1__5472_SHARP_) { + var or__3443__auto____$1 = p1.call(null, p1__5472_SHARP_); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + return p2.call(null, p1__5472_SHARP_); + } + }, args); + } + }; + var G__5480 = 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__5480__delegate.call(this, x, y, z, args); + }; + G__5480.cljs$lang$maxFixedArity = 3; + G__5480.cljs$lang$applyTo = function(arglist__5481) { + var x = cljs.core.first(arglist__5481); + arglist__5481 = cljs.core.next(arglist__5481); + var y = cljs.core.first(arglist__5481); + arglist__5481 = cljs.core.next(arglist__5481); + var z = cljs.core.first(arglist__5481); + var args = cljs.core.rest(arglist__5481); + return G__5480__delegate(x, y, z, args); + }; + G__5480.cljs$core$IFn$_invoke$arity$variadic = G__5480__delegate; + return G__5480; + }(); + 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__3443__auto__ = p1.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p2.call(null, x); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + return p3.call(null, x); + } + } + }; + var sp3__2 = function(x, y) { + var or__3443__auto__ = p1.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p2.call(null, x); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + var or__3443__auto____$2 = p3.call(null, x); + if (cljs.core.truth_(or__3443__auto____$2)) { + return or__3443__auto____$2; + } else { + var or__3443__auto____$3 = p1.call(null, y); + if (cljs.core.truth_(or__3443__auto____$3)) { + return or__3443__auto____$3; + } else { + var or__3443__auto____$4 = p2.call(null, y); + if (cljs.core.truth_(or__3443__auto____$4)) { + return or__3443__auto____$4; + } else { + return p3.call(null, y); + } + } + } + } + } + }; + var sp3__3 = function(x, y, z) { + var or__3443__auto__ = p1.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p2.call(null, x); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + var or__3443__auto____$2 = p3.call(null, x); + if (cljs.core.truth_(or__3443__auto____$2)) { + return or__3443__auto____$2; + } else { + var or__3443__auto____$3 = p1.call(null, y); + if (cljs.core.truth_(or__3443__auto____$3)) { + return or__3443__auto____$3; + } else { + var or__3443__auto____$4 = p2.call(null, y); + if (cljs.core.truth_(or__3443__auto____$4)) { + return or__3443__auto____$4; + } else { + var or__3443__auto____$5 = p3.call(null, y); + if (cljs.core.truth_(or__3443__auto____$5)) { + return or__3443__auto____$5; + } else { + var or__3443__auto____$6 = p1.call(null, z); + if (cljs.core.truth_(or__3443__auto____$6)) { + return or__3443__auto____$6; + } else { + var or__3443__auto____$7 = p2.call(null, z); + if (cljs.core.truth_(or__3443__auto____$7)) { + return or__3443__auto____$7; + } else { + return p3.call(null, z); + } + } + } + } + } + } + } + } + }; + var sp3__4 = function() { + var G__5482__delegate = function(x, y, z, args) { + var or__3443__auto__ = sp3.call(null, x, y, z); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.some.call(null, function(p1__5473_SHARP_) { + var or__3443__auto____$1 = p1.call(null, p1__5473_SHARP_); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + var or__3443__auto____$2 = p2.call(null, p1__5473_SHARP_); + if (cljs.core.truth_(or__3443__auto____$2)) { + return or__3443__auto____$2; + } else { + return p3.call(null, p1__5473_SHARP_); + } + } + }, args); + } + }; + var G__5482 = 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__5482__delegate.call(this, x, y, z, args); + }; + G__5482.cljs$lang$maxFixedArity = 3; + G__5482.cljs$lang$applyTo = function(arglist__5483) { + var x = cljs.core.first(arglist__5483); + arglist__5483 = cljs.core.next(arglist__5483); + var y = cljs.core.first(arglist__5483); + arglist__5483 = cljs.core.next(arglist__5483); + var z = cljs.core.first(arglist__5483); + var args = cljs.core.rest(arglist__5483); + return G__5482__delegate(x, y, z, args); + }; + G__5482.cljs$core$IFn$_invoke$arity$variadic = G__5482__delegate; + return G__5482; + }(); + 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__5484__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__5474_SHARP_) { + return p1__5474_SHARP_.call(null, x); + }, ps__$1); + }; + var spn__2 = function(x, y) { + return cljs.core.some.call(null, function(p1__5475_SHARP_) { + var or__3443__auto__ = p1__5475_SHARP_.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return p1__5475_SHARP_.call(null, y); + } + }, ps__$1); + }; + var spn__3 = function(x, y, z) { + return cljs.core.some.call(null, function(p1__5476_SHARP_) { + var or__3443__auto__ = p1__5476_SHARP_.call(null, x); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = p1__5476_SHARP_.call(null, y); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + return p1__5476_SHARP_.call(null, z); + } + } + }, ps__$1); + }; + var spn__4 = function() { + var G__5485__delegate = function(x, y, z, args) { + var or__3443__auto__ = spn.call(null, x, y, z); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.some.call(null, function(p1__5477_SHARP_) { + return cljs.core.some.call(null, p1__5477_SHARP_, args); + }, ps__$1); + } + }; + var G__5485 = 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__5485__delegate.call(this, x, y, z, args); + }; + G__5485.cljs$lang$maxFixedArity = 3; + G__5485.cljs$lang$applyTo = function(arglist__5486) { + var x = cljs.core.first(arglist__5486); + arglist__5486 = cljs.core.next(arglist__5486); + var y = cljs.core.first(arglist__5486); + arglist__5486 = cljs.core.next(arglist__5486); + var z = cljs.core.first(arglist__5486); + var args = cljs.core.rest(arglist__5486); + return G__5485__delegate(x, y, z, args); + }; + G__5485.cljs$core$IFn$_invoke$arity$variadic = G__5485__delegate; + return G__5485; + }(); + 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__5484 = 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__5484__delegate.call(this, p1, p2, p3, ps); + }; + G__5484.cljs$lang$maxFixedArity = 3; + G__5484.cljs$lang$applyTo = function(arglist__5487) { + var p1 = cljs.core.first(arglist__5487); + arglist__5487 = cljs.core.next(arglist__5487); + var p2 = cljs.core.first(arglist__5487); + arglist__5487 = cljs.core.next(arglist__5487); + var p3 = cljs.core.first(arglist__5487); + var ps = cljs.core.rest(arglist__5487); + return G__5484__delegate(p1, p2, p3, ps); + }; + G__5484.cljs$core$IFn$_invoke$arity$variadic = G__5484__delegate; + return G__5484; + }(); + 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__4291__auto___5489 = size; + var i_5490 = 0; + while (true) { + if (i_5490 < n__4291__auto___5489) { + cljs.core.chunk_append.call(null, b, f.call(null, cljs.core._nth.call(null, c, i_5490))); + var G__5491 = i_5490 + 1; + i_5490 = G__5491; + 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__5492__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__5488_SHARP_) { + return cljs.core.apply.call(null, f, p1__5488_SHARP_); + }, step.call(null, cljs.core.conj.call(null, colls, c3, c2, c1))); + }; + var G__5492 = 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__5492__delegate.call(this, f, c1, c2, c3, colls); + }; + G__5492.cljs$lang$maxFixedArity = 4; + G__5492.cljs$lang$applyTo = function(arglist__5493) { + var f = cljs.core.first(arglist__5493); + arglist__5493 = cljs.core.next(arglist__5493); + var c1 = cljs.core.first(arglist__5493); + arglist__5493 = cljs.core.next(arglist__5493); + var c2 = cljs.core.first(arglist__5493); + arglist__5493 = cljs.core.next(arglist__5493); + var c3 = cljs.core.first(arglist__5493); + var colls = cljs.core.rest(arglist__5493); + return G__5492__delegate(f, c1, c2, c3, colls); + }; + G__5492.cljs$core$IFn$_invoke$arity$variadic = G__5492__delegate; + return G__5492; + }(); + 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__5494 = n__$1 - 1; + var G__5495 = cljs.core.rest.call(null, s); + n__$1 = G__5494; + coll__$1 = G__5495; + 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__5496 = cljs.core.next.call(null, s); + var G__5497 = cljs.core.next.call(null, lead); + s = G__5496; + lead = G__5497; + 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__3431__auto__ = s; + if (and__3431__auto__) { + return pred__$1.call(null, cljs.core.first.call(null, s)); + } else { + return and__3431__auto__; + } + }())) { + var G__5498 = pred__$1; + var G__5499 = cljs.core.rest.call(null, s); + pred__$1 = G__5498; + coll__$1 = G__5499; + 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__5500__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__5500 = 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__5500__delegate.call(this, c1, c2, colls); + }; + G__5500.cljs$lang$maxFixedArity = 2; + G__5500.cljs$lang$applyTo = function(arglist__5501) { + var c1 = cljs.core.first(arglist__5501); + arglist__5501 = cljs.core.next(arglist__5501); + var c2 = cljs.core.first(arglist__5501); + var colls = cljs.core.rest(arglist__5501); + return G__5500__delegate(c1, c2, colls); + }; + G__5500.cljs$core$IFn$_invoke$arity$variadic = G__5500__delegate; + return G__5500; + }(); + 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__5502__delegate = function(f, coll, colls) { + return cljs.core.flatten1.call(null, cljs.core.apply.call(null, cljs.core.map, f, coll, colls)); + }; + var G__5502 = 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__5502__delegate.call(this, f, coll, colls); + }; + G__5502.cljs$lang$maxFixedArity = 2; + G__5502.cljs$lang$applyTo = function(arglist__5503) { + var f = cljs.core.first(arglist__5503); + arglist__5503 = cljs.core.next(arglist__5503); + var coll = cljs.core.first(arglist__5503); + var colls = cljs.core.rest(arglist__5503); + return G__5502__delegate(f, coll, colls); + }; + G__5502.cljs$core$IFn$_invoke$arity$variadic = G__5502__delegate; + return G__5502; + }(); + 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__4291__auto___5504 = size; + var i_5505 = 0; + while (true) { + if (i_5505 < n__4291__auto___5504) { + if (cljs.core.truth_(pred.call(null, cljs.core._nth.call(null, c, i_5505)))) { + cljs.core.chunk_append.call(null, b, cljs.core._nth.call(null, c, i_5505)); + } else { + } + var G__5506 = i_5505 + 1; + i_5505 = G__5506; + 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__5507_SHARP_) { + return!cljs.core.sequential_QMARK_.call(null, p1__5507_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__5509 = to; + if (G__5509) { + var bit__4086__auto__ = G__5509.cljs$lang$protocol_mask$partition1$ & 4; + if (bit__4086__auto__ || G__5509.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__5510__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__5510 = 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__5510__delegate.call(this, f, c1, c2, c3, colls); + }; + G__5510.cljs$lang$maxFixedArity = 4; + G__5510.cljs$lang$applyTo = function(arglist__5511) { + var f = cljs.core.first(arglist__5511); + arglist__5511 = cljs.core.next(arglist__5511); + var c1 = cljs.core.first(arglist__5511); + arglist__5511 = cljs.core.next(arglist__5511); + var c2 = cljs.core.first(arglist__5511); + arglist__5511 = cljs.core.next(arglist__5511); + var c3 = cljs.core.first(arglist__5511); + var colls = cljs.core.rest(arglist__5511); + return G__5510__delegate(f, c1, c2, c3, colls); + }; + G__5510.cljs$core$IFn$_invoke$arity$variadic = G__5510__delegate; + return G__5510; + }(); + 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__5513 = m__$1; + if (G__5513) { + var bit__4093__auto__ = G__5513.cljs$lang$protocol_mask$partition0$ & 256; + if (bit__4093__auto__ || G__5513.cljs$core$ILookup$) { + return true; + } else { + if (!G__5513.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, G__5513); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ILookup, G__5513); + } + }()) { + 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__5514 = sentinel; + var G__5515 = m__$2; + var G__5516 = cljs.core.next.call(null, ks__$1); + sentinel = G__5514; + m__$1 = G__5515; + ks__$1 = G__5516; + 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__5517, v) { + var vec__5519 = p__5517; + var k = cljs.core.nth.call(null, vec__5519, 0, null); + var ks = cljs.core.nthnext.call(null, vec__5519, 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__5520, f) { + var vec__5530 = p__5520; + var k = cljs.core.nth.call(null, vec__5530, 0, null); + var ks = cljs.core.nthnext.call(null, vec__5530, 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__5521, f, a) { + var vec__5531 = p__5521; + var k = cljs.core.nth.call(null, vec__5531, 0, null); + var ks = cljs.core.nthnext.call(null, vec__5531, 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__5522, f, a, b) { + var vec__5532 = p__5522; + var k = cljs.core.nth.call(null, vec__5532, 0, null); + var ks = cljs.core.nthnext.call(null, vec__5532, 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__5523, f, a, b, c) { + var vec__5533 = p__5523; + var k = cljs.core.nth.call(null, vec__5533, 0, null); + var ks = cljs.core.nthnext.call(null, vec__5533, 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__5535__delegate = function(m, p__5524, f, a, b, c, args) { + var vec__5534 = p__5524; + var k = cljs.core.nth.call(null, vec__5534, 0, null); + var ks = cljs.core.nthnext.call(null, vec__5534, 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__5535 = function(m, p__5524, 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__5535__delegate.call(this, m, p__5524, f, a, b, c, args); + }; + G__5535.cljs$lang$maxFixedArity = 6; + G__5535.cljs$lang$applyTo = function(arglist__5536) { + var m = cljs.core.first(arglist__5536); + arglist__5536 = cljs.core.next(arglist__5536); + var p__5524 = cljs.core.first(arglist__5536); + arglist__5536 = cljs.core.next(arglist__5536); + var f = cljs.core.first(arglist__5536); + arglist__5536 = cljs.core.next(arglist__5536); + var a = cljs.core.first(arglist__5536); + arglist__5536 = cljs.core.next(arglist__5536); + var b = cljs.core.first(arglist__5536); + arglist__5536 = cljs.core.next(arglist__5536); + var c = cljs.core.first(arglist__5536); + var args = cljs.core.rest(arglist__5536); + return G__5535__delegate(m, p__5524, f, a, b, c, args); + }; + G__5535.cljs$core$IFn$_invoke$arity$variadic = G__5535__delegate; + return G__5535; + }(); + update_in = function(m, p__5524, f, a, b, c, var_args) { + var args = var_args; + switch(arguments.length) { + case 3: + return update_in__3.call(this, m, p__5524, f); + case 4: + return update_in__4.call(this, m, p__5524, f, a); + case 5: + return update_in__5.call(this, m, p__5524, f, a, b); + case 6: + return update_in__6.call(this, m, p__5524, f, a, b, c); + default: + return update_in__7.cljs$core$IFn$_invoke$arity$variadic(m, p__5524, 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__4013__auto__, writer__4014__auto__, opts__4015__auto__) { + return cljs.core._write.call(null, writer__4014__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__5537 = ll - 5; + var G__5538 = r; + ll = G__5537; + ret = G__5538; + 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__5539 = cljs.core.pv_aget.call(null, node, i >>> level & 31); + var G__5540 = level - 5; + node = G__5539; + level = G__5540; + 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$ = 8196; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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 (typeof k === "number") { + return cljs.core._assoc_n.call(null, coll__$1, k, v); + } else { + throw new Error("Vector's key for assoc must be a number."); + } +}; +cljs.core.PersistentVector.prototype.call = function() { + var G__5542 = null; + var G__5542__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__5542__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__5542 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5542__2.call(this, self__, k); + case 3: + return G__5542__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5542; +}(); +cljs.core.PersistentVector.prototype.apply = function(self__, args5541) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5541))); +}; +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__5543 = j + 1; + var G__5544 = init__$2; + j = G__5543; + init__$1 = G__5544; + 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__5545 = i + step_init[0]; + i = G__5545; + 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__4291__auto___5546 = len; + var i_5547 = 0; + while (true) { + if (i_5547 < n__4291__auto___5546) { + new_tail[i_5547] = self__.tail[i_5547]; + var G__5548 = i_5547 + 1; + i_5547 = G__5548; + 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; + if (0 <= n && n < self__.cnt) { + if (cljs.core.tail_off.call(null, coll__$1) <= n) { + var new_tail = cljs.core.aclone.call(null, self__.tail); + new_tail[n & 31] = val; + 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, n, val), self__.tail, null); + } + } else { + if (n === self__.cnt) { + return cljs.core._conj.call(null, coll__$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 [0,"), cljs.core.str(self__.cnt), cljs.core.str("]")].join("")); + } else { + return null; + } + } + } +}; +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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.PersistentVector(self__.meta, 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__5549 = i + 1; + var G__5550 = cljs.core.conj_BANG_.call(null, out, xs__$1[i]); + i = G__5549; + out = G__5550; + 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__5551) { + var args = cljs.core.seq(arglist__5551); + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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$partition0$ = 166617887; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.Subvec.cljs$lang$type = true; +cljs.core.Subvec.cljs$lang$ctorStr = "cljs.core/Subvec"; +cljs.core.Subvec.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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; + if (typeof key === "number") { + return cljs.core._assoc_n.call(null, coll__$1, key, val); + } else { + throw new Error("Subvec's key for assoc must be a number."); + } +}; +cljs.core.Subvec.prototype.call = function() { + var G__5553 = null; + var G__5553__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__5553__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__5553 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5553__2.call(this, self__, k); + case 3: + return G__5553__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5553; +}(); +cljs.core.Subvec.prototype.apply = function(self__, args5552) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5552))); +}; +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.cljs$core$IReversible$_rseq$arity$1 = function(coll) { + var self__ = this; + var coll__$1 = this; + if (!(self__.start === self__.end)) { + return new cljs.core.RSeq(coll__$1, self__.end - self__.start - 1, null); + } else { + return 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; + var v_pos = self__.start + n; + return cljs.core.build_subvec.call(null, self__.meta, cljs.core.assoc.call(null, self__.v, v_pos, val), self__.start, function() { + var x__3750__auto__ = self__.end; + var y__3751__auto__ = v_pos + 1; + return x__3750__auto__ > y__3751__auto__ ? x__3750__auto__ : y__3751__auto__; + }(), null); +}; +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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.Subvec(self__.meta, 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__5554 = meta; + var G__5555 = v.v; + var G__5556 = v.start + start; + var G__5557 = v.start + end; + var G__5558 = __hash; + meta = G__5554; + v = G__5555; + start = G__5556; + end = G__5557; + __hash = G__5558; + 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 obj5562 = {}; + return obj5562; + }(), 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__5563 = cljs.core.tv_ensure_editable.call(null, root.edit, cljs.core.pv_aget.call(null, node, i >>> level & 31)); + var G__5564 = level - 5; + node = G__5563; + level = G__5564; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__auto__, "cljs.core/TransientVector"); +}; +cljs.core.TransientVector.prototype.call = function() { + var G__5566 = null; + var G__5566__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__5566__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__5566 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5566__2.call(this, self__, k); + case 3: + return G__5566__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5566; +}(); +cljs.core.TransientVector.prototype.apply = function(self__, args5565) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5565))); +}; +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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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$partition0$ = 31858766; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.PersistentQueue.cljs$lang$type = true; +cljs.core.PersistentQueue.cljs$lang$ctorStr = "cljs.core/PersistentQueue"; +cljs.core.PersistentQueue.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__3443__auto__ = self__.rear; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__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__3443__auto__ = self__.front; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__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$ICloneable$_clone$arity$1 = function(coll) { + var self__ = this; + var coll__$1 = this; + return new cljs.core.PersistentQueue(self__.meta, 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5567 = i + incr; + i = G__5567; + 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__5568 = i + 1; + var G__5569 = cljs.core.assoc_BANG_.call(null, out, k__$1, so[k__$1]); + i = G__5568; + out = G__5569; + 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 obj5573 = {}; + return obj5573; + }(); + var l = ks.length; + var i_5574 = 0; + while (true) { + if (i_5574 < l) { + var k_5575 = ks[i_5574]; + new_obj[k_5575] = obj[k_5575]; + var G__5576 = i_5574 + 1; + i_5574 = G__5576; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_imap.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5579 = null; + var G__5579__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__5579__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__5579 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5579__2.call(this, self__, k); + case 3: + return G__5579__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5579; +}(); +cljs.core.ObjMap.prototype.apply = function(self__, args5578) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5578))); +}; +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__5580 = cljs.core.rest.call(null, keys__$1); + var G__5581 = init__$2; + keys__$1 = G__5580; + init__$1 = G__5581; + 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__5577_SHARP_) { + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [p1__5577_SHARP_, self__.strobj[p1__5577_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 obj5583 = {}; + return obj5583; +}(), 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__5584 = i + 2; + i = G__5584; + 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__5585 = i + 2; + i = G__5585; + 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__5586 = i + 2; + i = G__5586; + 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__5587 = i + 2; + i = G__5587; + 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__5588 = i + 2; + i = G__5588; + 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_5589 = 0; + while (true) { + if (i_5589 < l) { + narr[i_5589] = arr[i_5589]; + var G__5590 = i_5589 + 1; + i_5589 = G__5590; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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$ = 8196; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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 obj5593 = {}; + return obj5593; + }(), 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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_imap.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5594 = cljs.core.aclone.call(null, self__.arr); + G__5594[idx + 1] = v; + return G__5594; + }(); + 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__5595 = null; + var G__5595__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__5595__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__5595 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5595__2.call(this, self__, k); + case 3: + return G__5595__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5595; +}(); +cljs.core.PersistentArrayMap.prototype.apply = function(self__, args5591) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5591))); +}; +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__5596 = i + 2; + var G__5597 = init__$2; + i = G__5596; + init__$1 = G__5597; + 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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.PersistentArrayMap(self__.meta, 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__5598 = s + 2; + var G__5599 = d; + s = G__5598; + d = G__5599; + 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__5600 = s + 2; + var G__5601 = d + 2; + s = G__5600; + d = G__5601; + 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__5602 = i + 2; + var G__5603 = cljs.core._assoc_BANG_.call(null, ret, arr__$1[i], arr__$1[i + 1]); + i = G__5602; + ret = G__5603; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5604_5606 = self__.arr; + G__5604_5606.pop(); + G__5604_5606.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__5605 = o; + if (G__5605) { + var bit__4093__auto__ = G__5605.cljs$lang$protocol_mask$partition0$ & 2048; + if (bit__4093__auto__ || G__5605.cljs$core$IMapEntry$) { + return true; + } else { + if (!G__5605.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__5605); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__5605); + } + }()) { + 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__5607 = cljs.core.next.call(null, es); + var G__5608 = cljs.core._assoc_BANG_.call(null, tcoll__$2, cljs.core.key.call(null, e), cljs.core.val.call(null, e)); + es = G__5607; + tcoll__$2 = G__5608; + 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__5609 = cljs.core.assoc_BANG_.call(null, out, arr[i], arr[i + 1]); + var G__5610 = i + 2; + out = G__5609; + i = G__5610; + 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__4013__auto__, writer__4014__auto__, opts__4015__auto__) { + return cljs.core._write.call(null, writer__4014__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__5613 = cljs.core.aclone.call(null, arr); + G__5613[i] = a; + return G__5613; + }; + var clone_and_set__5 = function(arr, i, a, j, b) { + var G__5614 = cljs.core.aclone.call(null, arr); + G__5614[i] = a; + G__5614[j] = b; + return G__5614; + }; + 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__5615 = i + 2; + var G__5616 = init__$2; + i = G__5615; + init__$1 = G__5616; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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_5617 = 0; + var j_5618 = 0; + while (true) { + if (i_5617 < 32) { + if ((self__.bitmap >>> i_5617 & 1) === 0) { + var G__5619 = i_5617 + 1; + var G__5620 = j_5618; + i_5617 = G__5619; + j_5618 = G__5620; + continue; + } else { + nodes[i_5617] = !(self__.arr[j_5618] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc_BANG_(edit__$1, shift + 5, cljs.core.hash.call(null, self__.arr[j_5618]), self__.arr[j_5618], self__.arr[j_5618 + 1], added_leaf_QMARK_) : self__.arr[j_5618 + 1]; + var G__5621 = i_5617 + 1; + var G__5622 = j_5618 + 2; + i_5617 = G__5621; + j_5618 = G__5622; + 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_5623 = 0; + var j_5624 = 0; + while (true) { + if (i_5623 < 32) { + if ((self__.bitmap >>> i_5623 & 1) === 0) { + var G__5625 = i_5623 + 1; + var G__5626 = j_5624; + i_5623 = G__5625; + j_5624 = G__5626; + continue; + } else { + nodes[i_5623] = !(self__.arr[j_5624] == null) ? cljs.core.BitmapIndexedNode.EMPTY.inode_assoc(shift + 5, cljs.core.hash.call(null, self__.arr[j_5624]), self__.arr[j_5624], self__.arr[j_5624 + 1], added_leaf_QMARK_) : self__.arr[j_5624 + 1]; + var G__5627 = i_5623 + 1; + var G__5628 = j_5624 + 2; + i_5623 = G__5627; + j_5624 = G__5628; + 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__5629 = i + 1; + var G__5630 = j + 2; + var G__5631 = bitmap | 1 << i; + i = G__5629; + j = G__5630; + bitmap = G__5631; + continue; + } else { + var G__5632 = i + 1; + var G__5633 = j; + var G__5634 = bitmap; + i = G__5632; + j = G__5633; + bitmap = G__5634; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5635 = i + 1; + var G__5636 = init__$2; + i = G__5635; + init__$1 = G__5636; + continue; + } + } else { + var G__5637 = i + 1; + var G__5638 = init__$1; + i = G__5637; + init__$1 = G__5638; + 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__5639 = i + 2; + i = G__5639; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5640 = j + 2; + j = G__5640; + continue; + } + } else { + var G__5641 = j + 2; + j = G__5641; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5642 = j + 1; + j = G__5642; + continue; + } + } else { + var G__5643 = j + 1; + j = G__5643; + 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$ = 8196; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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 obj5646 = {}; + return obj5646; + }(), 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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_imap.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5647 = null; + var G__5647__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__5647__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__5647 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5647__2.call(this, self__, k); + case 3: + return G__5647__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5647; +}(); +cljs.core.PersistentHashMap.prototype.apply = function(self__, args5644) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5644))); +}; +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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.PersistentHashMap(self__.meta, 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__5648 = i + 1; + var G__5649 = cljs.core._assoc_BANG_.call(null, out, ks[i], vs[i]); + i = G__5648; + out = G__5649; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5650 = o; + if (G__5650) { + var bit__4093__auto__ = G__5650.cljs$lang$protocol_mask$partition0$ & 2048; + if (bit__4093__auto__ || G__5650.cljs$core$IMapEntry$) { + return true; + } else { + if (!G__5650.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__5650); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMapEntry, G__5650); + } + }()) { + 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__5651 = cljs.core.next.call(null, es); + var G__5652 = tcoll__$1.assoc_BANG_(cljs.core.key.call(null, e), cljs.core.val.call(null, e)); + es = G__5651; + tcoll__$1 = G__5652; + 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__5653 = ascending_QMARK_ ? t.left : t.right; + var G__5654 = cljs.core.conj.call(null, stack__$1, t); + t = G__5653; + stack__$1 = G__5654; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5656 = null; + var G__5656__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__5656__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__5656 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5656__2.call(this, self__, k); + case 3: + return G__5656__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5656; +}(); +cljs.core.BlackNode.prototype.apply = function(self__, args5655) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5655))); +}; +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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5658 = null; + var G__5658__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__5658__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__5658 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5658__2.call(this, self__, k); + case 3: + return G__5658__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5658; +}(); +cljs.core.RedNode.prototype.apply = function(self__, args5657) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5657))); +}; +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$partition0$ = 418776847; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.PersistentTreeMap.cljs$lang$type = true; +cljs.core.PersistentTreeMap.cljs$lang$ctorStr = "cljs.core/PersistentTreeMap"; +cljs.core.PersistentTreeMap.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_imap.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5660 = null; + var G__5660__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__5660__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__5660 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5660__2.call(this, self__, k); + case 3: + return G__5660__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5660; +}(); +cljs.core.PersistentTreeMap.prototype.apply = function(self__, args5659) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5659))); +}; +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.toString = function() { + var self__ = this; + var coll = this; + return cljs.core.pr_str_STAR_.call(null, coll); +}; +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__5661 = t.left; + t = G__5661; + continue; + } else { + if (new cljs.core.Keyword(null, "else", "else", 1017020587)) { + var G__5662 = t.right; + t = G__5662; + 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__5663 = cljs.core.conj.call(null, stack, t); + var G__5664 = t.left; + stack = G__5663; + t = G__5664; + continue; + } else { + var G__5665 = stack; + var G__5666 = t.right; + stack = G__5665; + t = G__5666; + continue; + } + } else { + if (new cljs.core.Keyword(null, "else", "else", 1017020587)) { + if (c > 0) { + var G__5667 = cljs.core.conj.call(null, stack, t); + var G__5668 = t.right; + stack = G__5667; + t = G__5668; + continue; + } else { + var G__5669 = stack; + var G__5670 = t.left; + stack = G__5669; + t = G__5670; + 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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.PersistentTreeMap(self__.comp, self__.tree, self__.cnt, self__.meta, 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__5671 = cljs.core.nnext.call(null, in$); + var G__5672 = cljs.core.assoc_BANG_.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$)); + in$ = G__5671; + out = G__5672; + 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__5673) { + var keyvals = cljs.core.seq(arglist__5673); + 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__5674) { + var keyvals = cljs.core.seq(arglist__5674); + 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 obj5678 = {}; + return obj5678; + }(); + 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__5679 = cljs.core.nnext.call(null, kvs); + kvs = G__5679; + 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__5680) { + var keyvals = cljs.core.seq(arglist__5680); + 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__5681 = cljs.core.nnext.call(null, in$); + var G__5682 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$)); + in$ = G__5681; + out = G__5682; + 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__5683) { + var keyvals = cljs.core.seq(arglist__5683); + 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__5684 = cljs.core.nnext.call(null, in$); + var G__5685 = cljs.core.assoc.call(null, out, cljs.core.first.call(null, in$), cljs.core.second.call(null, in$)); + in$ = G__5684; + out = G__5685; + 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__5686) { + var comparator = cljs.core.first(arglist__5686); + var keyvals = cljs.core.rest(arglist__5686); + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5687 = self__.mseq; + if (G__5687) { + var bit__4093__auto__ = G__5687.cljs$lang$protocol_mask$partition0$ & 128; + if (bit__4093__auto__ || G__5687.cljs$core$INext$) { + return true; + } else { + if (!G__5687.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5687); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5687); + } + }() ? 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__5688 = self__.mseq; + if (G__5688) { + var bit__4093__auto__ = G__5688.cljs$lang$protocol_mask$partition0$ & 128; + if (bit__4093__auto__ || G__5688.cljs$core$INext$) { + return true; + } else { + if (!G__5688.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5688); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5688); + } + }() ? 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5689 = self__.mseq; + if (G__5689) { + var bit__4093__auto__ = G__5689.cljs$lang$protocol_mask$partition0$ & 128; + if (bit__4093__auto__ || G__5689.cljs$core$INext$) { + return true; + } else { + if (!G__5689.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5689); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5689); + } + }() ? 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__5690 = self__.mseq; + if (G__5690) { + var bit__4093__auto__ = G__5690.cljs$lang$protocol_mask$partition0$ & 128; + if (bit__4093__auto__ || G__5690.cljs$core$INext$) { + return true; + } else { + if (!G__5690.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5690); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.INext, G__5690); + } + }() ? 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__5691_SHARP_, p2__5692_SHARP_) { + return cljs.core.conj.call(null, function() { + var or__3443__auto__ = p1__5691_SHARP_; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.PersistentArrayMap.EMPTY; + } + }(), p2__5692_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__5693) { + var maps = cljs.core.seq(arglist__5693); + 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__3443__auto__ = m1; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__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__5694) { + var f = cljs.core.first(arglist__5694); + var maps = cljs.core.rest(arglist__5694); + 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__5695 = 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__5696 = cljs.core.next.call(null, keys); + ret = G__5695; + keys = G__5696; + 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$ = 8196; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_iset.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5699 = null; + var G__5699__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__5699__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__5699 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5699__2.call(this, self__, k); + case 3: + return G__5699__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5699; +}(); +cljs.core.PersistentHashSet.prototype.apply = function(self__, args5698) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5698))); +}; +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__5697_SHARP_) { + return cljs.core.contains_QMARK_.call(null, coll__$1, p1__5697_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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.PersistentHashSet(self__.meta, 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__5700 = i + 1; + var G__5701 = cljs.core._assoc_BANG_.call(null, out, items[i], null); + i = G__5700; + out = G__5701; + 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__5702 = i + 1; + var G__5703 = cljs.core._conj_BANG_.call(null, out, items[i]); + i = G__5702; + out = G__5703; + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__auto__, "cljs.core/TransientHashSet"); +}; +cljs.core.TransientHashSet.prototype.call = function() { + var G__5705 = null; + var G__5705__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__5705__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__5705 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5705__2.call(this, self__, k); + case 3: + return G__5705__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5705; +}(); +cljs.core.TransientHashSet.prototype.apply = function(self__, args5704) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5704))); +}; +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$partition0$ = 417730831; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.PersistentTreeSet.cljs$lang$type = true; +cljs.core.PersistentTreeSet.cljs$lang$ctorStr = "cljs.core/PersistentTreeSet"; +cljs.core.PersistentTreeSet.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_iset.call(null, coll__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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__5708 = null; + var G__5708__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__5708__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__5708 = function(self__, k, not_found) { + switch(arguments.length) { + case 2: + return G__5708__2.call(this, self__, k); + case 3: + return G__5708__3.call(this, self__, k, not_found); + } + throw new Error("Invalid arity: " + arguments.length); + }; + return G__5708; +}(); +cljs.core.PersistentTreeSet.prototype.apply = function(self__, args5707) { + var self__ = this; + var self____$1 = this; + return self____$1.call.apply(self____$1, [self____$1].concat(cljs.core.aclone.call(null, args5707))); +}; +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__5706_SHARP_) { + return cljs.core.contains_QMARK_.call(null, coll__$1, p1__5706_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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.PersistentTreeSet(self__.meta, 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__4285__auto__ = arr; + var i = 0; + var res = cljs.core._as_transient.call(null, cljs.core.PersistentHashSet.EMPTY); + while (true) { + if (i < a__4285__auto__.length) { + var G__5709 = i + 1; + var G__5710 = cljs.core._conj_BANG_.call(null, res, arr[i]); + i = G__5709; + res = G__5710; + 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__5711 = cljs.core._next.call(null, in$__$1); + var G__5712 = cljs.core._conj_BANG_.call(null, out, cljs.core._first.call(null, in$__$1)); + in$__$1 = G__5711; + out = G__5712; + 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__5713__delegate = function(keys) { + return cljs.core.set.call(null, keys); + }; + var G__5713 = function(var_args) { + var keys = null; + if (arguments.length > 0) { + keys = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5713__delegate.call(this, keys); + }; + G__5713.cljs$lang$maxFixedArity = 0; + G__5713.cljs$lang$applyTo = function(arglist__5714) { + var keys = cljs.core.seq(arglist__5714); + return G__5713__delegate(keys); + }; + G__5713.cljs$core$IFn$_invoke$arity$variadic = G__5713__delegate; + return G__5713; + }(); + 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__5715) { + var keys = cljs.core.seq(arglist__5715); + 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__5716) { + var comparator = cljs.core.first(arglist__5716); + var keys = cljs.core.rest(arglist__5716); + 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__5717_SHARP_) { + var temp__4090__auto__ = cljs.core.find.call(null, smap, p1__5717_SHARP_); + if (cljs.core.truth_(temp__4090__auto__)) { + var e = temp__4090__auto__; + return cljs.core.second.call(null, e); + } else { + return p1__5717_SHARP_; + } + }, coll); + } +}; +cljs.core.distinct = function distinct(coll) { + var step = function step(xs, seen) { + return new cljs.core.LazySeq(null, function() { + return function(p__5724, seen__$1) { + while (true) { + var vec__5725 = p__5724; + var f = cljs.core.nth.call(null, vec__5725, 0, null); + var xs__$1 = vec__5725; + 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__5726 = cljs.core.rest.call(null, s); + var G__5727 = seen__$1; + p__5724 = G__5726; + seen__$1 = G__5727; + 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__5728 = cljs.core.conj.call(null, ret, cljs.core.first.call(null, s__$1)); + var G__5729 = cljs.core.next.call(null, s__$1); + ret = G__5728; + s__$1 = G__5729; + continue; + } else { + return cljs.core.seq.call(null, ret); + } + break; + } +}; +cljs.core.name = function name(x) { + if (function() { + var G__5731 = x; + if (G__5731) { + var bit__4086__auto__ = G__5731.cljs$lang$protocol_mask$partition1$ & 4096; + if (bit__4086__auto__ || G__5731.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__5732 = cljs.core.assoc_BANG_.call(null, map, cljs.core.first.call(null, ks), cljs.core.first.call(null, vs)); + var G__5733 = cljs.core.next.call(null, ks); + var G__5734 = cljs.core.next.call(null, vs); + map = G__5732; + ks = G__5733; + vs = G__5734; + 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__5737__delegate = function(k, x, y, more) { + return cljs.core.reduce.call(null, function(p1__5735_SHARP_, p2__5736_SHARP_) { + return max_key.call(null, k, p1__5735_SHARP_, p2__5736_SHARP_); + }, max_key.call(null, k, x, y), more); + }; + var G__5737 = 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__5737__delegate.call(this, k, x, y, more); + }; + G__5737.cljs$lang$maxFixedArity = 3; + G__5737.cljs$lang$applyTo = function(arglist__5738) { + var k = cljs.core.first(arglist__5738); + arglist__5738 = cljs.core.next(arglist__5738); + var x = cljs.core.first(arglist__5738); + arglist__5738 = cljs.core.next(arglist__5738); + var y = cljs.core.first(arglist__5738); + var more = cljs.core.rest(arglist__5738); + return G__5737__delegate(k, x, y, more); + }; + G__5737.cljs$core$IFn$_invoke$arity$variadic = G__5737__delegate; + return G__5737; + }(); + 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__5741__delegate = function(k, x, y, more) { + return cljs.core.reduce.call(null, function(p1__5739_SHARP_, p2__5740_SHARP_) { + return min_key.call(null, k, p1__5739_SHARP_, p2__5740_SHARP_); + }, min_key.call(null, k, x, y), more); + }; + var G__5741 = 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__5741__delegate.call(this, k, x, y, more); + }; + G__5741.cljs$lang$maxFixedArity = 3; + G__5741.cljs$lang$applyTo = function(arglist__5742) { + var k = cljs.core.first(arglist__5742); + arglist__5742 = cljs.core.next(arglist__5742); + var x = cljs.core.first(arglist__5742); + arglist__5742 = cljs.core.next(arglist__5742); + var y = cljs.core.first(arglist__5742); + var more = cljs.core.rest(arglist__5742); + return G__5741__delegate(k, x, y, more); + }; + G__5741.cljs$core$IFn$_invoke$arity$variadic = G__5741__delegate; + return G__5741; + }(); + 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__5745 = temp__4092__auto__; + var e = cljs.core.nth.call(null, vec__5745, 0, null); + var s = vec__5745; + 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__5746 = temp__4092__auto__; + var e = cljs.core.nth.call(null, vec__5746, 0, null); + var s = vec__5746; + 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__5749 = temp__4092__auto__; + var e = cljs.core.nth.call(null, vec__5749, 0, null); + var s = vec__5749; + 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__5750 = temp__4092__auto__; + var e = cljs.core.nth.call(null, vec__5750, 0, null); + var s = vec__5750; + 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$partition0$ = 32375006; + this.cljs$lang$protocol_mask$partition1$ = 8192; +}; +cljs.core.Range.cljs$lang$type = true; +cljs.core.Range.cljs$lang$ctorStr = "cljs.core/Range"; +cljs.core.Range.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__3854__auto__ = self__.__hash; + if (!(h__3854__auto__ == null)) { + return h__3854__auto__; + } else { + var h__3854__auto____$1 = cljs.core.hash_coll.call(null, rng__$1); + self__.__hash = h__3854__auto____$1; + return h__3854__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$ICloneable$_clone$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return new cljs.core.Range(self__.meta, 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__5751_SHARP_) { + return cljs.core._EQ_.call(null, fv, f.call(null, p1__5751_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__5762 = null; + var G__5762__0 = function() { + return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null)], null); + }; + var G__5762__1 = function(x) { + return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null, x)], null); + }; + var G__5762__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__5762__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__5762__4 = function() { + var G__5763__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__5763 = 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__5763__delegate.call(this, x, y, z, args); + }; + G__5763.cljs$lang$maxFixedArity = 3; + G__5763.cljs$lang$applyTo = function(arglist__5764) { + var x = cljs.core.first(arglist__5764); + arglist__5764 = cljs.core.next(arglist__5764); + var y = cljs.core.first(arglist__5764); + arglist__5764 = cljs.core.next(arglist__5764); + var z = cljs.core.first(arglist__5764); + var args = cljs.core.rest(arglist__5764); + return G__5763__delegate(x, y, z, args); + }; + G__5763.cljs$core$IFn$_invoke$arity$variadic = G__5763__delegate; + return G__5763; + }(); + G__5762 = function(x, y, z, var_args) { + var args = var_args; + switch(arguments.length) { + case 0: + return G__5762__0.call(this); + case 1: + return G__5762__1.call(this, x); + case 2: + return G__5762__2.call(this, x, y); + case 3: + return G__5762__3.call(this, x, y, z); + default: + return G__5762__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5762.cljs$lang$maxFixedArity = 3; + G__5762.cljs$lang$applyTo = G__5762__4.cljs$lang$applyTo; + return G__5762; + }(); + }; + var juxt__2 = function(f, g) { + return function() { + var G__5765 = null; + var G__5765__0 = function() { + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [f.call(null), g.call(null)], null); + }; + var G__5765__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__5765__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__5765__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__5765__4 = function() { + var G__5766__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__5766 = 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__5766__delegate.call(this, x, y, z, args); + }; + G__5766.cljs$lang$maxFixedArity = 3; + G__5766.cljs$lang$applyTo = function(arglist__5767) { + var x = cljs.core.first(arglist__5767); + arglist__5767 = cljs.core.next(arglist__5767); + var y = cljs.core.first(arglist__5767); + arglist__5767 = cljs.core.next(arglist__5767); + var z = cljs.core.first(arglist__5767); + var args = cljs.core.rest(arglist__5767); + return G__5766__delegate(x, y, z, args); + }; + G__5766.cljs$core$IFn$_invoke$arity$variadic = G__5766__delegate; + return G__5766; + }(); + G__5765 = function(x, y, z, var_args) { + var args = var_args; + switch(arguments.length) { + case 0: + return G__5765__0.call(this); + case 1: + return G__5765__1.call(this, x); + case 2: + return G__5765__2.call(this, x, y); + case 3: + return G__5765__3.call(this, x, y, z); + default: + return G__5765__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5765.cljs$lang$maxFixedArity = 3; + G__5765.cljs$lang$applyTo = G__5765__4.cljs$lang$applyTo; + return G__5765; + }(); + }; + var juxt__3 = function(f, g, h) { + return function() { + var G__5768 = null; + var G__5768__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__5768__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__5768__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__5768__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__5768__4 = function() { + var G__5769__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__5769 = 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__5769__delegate.call(this, x, y, z, args); + }; + G__5769.cljs$lang$maxFixedArity = 3; + G__5769.cljs$lang$applyTo = function(arglist__5770) { + var x = cljs.core.first(arglist__5770); + arglist__5770 = cljs.core.next(arglist__5770); + var y = cljs.core.first(arglist__5770); + arglist__5770 = cljs.core.next(arglist__5770); + var z = cljs.core.first(arglist__5770); + var args = cljs.core.rest(arglist__5770); + return G__5769__delegate(x, y, z, args); + }; + G__5769.cljs$core$IFn$_invoke$arity$variadic = G__5769__delegate; + return G__5769; + }(); + G__5768 = function(x, y, z, var_args) { + var args = var_args; + switch(arguments.length) { + case 0: + return G__5768__0.call(this); + case 1: + return G__5768__1.call(this, x); + case 2: + return G__5768__2.call(this, x, y); + case 3: + return G__5768__3.call(this, x, y, z); + default: + return G__5768__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5768.cljs$lang$maxFixedArity = 3; + G__5768.cljs$lang$applyTo = G__5768__4.cljs$lang$applyTo; + return G__5768; + }(); + }; + var juxt__4 = function() { + var G__5771__delegate = function(f, g, h, fs) { + var fs__$1 = cljs.core.list_STAR_.call(null, f, g, h, fs); + return function() { + var G__5772 = null; + var G__5772__0 = function() { + return cljs.core.reduce.call(null, function(p1__5752_SHARP_, p2__5753_SHARP_) { + return cljs.core.conj.call(null, p1__5752_SHARP_, p2__5753_SHARP_.call(null)); + }, cljs.core.PersistentVector.EMPTY, fs__$1); + }; + var G__5772__1 = function(x) { + return cljs.core.reduce.call(null, function(p1__5754_SHARP_, p2__5755_SHARP_) { + return cljs.core.conj.call(null, p1__5754_SHARP_, p2__5755_SHARP_.call(null, x)); + }, cljs.core.PersistentVector.EMPTY, fs__$1); + }; + var G__5772__2 = function(x, y) { + return cljs.core.reduce.call(null, function(p1__5756_SHARP_, p2__5757_SHARP_) { + return cljs.core.conj.call(null, p1__5756_SHARP_, p2__5757_SHARP_.call(null, x, y)); + }, cljs.core.PersistentVector.EMPTY, fs__$1); + }; + var G__5772__3 = function(x, y, z) { + return cljs.core.reduce.call(null, function(p1__5758_SHARP_, p2__5759_SHARP_) { + return cljs.core.conj.call(null, p1__5758_SHARP_, p2__5759_SHARP_.call(null, x, y, z)); + }, cljs.core.PersistentVector.EMPTY, fs__$1); + }; + var G__5772__4 = function() { + var G__5773__delegate = function(x, y, z, args) { + return cljs.core.reduce.call(null, function(p1__5760_SHARP_, p2__5761_SHARP_) { + return cljs.core.conj.call(null, p1__5760_SHARP_, cljs.core.apply.call(null, p2__5761_SHARP_, x, y, z, args)); + }, cljs.core.PersistentVector.EMPTY, fs__$1); + }; + var G__5773 = 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__5773__delegate.call(this, x, y, z, args); + }; + G__5773.cljs$lang$maxFixedArity = 3; + G__5773.cljs$lang$applyTo = function(arglist__5774) { + var x = cljs.core.first(arglist__5774); + arglist__5774 = cljs.core.next(arglist__5774); + var y = cljs.core.first(arglist__5774); + arglist__5774 = cljs.core.next(arglist__5774); + var z = cljs.core.first(arglist__5774); + var args = cljs.core.rest(arglist__5774); + return G__5773__delegate(x, y, z, args); + }; + G__5773.cljs$core$IFn$_invoke$arity$variadic = G__5773__delegate; + return G__5773; + }(); + G__5772 = function(x, y, z, var_args) { + var args = var_args; + switch(arguments.length) { + case 0: + return G__5772__0.call(this); + case 1: + return G__5772__1.call(this, x); + case 2: + return G__5772__2.call(this, x, y); + case 3: + return G__5772__3.call(this, x, y, z); + default: + return G__5772__4.cljs$core$IFn$_invoke$arity$variadic(x, y, z, cljs.core.array_seq(arguments, 3)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + G__5772.cljs$lang$maxFixedArity = 3; + G__5772.cljs$lang$applyTo = G__5772__4.cljs$lang$applyTo; + return G__5772; + }(); + }; + var G__5771 = 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__5771__delegate.call(this, f, g, h, fs); + }; + G__5771.cljs$lang$maxFixedArity = 3; + G__5771.cljs$lang$applyTo = function(arglist__5775) { + var f = cljs.core.first(arglist__5775); + arglist__5775 = cljs.core.next(arglist__5775); + var g = cljs.core.first(arglist__5775); + arglist__5775 = cljs.core.next(arglist__5775); + var h = cljs.core.first(arglist__5775); + var fs = cljs.core.rest(arglist__5775); + return G__5771__delegate(f, g, h, fs); + }; + G__5771.cljs$core$IFn$_invoke$arity$variadic = G__5771__delegate; + return G__5771; + }(); + 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__5776 = cljs.core.next.call(null, coll); + coll = G__5776; + continue; + } else { + return null; + } + break; + } + }; + var dorun__2 = function(n, coll) { + while (true) { + if (cljs.core.seq.call(null, coll) && n > 0) { + var G__5777 = n - 1; + var G__5778 = cljs.core.next.call(null, coll); + n = G__5777; + coll = G__5778; + 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__5780 = cljs.core.re_find.call(null, /^(?:\(\?([idmsux]*)\))?(.*)/, s); + var _ = cljs.core.nth.call(null, vec__5780, 0, null); + var flags = cljs.core.nth.call(null, vec__5780, 1, null); + var pattern = cljs.core.nth.call(null, vec__5780, 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_5782 = 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_5783__$1 = cljs.core.next.call(null, coll); + var n_5784 = (new cljs.core.Keyword(null, "print-length", "print-length", 3960797560)).cljs$core$IFn$_invoke$arity$1(opts); + while (true) { + if (coll_5783__$1 && (n_5784 == null || !(n_5784 === 0))) { + cljs.core._write.call(null, writer, sep); + print_one.call(null, cljs.core.first.call(null, coll_5783__$1), writer, opts); + var G__5785 = cljs.core.next.call(null, coll_5783__$1); + var G__5786 = n_5784 - 1; + coll_5783__$1 = G__5785; + n_5784 = G__5786; + 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_5782; + } +}; +cljs.core.write_all = function() { + var write_all__delegate = function(writer, ss) { + var seq__5791 = cljs.core.seq.call(null, ss); + var chunk__5792 = null; + var count__5793 = 0; + var i__5794 = 0; + while (true) { + if (i__5794 < count__5793) { + var s = cljs.core._nth.call(null, chunk__5792, i__5794); + cljs.core._write.call(null, writer, s); + var G__5795 = seq__5791; + var G__5796 = chunk__5792; + var G__5797 = count__5793; + var G__5798 = i__5794 + 1; + seq__5791 = G__5795; + chunk__5792 = G__5796; + count__5793 = G__5797; + i__5794 = G__5798; + continue; + } else { + var temp__4092__auto__ = cljs.core.seq.call(null, seq__5791); + if (temp__4092__auto__) { + var seq__5791__$1 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__5791__$1)) { + var c__4191__auto__ = cljs.core.chunk_first.call(null, seq__5791__$1); + var G__5799 = cljs.core.chunk_rest.call(null, seq__5791__$1); + var G__5800 = c__4191__auto__; + var G__5801 = cljs.core.count.call(null, c__4191__auto__); + var G__5802 = 0; + seq__5791 = G__5799; + chunk__5792 = G__5800; + count__5793 = G__5801; + i__5794 = G__5802; + continue; + } else { + var s = cljs.core.first.call(null, seq__5791__$1); + cljs.core._write.call(null, writer, s); + var G__5803 = cljs.core.next.call(null, seq__5791__$1); + var G__5804 = null; + var G__5805 = 0; + var G__5806 = 0; + seq__5791 = G__5803; + chunk__5792 = G__5804; + count__5793 = G__5805; + i__5794 = G__5806; + 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__5807) { + var writer = cljs.core.first(arglist__5807); + var ss = cljs.core.rest(arglist__5807); + 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 obj5809 = {'"':'\\"', "\\":"\\\\", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t"}; + return obj5809; +}(); +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__3431__auto__ = cljs.core.get.call(null, opts, new cljs.core.Keyword(null, "meta", "meta", 1017252215)); + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = function() { + var G__5815 = obj; + if (G__5815) { + var bit__4093__auto__ = G__5815.cljs$lang$protocol_mask$partition0$ & 131072; + if (bit__4093__auto__ || G__5815.cljs$core$IMeta$) { + return true; + } else { + if (!G__5815.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__5815); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IMeta, G__5815); + } + }(); + if (and__3431__auto____$1) { + return cljs.core.meta.call(null, obj); + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__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__5816 = obj; + if (G__5816) { + var bit__4086__auto__ = G__5816.cljs$lang$protocol_mask$partition0$ & 2147483648; + if (bit__4086__auto__ || G__5816.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__5818 = [cljs.core.str("0"), cljs.core.str(ns)].join(""); + ns = G__5818; + 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__5817 = obj; + if (G__5817) { + var bit__4093__auto__ = G__5817.cljs$lang$protocol_mask$partition0$ & 2147483648; + if (bit__4093__auto__ || G__5817.cljs$core$IPrintWithWriter$) { + return true; + } else { + if (!G__5817.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IPrintWithWriter, G__5817); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IPrintWithWriter, G__5817); + } + }()) { + 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__5823 = cljs.core.seq.call(null, cljs.core.next.call(null, objs)); + var chunk__5824 = null; + var count__5825 = 0; + var i__5826 = 0; + while (true) { + if (i__5826 < count__5825) { + var obj = cljs.core._nth.call(null, chunk__5824, i__5826); + cljs.core._write.call(null, writer, " "); + cljs.core.pr_writer.call(null, obj, writer, opts); + var G__5827 = seq__5823; + var G__5828 = chunk__5824; + var G__5829 = count__5825; + var G__5830 = i__5826 + 1; + seq__5823 = G__5827; + chunk__5824 = G__5828; + count__5825 = G__5829; + i__5826 = G__5830; + continue; + } else { + var temp__4092__auto__ = cljs.core.seq.call(null, seq__5823); + if (temp__4092__auto__) { + var seq__5823__$1 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__5823__$1)) { + var c__4191__auto__ = cljs.core.chunk_first.call(null, seq__5823__$1); + var G__5831 = cljs.core.chunk_rest.call(null, seq__5823__$1); + var G__5832 = c__4191__auto__; + var G__5833 = cljs.core.count.call(null, c__4191__auto__); + var G__5834 = 0; + seq__5823 = G__5831; + chunk__5824 = G__5832; + count__5825 = G__5833; + i__5826 = G__5834; + continue; + } else { + var obj = cljs.core.first.call(null, seq__5823__$1); + cljs.core._write.call(null, writer, " "); + cljs.core.pr_writer.call(null, obj, writer, opts); + var G__5835 = cljs.core.next.call(null, seq__5823__$1); + var G__5836 = null; + var G__5837 = 0; + var G__5838 = 0; + seq__5823 = G__5835; + chunk__5824 = G__5836; + count__5825 = G__5837; + i__5826 = G__5838; + 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__5839) { + var objs = cljs.core.seq(arglist__5839); + 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__5840) { + var objs = cljs.core.seq(arglist__5840); + 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__5841) { + var objs = cljs.core.seq(arglist__5841); + 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__5842) { + var objs = cljs.core.seq(arglist__5842); + 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__5843) { + var objs = cljs.core.seq(arglist__5843); + 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__5844) { + var objs = cljs.core.seq(arglist__5844); + 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__5845) { + var objs = cljs.core.seq(arglist__5845); + 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__5846) { + var objs = cljs.core.seq(arglist__5846); + 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.IAtom = function() { + var obj5848 = {}; + return obj5848; +}(); +cljs.core.IReset = function() { + var obj5850 = {}; + return obj5850; +}(); +cljs.core._reset_BANG_ = function _reset_BANG_(o, new_value) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$IReset$_reset_BANG_$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$IReset$_reset_BANG_$arity$2(o, new_value); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._reset_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._reset_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IReset.-reset!", o); + } + } + }().call(null, o, new_value); + } +}; +cljs.core.ISwap = function() { + var obj5852 = {}; + return obj5852; +}(); +cljs.core._swap_BANG_ = function() { + var _swap_BANG_ = null; + var _swap_BANG___2 = function(o, f) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ISwap$_swap_BANG_$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ISwap$_swap_BANG_$arity$2(o, f); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._swap_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISwap.-swap!", o); + } + } + }().call(null, o, f); + } + }; + var _swap_BANG___3 = function(o, f, a) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ISwap$_swap_BANG_$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ISwap$_swap_BANG_$arity$3(o, f, a); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._swap_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISwap.-swap!", o); + } + } + }().call(null, o, f, a); + } + }; + var _swap_BANG___4 = function(o, f, a, b) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ISwap$_swap_BANG_$arity$4; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ISwap$_swap_BANG_$arity$4(o, f, a, b); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._swap_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISwap.-swap!", o); + } + } + }().call(null, o, f, a, b); + } + }; + var _swap_BANG___5 = function(o, f, a, b, xs) { + if (function() { + var and__3431__auto__ = o; + if (and__3431__auto__) { + return o.cljs$core$ISwap$_swap_BANG_$arity$5; + } else { + return and__3431__auto__; + } + }()) { + return o.cljs$core$ISwap$_swap_BANG_$arity$5(o, f, a, b, xs); + } else { + var x__4070__auto__ = o == null ? null : o; + return function() { + var or__3443__auto__ = cljs.core._swap_BANG_[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._swap_BANG_["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ISwap.-swap!", o); + } + } + }().call(null, o, f, a, b, xs); + } + }; + _swap_BANG_ = function(o, f, a, b, xs) { + switch(arguments.length) { + case 2: + return _swap_BANG___2.call(this, o, f); + case 3: + return _swap_BANG___3.call(this, o, f, a); + case 4: + return _swap_BANG___4.call(this, o, f, a, b); + case 5: + return _swap_BANG___5.call(this, o, f, a, b, xs); + } + throw new Error("Invalid arity: " + arguments.length); + }; + _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; + return _swap_BANG_; +}(); +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$ = 16386; +}; +cljs.core.Atom.cljs$lang$type = true; +cljs.core.Atom.cljs$lang$ctorStr = "cljs.core/Atom"; +cljs.core.Atom.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5853 = cljs.core.seq.call(null, self__.watches); + var chunk__5854 = null; + var count__5855 = 0; + var i__5856 = 0; + while (true) { + if (i__5856 < count__5855) { + var vec__5857 = cljs.core._nth.call(null, chunk__5854, i__5856); + var key = cljs.core.nth.call(null, vec__5857, 0, null); + var f = cljs.core.nth.call(null, vec__5857, 1, null); + f.call(null, key, this$__$1, oldval, newval); + var G__5859 = seq__5853; + var G__5860 = chunk__5854; + var G__5861 = count__5855; + var G__5862 = i__5856 + 1; + seq__5853 = G__5859; + chunk__5854 = G__5860; + count__5855 = G__5861; + i__5856 = G__5862; + continue; + } else { + var temp__4092__auto__ = cljs.core.seq.call(null, seq__5853); + if (temp__4092__auto__) { + var seq__5853__$1 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__5853__$1)) { + var c__4191__auto__ = cljs.core.chunk_first.call(null, seq__5853__$1); + var G__5863 = cljs.core.chunk_rest.call(null, seq__5853__$1); + var G__5864 = c__4191__auto__; + var G__5865 = cljs.core.count.call(null, c__4191__auto__); + var G__5866 = 0; + seq__5853 = G__5863; + chunk__5854 = G__5864; + count__5855 = G__5865; + i__5856 = G__5866; + continue; + } else { + var vec__5858 = cljs.core.first.call(null, seq__5853__$1); + var key = cljs.core.nth.call(null, vec__5858, 0, null); + var f = cljs.core.nth.call(null, vec__5858, 1, null); + f.call(null, key, this$__$1, oldval, newval); + var G__5867 = cljs.core.next.call(null, seq__5853__$1); + var G__5868 = null; + var G__5869 = 0; + var G__5870 = 0; + seq__5853 = G__5867; + chunk__5854 = G__5868; + count__5855 = G__5869; + i__5856 = G__5870; + 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__5874__delegate = function(x, p__5871) { + var map__5873 = p__5871; + var map__5873__$1 = cljs.core.seq_QMARK_.call(null, map__5873) ? cljs.core.apply.call(null, cljs.core.hash_map, map__5873) : map__5873; + var validator = cljs.core.get.call(null, map__5873__$1, new cljs.core.Keyword(null, "validator", "validator", 4199087812)); + var meta = cljs.core.get.call(null, map__5873__$1, new cljs.core.Keyword(null, "meta", "meta", 1017252215)); + return new cljs.core.Atom(x, meta, validator, null); + }; + var G__5874 = function(x, var_args) { + var p__5871 = null; + if (arguments.length > 1) { + p__5871 = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0); + } + return G__5874__delegate.call(this, x, p__5871); + }; + G__5874.cljs$lang$maxFixedArity = 1; + G__5874.cljs$lang$applyTo = function(arglist__5875) { + var x = cljs.core.first(arglist__5875); + var p__5871 = cljs.core.rest(arglist__5875); + return G__5874__delegate(x, p__5871); + }; + G__5874.cljs$core$IFn$_invoke$arity$variadic = G__5874__delegate; + return G__5874; + }(); + atom = function(x, var_args) { + var p__5871 = 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) { + if (a instanceof cljs.core.Atom) { + var validate = a.validator; + if (validate == null) { + } else { + if (cljs.core.truth_(validate.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 = a.state; + a.state = new_value; + if (a.watches == null) { + } else { + cljs.core._notify_watches.call(null, a, old_value, new_value); + } + return new_value; + } else { + return cljs.core._reset_BANG_.call(null, a, new_value); + } +}; +cljs.core.deref = function deref(o) { + return cljs.core._deref.call(null, o); +}; +cljs.core.swap_BANG_ = function() { + var swap_BANG_ = null; + var swap_BANG___2 = function(a, f) { + if (a instanceof cljs.core.Atom) { + return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state)); + } else { + return cljs.core._swap_BANG_.call(null, a, f); + } + }; + var swap_BANG___3 = function(a, f, x) { + if (a instanceof cljs.core.Atom) { + return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state, x)); + } else { + return cljs.core._swap_BANG_.call(null, a, f, x); + } + }; + var swap_BANG___4 = function(a, f, x, y) { + if (a instanceof cljs.core.Atom) { + return cljs.core.reset_BANG_.call(null, a, f.call(null, a.state, x, y)); + } else { + return cljs.core._swap_BANG_.call(null, a, f, x, y); + } + }; + var swap_BANG___5 = function() { + var G__5876__delegate = function(a, f, x, y, more) { + if (a instanceof cljs.core.Atom) { + return cljs.core.reset_BANG_.call(null, a, cljs.core.apply.call(null, f, a.state, x, y, more)); + } else { + return cljs.core._swap_BANG_.call(null, a, f, x, y, more); + } + }; + var G__5876 = function(a, f, x, y, var_args) { + var more = null; + if (arguments.length > 4) { + more = cljs.core.array_seq(Array.prototype.slice.call(arguments, 4), 0); + } + return G__5876__delegate.call(this, a, f, x, y, more); + }; + G__5876.cljs$lang$maxFixedArity = 4; + G__5876.cljs$lang$applyTo = function(arglist__5877) { + var a = cljs.core.first(arglist__5877); + arglist__5877 = cljs.core.next(arglist__5877); + var f = cljs.core.first(arglist__5877); + arglist__5877 = cljs.core.next(arglist__5877); + var x = cljs.core.first(arglist__5877); + arglist__5877 = cljs.core.next(arglist__5877); + var y = cljs.core.first(arglist__5877); + var more = cljs.core.rest(arglist__5877); + return G__5876__delegate(a, f, x, y, more); + }; + G__5876.cljs$core$IFn$_invoke$arity$variadic = G__5876__delegate; + return G__5876; + }(); + swap_BANG_ = function(a, f, x, y, 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); + default: + return swap_BANG___5.cljs$core$IFn$_invoke$arity$variadic(a, f, x, y, cljs.core.array_seq(arguments, 4)); + } + throw new Error("Invalid arity: " + arguments.length); + }; + swap_BANG_.cljs$lang$maxFixedArity = 4; + swap_BANG_.cljs$lang$applyTo = swap_BANG___5.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$variadic = swap_BANG___5.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.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__5878) { + var iref = cljs.core.first(arglist__5878); + arglist__5878 = cljs.core.next(arglist__5878); + var f = cljs.core.first(arglist__5878); + var args = cljs.core.rest(arglist__5878); + 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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__5879) { + var map__5880 = p__5879; + var map__5880__$1 = cljs.core.seq_QMARK_.call(null, map__5880) ? cljs.core.apply.call(null, cljs.core.hash_map, map__5880) : map__5880; + var curr_state = map__5880__$1; + var done = cljs.core.get.call(null, map__5880__$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 obj5882 = {}; + return obj5882; +}(); +cljs.core._clj__GT_js = function _clj__GT_js(x) { + if (function() { + var and__3431__auto__ = x; + if (and__3431__auto__) { + return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return x.cljs$core$IEncodeJS$_clj__GT_js$arity$1(x); + } else { + var x__4070__auto__ = x == null ? null : x; + return function() { + var or__3443__auto__ = cljs.core._clj__GT_js[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._clj__GT_js["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = x; + if (and__3431__auto__) { + return x.cljs$core$IEncodeJS$_key__GT_js$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return x.cljs$core$IEncodeJS$_key__GT_js$arity$1(x); + } else { + var x__4070__auto__ = x == null ? null : x; + return function() { + var or__3443__auto__ = cljs.core._key__GT_js[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._key__GT_js["_"]; + if (or__3443__auto____$1) { + return or__3443__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__5884 = k; + if (G__5884) { + var bit__4093__auto__ = null; + if (cljs.core.truth_(function() { + var or__3443__auto__ = bit__4093__auto__; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return G__5884.cljs$core$IEncodeJS$; + } + }())) { + return true; + } else { + if (!G__5884.cljs$lang$protocol_mask$partition$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__5884); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__5884); + } + }()) { + 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__5898 = x; + if (G__5898) { + var bit__4093__auto__ = null; + if (cljs.core.truth_(function() { + var or__3443__auto__ = bit__4093__auto__; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return G__5898.cljs$core$IEncodeJS$; + } + }())) { + return true; + } else { + if (!G__5898.cljs$lang$protocol_mask$partition$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__5898); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeJS, G__5898); + } + }()) { + 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 obj5900 = {}; + return obj5900; + }(); + var seq__5901_5911 = cljs.core.seq.call(null, x); + var chunk__5902_5912 = null; + var count__5903_5913 = 0; + var i__5904_5914 = 0; + while (true) { + if (i__5904_5914 < count__5903_5913) { + var vec__5905_5915 = cljs.core._nth.call(null, chunk__5902_5912, i__5904_5914); + var k_5916 = cljs.core.nth.call(null, vec__5905_5915, 0, null); + var v_5917 = cljs.core.nth.call(null, vec__5905_5915, 1, null); + m[cljs.core.key__GT_js.call(null, k_5916)] = clj__GT_js.call(null, v_5917); + var G__5918 = seq__5901_5911; + var G__5919 = chunk__5902_5912; + var G__5920 = count__5903_5913; + var G__5921 = i__5904_5914 + 1; + seq__5901_5911 = G__5918; + chunk__5902_5912 = G__5919; + count__5903_5913 = G__5920; + i__5904_5914 = G__5921; + continue; + } else { + var temp__4092__auto___5922 = cljs.core.seq.call(null, seq__5901_5911); + if (temp__4092__auto___5922) { + var seq__5901_5923__$1 = temp__4092__auto___5922; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__5901_5923__$1)) { + var c__4191__auto___5924 = cljs.core.chunk_first.call(null, seq__5901_5923__$1); + var G__5925 = cljs.core.chunk_rest.call(null, seq__5901_5923__$1); + var G__5926 = c__4191__auto___5924; + var G__5927 = cljs.core.count.call(null, c__4191__auto___5924); + var G__5928 = 0; + seq__5901_5911 = G__5925; + chunk__5902_5912 = G__5926; + count__5903_5913 = G__5927; + i__5904_5914 = G__5928; + continue; + } else { + var vec__5906_5929 = cljs.core.first.call(null, seq__5901_5923__$1); + var k_5930 = cljs.core.nth.call(null, vec__5906_5929, 0, null); + var v_5931 = cljs.core.nth.call(null, vec__5906_5929, 1, null); + m[cljs.core.key__GT_js.call(null, k_5930)] = clj__GT_js.call(null, v_5931); + var G__5932 = cljs.core.next.call(null, seq__5901_5923__$1); + var G__5933 = null; + var G__5934 = 0; + var G__5935 = 0; + seq__5901_5911 = G__5932; + chunk__5902_5912 = G__5933; + count__5903_5913 = G__5934; + i__5904_5914 = G__5935; + continue; + } + } else { + } + } + break; + } + return m; + } else { + if (cljs.core.coll_QMARK_.call(null, x)) { + var arr = []; + var seq__5907_5936 = cljs.core.seq.call(null, cljs.core.map.call(null, clj__GT_js, x)); + var chunk__5908_5937 = null; + var count__5909_5938 = 0; + var i__5910_5939 = 0; + while (true) { + if (i__5910_5939 < count__5909_5938) { + var x_5940__$1 = cljs.core._nth.call(null, chunk__5908_5937, i__5910_5939); + arr.push(x_5940__$1); + var G__5941 = seq__5907_5936; + var G__5942 = chunk__5908_5937; + var G__5943 = count__5909_5938; + var G__5944 = i__5910_5939 + 1; + seq__5907_5936 = G__5941; + chunk__5908_5937 = G__5942; + count__5909_5938 = G__5943; + i__5910_5939 = G__5944; + continue; + } else { + var temp__4092__auto___5945 = cljs.core.seq.call(null, seq__5907_5936); + if (temp__4092__auto___5945) { + var seq__5907_5946__$1 = temp__4092__auto___5945; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__5907_5946__$1)) { + var c__4191__auto___5947 = cljs.core.chunk_first.call(null, seq__5907_5946__$1); + var G__5948 = cljs.core.chunk_rest.call(null, seq__5907_5946__$1); + var G__5949 = c__4191__auto___5947; + var G__5950 = cljs.core.count.call(null, c__4191__auto___5947); + var G__5951 = 0; + seq__5907_5936 = G__5948; + chunk__5908_5937 = G__5949; + count__5909_5938 = G__5950; + i__5910_5939 = G__5951; + continue; + } else { + var x_5952__$1 = cljs.core.first.call(null, seq__5907_5946__$1); + arr.push(x_5952__$1); + var G__5953 = cljs.core.next.call(null, seq__5907_5946__$1); + var G__5954 = null; + var G__5955 = 0; + var G__5956 = 0; + seq__5907_5936 = G__5953; + chunk__5908_5937 = G__5954; + count__5909_5938 = G__5955; + i__5910_5939 = G__5956; + 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 obj5958 = {}; + return obj5958; +}(); +cljs.core._js__GT_clj = function _js__GT_clj(x, options) { + if (function() { + var and__3431__auto__ = x; + if (and__3431__auto__) { + return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return x.cljs$core$IEncodeClojure$_js__GT_clj$arity$2(x, options); + } else { + var x__4070__auto__ = x == null ? null : x; + return function() { + var or__3443__auto__ = cljs.core._js__GT_clj[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._js__GT_clj["_"]; + if (or__3443__auto____$1) { + return or__3443__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__5979__delegate = function(x, opts) { + if (function() { + var G__5969 = x; + if (G__5969) { + var bit__4093__auto__ = null; + if (cljs.core.truth_(function() { + var or__3443__auto__ = bit__4093__auto__; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return G__5969.cljs$core$IEncodeClojure$; + } + }())) { + return true; + } else { + if (!G__5969.cljs$lang$protocol_mask$partition$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeClojure, G__5969); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.IEncodeClojure, G__5969); + } + }()) { + 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__5970 = opts; + var map__5970__$1 = cljs.core.seq_QMARK_.call(null, map__5970) ? cljs.core.apply.call(null, cljs.core.hash_map, map__5970) : map__5970; + var keywordize_keys = cljs.core.get.call(null, map__5970__$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__5970, map__5970__$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__4160__auto__ = function(map__5970, map__5970__$1, keywordize_keys, keyfn) { + return function iter__5975(s__5976) { + return new cljs.core.LazySeq(null, function(map__5970, map__5970__$1, keywordize_keys, keyfn) { + return function() { + var s__5976__$1 = s__5976; + while (true) { + var temp__4092__auto__ = cljs.core.seq.call(null, s__5976__$1); + if (temp__4092__auto__) { + var s__5976__$2 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, s__5976__$2)) { + var c__4158__auto__ = cljs.core.chunk_first.call(null, s__5976__$2); + var size__4159__auto__ = cljs.core.count.call(null, c__4158__auto__); + var b__5978 = cljs.core.chunk_buffer.call(null, size__4159__auto__); + if (function() { + var i__5977 = 0; + while (true) { + if (i__5977 < size__4159__auto__) { + var k = cljs.core._nth.call(null, c__4158__auto__, i__5977); + cljs.core.chunk_append.call(null, b__5978, 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__5980 = i__5977 + 1; + i__5977 = G__5980; + continue; + } else { + return true; + } + break; + } + }()) { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__5978), iter__5975.call(null, cljs.core.chunk_rest.call(null, s__5976__$2))); + } else { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__5978), null); + } + } else { + var k = cljs.core.first.call(null, s__5976__$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__5975.call(null, cljs.core.rest.call(null, s__5976__$2))); + } + } else { + return null; + } + break; + } + }; + }(map__5970, map__5970__$1, keywordize_keys, keyfn), null, null); + }; + }(map__5970, map__5970__$1, keywordize_keys, keyfn); + return iter__4160__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__5970, map__5970__$1, keywordize_keys, keyfn); + return f.call(null, x); + } else { + return null; + } + } + }; + var G__5979 = 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__5979__delegate.call(this, x, opts); + }; + G__5979.cljs$lang$maxFixedArity = 1; + G__5979.cljs$lang$applyTo = function(arglist__5981) { + var x = cljs.core.first(arglist__5981); + var opts = cljs.core.rest(arglist__5981); + return G__5979__delegate(x, opts); + }; + G__5979.cljs$core$IFn$_invoke$arity$variadic = G__5979__delegate; + return G__5979; + }(); + 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__5982__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__5982 = function(var_args) { + var args = null; + if (arguments.length > 0) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return G__5982__delegate.call(this, args); + }; + G__5982.cljs$lang$maxFixedArity = 0; + G__5982.cljs$lang$applyTo = function(arglist__5983) { + var args = cljs.core.seq(arglist__5983); + return G__5982__delegate(args); + }; + G__5982.cljs$core$IFn$_invoke$arity$variadic = G__5982__delegate; + return G__5982; + }(); +}; +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__5984 = ret; + f = G__5984; + continue; + } else { + return ret; + } + break; + } + }; + var trampoline__2 = function() { + var G__5985__delegate = function(f, args) { + return trampoline.call(null, function() { + return cljs.core.apply.call(null, f, args); + }); + }; + var G__5985 = 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__5985__delegate.call(this, f, args); + }; + G__5985.cljs$lang$maxFixedArity = 1; + G__5985.cljs$lang$applyTo = function(arglist__5986) { + var f = cljs.core.first(arglist__5986); + var args = cljs.core.rest(arglist__5986); + return G__5985__delegate(f, args); + }; + G__5985.cljs$core$IFn$_invoke$arity$variadic = G__5985__delegate; + return G__5985; + }(); + 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__5987) { + var f = cljs.core.first(arglist__5987); + var args = cljs.core.rest(arglist__5987); + 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__3443__auto__ = cljs.core._EQ_.call(null, child, parent); + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__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__3443__auto____$1) { + return or__3443__auto____$1; + } else { + var and__3431__auto__ = cljs.core.vector_QMARK_.call(null, parent); + if (and__3431__auto__) { + var and__3431__auto____$1 = cljs.core.vector_QMARK_.call(null, child); + if (and__3431__auto____$1) { + var and__3431__auto____$2 = cljs.core.count.call(null, parent) === cljs.core.count.call(null, child); + if (and__3431__auto____$2) { + var ret = true; + var i = 0; + while (true) { + if (!ret || i === cljs.core.count.call(null, parent)) { + return ret; + } else { + var G__5988 = isa_QMARK_.call(null, h, child.call(null, i), parent.call(null, i)); + var G__5989 = i + 1; + ret = G__5988; + i = G__5989; + continue; + } + break; + } + } else { + return and__3431__auto____$2; + } + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__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__3443__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__3443__auto__)) { + return or__3443__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__5990_SHARP_) { + return cljs.core.cons.call(null, cljs.core.first.call(null, p1__5990_SHARP_), cljs.core.interpose.call(null, cljs.core.first.call(null, p1__5990_SHARP_), cljs.core.second.call(null, p1__5990_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__5991_SHARP_, p2__5992_SHARP_) { + return cljs.core.apply.call(null, cljs.core.derive, p1__5991_SHARP_, p2__5992_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__3443__auto__ = cljs.core.truth_(function() { + var and__3431__auto__ = xprefs; + if (cljs.core.truth_(and__3431__auto__)) { + return xprefs.call(null, y); + } else { + return and__3431__auto__; + } + }()) ? true : null; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + var or__3443__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__5993 = cljs.core.rest.call(null, ps); + ps = G__5993; + continue; + } else { + return null; + } + break; + } + }(); + if (cljs.core.truth_(or__3443__auto____$1)) { + return or__3443__auto____$1; + } else { + var or__3443__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__5994 = cljs.core.rest.call(null, ps); + ps = G__5994; + continue; + } else { + return null; + } + break; + } + }(); + if (cljs.core.truth_(or__3443__auto____$2)) { + return or__3443__auto____$2; + } else { + return false; + } + } + } +}; +cljs.core.dominates = function dominates(x, y, prefer_table) { + var or__3443__auto__ = cljs.core.prefers_STAR_.call(null, x, y, prefer_table); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__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__5997) { + var vec__5998 = p__5997; + var k = cljs.core.nth.call(null, vec__5998, 0, null); + var _ = cljs.core.nth.call(null, vec__5998, 1, null); + var e = vec__5998; + if (cljs.core.isa_QMARK_.call(null, cljs.core.deref.call(null, hierarchy), dispatch_val, k)) { + var be2 = cljs.core.truth_(function() { + var or__3443__auto__ = be == null; + if (or__3443__auto__) { + return or__3443__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 obj6000 = {}; + return obj6000; +}(); +cljs.core._reset = function _reset(mf) { + if (function() { + var and__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_reset$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_reset$arity$1(mf); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._reset[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._reset["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_add_method$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_add_method$arity$3(mf, dispatch_val, method); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._add_method[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._add_method["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_remove_method$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_remove_method$arity$2(mf, dispatch_val); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._remove_method[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._remove_method["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_prefer_method$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_prefer_method$arity$3(mf, dispatch_val, dispatch_val_y); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._prefer_method[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._prefer_method["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_get_method$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_get_method$arity$2(mf, dispatch_val); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._get_method[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._get_method["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_methods$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_methods$arity$1(mf); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._methods[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._methods["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_prefers$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_prefers$arity$1(mf); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._prefers[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._prefers["_"]; + if (or__3443__auto____$1) { + return or__3443__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__3431__auto__ = mf; + if (and__3431__auto__) { + return mf.cljs$core$IMultiFn$_dispatch$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return mf.cljs$core$IMultiFn$_dispatch$arity$2(mf, args); + } else { + var x__4070__auto__ = mf == null ? null : mf; + return function() { + var or__3443__auto__ = cljs.core._dispatch[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = cljs.core._dispatch["_"]; + if (or__3443__auto____$1) { + return or__3443__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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__6001__delegate = function(_, args) { + var self = this; + return cljs.core._dispatch.call(null, self, args); + }; + var G__6001 = function(_, var_args) { + var args = null; + if (arguments.length > 1) { + args = cljs.core.array_seq(Array.prototype.slice.call(arguments, 1), 0); + } + return G__6001__delegate.call(this, _, args); + }; + G__6001.cljs$lang$maxFixedArity = 1; + G__6001.cljs$lang$applyTo = function(arglist__6002) { + var _ = cljs.core.first(arglist__6002); + var args = cljs.core.rest(arglist__6002); + return G__6001__delegate(_, args); + }; + G__6001.cljs$core$IFn$_invoke$arity$variadic = G__6001__delegate; + return G__6001; +}(); +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__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__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__4013__auto__, writer__4014__auto__, opts__4015__auto__) { + return cljs.core._write.call(null, writer__4014__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("goog.dom.classes"); +goog.require("goog.array"); +goog.dom.classes.set = function(element, className) { + element.className = className; +}; +goog.dom.classes.get = function(element) { + var className = element.className; + return goog.isString(className) && className.match(/\S+/g) || []; +}; +goog.dom.classes.add = function(element, var_args) { + var classes = goog.dom.classes.get(element); + var args = goog.array.slice(arguments, 1); + var expectedCount = classes.length + args.length; + goog.dom.classes.add_(classes, args); + goog.dom.classes.set(element, classes.join(" ")); + return classes.length == expectedCount; +}; +goog.dom.classes.remove = function(element, var_args) { + var classes = goog.dom.classes.get(element); + var args = goog.array.slice(arguments, 1); + var newClasses = goog.dom.classes.getDifference_(classes, args); + goog.dom.classes.set(element, newClasses.join(" ")); + return newClasses.length == classes.length - args.length; +}; +goog.dom.classes.add_ = function(classes, args) { + for (var i = 0;i < args.length;i++) { + if (!goog.array.contains(classes, args[i])) { + classes.push(args[i]); + } + } +}; +goog.dom.classes.getDifference_ = function(arr1, arr2) { + return goog.array.filter(arr1, function(item) { + return!goog.array.contains(arr2, item); + }); +}; +goog.dom.classes.swap = function(element, fromClass, toClass) { + var classes = goog.dom.classes.get(element); + var removed = false; + for (var i = 0;i < classes.length;i++) { + if (classes[i] == fromClass) { + goog.array.splice(classes, i--, 1); + removed = true; + } + } + if (removed) { + classes.push(toClass); + goog.dom.classes.set(element, classes.join(" ")); + } + return removed; +}; +goog.dom.classes.addRemove = function(element, classesToRemove, classesToAdd) { + var classes = goog.dom.classes.get(element); + if (goog.isString(classesToRemove)) { + goog.array.remove(classes, classesToRemove); + } else { + if (goog.isArray(classesToRemove)) { + classes = goog.dom.classes.getDifference_(classes, classesToRemove); + } + } + if (goog.isString(classesToAdd) && !goog.array.contains(classes, classesToAdd)) { + classes.push(classesToAdd); + } else { + if (goog.isArray(classesToAdd)) { + goog.dom.classes.add_(classes, classesToAdd); + } + } + goog.dom.classes.set(element, classes.join(" ")); +}; +goog.dom.classes.has = function(element, className) { + return goog.array.contains(goog.dom.classes.get(element), className); +}; +goog.dom.classes.enable = function(element, className, enabled) { + if (enabled) { + goog.dom.classes.add(element, className); + } else { + goog.dom.classes.remove(element, className); + } +}; +goog.dom.classes.toggle = function(element, className) { + var add = !goog.dom.classes.has(element, className); + goog.dom.classes.enable(element, className, add); + return add; +}; +goog.provide("goog.userAgent"); +goog.require("goog.string"); +goog.userAgent.ASSUME_IE = false; +goog.userAgent.ASSUME_GECKO = false; +goog.userAgent.ASSUME_WEBKIT = false; +goog.userAgent.ASSUME_MOBILE_WEBKIT = false; +goog.userAgent.ASSUME_OPERA = false; +goog.userAgent.ASSUME_ANY_VERSION = false; +goog.userAgent.BROWSER_KNOWN_ = goog.userAgent.ASSUME_IE || (goog.userAgent.ASSUME_GECKO || (goog.userAgent.ASSUME_MOBILE_WEBKIT || (goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_OPERA))); +goog.userAgent.getUserAgentString = function() { + return goog.global["navigator"] ? goog.global["navigator"].userAgent : null; +}; +goog.userAgent.getNavigator = function() { + return goog.global["navigator"]; +}; +goog.userAgent.init_ = function() { + goog.userAgent.detectedOpera_ = false; + goog.userAgent.detectedIe_ = false; + goog.userAgent.detectedWebkit_ = false; + goog.userAgent.detectedMobile_ = false; + goog.userAgent.detectedGecko_ = false; + var ua; + if (!goog.userAgent.BROWSER_KNOWN_ && (ua = goog.userAgent.getUserAgentString())) { + var navigator = goog.userAgent.getNavigator(); + goog.userAgent.detectedOpera_ = ua.indexOf("Opera") == 0; + goog.userAgent.detectedIe_ = !goog.userAgent.detectedOpera_ && ua.indexOf("MSIE") != -1; + goog.userAgent.detectedWebkit_ = !goog.userAgent.detectedOpera_ && ua.indexOf("WebKit") != -1; + goog.userAgent.detectedMobile_ = goog.userAgent.detectedWebkit_ && ua.indexOf("Mobile") != -1; + goog.userAgent.detectedGecko_ = !goog.userAgent.detectedOpera_ && (!goog.userAgent.detectedWebkit_ && navigator.product == "Gecko"); + } +}; +if (!goog.userAgent.BROWSER_KNOWN_) { + goog.userAgent.init_(); +} +goog.userAgent.OPERA = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_OPERA : goog.userAgent.detectedOpera_; +goog.userAgent.IE = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_IE : goog.userAgent.detectedIe_; +goog.userAgent.GECKO = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_GECKO : goog.userAgent.detectedGecko_; +goog.userAgent.WEBKIT = goog.userAgent.BROWSER_KNOWN_ ? goog.userAgent.ASSUME_WEBKIT || goog.userAgent.ASSUME_MOBILE_WEBKIT : goog.userAgent.detectedWebkit_; +goog.userAgent.MOBILE = goog.userAgent.ASSUME_MOBILE_WEBKIT || goog.userAgent.detectedMobile_; +goog.userAgent.SAFARI = goog.userAgent.WEBKIT; +goog.userAgent.determinePlatform_ = function() { + var navigator = goog.userAgent.getNavigator(); + return navigator && navigator.platform || ""; +}; +goog.userAgent.PLATFORM = goog.userAgent.determinePlatform_(); +goog.userAgent.ASSUME_MAC = false; +goog.userAgent.ASSUME_WINDOWS = false; +goog.userAgent.ASSUME_LINUX = false; +goog.userAgent.ASSUME_X11 = false; +goog.userAgent.ASSUME_ANDROID = false; +goog.userAgent.ASSUME_IPHONE = false; +goog.userAgent.ASSUME_IPAD = false; +goog.userAgent.PLATFORM_KNOWN_ = goog.userAgent.ASSUME_MAC || (goog.userAgent.ASSUME_WINDOWS || (goog.userAgent.ASSUME_LINUX || (goog.userAgent.ASSUME_X11 || (goog.userAgent.ASSUME_ANDROID || (goog.userAgent.ASSUME_IPHONE || goog.userAgent.ASSUME_IPAD))))); +goog.userAgent.initPlatform_ = function() { + goog.userAgent.detectedMac_ = goog.string.contains(goog.userAgent.PLATFORM, "Mac"); + goog.userAgent.detectedWindows_ = goog.string.contains(goog.userAgent.PLATFORM, "Win"); + goog.userAgent.detectedLinux_ = goog.string.contains(goog.userAgent.PLATFORM, "Linux"); + goog.userAgent.detectedX11_ = !!goog.userAgent.getNavigator() && goog.string.contains(goog.userAgent.getNavigator()["appVersion"] || "", "X11"); + var ua = goog.userAgent.getUserAgentString(); + goog.userAgent.detectedAndroid_ = !!ua && ua.indexOf("Android") >= 0; + goog.userAgent.detectedIPhone_ = !!ua && ua.indexOf("iPhone") >= 0; + goog.userAgent.detectedIPad_ = !!ua && ua.indexOf("iPad") >= 0; +}; +if (!goog.userAgent.PLATFORM_KNOWN_) { + goog.userAgent.initPlatform_(); +} +goog.userAgent.MAC = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_MAC : goog.userAgent.detectedMac_; +goog.userAgent.WINDOWS = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_WINDOWS : goog.userAgent.detectedWindows_; +goog.userAgent.LINUX = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_LINUX : goog.userAgent.detectedLinux_; +goog.userAgent.X11 = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_X11 : goog.userAgent.detectedX11_; +goog.userAgent.ANDROID = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_ANDROID : goog.userAgent.detectedAndroid_; +goog.userAgent.IPHONE = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPHONE : goog.userAgent.detectedIPhone_; +goog.userAgent.IPAD = goog.userAgent.PLATFORM_KNOWN_ ? goog.userAgent.ASSUME_IPAD : goog.userAgent.detectedIPad_; +goog.userAgent.determineVersion_ = function() { + var version = "", re; + if (goog.userAgent.OPERA && goog.global["opera"]) { + var operaVersion = goog.global["opera"].version; + version = typeof operaVersion == "function" ? operaVersion() : operaVersion; + } else { + if (goog.userAgent.GECKO) { + re = /rv\:([^\);]+)(\)|;)/; + } else { + if (goog.userAgent.IE) { + re = /MSIE\s+([^\);]+)(\)|;)/; + } else { + if (goog.userAgent.WEBKIT) { + re = /WebKit\/(\S+)/; + } + } + } + if (re) { + var arr = re.exec(goog.userAgent.getUserAgentString()); + version = arr ? arr[1] : ""; + } + } + if (goog.userAgent.IE) { + var docMode = goog.userAgent.getDocumentMode_(); + if (docMode > parseFloat(version)) { + return String(docMode); + } + } + return version; +}; +goog.userAgent.getDocumentMode_ = function() { + var doc = goog.global["document"]; + return doc ? doc["documentMode"] : undefined; +}; +goog.userAgent.VERSION = goog.userAgent.determineVersion_(); +goog.userAgent.compare = function(v1, v2) { + return goog.string.compareVersions(v1, v2); +}; +goog.userAgent.isVersionCache_ = {}; +goog.userAgent.isVersion = function(version) { + return goog.userAgent.ASSUME_ANY_VERSION || (goog.userAgent.isVersionCache_[version] || (goog.userAgent.isVersionCache_[version] = goog.string.compareVersions(goog.userAgent.VERSION, version) >= 0)); +}; +goog.userAgent.isDocumentMode = function(documentMode) { + return goog.userAgent.IE && goog.userAgent.DOCUMENT_MODE >= documentMode; +}; +goog.userAgent.DOCUMENT_MODE = function() { + var doc = goog.global["document"]; + if (!doc || !goog.userAgent.IE) { + return undefined; + } + var mode = goog.userAgent.getDocumentMode_(); + return mode || (doc["compatMode"] == "CSS1Compat" ? parseInt(goog.userAgent.VERSION, 10) : 5); +}(); +goog.provide("goog.dom.BrowserFeature"); +goog.require("goog.userAgent"); +goog.dom.BrowserFeature = {CAN_ADD_NAME_OR_TYPE_ATTRIBUTES:!goog.userAgent.IE || goog.userAgent.isDocumentMode(9), CAN_USE_CHILDREN_ATTRIBUTE:!goog.userAgent.GECKO && !goog.userAgent.IE || (goog.userAgent.IE && goog.userAgent.isDocumentMode(9) || goog.userAgent.GECKO && goog.userAgent.isVersion("1.9.1")), CAN_USE_INNER_TEXT:goog.userAgent.IE && !goog.userAgent.isVersion("9"), CAN_USE_PARENT_ELEMENT_PROPERTY:goog.userAgent.IE || (goog.userAgent.OPERA || goog.userAgent.WEBKIT), INNER_HTML_NEEDS_SCOPED_ELEMENT:goog.userAgent.IE}; +goog.provide("goog.dom.TagName"); +goog.dom.TagName = {A:"A", ABBR:"ABBR", ACRONYM:"ACRONYM", ADDRESS:"ADDRESS", APPLET:"APPLET", AREA:"AREA", ARTICLE:"ARTICLE", ASIDE:"ASIDE", AUDIO:"AUDIO", B:"B", BASE:"BASE", BASEFONT:"BASEFONT", BDI:"BDI", BDO:"BDO", BIG:"BIG", BLOCKQUOTE:"BLOCKQUOTE", BODY:"BODY", BR:"BR", BUTTON:"BUTTON", CANVAS:"CANVAS", CAPTION:"CAPTION", CENTER:"CENTER", CITE:"CITE", CODE:"CODE", COL:"COL", COLGROUP:"COLGROUP", COMMAND:"COMMAND", DATA:"DATA", DATALIST:"DATALIST", DD:"DD", DEL:"DEL", DETAILS:"DETAILS", DFN:"DFN", +DIALOG:"DIALOG", DIR:"DIR", DIV:"DIV", DL:"DL", DT:"DT", EM:"EM", EMBED:"EMBED", FIELDSET:"FIELDSET", FIGCAPTION:"FIGCAPTION", FIGURE:"FIGURE", FONT:"FONT", FOOTER:"FOOTER", FORM:"FORM", FRAME:"FRAME", FRAMESET:"FRAMESET", H1:"H1", H2:"H2", H3:"H3", H4:"H4", H5:"H5", H6:"H6", HEAD:"HEAD", HEADER:"HEADER", HGROUP:"HGROUP", HR:"HR", HTML:"HTML", I:"I", IFRAME:"IFRAME", IMG:"IMG", INPUT:"INPUT", INS:"INS", ISINDEX:"ISINDEX", KBD:"KBD", KEYGEN:"KEYGEN", LABEL:"LABEL", LEGEND:"LEGEND", LI:"LI", LINK:"LINK", +MAP:"MAP", MARK:"MARK", MATH:"MATH", MENU:"MENU", META:"META", METER:"METER", NAV:"NAV", NOFRAMES:"NOFRAMES", NOSCRIPT:"NOSCRIPT", OBJECT:"OBJECT", OL:"OL", OPTGROUP:"OPTGROUP", OPTION:"OPTION", OUTPUT:"OUTPUT", P:"P", PARAM:"PARAM", PRE:"PRE", PROGRESS:"PROGRESS", Q:"Q", RP:"RP", RT:"RT", RUBY:"RUBY", S:"S", SAMP:"SAMP", SCRIPT:"SCRIPT", SECTION:"SECTION", SELECT:"SELECT", SMALL:"SMALL", SOURCE:"SOURCE", SPAN:"SPAN", STRIKE:"STRIKE", STRONG:"STRONG", STYLE:"STYLE", SUB:"SUB", SUMMARY:"SUMMARY", +SUP:"SUP", SVG:"SVG", TABLE:"TABLE", TBODY:"TBODY", TD:"TD", TEXTAREA:"TEXTAREA", TFOOT:"TFOOT", TH:"TH", THEAD:"THEAD", TIME:"TIME", TITLE:"TITLE", TR:"TR", TRACK:"TRACK", TT:"TT", U:"U", UL:"UL", VAR:"VAR", VIDEO:"VIDEO", WBR:"WBR"}; +goog.provide("goog.math"); +goog.require("goog.array"); +goog.require("goog.asserts"); +goog.math.randomInt = function(a) { + return Math.floor(Math.random() * a); +}; +goog.math.uniformRandom = function(a, b) { + return a + Math.random() * (b - a); +}; +goog.math.clamp = function(value, min, max) { + return Math.min(Math.max(value, min), max); +}; +goog.math.modulo = function(a, b) { + var r = a % b; + return r * b < 0 ? r + b : r; +}; +goog.math.lerp = function(a, b, x) { + return a + x * (b - a); +}; +goog.math.nearlyEquals = function(a, b, opt_tolerance) { + return Math.abs(a - b) <= (opt_tolerance || 1E-6); +}; +goog.math.standardAngle = function(angle) { + return goog.math.modulo(angle, 360); +}; +goog.math.toRadians = function(angleDegrees) { + return angleDegrees * Math.PI / 180; +}; +goog.math.toDegrees = function(angleRadians) { + return angleRadians * 180 / Math.PI; +}; +goog.math.angleDx = function(degrees, radius) { + return radius * Math.cos(goog.math.toRadians(degrees)); +}; +goog.math.angleDy = function(degrees, radius) { + return radius * Math.sin(goog.math.toRadians(degrees)); +}; +goog.math.angle = function(x1, y1, x2, y2) { + return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1))); +}; +goog.math.angleDifference = function(startAngle, endAngle) { + var d = goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle); + if (d > 180) { + d = d - 360; + } else { + if (d <= -180) { + d = 360 + d; + } + } + return d; +}; +goog.math.sign = function(x) { + return x == 0 ? 0 : x < 0 ? -1 : 1; +}; +goog.math.longestCommonSubsequence = function(array1, array2, opt_compareFn, opt_collectorFn) { + var compare = opt_compareFn || function(a, b) { + return a == b; + }; + var collect = opt_collectorFn || function(i1, i2) { + return array1[i1]; + }; + var length1 = array1.length; + var length2 = array2.length; + var arr = []; + for (var i = 0;i < length1 + 1;i++) { + arr[i] = []; + arr[i][0] = 0; + } + for (var j = 0;j < length2 + 1;j++) { + arr[0][j] = 0; + } + for (i = 1;i <= length1;i++) { + for (j = 1;j <= length1;j++) { + if (compare(array1[i - 1], array2[j - 1])) { + arr[i][j] = arr[i - 1][j - 1] + 1; + } else { + arr[i][j] = Math.max(arr[i - 1][j], arr[i][j - 1]); + } + } + } + var result = []; + var i = length1, j = length2; + while (i > 0 && j > 0) { + if (compare(array1[i - 1], array2[j - 1])) { + result.unshift(collect(i - 1, j - 1)); + i--; + j--; + } else { + if (arr[i - 1][j] > arr[i][j - 1]) { + i--; + } else { + j--; + } + } + } + return result; +}; +goog.math.sum = function(var_args) { + return(goog.array.reduce(arguments, function(sum, value) { + return sum + value; + }, 0)); +}; +goog.math.average = function(var_args) { + return goog.math.sum.apply(null, arguments) / arguments.length; +}; +goog.math.standardDeviation = function(var_args) { + var sampleSize = arguments.length; + if (sampleSize < 2) { + return 0; + } + var mean = goog.math.average.apply(null, arguments); + var variance = goog.math.sum.apply(null, goog.array.map(arguments, function(val) { + return Math.pow(val - mean, 2); + })) / (sampleSize - 1); + return Math.sqrt(variance); +}; +goog.math.isInt = function(num) { + return isFinite(num) && num % 1 == 0; +}; +goog.math.isFiniteNumber = function(num) { + return isFinite(num) && !isNaN(num); +}; +goog.math.safeFloor = function(num, opt_epsilon) { + goog.asserts.assert(!goog.isDef(opt_epsilon) || opt_epsilon > 0); + return Math.floor(num + (opt_epsilon || 2E-15)); +}; +goog.math.safeCeil = function(num, opt_epsilon) { + goog.asserts.assert(!goog.isDef(opt_epsilon) || opt_epsilon > 0); + return Math.ceil(num - (opt_epsilon || 2E-15)); +}; +goog.provide("goog.math.Coordinate"); +goog.require("goog.math"); +goog.math.Coordinate = function(opt_x, opt_y) { + this.x = goog.isDef(opt_x) ? opt_x : 0; + this.y = goog.isDef(opt_y) ? opt_y : 0; +}; +goog.math.Coordinate.prototype.clone = function() { + return new goog.math.Coordinate(this.x, this.y); +}; +if (goog.DEBUG) { + goog.math.Coordinate.prototype.toString = function() { + return "(" + this.x + ", " + this.y + ")"; + }; +} +goog.math.Coordinate.equals = function(a, b) { + if (a == b) { + return true; + } + if (!a || !b) { + return false; + } + return a.x == b.x && a.y == b.y; +}; +goog.math.Coordinate.distance = function(a, b) { + var dx = a.x - b.x; + var dy = a.y - b.y; + return Math.sqrt(dx * dx + dy * dy); +}; +goog.math.Coordinate.magnitude = function(a) { + return Math.sqrt(a.x * a.x + a.y * a.y); +}; +goog.math.Coordinate.azimuth = function(a) { + return goog.math.angle(0, 0, a.x, a.y); +}; +goog.math.Coordinate.squaredDistance = function(a, b) { + var dx = a.x - b.x; + var dy = a.y - b.y; + return dx * dx + dy * dy; +}; +goog.math.Coordinate.difference = function(a, b) { + return new goog.math.Coordinate(a.x - b.x, a.y - b.y); +}; +goog.math.Coordinate.sum = function(a, b) { + return new goog.math.Coordinate(a.x + b.x, a.y + b.y); +}; +goog.math.Coordinate.prototype.ceil = function() { + this.x = Math.ceil(this.x); + this.y = Math.ceil(this.y); + return this; +}; +goog.math.Coordinate.prototype.floor = function() { + this.x = Math.floor(this.x); + this.y = Math.floor(this.y); + return this; +}; +goog.math.Coordinate.prototype.round = function() { + this.x = Math.round(this.x); + this.y = Math.round(this.y); + return this; +}; +goog.math.Coordinate.prototype.translate = function(tx, opt_ty) { + if (tx instanceof goog.math.Coordinate) { + this.x += tx.x; + this.y += tx.y; + } else { + this.x += tx; + if (goog.isNumber(opt_ty)) { + this.y += opt_ty; + } + } + return this; +}; +goog.math.Coordinate.prototype.scale = function(sx, opt_sy) { + var sy = goog.isNumber(opt_sy) ? opt_sy : sx; + this.x *= sx; + this.y *= sy; + return this; +}; +goog.provide("goog.math.Size"); +goog.math.Size = function(width, height) { + this.width = width; + this.height = height; +}; +goog.math.Size.equals = function(a, b) { + if (a == b) { + return true; + } + if (!a || !b) { + return false; + } + return a.width == b.width && a.height == b.height; +}; +goog.math.Size.prototype.clone = function() { + return new goog.math.Size(this.width, this.height); +}; +if (goog.DEBUG) { + goog.math.Size.prototype.toString = function() { + return "(" + this.width + " x " + this.height + ")"; + }; +} +goog.math.Size.prototype.getLongest = function() { + return Math.max(this.width, this.height); +}; +goog.math.Size.prototype.getShortest = function() { + return Math.min(this.width, this.height); +}; +goog.math.Size.prototype.area = function() { + return this.width * this.height; +}; +goog.math.Size.prototype.perimeter = function() { + return(this.width + this.height) * 2; +}; +goog.math.Size.prototype.aspectRatio = function() { + return this.width / this.height; +}; +goog.math.Size.prototype.isEmpty = function() { + return!this.area(); +}; +goog.math.Size.prototype.ceil = function() { + this.width = Math.ceil(this.width); + this.height = Math.ceil(this.height); + return this; +}; +goog.math.Size.prototype.fitsInside = function(target) { + return this.width <= target.width && this.height <= target.height; +}; +goog.math.Size.prototype.floor = function() { + this.width = Math.floor(this.width); + this.height = Math.floor(this.height); + return this; +}; +goog.math.Size.prototype.round = function() { + this.width = Math.round(this.width); + this.height = Math.round(this.height); + return this; +}; +goog.math.Size.prototype.scale = function(sx, opt_sy) { + var sy = goog.isNumber(opt_sy) ? opt_sy : sx; + this.width *= sx; + this.height *= sy; + return this; +}; +goog.math.Size.prototype.scaleToFit = function(target) { + var s = this.aspectRatio() > target.aspectRatio() ? target.width / this.width : target.height / this.height; + return this.scale(s); +}; +goog.provide("goog.dom"); +goog.provide("goog.dom.DomHelper"); +goog.provide("goog.dom.NodeType"); +goog.require("goog.array"); +goog.require("goog.dom.BrowserFeature"); +goog.require("goog.dom.TagName"); +goog.require("goog.dom.classes"); +goog.require("goog.math.Coordinate"); +goog.require("goog.math.Size"); +goog.require("goog.object"); +goog.require("goog.string"); +goog.require("goog.userAgent"); +goog.dom.ASSUME_QUIRKS_MODE = false; +goog.dom.ASSUME_STANDARDS_MODE = false; +goog.dom.COMPAT_MODE_KNOWN_ = goog.dom.ASSUME_QUIRKS_MODE || goog.dom.ASSUME_STANDARDS_MODE; +goog.dom.NodeType = {ELEMENT:1, ATTRIBUTE:2, TEXT:3, CDATA_SECTION:4, ENTITY_REFERENCE:5, ENTITY:6, PROCESSING_INSTRUCTION:7, COMMENT:8, DOCUMENT:9, DOCUMENT_TYPE:10, DOCUMENT_FRAGMENT:11, NOTATION:12}; +goog.dom.getDomHelper = function(opt_element) { + return opt_element ? new goog.dom.DomHelper(goog.dom.getOwnerDocument(opt_element)) : goog.dom.defaultDomHelper_ || (goog.dom.defaultDomHelper_ = new goog.dom.DomHelper); +}; +goog.dom.defaultDomHelper_; +goog.dom.getDocument = function() { + return document; +}; +goog.dom.getElement = function(element) { + return goog.isString(element) ? document.getElementById(element) : element; +}; +goog.dom.$ = goog.dom.getElement; +goog.dom.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) { + return goog.dom.getElementsByTagNameAndClass_(document, opt_tag, opt_class, opt_el); +}; +goog.dom.getElementsByClass = function(className, opt_el) { + var parent = opt_el || document; + if (goog.dom.canUseQuerySelector_(parent)) { + return parent.querySelectorAll("." + className); + } else { + if (parent.getElementsByClassName) { + return parent.getElementsByClassName(className); + } + } + return goog.dom.getElementsByTagNameAndClass_(document, "*", className, opt_el); +}; +goog.dom.getElementByClass = function(className, opt_el) { + var parent = opt_el || document; + var retVal = null; + if (goog.dom.canUseQuerySelector_(parent)) { + retVal = parent.querySelector("." + className); + } else { + retVal = goog.dom.getElementsByClass(className, opt_el)[0]; + } + return retVal || null; +}; +goog.dom.canUseQuerySelector_ = function(parent) { + return!!(parent.querySelectorAll && parent.querySelector); +}; +goog.dom.getElementsByTagNameAndClass_ = function(doc, opt_tag, opt_class, opt_el) { + var parent = opt_el || doc; + var tagName = opt_tag && opt_tag != "*" ? opt_tag.toUpperCase() : ""; + if (goog.dom.canUseQuerySelector_(parent) && (tagName || opt_class)) { + var query = tagName + (opt_class ? "." + opt_class : ""); + return parent.querySelectorAll(query); + } + if (opt_class && parent.getElementsByClassName) { + var els = parent.getElementsByClassName(opt_class); + if (tagName) { + var arrayLike = {}; + var len = 0; + for (var i = 0, el;el = els[i];i++) { + if (tagName == el.nodeName) { + arrayLike[len++] = el; + } + } + arrayLike.length = len; + return arrayLike; + } else { + return els; + } + } + var els = parent.getElementsByTagName(tagName || "*"); + if (opt_class) { + var arrayLike = {}; + var len = 0; + for (var i = 0, el;el = els[i];i++) { + var className = el.className; + if (typeof className.split == "function" && goog.array.contains(className.split(/\s+/), opt_class)) { + arrayLike[len++] = el; + } + } + arrayLike.length = len; + return arrayLike; + } else { + return els; + } +}; +goog.dom.$$ = goog.dom.getElementsByTagNameAndClass; +goog.dom.setProperties = function(element, properties) { + goog.object.forEach(properties, function(val, key) { + if (key == "style") { + element.style.cssText = val; + } else { + if (key == "class") { + element.className = val; + } else { + if (key == "for") { + element.htmlFor = val; + } else { + if (key in goog.dom.DIRECT_ATTRIBUTE_MAP_) { + element.setAttribute(goog.dom.DIRECT_ATTRIBUTE_MAP_[key], val); + } else { + if (goog.string.startsWith(key, "aria-") || goog.string.startsWith(key, "data-")) { + element.setAttribute(key, val); + } else { + element[key] = val; + } + } + } + } + } + }); +}; +goog.dom.DIRECT_ATTRIBUTE_MAP_ = {"cellpadding":"cellPadding", "cellspacing":"cellSpacing", "colspan":"colSpan", "frameborder":"frameBorder", "height":"height", "maxlength":"maxLength", "role":"role", "rowspan":"rowSpan", "type":"type", "usemap":"useMap", "valign":"vAlign", "width":"width"}; +goog.dom.getViewportSize = function(opt_window) { + return goog.dom.getViewportSize_(opt_window || window); +}; +goog.dom.getViewportSize_ = function(win) { + var doc = win.document; + var el = goog.dom.isCss1CompatMode_(doc) ? doc.documentElement : doc.body; + return new goog.math.Size(el.clientWidth, el.clientHeight); +}; +goog.dom.getDocumentHeight = function() { + return goog.dom.getDocumentHeight_(window); +}; +goog.dom.getDocumentHeight_ = function(win) { + var doc = win.document; + var height = 0; + if (doc) { + var vh = goog.dom.getViewportSize_(win).height; + var body = doc.body; + var docEl = doc.documentElement; + if (goog.dom.isCss1CompatMode_(doc) && docEl.scrollHeight) { + height = docEl.scrollHeight != vh ? docEl.scrollHeight : docEl.offsetHeight; + } else { + var sh = docEl.scrollHeight; + var oh = docEl.offsetHeight; + if (docEl.clientHeight != oh) { + sh = body.scrollHeight; + oh = body.offsetHeight; + } + if (sh > vh) { + height = sh > oh ? sh : oh; + } else { + height = sh < oh ? sh : oh; + } + } + } + return height; +}; +goog.dom.getPageScroll = function(opt_window) { + var win = opt_window || (goog.global || window); + return goog.dom.getDomHelper(win.document).getDocumentScroll(); +}; +goog.dom.getDocumentScroll = function() { + return goog.dom.getDocumentScroll_(document); +}; +goog.dom.getDocumentScroll_ = function(doc) { + var el = goog.dom.getDocumentScrollElement_(doc); + var win = goog.dom.getWindow_(doc); + return new goog.math.Coordinate(win.pageXOffset || el.scrollLeft, win.pageYOffset || el.scrollTop); +}; +goog.dom.getDocumentScrollElement = function() { + return goog.dom.getDocumentScrollElement_(document); +}; +goog.dom.getDocumentScrollElement_ = function(doc) { + return!goog.userAgent.WEBKIT && goog.dom.isCss1CompatMode_(doc) ? doc.documentElement : doc.body; +}; +goog.dom.getWindow = function(opt_doc) { + return opt_doc ? goog.dom.getWindow_(opt_doc) : window; +}; +goog.dom.getWindow_ = function(doc) { + return doc.parentWindow || doc.defaultView; +}; +goog.dom.createDom = function(tagName, opt_attributes, var_args) { + return goog.dom.createDom_(document, arguments); +}; +goog.dom.createDom_ = function(doc, args) { + var tagName = args[0]; + var attributes = args[1]; + if (!goog.dom.BrowserFeature.CAN_ADD_NAME_OR_TYPE_ATTRIBUTES && (attributes && (attributes.name || attributes.type))) { + var tagNameArr = ["\x3c", tagName]; + if (attributes.name) { + tagNameArr.push(' name\x3d"', goog.string.htmlEscape(attributes.name), '"'); + } + if (attributes.type) { + tagNameArr.push(' type\x3d"', goog.string.htmlEscape(attributes.type), '"'); + var clone = {}; + goog.object.extend(clone, attributes); + delete clone["type"]; + attributes = clone; + } + tagNameArr.push("\x3e"); + tagName = tagNameArr.join(""); + } + var element = doc.createElement(tagName); + if (attributes) { + if (goog.isString(attributes)) { + element.className = attributes; + } else { + if (goog.isArray(attributes)) { + goog.dom.classes.add.apply(null, [element].concat(attributes)); + } else { + goog.dom.setProperties(element, attributes); + } + } + } + if (args.length > 2) { + goog.dom.append_(doc, element, args, 2); + } + return element; +}; +goog.dom.append_ = function(doc, parent, args, startIndex) { + function childHandler(child) { + if (child) { + parent.appendChild(goog.isString(child) ? doc.createTextNode(child) : child); + } + } + for (var i = startIndex;i < args.length;i++) { + var arg = args[i]; + if (goog.isArrayLike(arg) && !goog.dom.isNodeLike(arg)) { + goog.array.forEach(goog.dom.isNodeList(arg) ? goog.array.toArray(arg) : arg, childHandler); + } else { + childHandler(arg); + } + } +}; +goog.dom.$dom = goog.dom.createDom; +goog.dom.createElement = function(name) { + return document.createElement(name); +}; +goog.dom.createTextNode = function(content) { + return document.createTextNode(String(content)); +}; +goog.dom.createTable = function(rows, columns, opt_fillWithNbsp) { + return goog.dom.createTable_(document, rows, columns, !!opt_fillWithNbsp); +}; +goog.dom.createTable_ = function(doc, rows, columns, fillWithNbsp) { + var rowHtml = ["\x3ctr\x3e"]; + for (var i = 0;i < columns;i++) { + rowHtml.push(fillWithNbsp ? "\x3ctd\x3e\x26nbsp;\x3c/td\x3e" : "\x3ctd\x3e\x3c/td\x3e"); + } + rowHtml.push("\x3c/tr\x3e"); + rowHtml = rowHtml.join(""); + var totalHtml = ["\x3ctable\x3e"]; + for (i = 0;i < rows;i++) { + totalHtml.push(rowHtml); + } + totalHtml.push("\x3c/table\x3e"); + var elem = doc.createElement(goog.dom.TagName.DIV); + elem.innerHTML = totalHtml.join(""); + return(elem.removeChild(elem.firstChild)); +}; +goog.dom.htmlToDocumentFragment = function(htmlString) { + return goog.dom.htmlToDocumentFragment_(document, htmlString); +}; +goog.dom.htmlToDocumentFragment_ = function(doc, htmlString) { + var tempDiv = doc.createElement("div"); + if (goog.dom.BrowserFeature.INNER_HTML_NEEDS_SCOPED_ELEMENT) { + tempDiv.innerHTML = "\x3cbr\x3e" + htmlString; + tempDiv.removeChild(tempDiv.firstChild); + } else { + tempDiv.innerHTML = htmlString; + } + if (tempDiv.childNodes.length == 1) { + return(tempDiv.removeChild(tempDiv.firstChild)); + } else { + var fragment = doc.createDocumentFragment(); + while (tempDiv.firstChild) { + fragment.appendChild(tempDiv.firstChild); + } + return fragment; + } +}; +goog.dom.getCompatMode = function() { + return goog.dom.isCss1CompatMode() ? "CSS1Compat" : "BackCompat"; +}; +goog.dom.isCss1CompatMode = function() { + return goog.dom.isCss1CompatMode_(document); +}; +goog.dom.isCss1CompatMode_ = function(doc) { + if (goog.dom.COMPAT_MODE_KNOWN_) { + return goog.dom.ASSUME_STANDARDS_MODE; + } + return doc.compatMode == "CSS1Compat"; +}; +goog.dom.canHaveChildren = function(node) { + if (node.nodeType != goog.dom.NodeType.ELEMENT) { + return false; + } + switch(node.tagName) { + case goog.dom.TagName.APPLET: + ; + case goog.dom.TagName.AREA: + ; + case goog.dom.TagName.BASE: + ; + case goog.dom.TagName.BR: + ; + case goog.dom.TagName.COL: + ; + case goog.dom.TagName.COMMAND: + ; + case goog.dom.TagName.EMBED: + ; + case goog.dom.TagName.FRAME: + ; + case goog.dom.TagName.HR: + ; + case goog.dom.TagName.IMG: + ; + case goog.dom.TagName.INPUT: + ; + case goog.dom.TagName.IFRAME: + ; + case goog.dom.TagName.ISINDEX: + ; + case goog.dom.TagName.KEYGEN: + ; + case goog.dom.TagName.LINK: + ; + case goog.dom.TagName.NOFRAMES: + ; + case goog.dom.TagName.NOSCRIPT: + ; + case goog.dom.TagName.META: + ; + case goog.dom.TagName.OBJECT: + ; + case goog.dom.TagName.PARAM: + ; + case goog.dom.TagName.SCRIPT: + ; + case goog.dom.TagName.SOURCE: + ; + case goog.dom.TagName.STYLE: + ; + case goog.dom.TagName.TRACK: + ; + case goog.dom.TagName.WBR: + return false; + } + return true; +}; +goog.dom.appendChild = function(parent, child) { + parent.appendChild(child); +}; +goog.dom.append = function(parent, var_args) { + goog.dom.append_(goog.dom.getOwnerDocument(parent), parent, arguments, 1); +}; +goog.dom.removeChildren = function(node) { + var child; + while (child = node.firstChild) { + node.removeChild(child); + } +}; +goog.dom.insertSiblingBefore = function(newNode, refNode) { + if (refNode.parentNode) { + refNode.parentNode.insertBefore(newNode, refNode); + } +}; +goog.dom.insertSiblingAfter = function(newNode, refNode) { + if (refNode.parentNode) { + refNode.parentNode.insertBefore(newNode, refNode.nextSibling); + } +}; +goog.dom.insertChildAt = function(parent, child, index) { + parent.insertBefore(child, parent.childNodes[index] || null); +}; +goog.dom.removeNode = function(node) { + return node && node.parentNode ? node.parentNode.removeChild(node) : null; +}; +goog.dom.replaceNode = function(newNode, oldNode) { + var parent = oldNode.parentNode; + if (parent) { + parent.replaceChild(newNode, oldNode); + } +}; +goog.dom.flattenElement = function(element) { + var child, parent = element.parentNode; + if (parent && parent.nodeType != goog.dom.NodeType.DOCUMENT_FRAGMENT) { + if (element.removeNode) { + return(element.removeNode(false)); + } else { + while (child = element.firstChild) { + parent.insertBefore(child, element); + } + return(goog.dom.removeNode(element)); + } + } +}; +goog.dom.getChildren = function(element) { + if (goog.dom.BrowserFeature.CAN_USE_CHILDREN_ATTRIBUTE && element.children != undefined) { + return element.children; + } + return goog.array.filter(element.childNodes, function(node) { + return node.nodeType == goog.dom.NodeType.ELEMENT; + }); +}; +goog.dom.getFirstElementChild = function(node) { + if (node.firstElementChild != undefined) { + return(node).firstElementChild; + } + return goog.dom.getNextElementNode_(node.firstChild, true); +}; +goog.dom.getLastElementChild = function(node) { + if (node.lastElementChild != undefined) { + return(node).lastElementChild; + } + return goog.dom.getNextElementNode_(node.lastChild, false); +}; +goog.dom.getNextElementSibling = function(node) { + if (node.nextElementSibling != undefined) { + return(node).nextElementSibling; + } + return goog.dom.getNextElementNode_(node.nextSibling, true); +}; +goog.dom.getPreviousElementSibling = function(node) { + if (node.previousElementSibling != undefined) { + return(node).previousElementSibling; + } + return goog.dom.getNextElementNode_(node.previousSibling, false); +}; +goog.dom.getNextElementNode_ = function(node, forward) { + while (node && node.nodeType != goog.dom.NodeType.ELEMENT) { + node = forward ? node.nextSibling : node.previousSibling; + } + return(node); +}; +goog.dom.getNextNode = function(node) { + if (!node) { + return null; + } + if (node.firstChild) { + return node.firstChild; + } + while (node && !node.nextSibling) { + node = node.parentNode; + } + return node ? node.nextSibling : null; +}; +goog.dom.getPreviousNode = function(node) { + if (!node) { + return null; + } + if (!node.previousSibling) { + return node.parentNode; + } + node = node.previousSibling; + while (node && node.lastChild) { + node = node.lastChild; + } + return node; +}; +goog.dom.isNodeLike = function(obj) { + return goog.isObject(obj) && obj.nodeType > 0; +}; +goog.dom.isElement = function(obj) { + return goog.isObject(obj) && obj.nodeType == goog.dom.NodeType.ELEMENT; +}; +goog.dom.isWindow = function(obj) { + return goog.isObject(obj) && obj["window"] == obj; +}; +goog.dom.getParentElement = function(element) { + if (goog.dom.BrowserFeature.CAN_USE_PARENT_ELEMENT_PROPERTY) { + return element.parentElement; + } + var parent = element.parentNode; + return goog.dom.isElement(parent) ? (parent) : null; +}; +goog.dom.contains = function(parent, descendant) { + if (parent.contains && descendant.nodeType == goog.dom.NodeType.ELEMENT) { + return parent == descendant || parent.contains(descendant); + } + if (typeof parent.compareDocumentPosition != "undefined") { + return parent == descendant || Boolean(parent.compareDocumentPosition(descendant) & 16); + } + while (descendant && parent != descendant) { + descendant = descendant.parentNode; + } + return descendant == parent; +}; +goog.dom.compareNodeOrder = function(node1, node2) { + if (node1 == node2) { + return 0; + } + if (node1.compareDocumentPosition) { + return node1.compareDocumentPosition(node2) & 2 ? 1 : -1; + } + if (goog.userAgent.IE && !goog.userAgent.isDocumentMode(9)) { + if (node1.nodeType == goog.dom.NodeType.DOCUMENT) { + return-1; + } + if (node2.nodeType == goog.dom.NodeType.DOCUMENT) { + return 1; + } + } + if ("sourceIndex" in node1 || node1.parentNode && "sourceIndex" in node1.parentNode) { + var isElement1 = node1.nodeType == goog.dom.NodeType.ELEMENT; + var isElement2 = node2.nodeType == goog.dom.NodeType.ELEMENT; + if (isElement1 && isElement2) { + return node1.sourceIndex - node2.sourceIndex; + } else { + var parent1 = node1.parentNode; + var parent2 = node2.parentNode; + if (parent1 == parent2) { + return goog.dom.compareSiblingOrder_(node1, node2); + } + if (!isElement1 && goog.dom.contains(parent1, node2)) { + return-1 * goog.dom.compareParentsDescendantNodeIe_(node1, node2); + } + if (!isElement2 && goog.dom.contains(parent2, node1)) { + return goog.dom.compareParentsDescendantNodeIe_(node2, node1); + } + return(isElement1 ? node1.sourceIndex : parent1.sourceIndex) - (isElement2 ? node2.sourceIndex : parent2.sourceIndex); + } + } + var doc = goog.dom.getOwnerDocument(node1); + var range1, range2; + range1 = doc.createRange(); + range1.selectNode(node1); + range1.collapse(true); + range2 = doc.createRange(); + range2.selectNode(node2); + range2.collapse(true); + return range1.compareBoundaryPoints(goog.global["Range"].START_TO_END, range2); +}; +goog.dom.compareParentsDescendantNodeIe_ = function(textNode, node) { + var parent = textNode.parentNode; + if (parent == node) { + return-1; + } + var sibling = node; + while (sibling.parentNode != parent) { + sibling = sibling.parentNode; + } + return goog.dom.compareSiblingOrder_(sibling, textNode); +}; +goog.dom.compareSiblingOrder_ = function(node1, node2) { + var s = node2; + while (s = s.previousSibling) { + if (s == node1) { + return-1; + } + } + return 1; +}; +goog.dom.findCommonAncestor = function(var_args) { + var i, count = arguments.length; + if (!count) { + return null; + } else { + if (count == 1) { + return arguments[0]; + } + } + var paths = []; + var minLength = Infinity; + for (i = 0;i < count;i++) { + var ancestors = []; + var node = arguments[i]; + while (node) { + ancestors.unshift(node); + node = node.parentNode; + } + paths.push(ancestors); + minLength = Math.min(minLength, ancestors.length); + } + var output = null; + for (i = 0;i < minLength;i++) { + var first = paths[0][i]; + for (var j = 1;j < count;j++) { + if (first != paths[j][i]) { + return output; + } + } + output = first; + } + return output; +}; +goog.dom.getOwnerDocument = function(node) { + return(node.nodeType == goog.dom.NodeType.DOCUMENT ? node : node.ownerDocument || node.document); +}; +goog.dom.getFrameContentDocument = function(frame) { + var doc = frame.contentDocument || frame.contentWindow.document; + return doc; +}; +goog.dom.getFrameContentWindow = function(frame) { + return frame.contentWindow || goog.dom.getWindow_(goog.dom.getFrameContentDocument(frame)); +}; +goog.dom.setTextContent = function(element, text) { + if ("textContent" in element) { + element.textContent = text; + } else { + if (element.firstChild && element.firstChild.nodeType == goog.dom.NodeType.TEXT) { + while (element.lastChild != element.firstChild) { + element.removeChild(element.lastChild); + } + element.firstChild.data = text; + } else { + goog.dom.removeChildren(element); + var doc = goog.dom.getOwnerDocument(element); + element.appendChild(doc.createTextNode(String(text))); + } + } +}; +goog.dom.getOuterHtml = function(element) { + if ("outerHTML" in element) { + return element.outerHTML; + } else { + var doc = goog.dom.getOwnerDocument(element); + var div = doc.createElement("div"); + div.appendChild(element.cloneNode(true)); + return div.innerHTML; + } +}; +goog.dom.findNode = function(root, p) { + var rv = []; + var found = goog.dom.findNodes_(root, p, rv, true); + return found ? rv[0] : undefined; +}; +goog.dom.findNodes = function(root, p) { + var rv = []; + goog.dom.findNodes_(root, p, rv, false); + return rv; +}; +goog.dom.findNodes_ = function(root, p, rv, findOne) { + if (root != null) { + var child = root.firstChild; + while (child) { + if (p(child)) { + rv.push(child); + if (findOne) { + return true; + } + } + if (goog.dom.findNodes_(child, p, rv, findOne)) { + return true; + } + child = child.nextSibling; + } + } + return false; +}; +goog.dom.TAGS_TO_IGNORE_ = {"SCRIPT":1, "STYLE":1, "HEAD":1, "IFRAME":1, "OBJECT":1}; +goog.dom.PREDEFINED_TAG_VALUES_ = {"IMG":" ", "BR":"\n"}; +goog.dom.isFocusableTabIndex = function(element) { + var attrNode = element.getAttributeNode("tabindex"); + if (attrNode && attrNode.specified) { + var index = element.tabIndex; + return goog.isNumber(index) && (index >= 0 && index < 32768); + } + return false; +}; +goog.dom.setFocusableTabIndex = function(element, enable) { + if (enable) { + element.tabIndex = 0; + } else { + element.tabIndex = -1; + element.removeAttribute("tabIndex"); + } +}; +goog.dom.getTextContent = function(node) { + var textContent; + if (goog.dom.BrowserFeature.CAN_USE_INNER_TEXT && "innerText" in node) { + textContent = goog.string.canonicalizeNewlines(node.innerText); + } else { + var buf = []; + goog.dom.getTextContent_(node, buf, true); + textContent = buf.join(""); + } + textContent = textContent.replace(/ \xAD /g, " ").replace(/\xAD/g, ""); + textContent = textContent.replace(/\u200B/g, ""); + if (!goog.dom.BrowserFeature.CAN_USE_INNER_TEXT) { + textContent = textContent.replace(/ +/g, " "); + } + if (textContent != " ") { + textContent = textContent.replace(/^\s*/, ""); + } + return textContent; +}; +goog.dom.getRawTextContent = function(node) { + var buf = []; + goog.dom.getTextContent_(node, buf, false); + return buf.join(""); +}; +goog.dom.getTextContent_ = function(node, buf, normalizeWhitespace) { + if (node.nodeName in goog.dom.TAGS_TO_IGNORE_) { + } else { + if (node.nodeType == goog.dom.NodeType.TEXT) { + if (normalizeWhitespace) { + buf.push(String(node.nodeValue).replace(/(\r\n|\r|\n)/g, "")); + } else { + buf.push(node.nodeValue); + } + } else { + if (node.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) { + buf.push(goog.dom.PREDEFINED_TAG_VALUES_[node.nodeName]); + } else { + var child = node.firstChild; + while (child) { + goog.dom.getTextContent_(child, buf, normalizeWhitespace); + child = child.nextSibling; + } + } + } + } +}; +goog.dom.getNodeTextLength = function(node) { + return goog.dom.getTextContent(node).length; +}; +goog.dom.getNodeTextOffset = function(node, opt_offsetParent) { + var root = opt_offsetParent || goog.dom.getOwnerDocument(node).body; + var buf = []; + while (node && node != root) { + var cur = node; + while (cur = cur.previousSibling) { + buf.unshift(goog.dom.getTextContent(cur)); + } + node = node.parentNode; + } + return goog.string.trimLeft(buf.join("")).replace(/ +/g, " ").length; +}; +goog.dom.getNodeAtOffset = function(parent, offset, opt_result) { + var stack = [parent], pos = 0, cur = null; + while (stack.length > 0 && pos < offset) { + cur = stack.pop(); + if (cur.nodeName in goog.dom.TAGS_TO_IGNORE_) { + } else { + if (cur.nodeType == goog.dom.NodeType.TEXT) { + var text = cur.nodeValue.replace(/(\r\n|\r|\n)/g, "").replace(/ +/g, " "); + pos += text.length; + } else { + if (cur.nodeName in goog.dom.PREDEFINED_TAG_VALUES_) { + pos += goog.dom.PREDEFINED_TAG_VALUES_[cur.nodeName].length; + } else { + for (var i = cur.childNodes.length - 1;i >= 0;i--) { + stack.push(cur.childNodes[i]); + } + } + } + } + } + if (goog.isObject(opt_result)) { + opt_result.remainder = cur ? cur.nodeValue.length + offset - pos - 1 : 0; + opt_result.node = cur; + } + return cur; +}; +goog.dom.isNodeList = function(val) { + if (val && typeof val.length == "number") { + if (goog.isObject(val)) { + return typeof val.item == "function" || typeof val.item == "string"; + } else { + if (goog.isFunction(val)) { + return typeof val.item == "function"; + } + } + } + return false; +}; +goog.dom.getAncestorByTagNameAndClass = function(element, opt_tag, opt_class) { + if (!opt_tag && !opt_class) { + return null; + } + var tagName = opt_tag ? opt_tag.toUpperCase() : null; + return(goog.dom.getAncestor(element, function(node) { + return(!tagName || node.nodeName == tagName) && (!opt_class || goog.dom.classes.has(node, opt_class)); + }, true)); +}; +goog.dom.getAncestorByClass = function(element, className) { + return goog.dom.getAncestorByTagNameAndClass(element, null, className); +}; +goog.dom.getAncestor = function(element, matcher, opt_includeNode, opt_maxSearchSteps) { + if (!opt_includeNode) { + element = element.parentNode; + } + var ignoreSearchSteps = opt_maxSearchSteps == null; + var steps = 0; + while (element && (ignoreSearchSteps || steps <= opt_maxSearchSteps)) { + if (matcher(element)) { + return element; + } + element = element.parentNode; + steps++; + } + return null; +}; +goog.dom.getActiveElement = function(doc) { + try { + return doc && doc.activeElement; + } catch (e) { + } + return null; +}; +goog.dom.DomHelper = function(opt_document) { + this.document_ = opt_document || (goog.global.document || document); +}; +goog.dom.DomHelper.prototype.getDomHelper = goog.dom.getDomHelper; +goog.dom.DomHelper.prototype.setDocument = function(document) { + this.document_ = document; +}; +goog.dom.DomHelper.prototype.getDocument = function() { + return this.document_; +}; +goog.dom.DomHelper.prototype.getElement = function(element) { + if (goog.isString(element)) { + return this.document_.getElementById(element); + } else { + return element; + } +}; +goog.dom.DomHelper.prototype.$ = goog.dom.DomHelper.prototype.getElement; +goog.dom.DomHelper.prototype.getElementsByTagNameAndClass = function(opt_tag, opt_class, opt_el) { + return goog.dom.getElementsByTagNameAndClass_(this.document_, opt_tag, opt_class, opt_el); +}; +goog.dom.DomHelper.prototype.getElementsByClass = function(className, opt_el) { + var doc = opt_el || this.document_; + return goog.dom.getElementsByClass(className, doc); +}; +goog.dom.DomHelper.prototype.getElementByClass = function(className, opt_el) { + var doc = opt_el || this.document_; + return goog.dom.getElementByClass(className, doc); +}; +goog.dom.DomHelper.prototype.$$ = goog.dom.DomHelper.prototype.getElementsByTagNameAndClass; +goog.dom.DomHelper.prototype.setProperties = goog.dom.setProperties; +goog.dom.DomHelper.prototype.getViewportSize = function(opt_window) { + return goog.dom.getViewportSize(opt_window || this.getWindow()); +}; +goog.dom.DomHelper.prototype.getDocumentHeight = function() { + return goog.dom.getDocumentHeight_(this.getWindow()); +}; +goog.dom.Appendable; +goog.dom.DomHelper.prototype.createDom = function(tagName, opt_attributes, var_args) { + return goog.dom.createDom_(this.document_, arguments); +}; +goog.dom.DomHelper.prototype.$dom = goog.dom.DomHelper.prototype.createDom; +goog.dom.DomHelper.prototype.createElement = function(name) { + return this.document_.createElement(name); +}; +goog.dom.DomHelper.prototype.createTextNode = function(content) { + return this.document_.createTextNode(String(content)); +}; +goog.dom.DomHelper.prototype.createTable = function(rows, columns, opt_fillWithNbsp) { + return goog.dom.createTable_(this.document_, rows, columns, !!opt_fillWithNbsp); +}; +goog.dom.DomHelper.prototype.htmlToDocumentFragment = function(htmlString) { + return goog.dom.htmlToDocumentFragment_(this.document_, htmlString); +}; +goog.dom.DomHelper.prototype.getCompatMode = function() { + return this.isCss1CompatMode() ? "CSS1Compat" : "BackCompat"; +}; +goog.dom.DomHelper.prototype.isCss1CompatMode = function() { + return goog.dom.isCss1CompatMode_(this.document_); +}; +goog.dom.DomHelper.prototype.getWindow = function() { + return goog.dom.getWindow_(this.document_); +}; +goog.dom.DomHelper.prototype.getDocumentScrollElement = function() { + return goog.dom.getDocumentScrollElement_(this.document_); +}; +goog.dom.DomHelper.prototype.getDocumentScroll = function() { + return goog.dom.getDocumentScroll_(this.document_); +}; +goog.dom.DomHelper.prototype.getActiveElement = function(opt_doc) { + return goog.dom.getActiveElement(opt_doc || this.document_); +}; +goog.dom.DomHelper.prototype.appendChild = goog.dom.appendChild; +goog.dom.DomHelper.prototype.append = goog.dom.append; +goog.dom.DomHelper.prototype.canHaveChildren = goog.dom.canHaveChildren; +goog.dom.DomHelper.prototype.removeChildren = goog.dom.removeChildren; +goog.dom.DomHelper.prototype.insertSiblingBefore = goog.dom.insertSiblingBefore; +goog.dom.DomHelper.prototype.insertSiblingAfter = goog.dom.insertSiblingAfter; +goog.dom.DomHelper.prototype.insertChildAt = goog.dom.insertChildAt; +goog.dom.DomHelper.prototype.removeNode = goog.dom.removeNode; +goog.dom.DomHelper.prototype.replaceNode = goog.dom.replaceNode; +goog.dom.DomHelper.prototype.flattenElement = goog.dom.flattenElement; +goog.dom.DomHelper.prototype.getChildren = goog.dom.getChildren; +goog.dom.DomHelper.prototype.getFirstElementChild = goog.dom.getFirstElementChild; +goog.dom.DomHelper.prototype.getLastElementChild = goog.dom.getLastElementChild; +goog.dom.DomHelper.prototype.getNextElementSibling = goog.dom.getNextElementSibling; +goog.dom.DomHelper.prototype.getPreviousElementSibling = goog.dom.getPreviousElementSibling; +goog.dom.DomHelper.prototype.getNextNode = goog.dom.getNextNode; +goog.dom.DomHelper.prototype.getPreviousNode = goog.dom.getPreviousNode; +goog.dom.DomHelper.prototype.isNodeLike = goog.dom.isNodeLike; +goog.dom.DomHelper.prototype.isElement = goog.dom.isElement; +goog.dom.DomHelper.prototype.isWindow = goog.dom.isWindow; +goog.dom.DomHelper.prototype.getParentElement = goog.dom.getParentElement; +goog.dom.DomHelper.prototype.contains = goog.dom.contains; +goog.dom.DomHelper.prototype.compareNodeOrder = goog.dom.compareNodeOrder; +goog.dom.DomHelper.prototype.findCommonAncestor = goog.dom.findCommonAncestor; +goog.dom.DomHelper.prototype.getOwnerDocument = goog.dom.getOwnerDocument; +goog.dom.DomHelper.prototype.getFrameContentDocument = goog.dom.getFrameContentDocument; +goog.dom.DomHelper.prototype.getFrameContentWindow = goog.dom.getFrameContentWindow; +goog.dom.DomHelper.prototype.setTextContent = goog.dom.setTextContent; +goog.dom.DomHelper.prototype.getOuterHtml = goog.dom.getOuterHtml; +goog.dom.DomHelper.prototype.findNode = goog.dom.findNode; +goog.dom.DomHelper.prototype.findNodes = goog.dom.findNodes; +goog.dom.DomHelper.prototype.isFocusableTabIndex = goog.dom.isFocusableTabIndex; +goog.dom.DomHelper.prototype.setFocusableTabIndex = goog.dom.setFocusableTabIndex; +goog.dom.DomHelper.prototype.getTextContent = goog.dom.getTextContent; +goog.dom.DomHelper.prototype.getNodeTextLength = goog.dom.getNodeTextLength; +goog.dom.DomHelper.prototype.getNodeTextOffset = goog.dom.getNodeTextOffset; +goog.dom.DomHelper.prototype.getNodeAtOffset = goog.dom.getNodeAtOffset; +goog.dom.DomHelper.prototype.isNodeList = goog.dom.isNodeList; +goog.dom.DomHelper.prototype.getAncestorByTagNameAndClass = goog.dom.getAncestorByTagNameAndClass; +goog.dom.DomHelper.prototype.getAncestorByClass = goog.dom.getAncestorByClass; +goog.dom.DomHelper.prototype.getAncestor = goog.dom.getAncestor; +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__6455 = cljs.core.pop.call(null, v__$1); + v__$1 = G__6455; + 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__6459 = cljs.core._EQ_; + var expr__6460 = limit; + if (cljs.core.truth_(pred__6459.call(null, 1, expr__6460))) { + return new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [s], null); + } else { + if (cljs.core.truth_(pred__6459.call(null, 2, expr__6460))) { + 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__6462 = s__$1.substring(index + cljs.core.count.call(null, m)); + var G__6463 = limit__$1 - 1; + var G__6464 = cljs.core.conj.call(null, parts, s__$1.substring(0, index)); + s__$1 = G__6462; + limit__$1 = G__6463; + parts = G__6464; + 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__6465 = index - 1; + index = G__6465; + 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___6466 = cljs.core.get.call(null, cmap, ch); + if (cljs.core.truth_(temp__4090__auto___6466)) { + var replacement_6467 = temp__4090__auto___6466; + buffer.append([cljs.core.str(replacement_6467)].join("")); + } else { + buffer.append(ch); + } + var G__6468 = index + 1; + index = G__6468; + continue; + } + break; + } +}; +goog.provide("goog.dom.xml"); +goog.require("goog.dom"); +goog.require("goog.dom.NodeType"); +goog.dom.xml.MAX_XML_SIZE_KB = 2 * 1024; +goog.dom.xml.MAX_ELEMENT_DEPTH = 256; +goog.dom.xml.createDocument = function(opt_rootTagName, opt_namespaceUri) { + if (opt_namespaceUri && !opt_rootTagName) { + throw Error("Can't create document with namespace and no root tag"); + } + if (document.implementation && document.implementation.createDocument) { + return document.implementation.createDocument(opt_namespaceUri || "", opt_rootTagName || "", null); + } else { + if (typeof ActiveXObject != "undefined") { + var doc = goog.dom.xml.createMsXmlDocument_(); + if (doc) { + if (opt_rootTagName) { + doc.appendChild(doc.createNode(goog.dom.NodeType.ELEMENT, opt_rootTagName, opt_namespaceUri || "")); + } + return doc; + } + } + } + throw Error("Your browser does not support creating new documents"); +}; +goog.dom.xml.loadXml = function(xml) { + if (typeof DOMParser != "undefined") { + return(new DOMParser).parseFromString(xml, "application/xml"); + } else { + if (typeof ActiveXObject != "undefined") { + var doc = goog.dom.xml.createMsXmlDocument_(); + doc.loadXML(xml); + return doc; + } + } + throw Error("Your browser does not support loading xml documents"); +}; +goog.dom.xml.serialize = function(xml) { + if (typeof XMLSerializer != "undefined") { + return(new XMLSerializer).serializeToString(xml); + } + var text = xml.xml; + if (text) { + return text; + } + throw Error("Your browser does not support serializing XML documents"); +}; +goog.dom.xml.selectSingleNode = function(node, path) { + if (typeof node.selectSingleNode != "undefined") { + var doc = goog.dom.getOwnerDocument(node); + if (typeof doc.setProperty != "undefined") { + doc.setProperty("SelectionLanguage", "XPath"); + } + return node.selectSingleNode(path); + } else { + if (document.implementation.hasFeature("XPath", "3.0")) { + var doc = goog.dom.getOwnerDocument(node); + var resolver = doc.createNSResolver(doc.documentElement); + var result = doc.evaluate(path, node, resolver, XPathResult.FIRST_ORDERED_NODE_TYPE, null); + return result.singleNodeValue; + } + } + return null; +}; +goog.dom.xml.selectNodes = function(node, path) { + if (typeof node.selectNodes != "undefined") { + var doc = goog.dom.getOwnerDocument(node); + if (typeof doc.setProperty != "undefined") { + doc.setProperty("SelectionLanguage", "XPath"); + } + return node.selectNodes(path); + } else { + if (document.implementation.hasFeature("XPath", "3.0")) { + var doc = goog.dom.getOwnerDocument(node); + var resolver = doc.createNSResolver(doc.documentElement); + var nodes = doc.evaluate(path, node, resolver, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null); + var results = []; + var count = nodes.snapshotLength; + for (var i = 0;i < count;i++) { + results.push(nodes.snapshotItem(i)); + } + return results; + } else { + return[]; + } + } +}; +goog.dom.xml.setAttributes = function(element, attributes) { + for (var key in attributes) { + if (attributes.hasOwnProperty(key)) { + element.setAttribute(key, attributes[key]); + } + } +}; +goog.dom.xml.createMsXmlDocument_ = function() { + var doc = new ActiveXObject("MSXML2.DOMDocument"); + if (doc) { + doc.resolveExternals = false; + doc.validateOnParse = false; + try { + doc.setProperty("ProhibitDTD", true); + doc.setProperty("MaxXMLSize", goog.dom.xml.MAX_XML_SIZE_KB); + doc.setProperty("MaxElementDepth", goog.dom.xml.MAX_ELEMENT_DEPTH); + } catch (e) { + } + } + return doc; +}; +goog.provide("goog.dom.vendor"); +goog.require("goog.userAgent"); +goog.dom.vendor.getVendorJsPrefix = function() { + if (goog.userAgent.WEBKIT) { + return "Webkit"; + } else { + if (goog.userAgent.GECKO) { + return "Moz"; + } else { + if (goog.userAgent.IE) { + return "ms"; + } else { + if (goog.userAgent.OPERA) { + return "O"; + } + } + } + } + return null; +}; +goog.dom.vendor.getVendorPrefix = function() { + if (goog.userAgent.WEBKIT) { + return "-webkit"; + } else { + if (goog.userAgent.GECKO) { + return "-moz"; + } else { + if (goog.userAgent.IE) { + return "-ms"; + } else { + if (goog.userAgent.OPERA) { + return "-o"; + } + } + } + } + return null; +}; +goog.provide("goog.math.Box"); +goog.require("goog.math.Coordinate"); +goog.math.Box = function(top, right, bottom, left) { + this.top = top; + this.right = right; + this.bottom = bottom; + this.left = left; +}; +goog.math.Box.boundingBox = function(var_args) { + var box = new goog.math.Box(arguments[0].y, arguments[0].x, arguments[0].y, arguments[0].x); + for (var i = 1;i < arguments.length;i++) { + var coord = arguments[i]; + box.top = Math.min(box.top, coord.y); + box.right = Math.max(box.right, coord.x); + box.bottom = Math.max(box.bottom, coord.y); + box.left = Math.min(box.left, coord.x); + } + return box; +}; +goog.math.Box.prototype.clone = function() { + return new goog.math.Box(this.top, this.right, this.bottom, this.left); +}; +if (goog.DEBUG) { + goog.math.Box.prototype.toString = function() { + return "(" + this.top + "t, " + this.right + "r, " + this.bottom + "b, " + this.left + "l)"; + }; +} +goog.math.Box.prototype.contains = function(other) { + return goog.math.Box.contains(this, other); +}; +goog.math.Box.prototype.expand = function(top, opt_right, opt_bottom, opt_left) { + if (goog.isObject(top)) { + this.top -= top.top; + this.right += top.right; + this.bottom += top.bottom; + this.left -= top.left; + } else { + this.top -= top; + this.right += opt_right; + this.bottom += opt_bottom; + this.left -= opt_left; + } + return this; +}; +goog.math.Box.prototype.expandToInclude = function(box) { + this.left = Math.min(this.left, box.left); + this.top = Math.min(this.top, box.top); + this.right = Math.max(this.right, box.right); + this.bottom = Math.max(this.bottom, box.bottom); +}; +goog.math.Box.equals = function(a, b) { + if (a == b) { + return true; + } + if (!a || !b) { + return false; + } + return a.top == b.top && (a.right == b.right && (a.bottom == b.bottom && a.left == b.left)); +}; +goog.math.Box.contains = function(box, other) { + if (!box || !other) { + return false; + } + if (other instanceof goog.math.Box) { + return other.left >= box.left && (other.right <= box.right && (other.top >= box.top && other.bottom <= box.bottom)); + } + return other.x >= box.left && (other.x <= box.right && (other.y >= box.top && other.y <= box.bottom)); +}; +goog.math.Box.relativePositionX = function(box, coord) { + if (coord.x < box.left) { + return coord.x - box.left; + } else { + if (coord.x > box.right) { + return coord.x - box.right; + } + } + return 0; +}; +goog.math.Box.relativePositionY = function(box, coord) { + if (coord.y < box.top) { + return coord.y - box.top; + } else { + if (coord.y > box.bottom) { + return coord.y - box.bottom; + } + } + return 0; +}; +goog.math.Box.distance = function(box, coord) { + var x = goog.math.Box.relativePositionX(box, coord); + var y = goog.math.Box.relativePositionY(box, coord); + return Math.sqrt(x * x + y * y); +}; +goog.math.Box.intersects = function(a, b) { + return a.left <= b.right && (b.left <= a.right && (a.top <= b.bottom && b.top <= a.bottom)); +}; +goog.math.Box.intersectsWithPadding = function(a, b, padding) { + return a.left <= b.right + padding && (b.left <= a.right + padding && (a.top <= b.bottom + padding && b.top <= a.bottom + padding)); +}; +goog.math.Box.prototype.ceil = function() { + this.top = Math.ceil(this.top); + this.right = Math.ceil(this.right); + this.bottom = Math.ceil(this.bottom); + this.left = Math.ceil(this.left); + return this; +}; +goog.math.Box.prototype.floor = function() { + this.top = Math.floor(this.top); + this.right = Math.floor(this.right); + this.bottom = Math.floor(this.bottom); + this.left = Math.floor(this.left); + return this; +}; +goog.math.Box.prototype.round = function() { + this.top = Math.round(this.top); + this.right = Math.round(this.right); + this.bottom = Math.round(this.bottom); + this.left = Math.round(this.left); + return this; +}; +goog.math.Box.prototype.translate = function(tx, opt_ty) { + if (tx instanceof goog.math.Coordinate) { + this.left += tx.x; + this.right += tx.x; + this.top += tx.y; + this.bottom += tx.y; + } else { + this.left += tx; + this.right += tx; + if (goog.isNumber(opt_ty)) { + this.top += opt_ty; + this.bottom += opt_ty; + } + } + return this; +}; +goog.math.Box.prototype.scale = function(sx, opt_sy) { + var sy = goog.isNumber(opt_sy) ? opt_sy : sx; + this.left *= sx; + this.right *= sx; + this.top *= sy; + this.bottom *= sy; + return this; +}; +goog.provide("goog.math.Rect"); +goog.require("goog.math.Box"); +goog.require("goog.math.Coordinate"); +goog.require("goog.math.Size"); +goog.math.Rect = function(x, y, w, h) { + this.left = x; + this.top = y; + this.width = w; + this.height = h; +}; +goog.math.Rect.prototype.clone = function() { + return new goog.math.Rect(this.left, this.top, this.width, this.height); +}; +goog.math.Rect.prototype.toBox = function() { + var right = this.left + this.width; + var bottom = this.top + this.height; + return new goog.math.Box(this.top, right, bottom, this.left); +}; +goog.math.Rect.createFromBox = function(box) { + return new goog.math.Rect(box.left, box.top, box.right - box.left, box.bottom - box.top); +}; +if (goog.DEBUG) { + goog.math.Rect.prototype.toString = function() { + return "(" + this.left + ", " + this.top + " - " + this.width + "w x " + this.height + "h)"; + }; +} +goog.math.Rect.equals = function(a, b) { + if (a == b) { + return true; + } + if (!a || !b) { + return false; + } + return a.left == b.left && (a.width == b.width && (a.top == b.top && a.height == b.height)); +}; +goog.math.Rect.prototype.intersection = function(rect) { + var x0 = Math.max(this.left, rect.left); + var x1 = Math.min(this.left + this.width, rect.left + rect.width); + if (x0 <= x1) { + var y0 = Math.max(this.top, rect.top); + var y1 = Math.min(this.top + this.height, rect.top + rect.height); + if (y0 <= y1) { + this.left = x0; + this.top = y0; + this.width = x1 - x0; + this.height = y1 - y0; + return true; + } + } + return false; +}; +goog.math.Rect.intersection = function(a, b) { + var x0 = Math.max(a.left, b.left); + var x1 = Math.min(a.left + a.width, b.left + b.width); + if (x0 <= x1) { + var y0 = Math.max(a.top, b.top); + var y1 = Math.min(a.top + a.height, b.top + b.height); + if (y0 <= y1) { + return new goog.math.Rect(x0, y0, x1 - x0, y1 - y0); + } + } + return null; +}; +goog.math.Rect.intersects = function(a, b) { + return a.left <= b.left + b.width && (b.left <= a.left + a.width && (a.top <= b.top + b.height && b.top <= a.top + a.height)); +}; +goog.math.Rect.prototype.intersects = function(rect) { + return goog.math.Rect.intersects(this, rect); +}; +goog.math.Rect.difference = function(a, b) { + var intersection = goog.math.Rect.intersection(a, b); + if (!intersection || (!intersection.height || !intersection.width)) { + return[a.clone()]; + } + var result = []; + var top = a.top; + var height = a.height; + var ar = a.left + a.width; + var ab = a.top + a.height; + var br = b.left + b.width; + var bb = b.top + b.height; + if (b.top > a.top) { + result.push(new goog.math.Rect(a.left, a.top, a.width, b.top - a.top)); + top = b.top; + height -= b.top - a.top; + } + if (bb < ab) { + result.push(new goog.math.Rect(a.left, bb, a.width, ab - bb)); + height = bb - top; + } + if (b.left > a.left) { + result.push(new goog.math.Rect(a.left, top, b.left - a.left, height)); + } + if (br < ar) { + result.push(new goog.math.Rect(br, top, ar - br, height)); + } + return result; +}; +goog.math.Rect.prototype.difference = function(rect) { + return goog.math.Rect.difference(this, rect); +}; +goog.math.Rect.prototype.boundingRect = function(rect) { + var right = Math.max(this.left + this.width, rect.left + rect.width); + var bottom = Math.max(this.top + this.height, rect.top + rect.height); + this.left = Math.min(this.left, rect.left); + this.top = Math.min(this.top, rect.top); + this.width = right - this.left; + this.height = bottom - this.top; +}; +goog.math.Rect.boundingRect = function(a, b) { + if (!a || !b) { + return null; + } + var clone = a.clone(); + clone.boundingRect(b); + return clone; +}; +goog.math.Rect.prototype.contains = function(another) { + if (another instanceof goog.math.Rect) { + return this.left <= another.left && (this.left + this.width >= another.left + another.width && (this.top <= another.top && this.top + this.height >= another.top + another.height)); + } else { + return another.x >= this.left && (another.x <= this.left + this.width && (another.y >= this.top && another.y <= this.top + this.height)); + } +}; +goog.math.Rect.prototype.getSize = function() { + return new goog.math.Size(this.width, this.height); +}; +goog.math.Rect.prototype.ceil = function() { + this.left = Math.ceil(this.left); + this.top = Math.ceil(this.top); + this.width = Math.ceil(this.width); + this.height = Math.ceil(this.height); + return this; +}; +goog.math.Rect.prototype.floor = function() { + this.left = Math.floor(this.left); + this.top = Math.floor(this.top); + this.width = Math.floor(this.width); + this.height = Math.floor(this.height); + return this; +}; +goog.math.Rect.prototype.round = function() { + this.left = Math.round(this.left); + this.top = Math.round(this.top); + this.width = Math.round(this.width); + this.height = Math.round(this.height); + return this; +}; +goog.math.Rect.prototype.translate = function(tx, opt_ty) { + if (tx instanceof goog.math.Coordinate) { + this.left += tx.x; + this.top += tx.y; + } else { + this.left += tx; + if (goog.isNumber(opt_ty)) { + this.top += opt_ty; + } + } + return this; +}; +goog.math.Rect.prototype.scale = function(sx, opt_sy) { + var sy = goog.isNumber(opt_sy) ? opt_sy : sx; + this.left *= sx; + this.width *= sx; + this.top *= sy; + this.height *= sy; + return this; +}; +goog.provide("goog.style"); +goog.require("goog.array"); +goog.require("goog.dom"); +goog.require("goog.dom.vendor"); +goog.require("goog.math.Box"); +goog.require("goog.math.Coordinate"); +goog.require("goog.math.Rect"); +goog.require("goog.math.Size"); +goog.require("goog.object"); +goog.require("goog.string"); +goog.require("goog.userAgent"); +goog.style.setStyle = function(element, style, opt_value) { + if (goog.isString(style)) { + goog.style.setStyle_(element, opt_value, style); + } else { + goog.object.forEach(style, goog.partial(goog.style.setStyle_, element)); + } +}; +goog.style.setStyle_ = function(element, value, style) { + var propertyName = goog.style.getVendorJsStyleName_(element, style); + if (propertyName) { + element.style[propertyName] = value; + } +}; +goog.style.getVendorJsStyleName_ = function(element, style) { + var camelStyle = goog.string.toCamelCase(style); + if (element.style[camelStyle] === undefined) { + var prefixedStyle = goog.dom.vendor.getVendorJsPrefix() + goog.string.toTitleCase(style); + if (element.style[prefixedStyle] !== undefined) { + return prefixedStyle; + } + } + return camelStyle; +}; +goog.style.getVendorStyleName_ = function(element, style) { + var camelStyle = goog.string.toCamelCase(style); + if (element.style[camelStyle] === undefined) { + var prefixedStyle = goog.dom.vendor.getVendorJsPrefix() + goog.string.toTitleCase(style); + if (element.style[prefixedStyle] !== undefined) { + return goog.dom.vendor.getVendorPrefix() + "-" + style; + } + } + return style; +}; +goog.style.getStyle = function(element, property) { + var styleValue = element.style[goog.string.toCamelCase(property)]; + if (typeof styleValue !== "undefined") { + return styleValue; + } + return element.style[goog.style.getVendorJsStyleName_(element, property)] || ""; +}; +goog.style.getComputedStyle = function(element, property) { + var doc = goog.dom.getOwnerDocument(element); + if (doc.defaultView && doc.defaultView.getComputedStyle) { + var styles = doc.defaultView.getComputedStyle(element, null); + if (styles) { + return styles[property] || (styles.getPropertyValue(property) || ""); + } + } + return ""; +}; +goog.style.getCascadedStyle = function(element, style) { + return element.currentStyle ? element.currentStyle[style] : null; +}; +goog.style.getStyle_ = function(element, style) { + return goog.style.getComputedStyle(element, style) || (goog.style.getCascadedStyle(element, style) || element.style && element.style[style]); +}; +goog.style.getComputedPosition = function(element) { + return goog.style.getStyle_(element, "position"); +}; +goog.style.getBackgroundColor = function(element) { + return goog.style.getStyle_(element, "backgroundColor"); +}; +goog.style.getComputedOverflowX = function(element) { + return goog.style.getStyle_(element, "overflowX"); +}; +goog.style.getComputedOverflowY = function(element) { + return goog.style.getStyle_(element, "overflowY"); +}; +goog.style.getComputedZIndex = function(element) { + return goog.style.getStyle_(element, "zIndex"); +}; +goog.style.getComputedTextAlign = function(element) { + return goog.style.getStyle_(element, "textAlign"); +}; +goog.style.getComputedCursor = function(element) { + return goog.style.getStyle_(element, "cursor"); +}; +goog.style.setPosition = function(el, arg1, opt_arg2) { + var x, y; + var buggyGeckoSubPixelPos = goog.userAgent.GECKO && ((goog.userAgent.MAC || goog.userAgent.X11) && goog.userAgent.isVersion("1.9")); + if (arg1 instanceof goog.math.Coordinate) { + x = arg1.x; + y = arg1.y; + } else { + x = arg1; + y = opt_arg2; + } + el.style.left = goog.style.getPixelStyleValue_((x), buggyGeckoSubPixelPos); + el.style.top = goog.style.getPixelStyleValue_((y), buggyGeckoSubPixelPos); +}; +goog.style.getPosition = function(element) { + return new goog.math.Coordinate(element.offsetLeft, element.offsetTop); +}; +goog.style.getClientViewportElement = function(opt_node) { + var doc; + if (opt_node) { + doc = goog.dom.getOwnerDocument(opt_node); + } else { + doc = goog.dom.getDocument(); + } + if (goog.userAgent.IE && (!goog.userAgent.isDocumentMode(9) && !goog.dom.getDomHelper(doc).isCss1CompatMode())) { + return doc.body; + } + return doc.documentElement; +}; +goog.style.getViewportPageOffset = function(doc) { + var body = doc.body; + var documentElement = doc.documentElement; + var scrollLeft = body.scrollLeft || documentElement.scrollLeft; + var scrollTop = body.scrollTop || documentElement.scrollTop; + return new goog.math.Coordinate(scrollLeft, scrollTop); +}; +goog.style.getBoundingClientRect_ = function(el) { + var rect = el.getBoundingClientRect(); + if (goog.userAgent.IE) { + var doc = el.ownerDocument; + rect.left -= doc.documentElement.clientLeft + doc.body.clientLeft; + rect.top -= doc.documentElement.clientTop + doc.body.clientTop; + } + return(rect); +}; +goog.style.getOffsetParent = function(element) { + if (goog.userAgent.IE && !goog.userAgent.isDocumentMode(8)) { + return element.offsetParent; + } + var doc = goog.dom.getOwnerDocument(element); + var positionStyle = goog.style.getStyle_(element, "position"); + var skipStatic = positionStyle == "fixed" || positionStyle == "absolute"; + for (var parent = element.parentNode;parent && parent != doc;parent = parent.parentNode) { + positionStyle = goog.style.getStyle_((parent), "position"); + skipStatic = skipStatic && (positionStyle == "static" && (parent != doc.documentElement && parent != doc.body)); + if (!skipStatic && (parent.scrollWidth > parent.clientWidth || (parent.scrollHeight > parent.clientHeight || (positionStyle == "fixed" || (positionStyle == "absolute" || positionStyle == "relative"))))) { + return(parent); + } + } + return null; +}; +goog.style.getVisibleRectForElement = function(element) { + var visibleRect = new goog.math.Box(0, Infinity, Infinity, 0); + var dom = goog.dom.getDomHelper(element); + var body = dom.getDocument().body; + var documentElement = dom.getDocument().documentElement; + var scrollEl = dom.getDocumentScrollElement(); + for (var el = element;el = goog.style.getOffsetParent(el);) { + if ((!goog.userAgent.IE || el.clientWidth != 0) && ((!goog.userAgent.WEBKIT || (el.clientHeight != 0 || el != body)) && (el != body && (el != documentElement && goog.style.getStyle_(el, "overflow") != "visible")))) { + var pos = goog.style.getPageOffset(el); + var client = goog.style.getClientLeftTop(el); + pos.x += client.x; + pos.y += client.y; + visibleRect.top = Math.max(visibleRect.top, pos.y); + visibleRect.right = Math.min(visibleRect.right, pos.x + el.clientWidth); + visibleRect.bottom = Math.min(visibleRect.bottom, pos.y + el.clientHeight); + visibleRect.left = Math.max(visibleRect.left, pos.x); + } + } + var scrollX = scrollEl.scrollLeft, scrollY = scrollEl.scrollTop; + visibleRect.left = Math.max(visibleRect.left, scrollX); + visibleRect.top = Math.max(visibleRect.top, scrollY); + var winSize = dom.getViewportSize(); + visibleRect.right = Math.min(visibleRect.right, scrollX + winSize.width); + visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + winSize.height); + return visibleRect.top >= 0 && (visibleRect.left >= 0 && (visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left)) ? visibleRect : null; +}; +goog.style.getContainerOffsetToScrollInto = function(element, container, opt_center) { + var elementPos = goog.style.getPageOffset(element); + var containerPos = goog.style.getPageOffset(container); + var containerBorder = goog.style.getBorderBox(container); + var relX = elementPos.x - containerPos.x - containerBorder.left; + var relY = elementPos.y - containerPos.y - containerBorder.top; + var spaceX = container.clientWidth - element.offsetWidth; + var spaceY = container.clientHeight - element.offsetHeight; + var scrollLeft = container.scrollLeft; + var scrollTop = container.scrollTop; + if (opt_center) { + scrollLeft += relX - spaceX / 2; + scrollTop += relY - spaceY / 2; + } else { + scrollLeft += Math.min(relX, Math.max(relX - spaceX, 0)); + scrollTop += Math.min(relY, Math.max(relY - spaceY, 0)); + } + return new goog.math.Coordinate(scrollLeft, scrollTop); +}; +goog.style.scrollIntoContainerView = function(element, container, opt_center) { + var offset = goog.style.getContainerOffsetToScrollInto(element, container, opt_center); + container.scrollLeft = offset.x; + container.scrollTop = offset.y; +}; +goog.style.getClientLeftTop = function(el) { + if (goog.userAgent.GECKO && !goog.userAgent.isVersion("1.9")) { + var left = parseFloat(goog.style.getComputedStyle(el, "borderLeftWidth")); + if (goog.style.isRightToLeft(el)) { + var scrollbarWidth = el.offsetWidth - el.clientWidth - left - parseFloat(goog.style.getComputedStyle(el, "borderRightWidth")); + left += scrollbarWidth; + } + return new goog.math.Coordinate(left, parseFloat(goog.style.getComputedStyle(el, "borderTopWidth"))); + } + return new goog.math.Coordinate(el.clientLeft, el.clientTop); +}; +goog.style.getPageOffset = function(el) { + var box, doc = goog.dom.getOwnerDocument(el); + var positionStyle = goog.style.getStyle_(el, "position"); + goog.asserts.assertObject(el, "Parameter is required"); + var BUGGY_GECKO_BOX_OBJECT = goog.userAgent.GECKO && (doc.getBoxObjectFor && (!el.getBoundingClientRect && (positionStyle == "absolute" && ((box = doc.getBoxObjectFor(el)) && (box.screenX < 0 || box.screenY < 0))))); + var pos = new goog.math.Coordinate(0, 0); + var viewportElement = goog.style.getClientViewportElement(doc); + if (el == viewportElement) { + return pos; + } + if (el.getBoundingClientRect) { + box = goog.style.getBoundingClientRect_(el); + var scrollCoord = goog.dom.getDomHelper(doc).getDocumentScroll(); + pos.x = box.left + scrollCoord.x; + pos.y = box.top + scrollCoord.y; + } else { + if (doc.getBoxObjectFor && !BUGGY_GECKO_BOX_OBJECT) { + box = doc.getBoxObjectFor(el); + var vpBox = doc.getBoxObjectFor(viewportElement); + pos.x = box.screenX - vpBox.screenX; + pos.y = box.screenY - vpBox.screenY; + } else { + var parent = el; + do { + pos.x += parent.offsetLeft; + pos.y += parent.offsetTop; + if (parent != el) { + pos.x += parent.clientLeft || 0; + pos.y += parent.clientTop || 0; + } + if (goog.userAgent.WEBKIT && goog.style.getComputedPosition(parent) == "fixed") { + pos.x += doc.body.scrollLeft; + pos.y += doc.body.scrollTop; + break; + } + parent = parent.offsetParent; + } while (parent && parent != el); + if (goog.userAgent.OPERA || goog.userAgent.WEBKIT && positionStyle == "absolute") { + pos.y -= doc.body.offsetTop; + } + for (parent = el;(parent = goog.style.getOffsetParent(parent)) && (parent != doc.body && parent != viewportElement);) { + pos.x -= parent.scrollLeft; + if (!goog.userAgent.OPERA || parent.tagName != "TR") { + pos.y -= parent.scrollTop; + } + } + } + } + return pos; +}; +goog.style.getPageOffsetLeft = function(el) { + return goog.style.getPageOffset(el).x; +}; +goog.style.getPageOffsetTop = function(el) { + return goog.style.getPageOffset(el).y; +}; +goog.style.getFramedPageOffset = function(el, relativeWin) { + var position = new goog.math.Coordinate(0, 0); + var currentWin = goog.dom.getWindow(goog.dom.getOwnerDocument(el)); + var currentEl = el; + do { + var offset = currentWin == relativeWin ? goog.style.getPageOffset(currentEl) : goog.style.getClientPosition(currentEl); + position.x += offset.x; + position.y += offset.y; + } while (currentWin && (currentWin != relativeWin && ((currentEl = currentWin.frameElement) && (currentWin = currentWin.parent)))); + return position; +}; +goog.style.translateRectForAnotherFrame = function(rect, origBase, newBase) { + if (origBase.getDocument() != newBase.getDocument()) { + var body = origBase.getDocument().body; + var pos = goog.style.getFramedPageOffset(body, newBase.getWindow()); + pos = goog.math.Coordinate.difference(pos, goog.style.getPageOffset(body)); + if (goog.userAgent.IE && !origBase.isCss1CompatMode()) { + pos = goog.math.Coordinate.difference(pos, origBase.getDocumentScroll()); + } + rect.left += pos.x; + rect.top += pos.y; + } +}; +goog.style.getRelativePosition = function(a, b) { + var ap = goog.style.getClientPosition(a); + var bp = goog.style.getClientPosition(b); + return new goog.math.Coordinate(ap.x - bp.x, ap.y - bp.y); +}; +goog.style.getClientPosition = function(el) { + var pos = new goog.math.Coordinate; + if (el.nodeType == goog.dom.NodeType.ELEMENT) { + el = (el); + if (el.getBoundingClientRect) { + var box = goog.style.getBoundingClientRect_(el); + pos.x = box.left; + pos.y = box.top; + } else { + var scrollCoord = goog.dom.getDomHelper(el).getDocumentScroll(); + var pageCoord = goog.style.getPageOffset(el); + pos.x = pageCoord.x - scrollCoord.x; + pos.y = pageCoord.y - scrollCoord.y; + } + if (goog.userAgent.GECKO && !goog.userAgent.isVersion(12)) { + pos = goog.math.Coordinate.sum(pos, goog.style.getCssTranslation(el)); + } + } else { + var isAbstractedEvent = goog.isFunction(el.getBrowserEvent); + var targetEvent = el; + if (el.targetTouches) { + targetEvent = el.targetTouches[0]; + } else { + if (isAbstractedEvent && el.getBrowserEvent().targetTouches) { + targetEvent = el.getBrowserEvent().targetTouches[0]; + } + } + pos.x = targetEvent.clientX; + pos.y = targetEvent.clientY; + } + return pos; +}; +goog.style.setPageOffset = function(el, x, opt_y) { + var cur = goog.style.getPageOffset(el); + if (x instanceof goog.math.Coordinate) { + opt_y = x.y; + x = x.x; + } + var dx = x - cur.x; + var dy = opt_y - cur.y; + goog.style.setPosition(el, el.offsetLeft + dx, el.offsetTop + dy); +}; +goog.style.setSize = function(element, w, opt_h) { + var h; + if (w instanceof goog.math.Size) { + h = w.height; + w = w.width; + } else { + if (opt_h == undefined) { + throw Error("missing height argument"); + } + h = opt_h; + } + goog.style.setWidth(element, (w)); + goog.style.setHeight(element, (h)); +}; +goog.style.getPixelStyleValue_ = function(value, round) { + if (typeof value == "number") { + value = (round ? Math.round(value) : value) + "px"; + } + return value; +}; +goog.style.setHeight = function(element, height) { + element.style.height = goog.style.getPixelStyleValue_(height, true); +}; +goog.style.setWidth = function(element, width) { + element.style.width = goog.style.getPixelStyleValue_(width, true); +}; +goog.style.getSize = function(element) { + if (goog.style.getStyle_(element, "display") != "none") { + return goog.style.getSizeWithDisplay_(element); + } + var style = element.style; + var originalDisplay = style.display; + var originalVisibility = style.visibility; + var originalPosition = style.position; + style.visibility = "hidden"; + style.position = "absolute"; + style.display = "inline"; + var size = goog.style.getSizeWithDisplay_(element); + style.display = originalDisplay; + style.position = originalPosition; + style.visibility = originalVisibility; + return size; +}; +goog.style.getSizeWithDisplay_ = function(element) { + var offsetWidth = element.offsetWidth; + var offsetHeight = element.offsetHeight; + var webkitOffsetsZero = goog.userAgent.WEBKIT && (!offsetWidth && !offsetHeight); + if ((!goog.isDef(offsetWidth) || webkitOffsetsZero) && element.getBoundingClientRect) { + var clientRect = goog.style.getBoundingClientRect_(element); + return new goog.math.Size(clientRect.right - clientRect.left, clientRect.bottom - clientRect.top); + } + return new goog.math.Size(offsetWidth, offsetHeight); +}; +goog.style.getBounds = function(element) { + var o = goog.style.getPageOffset(element); + var s = goog.style.getSize(element); + return new goog.math.Rect(o.x, o.y, s.width, s.height); +}; +goog.style.toCamelCase = function(selector) { + return goog.string.toCamelCase(String(selector)); +}; +goog.style.toSelectorCase = function(selector) { + return goog.string.toSelectorCase(selector); +}; +goog.style.getOpacity = function(el) { + var style = el.style; + var result = ""; + if ("opacity" in style) { + result = style.opacity; + } else { + if ("MozOpacity" in style) { + result = style.MozOpacity; + } else { + if ("filter" in style) { + var match = style.filter.match(/alpha\(opacity=([\d.]+)\)/); + if (match) { + result = String(match[1] / 100); + } + } + } + } + return result == "" ? result : Number(result); +}; +goog.style.setOpacity = function(el, alpha) { + var style = el.style; + if ("opacity" in style) { + style.opacity = alpha; + } else { + if ("MozOpacity" in style) { + style.MozOpacity = alpha; + } else { + if ("filter" in style) { + if (alpha === "") { + style.filter = ""; + } else { + style.filter = "alpha(opacity\x3d" + alpha * 100 + ")"; + } + } + } + } +}; +goog.style.setTransparentBackgroundImage = function(el, src) { + var style = el.style; + if (goog.userAgent.IE && !goog.userAgent.isVersion("8")) { + style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(" + 'src\x3d"' + src + '", sizingMethod\x3d"crop")'; + } else { + style.backgroundImage = "url(" + src + ")"; + style.backgroundPosition = "top left"; + style.backgroundRepeat = "no-repeat"; + } +}; +goog.style.clearTransparentBackgroundImage = function(el) { + var style = el.style; + if ("filter" in style) { + style.filter = ""; + } else { + style.backgroundImage = "none"; + } +}; +goog.style.showElement = function(el, display) { + el.style.display = display ? "" : "none"; +}; +goog.style.isElementShown = function(el) { + return el.style.display != "none"; +}; +goog.style.installStyles = function(stylesString, opt_node) { + var dh = goog.dom.getDomHelper(opt_node); + var styleSheet = null; + if (goog.userAgent.IE) { + styleSheet = dh.getDocument().createStyleSheet(); + goog.style.setStyles(styleSheet, stylesString); + } else { + var head = dh.getElementsByTagNameAndClass("head")[0]; + if (!head) { + var body = dh.getElementsByTagNameAndClass("body")[0]; + head = dh.createDom("head"); + body.parentNode.insertBefore(head, body); + } + styleSheet = dh.createDom("style"); + goog.style.setStyles(styleSheet, stylesString); + dh.appendChild(head, styleSheet); + } + return styleSheet; +}; +goog.style.uninstallStyles = function(styleSheet) { + var node = styleSheet.ownerNode || (styleSheet.owningElement || (styleSheet)); + goog.dom.removeNode(node); +}; +goog.style.setStyles = function(element, stylesString) { + if (goog.userAgent.IE) { + element.cssText = stylesString; + } else { + element.innerHTML = stylesString; + } +}; +goog.style.setPreWrap = function(el) { + var style = el.style; + if (goog.userAgent.IE && !goog.userAgent.isVersion("8")) { + style.whiteSpace = "pre"; + style.wordWrap = "break-word"; + } else { + if (goog.userAgent.GECKO) { + style.whiteSpace = "-moz-pre-wrap"; + } else { + style.whiteSpace = "pre-wrap"; + } + } +}; +goog.style.setInlineBlock = function(el) { + var style = el.style; + style.position = "relative"; + if (goog.userAgent.IE && !goog.userAgent.isVersion("8")) { + style.zoom = "1"; + style.display = "inline"; + } else { + if (goog.userAgent.GECKO) { + style.display = goog.userAgent.isVersion("1.9a") ? "inline-block" : "-moz-inline-box"; + } else { + style.display = "inline-block"; + } + } +}; +goog.style.isRightToLeft = function(el) { + return "rtl" == goog.style.getStyle_(el, "direction"); +}; +goog.style.unselectableStyle_ = goog.userAgent.GECKO ? "MozUserSelect" : goog.userAgent.WEBKIT ? "WebkitUserSelect" : null; +goog.style.isUnselectable = function(el) { + if (goog.style.unselectableStyle_) { + return el.style[goog.style.unselectableStyle_].toLowerCase() == "none"; + } else { + if (goog.userAgent.IE || goog.userAgent.OPERA) { + return el.getAttribute("unselectable") == "on"; + } + } + return false; +}; +goog.style.setUnselectable = function(el, unselectable, opt_noRecurse) { + var descendants = !opt_noRecurse ? el.getElementsByTagName("*") : null; + var name = goog.style.unselectableStyle_; + if (name) { + var value = unselectable ? "none" : ""; + el.style[name] = value; + if (descendants) { + for (var i = 0, descendant;descendant = descendants[i];i++) { + descendant.style[name] = value; + } + } + } else { + if (goog.userAgent.IE || goog.userAgent.OPERA) { + var value = unselectable ? "on" : ""; + el.setAttribute("unselectable", value); + if (descendants) { + for (var i = 0, descendant;descendant = descendants[i];i++) { + descendant.setAttribute("unselectable", value); + } + } + } + } +}; +goog.style.getBorderBoxSize = function(element) { + return new goog.math.Size(element.offsetWidth, element.offsetHeight); +}; +goog.style.setBorderBoxSize = function(element, size) { + var doc = goog.dom.getOwnerDocument(element); + var isCss1CompatMode = goog.dom.getDomHelper(doc).isCss1CompatMode(); + if (goog.userAgent.IE && (!isCss1CompatMode || !goog.userAgent.isVersion("8"))) { + var style = element.style; + if (isCss1CompatMode) { + var paddingBox = goog.style.getPaddingBox(element); + var borderBox = goog.style.getBorderBox(element); + style.pixelWidth = size.width - borderBox.left - paddingBox.left - paddingBox.right - borderBox.right; + style.pixelHeight = size.height - borderBox.top - paddingBox.top - paddingBox.bottom - borderBox.bottom; + } else { + style.pixelWidth = size.width; + style.pixelHeight = size.height; + } + } else { + goog.style.setBoxSizingSize_(element, size, "border-box"); + } +}; +goog.style.getContentBoxSize = function(element) { + var doc = goog.dom.getOwnerDocument(element); + var ieCurrentStyle = goog.userAgent.IE && element.currentStyle; + if (ieCurrentStyle && (goog.dom.getDomHelper(doc).isCss1CompatMode() && (ieCurrentStyle.width != "auto" && (ieCurrentStyle.height != "auto" && !ieCurrentStyle.boxSizing)))) { + var width = goog.style.getIePixelValue_(element, ieCurrentStyle.width, "width", "pixelWidth"); + var height = goog.style.getIePixelValue_(element, ieCurrentStyle.height, "height", "pixelHeight"); + return new goog.math.Size(width, height); + } else { + var borderBoxSize = goog.style.getBorderBoxSize(element); + var paddingBox = goog.style.getPaddingBox(element); + var borderBox = goog.style.getBorderBox(element); + return new goog.math.Size(borderBoxSize.width - borderBox.left - paddingBox.left - paddingBox.right - borderBox.right, borderBoxSize.height - borderBox.top - paddingBox.top - paddingBox.bottom - borderBox.bottom); + } +}; +goog.style.setContentBoxSize = function(element, size) { + var doc = goog.dom.getOwnerDocument(element); + var isCss1CompatMode = goog.dom.getDomHelper(doc).isCss1CompatMode(); + if (goog.userAgent.IE && (!isCss1CompatMode || !goog.userAgent.isVersion("8"))) { + var style = element.style; + if (isCss1CompatMode) { + style.pixelWidth = size.width; + style.pixelHeight = size.height; + } else { + var paddingBox = goog.style.getPaddingBox(element); + var borderBox = goog.style.getBorderBox(element); + style.pixelWidth = size.width + borderBox.left + paddingBox.left + paddingBox.right + borderBox.right; + style.pixelHeight = size.height + borderBox.top + paddingBox.top + paddingBox.bottom + borderBox.bottom; + } + } else { + goog.style.setBoxSizingSize_(element, size, "content-box"); + } +}; +goog.style.setBoxSizingSize_ = function(element, size, boxSizing) { + var style = element.style; + if (goog.userAgent.GECKO) { + style.MozBoxSizing = boxSizing; + } else { + if (goog.userAgent.WEBKIT) { + style.WebkitBoxSizing = boxSizing; + } else { + style.boxSizing = boxSizing; + } + } + style.width = Math.max(size.width, 0) + "px"; + style.height = Math.max(size.height, 0) + "px"; +}; +goog.style.getIePixelValue_ = function(element, value, name, pixelName) { + if (/^\d+px?$/.test(value)) { + return parseInt(value, 10); + } else { + var oldStyleValue = element.style[name]; + var oldRuntimeValue = element.runtimeStyle[name]; + element.runtimeStyle[name] = element.currentStyle[name]; + element.style[name] = value; + var pixelValue = element.style[pixelName]; + element.style[name] = oldStyleValue; + element.runtimeStyle[name] = oldRuntimeValue; + return pixelValue; + } +}; +goog.style.getIePixelDistance_ = function(element, propName) { + var value = goog.style.getCascadedStyle(element, propName); + return value ? goog.style.getIePixelValue_(element, value, "left", "pixelLeft") : 0; +}; +goog.style.getBox_ = function(element, stylePrefix) { + if (goog.userAgent.IE) { + var left = goog.style.getIePixelDistance_(element, stylePrefix + "Left"); + var right = goog.style.getIePixelDistance_(element, stylePrefix + "Right"); + var top = goog.style.getIePixelDistance_(element, stylePrefix + "Top"); + var bottom = goog.style.getIePixelDistance_(element, stylePrefix + "Bottom"); + return new goog.math.Box(top, right, bottom, left); + } else { + var left = (goog.style.getComputedStyle(element, stylePrefix + "Left")); + var right = (goog.style.getComputedStyle(element, stylePrefix + "Right")); + var top = (goog.style.getComputedStyle(element, stylePrefix + "Top")); + var bottom = (goog.style.getComputedStyle(element, stylePrefix + "Bottom")); + return new goog.math.Box(parseFloat(top), parseFloat(right), parseFloat(bottom), parseFloat(left)); + } +}; +goog.style.getPaddingBox = function(element) { + return goog.style.getBox_(element, "padding"); +}; +goog.style.getMarginBox = function(element) { + return goog.style.getBox_(element, "margin"); +}; +goog.style.ieBorderWidthKeywords_ = {"thin":2, "medium":4, "thick":6}; +goog.style.getIePixelBorder_ = function(element, prop) { + if (goog.style.getCascadedStyle(element, prop + "Style") == "none") { + return 0; + } + var width = goog.style.getCascadedStyle(element, prop + "Width"); + if (width in goog.style.ieBorderWidthKeywords_) { + return goog.style.ieBorderWidthKeywords_[width]; + } + return goog.style.getIePixelValue_(element, width, "left", "pixelLeft"); +}; +goog.style.getBorderBox = function(element) { + if (goog.userAgent.IE) { + var left = goog.style.getIePixelBorder_(element, "borderLeft"); + var right = goog.style.getIePixelBorder_(element, "borderRight"); + var top = goog.style.getIePixelBorder_(element, "borderTop"); + var bottom = goog.style.getIePixelBorder_(element, "borderBottom"); + return new goog.math.Box(top, right, bottom, left); + } else { + var left = (goog.style.getComputedStyle(element, "borderLeftWidth")); + var right = (goog.style.getComputedStyle(element, "borderRightWidth")); + var top = (goog.style.getComputedStyle(element, "borderTopWidth")); + var bottom = (goog.style.getComputedStyle(element, "borderBottomWidth")); + return new goog.math.Box(parseFloat(top), parseFloat(right), parseFloat(bottom), parseFloat(left)); + } +}; +goog.style.getFontFamily = function(el) { + var doc = goog.dom.getOwnerDocument(el); + var font = ""; + if (doc.body.createTextRange) { + var range = doc.body.createTextRange(); + range.moveToElementText(el); + try { + font = range.queryCommandValue("FontName"); + } catch (e) { + font = ""; + } + } + if (!font) { + font = goog.style.getStyle_(el, "fontFamily"); + } + var fontsArray = font.split(","); + if (fontsArray.length > 1) { + font = fontsArray[0]; + } + return goog.string.stripQuotes(font, "\"'"); +}; +goog.style.lengthUnitRegex_ = /[^\d]+$/; +goog.style.getLengthUnits = function(value) { + var units = value.match(goog.style.lengthUnitRegex_); + return units && units[0] || null; +}; +goog.style.ABSOLUTE_CSS_LENGTH_UNITS_ = {"cm":1, "in":1, "mm":1, "pc":1, "pt":1}; +goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_ = {"em":1, "ex":1}; +goog.style.getFontSize = function(el) { + var fontSize = goog.style.getStyle_(el, "fontSize"); + var sizeUnits = goog.style.getLengthUnits(fontSize); + if (fontSize && "px" == sizeUnits) { + return parseInt(fontSize, 10); + } + if (goog.userAgent.IE) { + if (sizeUnits in goog.style.ABSOLUTE_CSS_LENGTH_UNITS_) { + return goog.style.getIePixelValue_(el, fontSize, "left", "pixelLeft"); + } else { + if (el.parentNode && (el.parentNode.nodeType == goog.dom.NodeType.ELEMENT && sizeUnits in goog.style.CONVERTIBLE_RELATIVE_CSS_UNITS_)) { + var parentElement = (el.parentNode); + var parentSize = goog.style.getStyle_(parentElement, "fontSize"); + return goog.style.getIePixelValue_(parentElement, fontSize == parentSize ? "1em" : fontSize, "left", "pixelLeft"); + } + } + } + var sizeElement = goog.dom.createDom("span", {"style":"visibility:hidden;position:absolute;" + "line-height:0;padding:0;margin:0;border:0;height:1em;"}); + goog.dom.appendChild(el, sizeElement); + fontSize = sizeElement.offsetHeight; + goog.dom.removeNode(sizeElement); + return fontSize; +}; +goog.style.parseStyleAttribute = function(value) { + var result = {}; + goog.array.forEach(value.split(/\s*;\s*/), function(pair) { + var keyValue = pair.split(/\s*:\s*/); + if (keyValue.length == 2) { + result[goog.string.toCamelCase(keyValue[0].toLowerCase())] = keyValue[1]; + } + }); + return result; +}; +goog.style.toStyleAttribute = function(obj) { + var buffer = []; + goog.object.forEach(obj, function(value, key) { + buffer.push(goog.string.toSelectorCase(key), ":", value, ";"); + }); + return buffer.join(""); +}; +goog.style.setFloat = function(el, value) { + el.style[goog.userAgent.IE ? "styleFloat" : "cssFloat"] = value; +}; +goog.style.getFloat = function(el) { + return el.style[goog.userAgent.IE ? "styleFloat" : "cssFloat"] || ""; +}; +goog.style.getScrollbarWidth = function(opt_className) { + var outerDiv = goog.dom.createElement("div"); + if (opt_className) { + outerDiv.className = opt_className; + } + outerDiv.style.cssText = "overflow:auto;" + "position:absolute;top:0;width:100px;height:100px"; + var innerDiv = goog.dom.createElement("div"); + goog.style.setSize(innerDiv, "200px", "200px"); + outerDiv.appendChild(innerDiv); + goog.dom.appendChild(goog.dom.getDocument().body, outerDiv); + var width = outerDiv.offsetWidth - outerDiv.clientWidth; + goog.dom.removeNode(outerDiv); + return width; +}; +goog.style.MATRIX_TRANSLATION_REGEX_ = new RegExp("matrix\\([0-9\\.\\-]+, [0-9\\.\\-]+, " + "[0-9\\.\\-]+, [0-9\\.\\-]+, " + "([0-9\\.\\-]+)p?x?, ([0-9\\.\\-]+)p?x?\\)"); +goog.style.getCssTranslation = function(element) { + var property; + if (goog.userAgent.IE) { + property = "-ms-transform"; + } else { + if (goog.userAgent.WEBKIT) { + property = "-webkit-transform"; + } else { + if (goog.userAgent.OPERA) { + property = "-o-transform"; + } else { + if (goog.userAgent.GECKO) { + property = "-moz-transform"; + } + } + } + } + var transform; + if (property) { + transform = goog.style.getStyle_(element, property); + } + if (!transform) { + transform = goog.style.getStyle_(element, "transform"); + } + if (!transform) { + return new goog.math.Coordinate(0, 0); + } + var matches = transform.match(goog.style.MATRIX_TRANSLATION_REGEX_); + if (!matches) { + return new goog.math.Coordinate(0, 0); + } + return new goog.math.Coordinate(parseFloat(matches[1]), parseFloat(matches[2])); +}; +goog.provide("goog.iter"); +goog.provide("goog.iter.Iterator"); +goog.provide("goog.iter.StopIteration"); +goog.require("goog.array"); +goog.require("goog.asserts"); +goog.iter.Iterable; +if ("StopIteration" in goog.global) { + goog.iter.StopIteration = goog.global["StopIteration"]; +} else { + goog.iter.StopIteration = Error("StopIteration"); +} +goog.iter.Iterator = function() { +}; +goog.iter.Iterator.prototype.next = function() { + throw goog.iter.StopIteration; +}; +goog.iter.Iterator.prototype.__iterator__ = function(opt_keys) { + return this; +}; +goog.iter.toIterator = function(iterable) { + if (iterable instanceof goog.iter.Iterator) { + return iterable; + } + if (typeof iterable.__iterator__ == "function") { + return iterable.__iterator__(false); + } + if (goog.isArrayLike(iterable)) { + var i = 0; + var newIter = new goog.iter.Iterator; + newIter.next = function() { + while (true) { + if (i >= iterable.length) { + throw goog.iter.StopIteration; + } + if (!(i in iterable)) { + i++; + continue; + } + return iterable[i++]; + } + }; + return newIter; + } + throw Error("Not implemented"); +}; +goog.iter.forEach = function(iterable, f, opt_obj) { + if (goog.isArrayLike(iterable)) { + try { + goog.array.forEach((iterable), f, opt_obj); + } catch (ex) { + if (ex !== goog.iter.StopIteration) { + throw ex; + } + } + } else { + iterable = goog.iter.toIterator(iterable); + try { + while (true) { + f.call(opt_obj, iterable.next(), undefined, iterable); + } + } catch (ex) { + if (ex !== goog.iter.StopIteration) { + throw ex; + } + } + } +}; +goog.iter.filter = function(iterable, f, opt_obj) { + var iterator = goog.iter.toIterator(iterable); + var newIter = new goog.iter.Iterator; + newIter.next = function() { + while (true) { + var val = iterator.next(); + if (f.call(opt_obj, val, undefined, iterator)) { + return val; + } + } + }; + return newIter; +}; +goog.iter.range = function(startOrStop, opt_stop, opt_step) { + var start = 0; + var stop = startOrStop; + var step = opt_step || 1; + if (arguments.length > 1) { + start = startOrStop; + stop = opt_stop; + } + if (step == 0) { + throw Error("Range step argument must not be zero"); + } + var newIter = new goog.iter.Iterator; + newIter.next = function() { + if (step > 0 && start >= stop || step < 0 && start <= stop) { + throw goog.iter.StopIteration; + } + var rv = start; + start += step; + return rv; + }; + return newIter; +}; +goog.iter.join = function(iterable, deliminator) { + return goog.iter.toArray(iterable).join(deliminator); +}; +goog.iter.map = function(iterable, f, opt_obj) { + var iterator = goog.iter.toIterator(iterable); + var newIter = new goog.iter.Iterator; + newIter.next = function() { + while (true) { + var val = iterator.next(); + return f.call(opt_obj, val, undefined, iterator); + } + }; + return newIter; +}; +goog.iter.reduce = function(iterable, f, val, opt_obj) { + var rval = val; + goog.iter.forEach(iterable, function(val) { + rval = f.call(opt_obj, rval, val); + }); + return rval; +}; +goog.iter.some = function(iterable, f, opt_obj) { + iterable = goog.iter.toIterator(iterable); + try { + while (true) { + if (f.call(opt_obj, iterable.next(), undefined, iterable)) { + return true; + } + } + } catch (ex) { + if (ex !== goog.iter.StopIteration) { + throw ex; + } + } + return false; +}; +goog.iter.every = function(iterable, f, opt_obj) { + iterable = goog.iter.toIterator(iterable); + try { + while (true) { + if (!f.call(opt_obj, iterable.next(), undefined, iterable)) { + return false; + } + } + } catch (ex) { + if (ex !== goog.iter.StopIteration) { + throw ex; + } + } + return true; +}; +goog.iter.chain = function(var_args) { + var args = arguments; + var length = args.length; + var i = 0; + var newIter = new goog.iter.Iterator; + newIter.next = function() { + try { + if (i >= length) { + throw goog.iter.StopIteration; + } + var current = goog.iter.toIterator(args[i]); + return current.next(); + } catch (ex) { + if (ex !== goog.iter.StopIteration || i >= length) { + throw ex; + } else { + i++; + return this.next(); + } + } + }; + return newIter; +}; +goog.iter.dropWhile = function(iterable, f, opt_obj) { + var iterator = goog.iter.toIterator(iterable); + var newIter = new goog.iter.Iterator; + var dropping = true; + newIter.next = function() { + while (true) { + var val = iterator.next(); + if (dropping && f.call(opt_obj, val, undefined, iterator)) { + continue; + } else { + dropping = false; + } + return val; + } + }; + return newIter; +}; +goog.iter.takeWhile = function(iterable, f, opt_obj) { + var iterator = goog.iter.toIterator(iterable); + var newIter = new goog.iter.Iterator; + var taking = true; + newIter.next = function() { + while (true) { + if (taking) { + var val = iterator.next(); + if (f.call(opt_obj, val, undefined, iterator)) { + return val; + } else { + taking = false; + } + } else { + throw goog.iter.StopIteration; + } + } + }; + return newIter; +}; +goog.iter.toArray = function(iterable) { + if (goog.isArrayLike(iterable)) { + return goog.array.toArray((iterable)); + } + iterable = goog.iter.toIterator(iterable); + var array = []; + goog.iter.forEach(iterable, function(val) { + array.push(val); + }); + return array; +}; +goog.iter.equals = function(iterable1, iterable2) { + iterable1 = goog.iter.toIterator(iterable1); + iterable2 = goog.iter.toIterator(iterable2); + var b1, b2; + try { + while (true) { + b1 = b2 = false; + var val1 = iterable1.next(); + b1 = true; + var val2 = iterable2.next(); + b2 = true; + if (val1 != val2) { + return false; + } + } + } catch (ex) { + if (ex !== goog.iter.StopIteration) { + throw ex; + } else { + if (b1 && !b2) { + return false; + } + if (!b2) { + try { + val2 = iterable2.next(); + return false; + } catch (ex1) { + if (ex1 !== goog.iter.StopIteration) { + throw ex1; + } + return true; + } + } + } + } + return false; +}; +goog.iter.nextOrValue = function(iterable, defaultValue) { + try { + return goog.iter.toIterator(iterable).next(); + } catch (e) { + if (e != goog.iter.StopIteration) { + throw e; + } + return defaultValue; + } +}; +goog.iter.product = function(var_args) { + var someArrayEmpty = goog.array.some(arguments, function(arr) { + return!arr.length; + }); + if (someArrayEmpty || !arguments.length) { + return new goog.iter.Iterator; + } + var iter = new goog.iter.Iterator; + var arrays = arguments; + var indicies = goog.array.repeat(0, arrays.length); + iter.next = function() { + if (indicies) { + var retVal = goog.array.map(indicies, function(valueIndex, arrayIndex) { + return arrays[arrayIndex][valueIndex]; + }); + for (var i = indicies.length - 1;i >= 0;i--) { + goog.asserts.assert(indicies); + if (indicies[i] < arrays[i].length - 1) { + indicies[i]++; + break; + } + if (i == 0) { + indicies = null; + break; + } + indicies[i] = 0; + } + return retVal; + } + throw goog.iter.StopIteration; + }; + return iter; +}; +goog.iter.cycle = function(iterable) { + var baseIterator = goog.iter.toIterator(iterable); + var cache = []; + var cacheIndex = 0; + var iter = new goog.iter.Iterator; + var useCache = false; + iter.next = function() { + var returnElement = null; + if (!useCache) { + try { + returnElement = baseIterator.next(); + cache.push(returnElement); + return returnElement; + } catch (e) { + if (e != goog.iter.StopIteration || goog.array.isEmpty(cache)) { + throw e; + } + useCache = true; + } + } + returnElement = cache[cacheIndex]; + cacheIndex = (cacheIndex + 1) % cache.length; + return returnElement; + }; + return iter; +}; +goog.provide("goog.structs"); +goog.require("goog.array"); +goog.require("goog.object"); +goog.structs.getCount = function(col) { + if (typeof col.getCount == "function") { + return col.getCount(); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return col.length; + } + return goog.object.getCount(col); +}; +goog.structs.getValues = function(col) { + if (typeof col.getValues == "function") { + return col.getValues(); + } + if (goog.isString(col)) { + return col.split(""); + } + if (goog.isArrayLike(col)) { + var rv = []; + var l = col.length; + for (var i = 0;i < l;i++) { + rv.push(col[i]); + } + return rv; + } + return goog.object.getValues(col); +}; +goog.structs.getKeys = function(col) { + if (typeof col.getKeys == "function") { + return col.getKeys(); + } + if (typeof col.getValues == "function") { + return undefined; + } + if (goog.isArrayLike(col) || goog.isString(col)) { + var rv = []; + var l = col.length; + for (var i = 0;i < l;i++) { + rv.push(i); + } + return rv; + } + return goog.object.getKeys(col); +}; +goog.structs.contains = function(col, val) { + if (typeof col.contains == "function") { + return col.contains(val); + } + if (typeof col.containsValue == "function") { + return col.containsValue(val); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return goog.array.contains((col), val); + } + return goog.object.containsValue(col, val); +}; +goog.structs.isEmpty = function(col) { + if (typeof col.isEmpty == "function") { + return col.isEmpty(); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return goog.array.isEmpty((col)); + } + return goog.object.isEmpty(col); +}; +goog.structs.clear = function(col) { + if (typeof col.clear == "function") { + col.clear(); + } else { + if (goog.isArrayLike(col)) { + goog.array.clear((col)); + } else { + goog.object.clear(col); + } + } +}; +goog.structs.forEach = function(col, f, opt_obj) { + if (typeof col.forEach == "function") { + col.forEach(f, opt_obj); + } else { + if (goog.isArrayLike(col) || goog.isString(col)) { + goog.array.forEach((col), f, opt_obj); + } else { + var keys = goog.structs.getKeys(col); + var values = goog.structs.getValues(col); + var l = values.length; + for (var i = 0;i < l;i++) { + f.call(opt_obj, values[i], keys && keys[i], col); + } + } + } +}; +goog.structs.filter = function(col, f, opt_obj) { + if (typeof col.filter == "function") { + return col.filter(f, opt_obj); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return goog.array.filter((col), f, opt_obj); + } + var rv; + var keys = goog.structs.getKeys(col); + var values = goog.structs.getValues(col); + var l = values.length; + if (keys) { + rv = {}; + for (var i = 0;i < l;i++) { + if (f.call(opt_obj, values[i], keys[i], col)) { + rv[keys[i]] = values[i]; + } + } + } else { + rv = []; + for (var i = 0;i < l;i++) { + if (f.call(opt_obj, values[i], undefined, col)) { + rv.push(values[i]); + } + } + } + return rv; +}; +goog.structs.map = function(col, f, opt_obj) { + if (typeof col.map == "function") { + return col.map(f, opt_obj); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return goog.array.map((col), f, opt_obj); + } + var rv; + var keys = goog.structs.getKeys(col); + var values = goog.structs.getValues(col); + var l = values.length; + if (keys) { + rv = {}; + for (var i = 0;i < l;i++) { + rv[keys[i]] = f.call(opt_obj, values[i], keys[i], col); + } + } else { + rv = []; + for (var i = 0;i < l;i++) { + rv[i] = f.call(opt_obj, values[i], undefined, col); + } + } + return rv; +}; +goog.structs.some = function(col, f, opt_obj) { + if (typeof col.some == "function") { + return col.some(f, opt_obj); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return goog.array.some((col), f, opt_obj); + } + var keys = goog.structs.getKeys(col); + var values = goog.structs.getValues(col); + var l = values.length; + for (var i = 0;i < l;i++) { + if (f.call(opt_obj, values[i], keys && keys[i], col)) { + return true; + } + } + return false; +}; +goog.structs.every = function(col, f, opt_obj) { + if (typeof col.every == "function") { + return col.every(f, opt_obj); + } + if (goog.isArrayLike(col) || goog.isString(col)) { + return goog.array.every((col), f, opt_obj); + } + var keys = goog.structs.getKeys(col); + var values = goog.structs.getValues(col); + var l = values.length; + for (var i = 0;i < l;i++) { + if (!f.call(opt_obj, values[i], keys && keys[i], col)) { + return false; + } + } + return true; +}; +goog.provide("goog.structs.Map"); +goog.require("goog.iter.Iterator"); +goog.require("goog.iter.StopIteration"); +goog.require("goog.object"); +goog.require("goog.structs"); +goog.structs.Map = function(opt_map, var_args) { + this.map_ = {}; + this.keys_ = []; + var argLength = arguments.length; + if (argLength > 1) { + if (argLength % 2) { + throw Error("Uneven number of arguments"); + } + for (var i = 0;i < argLength;i += 2) { + this.set(arguments[i], arguments[i + 1]); + } + } else { + if (opt_map) { + this.addAll((opt_map)); + } + } +}; +goog.structs.Map.prototype.count_ = 0; +goog.structs.Map.prototype.version_ = 0; +goog.structs.Map.prototype.getCount = function() { + return this.count_; +}; +goog.structs.Map.prototype.getValues = function() { + this.cleanupKeysArray_(); + var rv = []; + for (var i = 0;i < this.keys_.length;i++) { + var key = this.keys_[i]; + rv.push(this.map_[key]); + } + return rv; +}; +goog.structs.Map.prototype.getKeys = function() { + this.cleanupKeysArray_(); + return(this.keys_.concat()); +}; +goog.structs.Map.prototype.containsKey = function(key) { + return goog.structs.Map.hasKey_(this.map_, key); +}; +goog.structs.Map.prototype.containsValue = function(val) { + for (var i = 0;i < this.keys_.length;i++) { + var key = this.keys_[i]; + if (goog.structs.Map.hasKey_(this.map_, key) && this.map_[key] == val) { + return true; + } + } + return false; +}; +goog.structs.Map.prototype.equals = function(otherMap, opt_equalityFn) { + if (this === otherMap) { + return true; + } + if (this.count_ != otherMap.getCount()) { + return false; + } + var equalityFn = opt_equalityFn || goog.structs.Map.defaultEquals; + this.cleanupKeysArray_(); + for (var key, i = 0;key = this.keys_[i];i++) { + if (!equalityFn(this.get(key), otherMap.get(key))) { + return false; + } + } + return true; +}; +goog.structs.Map.defaultEquals = function(a, b) { + return a === b; +}; +goog.structs.Map.prototype.isEmpty = function() { + return this.count_ == 0; +}; +goog.structs.Map.prototype.clear = function() { + this.map_ = {}; + this.keys_.length = 0; + this.count_ = 0; + this.version_ = 0; +}; +goog.structs.Map.prototype.remove = function(key) { + if (goog.structs.Map.hasKey_(this.map_, key)) { + delete this.map_[key]; + this.count_--; + this.version_++; + if (this.keys_.length > 2 * this.count_) { + this.cleanupKeysArray_(); + } + return true; + } + return false; +}; +goog.structs.Map.prototype.cleanupKeysArray_ = function() { + if (this.count_ != this.keys_.length) { + var srcIndex = 0; + var destIndex = 0; + while (srcIndex < this.keys_.length) { + var key = this.keys_[srcIndex]; + if (goog.structs.Map.hasKey_(this.map_, key)) { + this.keys_[destIndex++] = key; + } + srcIndex++; + } + this.keys_.length = destIndex; + } + if (this.count_ != this.keys_.length) { + var seen = {}; + var srcIndex = 0; + var destIndex = 0; + while (srcIndex < this.keys_.length) { + var key = this.keys_[srcIndex]; + if (!goog.structs.Map.hasKey_(seen, key)) { + this.keys_[destIndex++] = key; + seen[key] = 1; + } + srcIndex++; + } + this.keys_.length = destIndex; + } +}; +goog.structs.Map.prototype.get = function(key, opt_val) { + if (goog.structs.Map.hasKey_(this.map_, key)) { + return this.map_[key]; + } + return opt_val; +}; +goog.structs.Map.prototype.set = function(key, value) { + if (!goog.structs.Map.hasKey_(this.map_, key)) { + this.count_++; + this.keys_.push(key); + this.version_++; + } + this.map_[key] = value; +}; +goog.structs.Map.prototype.addAll = function(map) { + var keys, values; + if (map instanceof goog.structs.Map) { + keys = map.getKeys(); + values = map.getValues(); + } else { + keys = goog.object.getKeys(map); + values = goog.object.getValues(map); + } + for (var i = 0;i < keys.length;i++) { + this.set(keys[i], values[i]); + } +}; +goog.structs.Map.prototype.clone = function() { + return new goog.structs.Map(this); +}; +goog.structs.Map.prototype.transpose = function() { + var transposed = new goog.structs.Map; + for (var i = 0;i < this.keys_.length;i++) { + var key = this.keys_[i]; + var value = this.map_[key]; + transposed.set(value, key); + } + return transposed; +}; +goog.structs.Map.prototype.toObject = function() { + this.cleanupKeysArray_(); + var obj = {}; + for (var i = 0;i < this.keys_.length;i++) { + var key = this.keys_[i]; + obj[key] = this.map_[key]; + } + return obj; +}; +goog.structs.Map.prototype.getKeyIterator = function() { + return this.__iterator__(true); +}; +goog.structs.Map.prototype.getValueIterator = function() { + return this.__iterator__(false); +}; +goog.structs.Map.prototype.__iterator__ = function(opt_keys) { + this.cleanupKeysArray_(); + var i = 0; + var keys = this.keys_; + var map = this.map_; + var version = this.version_; + var selfObj = this; + var newIter = new goog.iter.Iterator; + newIter.next = function() { + while (true) { + if (version != selfObj.version_) { + throw Error("The map has changed since the iterator was created"); + } + if (i >= keys.length) { + throw goog.iter.StopIteration; + } + var key = keys[i++]; + return opt_keys ? key : map[key]; + } + }; + return newIter; +}; +goog.structs.Map.hasKey_ = function(obj, key) { + return Object.prototype.hasOwnProperty.call(obj, key); +}; +goog.provide("goog.dom.forms"); +goog.require("goog.structs.Map"); +goog.dom.forms.getFormDataMap = function(form) { + var map = new goog.structs.Map; + goog.dom.forms.getFormDataHelper_(form, map, goog.dom.forms.addFormDataToMap_); + return map; +}; +goog.dom.forms.getFormDataString = function(form) { + var sb = []; + goog.dom.forms.getFormDataHelper_(form, sb, goog.dom.forms.addFormDataToStringBuffer_); + return sb.join("\x26"); +}; +goog.dom.forms.getFormDataHelper_ = function(form, result, fnAppend) { + var els = form.elements; + for (var el, i = 0;el = els[i];i++) { + if (el.form != form || (el.disabled || el.tagName.toLowerCase() == "fieldset")) { + continue; + } + var name = el.name; + switch(el.type.toLowerCase()) { + case "file": + ; + case "submit": + ; + case "reset": + ; + case "button": + break; + case "select-multiple": + var values = goog.dom.forms.getValue(el); + if (values != null) { + for (var value, j = 0;value = values[j];j++) { + fnAppend(result, name, value); + } + } + break; + default: + var value = goog.dom.forms.getValue(el); + if (value != null) { + fnAppend(result, name, value); + } + ; + } + } + var inputs = form.getElementsByTagName("input"); + for (var input, i = 0;input = inputs[i];i++) { + if (input.form == form && input.type.toLowerCase() == "image") { + name = input.name; + fnAppend(result, name, input.value); + fnAppend(result, name + ".x", "0"); + fnAppend(result, name + ".y", "0"); + } + } +}; +goog.dom.forms.addFormDataToMap_ = function(map, name, value) { + var array = map.get(name); + if (!array) { + array = []; + map.set(name, array); + } + array.push(value); +}; +goog.dom.forms.addFormDataToStringBuffer_ = function(sb, name, value) { + sb.push(encodeURIComponent(name) + "\x3d" + encodeURIComponent(value)); +}; +goog.dom.forms.hasFileInput = function(form) { + var els = form.elements; + for (var el, i = 0;el = els[i];i++) { + if (!el.disabled && (el.type && el.type.toLowerCase() == "file")) { + return true; + } + } + return false; +}; +goog.dom.forms.setDisabled = function(el, disabled) { + if (el.tagName == "FORM") { + var els = el.elements; + for (var i = 0;el = els[i];i++) { + goog.dom.forms.setDisabled(el, disabled); + } + } else { + if (disabled == true) { + el.blur(); + } + el.disabled = disabled; + } +}; +goog.dom.forms.focusAndSelect = function(el) { + el.focus(); + if (el.select) { + el.select(); + } +}; +goog.dom.forms.hasValue = function(el) { + var value = goog.dom.forms.getValue(el); + return!!value; +}; +goog.dom.forms.hasValueByName = function(form, name) { + var value = goog.dom.forms.getValueByName(form, name); + return!!value; +}; +goog.dom.forms.getValue = function(el) { + var type = el.type; + if (!goog.isDef(type)) { + return null; + } + switch(type.toLowerCase()) { + case "checkbox": + ; + case "radio": + return goog.dom.forms.getInputChecked_(el); + case "select-one": + return goog.dom.forms.getSelectSingle_(el); + case "select-multiple": + return goog.dom.forms.getSelectMultiple_(el); + default: + return goog.isDef(el.value) ? el.value : null; + } +}; +goog.dom.$F = goog.dom.forms.getValue; +goog.dom.forms.getValueByName = function(form, name) { + var els = form.elements[name]; + if (els.type) { + return goog.dom.forms.getValue(els); + } else { + for (var i = 0;i < els.length;i++) { + var val = goog.dom.forms.getValue(els[i]); + if (val) { + return val; + } + } + return null; + } +}; +goog.dom.forms.getInputChecked_ = function(el) { + return el.checked ? el.value : null; +}; +goog.dom.forms.getSelectSingle_ = function(el) { + var selectedIndex = el.selectedIndex; + return selectedIndex >= 0 ? el.options[selectedIndex].value : null; +}; +goog.dom.forms.getSelectMultiple_ = function(el) { + var values = []; + for (var option, i = 0;option = el.options[i];i++) { + if (option.selected) { + values.push(option.value); + } + } + return values.length ? values : null; +}; +goog.dom.forms.setValue = function(el, opt_value) { + var type = el.type; + if (goog.isDef(type)) { + switch(type.toLowerCase()) { + case "checkbox": + ; + case "radio": + goog.dom.forms.setInputChecked_(el, (opt_value)); + break; + case "select-one": + goog.dom.forms.setSelectSingle_(el, (opt_value)); + break; + case "select-multiple": + goog.dom.forms.setSelectMultiple_(el, (opt_value)); + break; + default: + el.value = goog.isDefAndNotNull(opt_value) ? opt_value : ""; + } + } +}; +goog.dom.forms.setInputChecked_ = function(el, opt_value) { + el.checked = opt_value ? "checked" : null; +}; +goog.dom.forms.setSelectSingle_ = function(el, opt_value) { + el.selectedIndex = -1; + if (goog.isString(opt_value)) { + for (var option, i = 0;option = el.options[i];i++) { + if (option.value == opt_value) { + option.selected = true; + break; + } + } + } +}; +goog.dom.forms.setSelectMultiple_ = function(el, opt_value) { + if (goog.isString(opt_value)) { + opt_value = [opt_value]; + } + for (var option, i = 0;option = el.options[i];i++) { + option.selected = false; + if (opt_value) { + for (var value, j = 0;value = opt_value[j];j++) { + if (option.value == value) { + option.selected = true; + } + } + } + } +}; +goog.provide("goog.debug.EntryPointMonitor"); +goog.provide("goog.debug.entryPointRegistry"); +goog.require("goog.asserts"); +goog.debug.EntryPointMonitor = function() { +}; +goog.debug.EntryPointMonitor.prototype.wrap; +goog.debug.EntryPointMonitor.prototype.unwrap; +goog.debug.entryPointRegistry.refList_ = []; +goog.debug.entryPointRegistry.monitors_ = []; +goog.debug.entryPointRegistry.monitorsMayExist_ = false; +goog.debug.entryPointRegistry.register = function(callback) { + goog.debug.entryPointRegistry.refList_[goog.debug.entryPointRegistry.refList_.length] = callback; + if (goog.debug.entryPointRegistry.monitorsMayExist_) { + var monitors = goog.debug.entryPointRegistry.monitors_; + for (var i = 0;i < monitors.length;i++) { + callback(goog.bind(monitors[i].wrap, monitors[i])); + } + } +}; +goog.debug.entryPointRegistry.monitorAll = function(monitor) { + goog.debug.entryPointRegistry.monitorsMayExist_ = true; + var transformer = goog.bind(monitor.wrap, monitor); + for (var i = 0;i < goog.debug.entryPointRegistry.refList_.length;i++) { + goog.debug.entryPointRegistry.refList_[i](transformer); + } + goog.debug.entryPointRegistry.monitors_.push(monitor); +}; +goog.debug.entryPointRegistry.unmonitorAllIfPossible = function(monitor) { + var monitors = goog.debug.entryPointRegistry.monitors_; + goog.asserts.assert(monitor == monitors[monitors.length - 1], "Only the most recent monitor can be unwrapped."); + var transformer = goog.bind(monitor.unwrap, monitor); + for (var i = 0;i < goog.debug.entryPointRegistry.refList_.length;i++) { + goog.debug.entryPointRegistry.refList_[i](transformer); + } + monitors.length--; +}; +goog.provide("goog.debug.errorHandlerWeakDep"); +goog.debug.errorHandlerWeakDep = {protectEntryPoint:function(fn, opt_tracers) { + return fn; +}}; +goog.provide("goog.events.BrowserFeature"); +goog.require("goog.userAgent"); +goog.events.BrowserFeature = {HAS_W3C_BUTTON:!goog.userAgent.IE || goog.userAgent.isDocumentMode(9), HAS_W3C_EVENT_SUPPORT:!goog.userAgent.IE || goog.userAgent.isDocumentMode(9), SET_KEY_CODE_TO_PREVENT_DEFAULT:goog.userAgent.IE && !goog.userAgent.isVersion("9"), HAS_NAVIGATOR_ONLINE_PROPERTY:!goog.userAgent.WEBKIT || goog.userAgent.isVersion("528"), HAS_HTML5_NETWORK_EVENT_SUPPORT:goog.userAgent.GECKO && goog.userAgent.isVersion("1.9b") || (goog.userAgent.IE && goog.userAgent.isVersion("8") || (goog.userAgent.OPERA && +goog.userAgent.isVersion("9.5") || goog.userAgent.WEBKIT && goog.userAgent.isVersion("528"))), HTML5_NETWORK_EVENTS_FIRE_ON_BODY:goog.userAgent.GECKO && !goog.userAgent.isVersion("8") || goog.userAgent.IE && !goog.userAgent.isVersion("9"), TOUCH_ENABLED:"ontouchstart" in goog.global || (!!(goog.global["document"] && (document.documentElement && "ontouchstart" in document.documentElement)) || !!(goog.global["navigator"] && goog.global["navigator"]["msMaxTouchPoints"]))}; +goog.provide("goog.disposable.IDisposable"); +goog.disposable.IDisposable = function() { +}; +goog.disposable.IDisposable.prototype.dispose; +goog.disposable.IDisposable.prototype.isDisposed; +goog.provide("goog.Disposable"); +goog.provide("goog.dispose"); +goog.require("goog.disposable.IDisposable"); +goog.Disposable = function() { + if (goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF) { + this.creationStack = (new Error).stack; + goog.Disposable.instances_[goog.getUid(this)] = this; + } +}; +goog.Disposable.MonitoringMode = {OFF:0, PERMANENT:1, INTERACTIVE:2}; +goog.Disposable.MONITORING_MODE = 0; +goog.Disposable.instances_ = {}; +goog.Disposable.getUndisposedObjects = function() { + var ret = []; + for (var id in goog.Disposable.instances_) { + if (goog.Disposable.instances_.hasOwnProperty(id)) { + ret.push(goog.Disposable.instances_[Number(id)]); + } + } + return ret; +}; +goog.Disposable.clearUndisposedObjects = function() { + goog.Disposable.instances_ = {}; +}; +goog.Disposable.prototype.disposed_ = false; +goog.Disposable.prototype.onDisposeCallbacks_; +goog.Disposable.prototype.creationStack; +goog.Disposable.prototype.isDisposed = function() { + return this.disposed_; +}; +goog.Disposable.prototype.getDisposed = goog.Disposable.prototype.isDisposed; +goog.Disposable.prototype.dispose = function() { + if (!this.disposed_) { + this.disposed_ = true; + this.disposeInternal(); + if (goog.Disposable.MONITORING_MODE != goog.Disposable.MonitoringMode.OFF) { + var uid = goog.getUid(this); + if (goog.Disposable.MONITORING_MODE == goog.Disposable.MonitoringMode.PERMANENT && !goog.Disposable.instances_.hasOwnProperty(uid)) { + throw Error(this + " did not call the goog.Disposable base " + "constructor or was disposed of after a clearUndisposedObjects " + "call"); + } + delete goog.Disposable.instances_[uid]; + } + } +}; +goog.Disposable.prototype.registerDisposable = function(disposable) { + this.addOnDisposeCallback(goog.partial(goog.dispose, disposable)); +}; +goog.Disposable.prototype.addOnDisposeCallback = function(callback, opt_scope) { + if (!this.onDisposeCallbacks_) { + this.onDisposeCallbacks_ = []; + } + this.onDisposeCallbacks_.push(goog.bind(callback, opt_scope)); +}; +goog.Disposable.prototype.disposeInternal = function() { + if (this.onDisposeCallbacks_) { + while (this.onDisposeCallbacks_.length) { + this.onDisposeCallbacks_.shift()(); + } + } +}; +goog.Disposable.isDisposed = function(obj) { + if (obj && typeof obj.isDisposed == "function") { + return obj.isDisposed(); + } + return false; +}; +goog.dispose = function(obj) { + if (obj && typeof obj.dispose == "function") { + obj.dispose(); + } +}; +goog.disposeAll = function(var_args) { + for (var i = 0, len = arguments.length;i < len;++i) { + var disposable = arguments[i]; + if (goog.isArrayLike(disposable)) { + goog.disposeAll.apply(null, disposable); + } else { + goog.dispose(disposable); + } + } +}; +goog.provide("goog.events.Event"); +goog.provide("goog.events.EventLike"); +goog.require("goog.Disposable"); +goog.events.EventLike; +goog.events.Event = function(type, opt_target) { + this.type = type; + this.target = opt_target; + this.currentTarget = this.target; +}; +goog.events.Event.prototype.disposeInternal = function() { +}; +goog.events.Event.prototype.dispose = function() { +}; +goog.events.Event.prototype.propagationStopped_ = false; +goog.events.Event.prototype.defaultPrevented = false; +goog.events.Event.prototype.returnValue_ = true; +goog.events.Event.prototype.stopPropagation = function() { + this.propagationStopped_ = true; +}; +goog.events.Event.prototype.preventDefault = function() { + this.defaultPrevented = true; + this.returnValue_ = false; +}; +goog.events.Event.stopPropagation = function(e) { + e.stopPropagation(); +}; +goog.events.Event.preventDefault = function(e) { + e.preventDefault(); +}; +goog.provide("goog.events.EventType"); +goog.require("goog.userAgent"); +goog.events.EventType = {CLICK:"click", DBLCLICK:"dblclick", MOUSEDOWN:"mousedown", MOUSEUP:"mouseup", MOUSEOVER:"mouseover", MOUSEOUT:"mouseout", MOUSEMOVE:"mousemove", SELECTSTART:"selectstart", KEYPRESS:"keypress", KEYDOWN:"keydown", KEYUP:"keyup", BLUR:"blur", FOCUS:"focus", DEACTIVATE:"deactivate", FOCUSIN:goog.userAgent.IE ? "focusin" : "DOMFocusIn", FOCUSOUT:goog.userAgent.IE ? "focusout" : "DOMFocusOut", CHANGE:"change", SELECT:"select", SUBMIT:"submit", INPUT:"input", PROPERTYCHANGE:"propertychange", +DRAGSTART:"dragstart", DRAG:"drag", DRAGENTER:"dragenter", DRAGOVER:"dragover", DRAGLEAVE:"dragleave", DROP:"drop", DRAGEND:"dragend", TOUCHSTART:"touchstart", TOUCHMOVE:"touchmove", TOUCHEND:"touchend", TOUCHCANCEL:"touchcancel", BEFOREUNLOAD:"beforeunload", CONTEXTMENU:"contextmenu", ERROR:"error", HELP:"help", LOAD:"load", LOSECAPTURE:"losecapture", READYSTATECHANGE:"readystatechange", RESIZE:"resize", SCROLL:"scroll", UNLOAD:"unload", HASHCHANGE:"hashchange", PAGEHIDE:"pagehide", PAGESHOW:"pageshow", +POPSTATE:"popstate", COPY:"copy", PASTE:"paste", CUT:"cut", BEFORECOPY:"beforecopy", BEFORECUT:"beforecut", BEFOREPASTE:"beforepaste", ONLINE:"online", OFFLINE:"offline", MESSAGE:"message", CONNECT:"connect", TRANSITIONEND:goog.userAgent.WEBKIT ? "webkitTransitionEnd" : goog.userAgent.OPERA ? "oTransitionEnd" : "transitionend", MSGESTURECHANGE:"MSGestureChange", MSGESTUREEND:"MSGestureEnd", MSGESTUREHOLD:"MSGestureHold", MSGESTURESTART:"MSGestureStart", MSGESTURETAP:"MSGestureTap", MSGOTPOINTERCAPTURE:"MSGotPointerCapture", +MSINERTIASTART:"MSInertiaStart", MSLOSTPOINTERCAPTURE:"MSLostPointerCapture", MSPOINTERCANCEL:"MSPointerCancel", MSPOINTERDOWN:"MSPointerDown", MSPOINTERMOVE:"MSPointerMove", MSPOINTEROVER:"MSPointerOver", MSPOINTEROUT:"MSPointerOut", MSPOINTERUP:"MSPointerUp", TEXTINPUT:"textinput", COMPOSITIONSTART:"compositionstart", COMPOSITIONUPDATE:"compositionupdate", COMPOSITIONEND:"compositionend"}; +goog.provide("goog.reflect"); +goog.reflect.object = function(type, object) { + return object; +}; +goog.reflect.sinkValue = function(x) { + goog.reflect.sinkValue[" "](x); + return x; +}; +goog.reflect.sinkValue[" "] = goog.nullFunction; +goog.reflect.canAccessProperty = function(obj, prop) { + try { + goog.reflect.sinkValue(obj[prop]); + return true; + } catch (e) { + } + return false; +}; +goog.provide("goog.events.BrowserEvent"); +goog.provide("goog.events.BrowserEvent.MouseButton"); +goog.require("goog.events.BrowserFeature"); +goog.require("goog.events.Event"); +goog.require("goog.events.EventType"); +goog.require("goog.reflect"); +goog.require("goog.userAgent"); +goog.events.BrowserEvent = function(opt_e, opt_currentTarget) { + if (opt_e) { + this.init(opt_e, opt_currentTarget); + } +}; +goog.inherits(goog.events.BrowserEvent, goog.events.Event); +goog.events.BrowserEvent.MouseButton = {LEFT:0, MIDDLE:1, RIGHT:2}; +goog.events.BrowserEvent.IEButtonMap = [1, 4, 2]; +goog.events.BrowserEvent.prototype.target = null; +goog.events.BrowserEvent.prototype.currentTarget; +goog.events.BrowserEvent.prototype.relatedTarget = null; +goog.events.BrowserEvent.prototype.offsetX = 0; +goog.events.BrowserEvent.prototype.offsetY = 0; +goog.events.BrowserEvent.prototype.clientX = 0; +goog.events.BrowserEvent.prototype.clientY = 0; +goog.events.BrowserEvent.prototype.screenX = 0; +goog.events.BrowserEvent.prototype.screenY = 0; +goog.events.BrowserEvent.prototype.button = 0; +goog.events.BrowserEvent.prototype.keyCode = 0; +goog.events.BrowserEvent.prototype.charCode = 0; +goog.events.BrowserEvent.prototype.ctrlKey = false; +goog.events.BrowserEvent.prototype.altKey = false; +goog.events.BrowserEvent.prototype.shiftKey = false; +goog.events.BrowserEvent.prototype.metaKey = false; +goog.events.BrowserEvent.prototype.state; +goog.events.BrowserEvent.prototype.platformModifierKey = false; +goog.events.BrowserEvent.prototype.event_ = null; +goog.events.BrowserEvent.prototype.init = function(e, opt_currentTarget) { + var type = this.type = e.type; + goog.events.Event.call(this, type); + this.target = (e.target) || e.srcElement; + this.currentTarget = (opt_currentTarget); + var relatedTarget = (e.relatedTarget); + if (relatedTarget) { + if (goog.userAgent.GECKO) { + if (!goog.reflect.canAccessProperty(relatedTarget, "nodeName")) { + relatedTarget = null; + } + } + } else { + if (type == goog.events.EventType.MOUSEOVER) { + relatedTarget = e.fromElement; + } else { + if (type == goog.events.EventType.MOUSEOUT) { + relatedTarget = e.toElement; + } + } + } + this.relatedTarget = relatedTarget; + this.offsetX = goog.userAgent.WEBKIT || e.offsetX !== undefined ? e.offsetX : e.layerX; + this.offsetY = goog.userAgent.WEBKIT || e.offsetY !== undefined ? e.offsetY : e.layerY; + this.clientX = e.clientX !== undefined ? e.clientX : e.pageX; + this.clientY = e.clientY !== undefined ? e.clientY : e.pageY; + this.screenX = e.screenX || 0; + this.screenY = e.screenY || 0; + this.button = e.button; + this.keyCode = e.keyCode || 0; + this.charCode = e.charCode || (type == "keypress" ? e.keyCode : 0); + this.ctrlKey = e.ctrlKey; + this.altKey = e.altKey; + this.shiftKey = e.shiftKey; + this.metaKey = e.metaKey; + this.platformModifierKey = goog.userAgent.MAC ? e.metaKey : e.ctrlKey; + this.state = e.state; + this.event_ = e; + if (e.defaultPrevented) { + this.preventDefault(); + } + delete this.propagationStopped_; +}; +goog.events.BrowserEvent.prototype.isButton = function(button) { + if (!goog.events.BrowserFeature.HAS_W3C_BUTTON) { + if (this.type == "click") { + return button == goog.events.BrowserEvent.MouseButton.LEFT; + } else { + return!!(this.event_.button & goog.events.BrowserEvent.IEButtonMap[button]); + } + } else { + return this.event_.button == button; + } +}; +goog.events.BrowserEvent.prototype.isMouseActionButton = function() { + return this.isButton(goog.events.BrowserEvent.MouseButton.LEFT) && !(goog.userAgent.WEBKIT && (goog.userAgent.MAC && this.ctrlKey)); +}; +goog.events.BrowserEvent.prototype.stopPropagation = function() { + goog.events.BrowserEvent.superClass_.stopPropagation.call(this); + if (this.event_.stopPropagation) { + this.event_.stopPropagation(); + } else { + this.event_.cancelBubble = true; + } +}; +goog.events.BrowserEvent.prototype.preventDefault = function() { + goog.events.BrowserEvent.superClass_.preventDefault.call(this); + var be = this.event_; + if (!be.preventDefault) { + be.returnValue = false; + if (goog.events.BrowserFeature.SET_KEY_CODE_TO_PREVENT_DEFAULT) { + try { + var VK_F1 = 112; + var VK_F12 = 123; + if (be.ctrlKey || be.keyCode >= VK_F1 && be.keyCode <= VK_F12) { + be.keyCode = -1; + } + } catch (ex) { + } + } + } else { + be.preventDefault(); + } +}; +goog.events.BrowserEvent.prototype.getBrowserEvent = function() { + return this.event_; +}; +goog.events.BrowserEvent.prototype.disposeInternal = function() { +}; +goog.provide("goog.events.EventWrapper"); +goog.events.EventWrapper = function() { +}; +goog.events.EventWrapper.prototype.listen = function(src, listener, opt_capt, opt_scope, opt_eventHandler) { +}; +goog.events.EventWrapper.prototype.unlisten = function(src, listener, opt_capt, opt_scope, opt_eventHandler) { +}; +goog.provide("goog.events.Listenable"); +goog.provide("goog.events.ListenableKey"); +goog.require("goog.events.EventLike"); +goog.events.Listenable = function() { +}; +goog.events.Listenable.USE_LISTENABLE_INTERFACE = false; +goog.events.Listenable.IMPLEMENTED_BY_PROP_ = "__closure_listenable"; +goog.events.Listenable.addImplementation = function(cls) { + cls.prototype[goog.events.Listenable.IMPLEMENTED_BY_PROP_] = true; +}; +goog.events.Listenable.isImplementedBy = function(obj) { + return!!(obj && obj[goog.events.Listenable.IMPLEMENTED_BY_PROP_]); +}; +goog.events.Listenable.prototype.listen; +goog.events.Listenable.prototype.listenOnce; +goog.events.Listenable.prototype.unlisten; +goog.events.Listenable.prototype.unlistenByKey; +goog.events.Listenable.prototype.dispatchEvent; +goog.events.Listenable.prototype.removeAllListeners; +goog.events.Listenable.prototype.fireListeners; +goog.events.Listenable.prototype.getListeners; +goog.events.Listenable.prototype.getListener; +goog.events.Listenable.prototype.hasListener; +goog.events.ListenableKey = function() { +}; +goog.events.ListenableKey.counter_ = 0; +goog.events.ListenableKey.reserveKey = function() { + return++goog.events.ListenableKey.counter_; +}; +goog.events.ListenableKey.prototype.src; +goog.events.ListenableKey.prototype.type; +goog.events.ListenableKey.prototype.listener; +goog.events.ListenableKey.prototype.capture; +goog.events.ListenableKey.prototype.handler; +goog.events.ListenableKey.prototype.key; +goog.provide("goog.events.Listener"); +goog.require("goog.events.ListenableKey"); +goog.events.Listener = function() { + if (goog.events.Listener.ENABLE_MONITORING) { + this.creationStack = (new Error).stack; + } +}; +goog.events.Listener.ENABLE_MONITORING = false; +goog.events.Listener.prototype.isFunctionListener_; +goog.events.Listener.prototype.listener; +goog.events.Listener.prototype.proxy; +goog.events.Listener.prototype.src; +goog.events.Listener.prototype.type; +goog.events.Listener.prototype.capture; +goog.events.Listener.prototype.handler; +goog.events.Listener.prototype.key = 0; +goog.events.Listener.prototype.removed = false; +goog.events.Listener.prototype.callOnce = false; +goog.events.Listener.prototype.creationStack; +goog.events.Listener.prototype.init = function(listener, proxy, src, type, capture, opt_handler) { + if (goog.isFunction(listener)) { + this.isFunctionListener_ = true; + } else { + if (listener && (listener.handleEvent && goog.isFunction(listener.handleEvent))) { + this.isFunctionListener_ = false; + } else { + throw Error("Invalid listener argument"); + } + } + this.listener = listener; + this.proxy = proxy; + this.src = src; + this.type = type; + this.capture = !!capture; + this.handler = opt_handler; + this.callOnce = false; + this.key = goog.events.ListenableKey.reserveKey(); + this.removed = false; +}; +goog.events.Listener.prototype.handleEvent = function(eventObject) { + if (this.isFunctionListener_) { + return this.listener.call(this.handler || this.src, eventObject); + } + return this.listener.handleEvent.call(this.listener, eventObject); +}; +goog.provide("goog.events"); +goog.provide("goog.events.Key"); +goog.require("goog.array"); +goog.require("goog.debug.entryPointRegistry"); +goog.require("goog.debug.errorHandlerWeakDep"); +goog.require("goog.events.BrowserEvent"); +goog.require("goog.events.BrowserFeature"); +goog.require("goog.events.Event"); +goog.require("goog.events.EventWrapper"); +goog.require("goog.events.Listenable"); +goog.require("goog.events.Listener"); +goog.require("goog.object"); +goog.require("goog.userAgent"); +goog.events.Key; +goog.events.ListenableType; +goog.events.listeners_ = {}; +goog.events.listenerTree_ = {}; +goog.events.sources_ = {}; +goog.events.onString_ = "on"; +goog.events.onStringMap_ = {}; +goog.events.keySeparator_ = "_"; +goog.events.listen = function(src, type, listener, opt_capt, opt_handler) { + if (goog.isArray(type)) { + for (var i = 0;i < type.length;i++) { + goog.events.listen(src, type[i], listener, opt_capt, opt_handler); + } + return null; + } + var listenableKey; + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(src)) { + listenableKey = src.listen((type), goog.events.wrapListener_(listener), opt_capt, opt_handler); + } else { + listenableKey = goog.events.listen_((src), type, listener, false, opt_capt, opt_handler); + } + var key = listenableKey.key; + goog.events.listeners_[key] = listenableKey; + return key; +}; +goog.events.listen_ = function(src, type, listener, callOnce, opt_capt, opt_handler) { + if (!type) { + throw Error("Invalid event type"); + } + var capture = !!opt_capt; + var map = goog.events.listenerTree_; + if (!(type in map)) { + map[type] = {count_:0, remaining_:0}; + } + map = map[type]; + if (!(capture in map)) { + map[capture] = {count_:0, remaining_:0}; + map.count_++; + } + map = map[capture]; + var srcUid = goog.getUid(src); + var listenerArray, listenerObj; + map.remaining_++; + if (!map[srcUid]) { + listenerArray = map[srcUid] = []; + map.count_++; + } else { + listenerArray = map[srcUid]; + for (var i = 0;i < listenerArray.length;i++) { + listenerObj = listenerArray[i]; + if (listenerObj.listener == listener && listenerObj.handler == opt_handler) { + if (listenerObj.removed) { + break; + } + if (!callOnce) { + listenerArray[i].callOnce = false; + } + return listenerArray[i]; + } + } + } + var proxy = goog.events.getProxy(); + listenerObj = new goog.events.Listener; + listenerObj.init(listener, proxy, src, type, capture, opt_handler); + listenerObj.callOnce = callOnce; + proxy.src = src; + proxy.listener = listenerObj; + listenerArray.push(listenerObj); + if (!goog.events.sources_[srcUid]) { + goog.events.sources_[srcUid] = []; + } + goog.events.sources_[srcUid].push(listenerObj); + if (src.addEventListener) { + if (src == goog.global || !src.customEvent_) { + src.addEventListener(type, proxy, capture); + } + } else { + src.attachEvent(goog.events.getOnString_(type), proxy); + } + return listenerObj; +}; +goog.events.getProxy = function() { + var proxyCallbackFunction = goog.events.handleBrowserEvent_; + var f = goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT ? function(eventObject) { + return proxyCallbackFunction.call(f.src, f.listener, eventObject); + } : function(eventObject) { + var v = proxyCallbackFunction.call(f.src, f.listener, eventObject); + if (!v) { + return v; + } + }; + return f; +}; +goog.events.listenOnce = function(src, type, listener, opt_capt, opt_handler) { + if (goog.isArray(type)) { + for (var i = 0;i < type.length;i++) { + goog.events.listenOnce(src, type[i], listener, opt_capt, opt_handler); + } + return null; + } + var listenableKey; + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(src)) { + listenableKey = src.listenOnce((type), goog.events.wrapListener_(listener), opt_capt, opt_handler); + } else { + listenableKey = goog.events.listen_((src), type, listener, true, opt_capt, opt_handler); + } + var key = listenableKey.key; + goog.events.listeners_[key] = listenableKey; + return key; +}; +goog.events.listenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) { + wrapper.listen(src, listener, opt_capt, opt_handler); +}; +goog.events.unlisten = function(src, type, listener, opt_capt, opt_handler) { + if (goog.isArray(type)) { + for (var i = 0;i < type.length;i++) { + goog.events.unlisten(src, type[i], listener, opt_capt, opt_handler); + } + return null; + } + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(src)) { + return src.unlisten((type), goog.events.wrapListener_(listener), opt_capt, opt_handler); + } + var capture = !!opt_capt; + var listenerArray = goog.events.getListeners_(src, type, capture); + if (!listenerArray) { + return false; + } + for (var i = 0;i < listenerArray.length;i++) { + if (listenerArray[i].listener == listener && (listenerArray[i].capture == capture && listenerArray[i].handler == opt_handler)) { + return goog.events.unlistenByKey(listenerArray[i].key); + } + } + return false; +}; +goog.events.unlistenByKey = function(key) { + var listener = goog.events.listeners_[key]; + if (!listener) { + return false; + } + if (listener.removed) { + return false; + } + var src = listener.src; + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(src)) { + return src.unlistenByKey(listener); + } + var type = listener.type; + var proxy = listener.proxy; + var capture = listener.capture; + if (src.removeEventListener) { + if (src == goog.global || !src.customEvent_) { + src.removeEventListener(type, proxy, capture); + } + } else { + if (src.detachEvent) { + src.detachEvent(goog.events.getOnString_(type), proxy); + } + } + var srcUid = goog.getUid(src); + if (goog.events.sources_[srcUid]) { + var sourcesArray = goog.events.sources_[srcUid]; + goog.array.remove(sourcesArray, listener); + if (sourcesArray.length == 0) { + delete goog.events.sources_[srcUid]; + } + } + listener.removed = true; + var listenerArray = goog.events.listenerTree_[type][capture][srcUid]; + if (listenerArray) { + listenerArray.needsCleanup_ = true; + goog.events.cleanUp_(type, capture, srcUid, listenerArray); + } + delete goog.events.listeners_[key]; + return true; +}; +goog.events.unlistenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) { + wrapper.unlisten(src, listener, opt_capt, opt_handler); +}; +goog.events.cleanUp = function(listenableKey) { + delete goog.events.listeners_[listenableKey.key]; +}; +goog.events.cleanUp_ = function(type, capture, srcUid, listenerArray) { + if (!listenerArray.locked_) { + if (listenerArray.needsCleanup_) { + for (var oldIndex = 0, newIndex = 0;oldIndex < listenerArray.length;oldIndex++) { + if (listenerArray[oldIndex].removed) { + var proxy = listenerArray[oldIndex].proxy; + proxy.src = null; + continue; + } + if (oldIndex != newIndex) { + listenerArray[newIndex] = listenerArray[oldIndex]; + } + newIndex++; + } + listenerArray.length = newIndex; + listenerArray.needsCleanup_ = false; + if (newIndex == 0) { + delete goog.events.listenerTree_[type][capture][srcUid]; + goog.events.listenerTree_[type][capture].count_--; + if (goog.events.listenerTree_[type][capture].count_ == 0) { + delete goog.events.listenerTree_[type][capture]; + goog.events.listenerTree_[type].count_--; + } + if (goog.events.listenerTree_[type].count_ == 0) { + delete goog.events.listenerTree_[type]; + } + } + } + } +}; +goog.events.removeAll = function(opt_obj, opt_type) { + var count = 0; + var noObj = opt_obj == null; + var noType = opt_type == null; + if (!noObj) { + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && (opt_obj && goog.events.Listenable.isImplementedBy(opt_obj))) { + return opt_obj.removeAllListeners(opt_type); + } + var srcUid = goog.getUid((opt_obj)); + if (goog.events.sources_[srcUid]) { + var sourcesArray = goog.events.sources_[srcUid]; + for (var i = sourcesArray.length - 1;i >= 0;i--) { + var listener = sourcesArray[i]; + if (noType || opt_type == listener.type) { + goog.events.unlistenByKey(listener.key); + count++; + } + } + } + } else { + goog.object.forEach(goog.events.listeners_, function(listener, key) { + goog.events.unlistenByKey(key); + count++; + }); + } + return count; +}; +goog.events.getListeners = function(obj, type, capture) { + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(obj)) { + return obj.getListeners(type, capture); + } else { + return goog.events.getListeners_(obj, type, capture) || []; + } +}; +goog.events.getListeners_ = function(obj, type, capture) { + var map = goog.events.listenerTree_; + if (type in map) { + map = map[type]; + if (capture in map) { + map = map[capture]; + var objUid = goog.getUid(obj); + if (map[objUid]) { + return map[objUid]; + } + } + } + return null; +}; +goog.events.getListener = function(src, type, listener, opt_capt, opt_handler) { + var capture = !!opt_capt; + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(src)) { + return src.getListener((type), goog.events.wrapListener_(listener), capture, opt_handler); + } + var listenerArray = goog.events.getListeners_(src, type, capture); + if (listenerArray) { + for (var i = 0;i < listenerArray.length;i++) { + if (!listenerArray[i].removed && (listenerArray[i].listener == listener && (listenerArray[i].capture == capture && listenerArray[i].handler == opt_handler))) { + return listenerArray[i]; + } + } + } + return null; +}; +goog.events.hasListener = function(obj, opt_type, opt_capture) { + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(obj)) { + return obj.hasListener(opt_type, opt_capture); + } + var objUid = goog.getUid(obj); + var listeners = goog.events.sources_[objUid]; + if (listeners) { + var hasType = goog.isDef(opt_type); + var hasCapture = goog.isDef(opt_capture); + if (hasType && hasCapture) { + var map = goog.events.listenerTree_[opt_type]; + return!!map && (!!map[opt_capture] && objUid in map[opt_capture]); + } else { + if (!(hasType || hasCapture)) { + return true; + } else { + return goog.array.some(listeners, function(listener) { + return hasType && listener.type == opt_type || hasCapture && listener.capture == opt_capture; + }); + } + } + } + return false; +}; +goog.events.expose = function(e) { + var str = []; + for (var key in e) { + if (e[key] && e[key].id) { + str.push(key + " \x3d " + e[key] + " (" + e[key].id + ")"); + } else { + str.push(key + " \x3d " + e[key]); + } + } + return str.join("\n"); +}; +goog.events.getOnString_ = function(type) { + if (type in goog.events.onStringMap_) { + return goog.events.onStringMap_[type]; + } + return goog.events.onStringMap_[type] = goog.events.onString_ + type; +}; +goog.events.fireListeners = function(obj, type, capture, eventObject) { + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE && goog.events.Listenable.isImplementedBy(obj)) { + return obj.fireListeners(type, capture, eventObject); + } + var map = goog.events.listenerTree_; + if (type in map) { + map = map[type]; + if (capture in map) { + return goog.events.fireListeners_(map[capture], obj, type, capture, eventObject); + } + } + return true; +}; +goog.events.fireListeners_ = function(map, obj, type, capture, eventObject) { + var retval = 1; + var objUid = goog.getUid(obj); + if (map[objUid]) { + var remaining = --map.remaining_; + var listenerArray = map[objUid]; + if (!listenerArray.locked_) { + listenerArray.locked_ = 1; + } else { + listenerArray.locked_++; + } + try { + var length = listenerArray.length; + for (var i = 0;i < length;i++) { + var listener = listenerArray[i]; + if (listener && !listener.removed) { + retval &= goog.events.fireListener(listener, eventObject) !== false; + } + } + } finally { + map.remaining_ = Math.max(remaining, map.remaining_); + listenerArray.locked_--; + goog.events.cleanUp_(type, capture, objUid, listenerArray); + } + } + return Boolean(retval); +}; +goog.events.fireListener = function(listener, eventObject) { + if (listener.callOnce) { + goog.events.unlistenByKey(listener.key); + } + return listener.handleEvent(eventObject); +}; +goog.events.getTotalListenerCount = function() { + return goog.object.getCount(goog.events.listeners_); +}; +goog.events.dispatchEvent = function(src, e) { + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE) { + return src.dispatchEvent(e); + } + var type = e.type || e; + var map = goog.events.listenerTree_; + if (!(type in map)) { + return true; + } + if (goog.isString(e)) { + e = new goog.events.Event(e, src); + } else { + if (!(e instanceof goog.events.Event)) { + var oldEvent = e; + e = new goog.events.Event((type), src); + goog.object.extend(e, oldEvent); + } else { + e.target = e.target || src; + } + } + var rv = 1, ancestors; + map = map[type]; + var hasCapture = true in map; + var targetsMap; + if (hasCapture) { + ancestors = []; + for (var parent = src;parent;parent = parent.getParentEventTarget()) { + ancestors.push(parent); + } + targetsMap = map[true]; + targetsMap.remaining_ = targetsMap.count_; + for (var i = ancestors.length - 1;!e.propagationStopped_ && (i >= 0 && targetsMap.remaining_);i--) { + e.currentTarget = ancestors[i]; + rv &= goog.events.fireListeners_(targetsMap, ancestors[i], e.type, true, e) && e.returnValue_ != false; + } + } + var hasBubble = false in map; + if (hasBubble) { + targetsMap = map[false]; + targetsMap.remaining_ = targetsMap.count_; + if (hasCapture) { + for (var i = 0;!e.propagationStopped_ && (i < ancestors.length && targetsMap.remaining_);i++) { + e.currentTarget = ancestors[i]; + rv &= goog.events.fireListeners_(targetsMap, ancestors[i], e.type, false, e) && e.returnValue_ != false; + } + } else { + for (var current = src;!e.propagationStopped_ && (current && targetsMap.remaining_);current = current.getParentEventTarget()) { + e.currentTarget = current; + rv &= goog.events.fireListeners_(targetsMap, current, e.type, false, e) && e.returnValue_ != false; + } + } + } + return Boolean(rv); +}; +goog.events.protectBrowserEventEntryPoint = function(errorHandler) { + goog.events.handleBrowserEvent_ = errorHandler.protectEntryPoint(goog.events.handleBrowserEvent_); +}; +goog.events.handleBrowserEvent_ = function(listener, opt_evt) { + if (listener.removed) { + return true; + } + var type = listener.type; + var map = goog.events.listenerTree_; + if (!(type in map)) { + return true; + } + map = map[type]; + var retval, targetsMap; + if (!goog.events.BrowserFeature.HAS_W3C_EVENT_SUPPORT) { + var ieEvent = opt_evt || (goog.getObjectByName("window.event")); + var hasCapture = true in map; + var hasBubble = false in map; + if (hasCapture) { + if (goog.events.isMarkedIeEvent_(ieEvent)) { + return true; + } + goog.events.markIeEvent_(ieEvent); + } + var evt = new goog.events.BrowserEvent; + evt.init(ieEvent, (this)); + retval = true; + try { + if (hasCapture) { + var ancestors = []; + for (var parent = evt.currentTarget;parent;parent = parent.parentNode) { + ancestors.push(parent); + } + targetsMap = map[true]; + targetsMap.remaining_ = targetsMap.count_; + for (var i = ancestors.length - 1;!evt.propagationStopped_ && (i >= 0 && targetsMap.remaining_);i--) { + evt.currentTarget = ancestors[i]; + retval &= goog.events.fireListeners_(targetsMap, ancestors[i], type, true, evt); + } + if (hasBubble) { + targetsMap = map[false]; + targetsMap.remaining_ = targetsMap.count_; + for (var i = 0;!evt.propagationStopped_ && (i < ancestors.length && targetsMap.remaining_);i++) { + evt.currentTarget = ancestors[i]; + retval &= goog.events.fireListeners_(targetsMap, ancestors[i], type, false, evt); + } + } + } else { + retval = goog.events.fireListener(listener, evt); + } + } finally { + if (ancestors) { + ancestors.length = 0; + } + } + return retval; + } + var be = new goog.events.BrowserEvent(opt_evt, (this)); + retval = goog.events.fireListener(listener, be); + return retval; +}; +goog.events.markIeEvent_ = function(e) { + var useReturnValue = false; + if (e.keyCode == 0) { + try { + e.keyCode = -1; + return; + } catch (ex) { + useReturnValue = true; + } + } + if (useReturnValue || (e.returnValue) == undefined) { + e.returnValue = true; + } +}; +goog.events.isMarkedIeEvent_ = function(e) { + return e.keyCode < 0 || e.returnValue != undefined; +}; +goog.events.uniqueIdCounter_ = 0; +goog.events.getUniqueId = function(identifier) { + return identifier + "_" + goog.events.uniqueIdCounter_++; +}; +goog.events.LISTENER_WRAPPER_PROP_ = "__closure_events_fn_" + (Math.random() * 1E9 >>> 0); +goog.events.wrapListener_ = function(listener) { + if (goog.isFunction(listener)) { + return listener; + } + return listener[goog.events.LISTENER_WRAPPER_PROP_] || (listener[goog.events.LISTENER_WRAPPER_PROP_] = function(e) { + return listener.handleEvent(e); + }); +}; +goog.debug.entryPointRegistry.register(function(transformer) { + goog.events.handleBrowserEvent_ = transformer(goog.events.handleBrowserEvent_); +}); +goog.provide("domina.support"); +goog.require("cljs.core"); +goog.require("goog.events"); +goog.require("goog.events"); +goog.require("goog.dom"); +goog.require("goog.dom"); +var div_6453 = document.createElement("div"); +var test_html_6454 = " \x3clink/\x3e\x3ctable\x3e\x3c/table\x3e\x3ca href\x3d'/a' style\x3d'top:1px;float:left;opacity:.55;'\x3ea\x3c/a\x3e\x3cinput type\x3d'checkbox'/\x3e"; +div_6453.innerHTML = test_html_6454; +domina.support.leading_whitespace_QMARK_ = cljs.core._EQ_.call(null, div_6453.firstChild.nodeType, 3); +domina.support.extraneous_tbody_QMARK_ = cljs.core._EQ_.call(null, div_6453.getElementsByTagName("tbody").length, 0); +domina.support.unscoped_html_elements_QMARK_ = cljs.core._EQ_.call(null, div_6453.getElementsByTagName("link").length, 0); +goog.provide("domina"); +goog.require("cljs.core"); +goog.require("goog.dom.classes"); +goog.require("domina.support"); +goog.require("goog.dom.classes"); +goog.require("cljs.core"); +goog.require("goog.events"); +goog.require("goog.string"); +goog.require("goog.dom.xml"); +goog.require("goog.dom"); +goog.require("goog.dom.forms"); +goog.require("goog.dom"); +goog.require("goog.string"); +goog.require("clojure.string"); +goog.require("goog.style"); +goog.require("clojure.string"); +goog.require("goog.dom.xml"); +goog.require("goog.style"); +goog.require("goog.dom.forms"); +goog.require("domina.support"); +goog.require("goog.events"); +goog.require("cljs.core"); +domina.re_html = /<|&#?\w+;/; +domina.re_leading_whitespace = /^\s+/; +domina.re_xhtml_tag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/i; +domina.re_tag_name = /<([\w:]+)/; +domina.re_no_inner_html = /<(?:script|style)/i; +domina.re_tbody = / 0) { + var G__6028 = wrapper.lastChild; + var G__6029 = level - 1; + wrapper = G__6028; + level = G__6029; + continue; + } else { + return wrapper; + } + break; + } + }(); + if (cljs.core.truth_(domina.support.extraneous_tbody_QMARK_)) { + domina.remove_extraneous_tbody_BANG_.call(null, div, html__$1, tag_name, start_wrap); + } else { + } + if (cljs.core.truth_(function() { + var and__3431__auto__ = cljs.core.not.call(null, domina.support.leading_whitespace_QMARK_); + if (and__3431__auto__) { + return cljs.core.re_find.call(null, domina.re_leading_whitespace, html__$1); + } else { + return and__3431__auto__; + } + }())) { + domina.restore_leading_whitespace_BANG_.call(null, div, html__$1); + } else { + } + return div.childNodes; +}; +domina.string_to_dom = function string_to_dom(s) { + if (cljs.core.truth_(cljs.core.re_find.call(null, domina.re_html, s))) { + return domina.html_to_dom.call(null, s); + } else { + return document.createTextNode(s); + } +}; +domina.DomContent = function() { + var obj6031 = {}; + return obj6031; +}(); +domina.nodes = function nodes(content) { + if (function() { + var and__3431__auto__ = content; + if (and__3431__auto__) { + return content.domina$DomContent$nodes$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return content.domina$DomContent$nodes$arity$1(content); + } else { + var x__4070__auto__ = content == null ? null : content; + return function() { + var or__3443__auto__ = domina.nodes[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.nodes["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "DomContent.nodes", content); + } + } + }().call(null, content); + } +}; +domina.single_node = function single_node(nodeseq) { + if (function() { + var and__3431__auto__ = nodeseq; + if (and__3431__auto__) { + return nodeseq.domina$DomContent$single_node$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return nodeseq.domina$DomContent$single_node$arity$1(nodeseq); + } else { + var x__4070__auto__ = nodeseq == null ? null : nodeseq; + return function() { + var or__3443__auto__ = domina.single_node[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.single_node["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "DomContent.single-node", nodeseq); + } + } + }().call(null, nodeseq); + } +}; +domina._STAR_debug_STAR_ = true; +domina.log_debug = function() { + var log_debug__delegate = function(mesg) { + if (cljs.core.truth_(function() { + var and__3431__auto__ = domina._STAR_debug_STAR_; + if (cljs.core.truth_(and__3431__auto__)) { + return!cljs.core._EQ_.call(null, window.console, undefined); + } else { + return and__3431__auto__; + } + }())) { + return console.log(cljs.core.apply.call(null, cljs.core.str, mesg)); + } else { + return null; + } + }; + var log_debug = function(var_args) { + var mesg = null; + if (arguments.length > 0) { + mesg = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return log_debug__delegate.call(this, mesg); + }; + log_debug.cljs$lang$maxFixedArity = 0; + log_debug.cljs$lang$applyTo = function(arglist__6032) { + var mesg = cljs.core.seq(arglist__6032); + return log_debug__delegate(mesg); + }; + log_debug.cljs$core$IFn$_invoke$arity$variadic = log_debug__delegate; + return log_debug; +}(); +domina.log = function() { + var log__delegate = function(mesg) { + if (cljs.core.truth_(window.console)) { + return console.log(cljs.core.apply.call(null, cljs.core.str, mesg)); + } else { + return null; + } + }; + var log = function(var_args) { + var mesg = null; + if (arguments.length > 0) { + mesg = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return log__delegate.call(this, mesg); + }; + log.cljs$lang$maxFixedArity = 0; + log.cljs$lang$applyTo = function(arglist__6033) { + var mesg = cljs.core.seq(arglist__6033); + return log__delegate(mesg); + }; + log.cljs$core$IFn$_invoke$arity$variadic = log__delegate; + return log; +}(); +domina.by_id = function by_id(id) { + return goog.dom.getElement(cljs.core.name.call(null, id)); +}; +domina.by_class = function by_class(class_name) { + return domina.normalize_seq.call(null, goog.dom.getElementsByClass(cljs.core.name.call(null, class_name))); +}; +domina.children = function children(content) { + return cljs.core.doall.call(null, cljs.core.mapcat.call(null, goog.dom.getChildren, domina.nodes.call(null, content))); +}; +domina.common_ancestor = function() { + var common_ancestor__delegate = function(contents) { + return cljs.core.apply.call(null, goog.dom.findCommonAncestor, cljs.core.map.call(null, domina.single_node, contents)); + }; + var common_ancestor = function(var_args) { + var contents = null; + if (arguments.length > 0) { + contents = cljs.core.array_seq(Array.prototype.slice.call(arguments, 0), 0); + } + return common_ancestor__delegate.call(this, contents); + }; + common_ancestor.cljs$lang$maxFixedArity = 0; + common_ancestor.cljs$lang$applyTo = function(arglist__6034) { + var contents = cljs.core.seq(arglist__6034); + return common_ancestor__delegate(contents); + }; + common_ancestor.cljs$core$IFn$_invoke$arity$variadic = common_ancestor__delegate; + return common_ancestor; +}(); +domina.ancestor_QMARK_ = function ancestor_QMARK_(ancestor_content, descendant_content) { + return cljs.core._EQ_.call(null, domina.common_ancestor.call(null, ancestor_content, descendant_content), domina.single_node.call(null, ancestor_content)); +}; +domina.clone = function clone(content) { + return cljs.core.map.call(null, function(p1__6035_SHARP_) { + return p1__6035_SHARP_.cloneNode(true); + }, domina.nodes.call(null, content)); +}; +domina.append_BANG_ = function append_BANG_(parent_content, child_content) { + domina.apply_with_cloning.call(null, goog.dom.appendChild, parent_content, child_content); + return parent_content; +}; +domina.insert_BANG_ = function insert_BANG_(parent_content, child_content, idx) { + domina.apply_with_cloning.call(null, function(p1__6036_SHARP_, p2__6037_SHARP_) { + return goog.dom.insertChildAt(p1__6036_SHARP_, p2__6037_SHARP_, idx); + }, parent_content, child_content); + return parent_content; +}; +domina.prepend_BANG_ = function prepend_BANG_(parent_content, child_content) { + domina.insert_BANG_.call(null, parent_content, child_content, 0); + return parent_content; +}; +domina.insert_before_BANG_ = function insert_before_BANG_(content, new_content) { + domina.apply_with_cloning.call(null, function(p1__6039_SHARP_, p2__6038_SHARP_) { + return goog.dom.insertSiblingBefore(p2__6038_SHARP_, p1__6039_SHARP_); + }, content, new_content); + return content; +}; +domina.insert_after_BANG_ = function insert_after_BANG_(content, new_content) { + domina.apply_with_cloning.call(null, function(p1__6041_SHARP_, p2__6040_SHARP_) { + return goog.dom.insertSiblingAfter(p2__6040_SHARP_, p1__6041_SHARP_); + }, content, new_content); + return content; +}; +domina.swap_content_BANG_ = function swap_content_BANG_(old_content, new_content) { + domina.apply_with_cloning.call(null, function(p1__6043_SHARP_, p2__6042_SHARP_) { + return goog.dom.replaceNode(p2__6042_SHARP_, p1__6043_SHARP_); + }, old_content, new_content); + return old_content; +}; +domina.detach_BANG_ = function detach_BANG_(content) { + return cljs.core.doall.call(null, cljs.core.map.call(null, goog.dom.removeNode, domina.nodes.call(null, content))); +}; +domina.destroy_BANG_ = function destroy_BANG_(content) { + return cljs.core.dorun.call(null, cljs.core.map.call(null, goog.dom.removeNode, domina.nodes.call(null, content))); +}; +domina.destroy_children_BANG_ = function destroy_children_BANG_(content) { + cljs.core.dorun.call(null, cljs.core.map.call(null, goog.dom.removeChildren, domina.nodes.call(null, content))); + return content; +}; +domina.style = function style(content, name) { + var s = goog.style.getStyle(domina.single_node.call(null, content), cljs.core.name.call(null, name)); + if (cljs.core.truth_(clojure.string.blank_QMARK_.call(null, s))) { + return null; + } else { + return s; + } +}; +domina.attr = function attr(content, name) { + return domina.single_node.call(null, content).getAttribute(cljs.core.name.call(null, name)); +}; +domina.set_style_BANG_ = function() { + var set_style_BANG___delegate = function(content, name, value) { + var seq__6048_6052 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6049_6053 = null; + var count__6050_6054 = 0; + var i__6051_6055 = 0; + while (true) { + if (i__6051_6055 < count__6050_6054) { + var n_6056 = cljs.core._nth.call(null, chunk__6049_6053, i__6051_6055); + goog.style.setStyle(n_6056, cljs.core.name.call(null, name), cljs.core.apply.call(null, cljs.core.str, value)); + var G__6057 = seq__6048_6052; + var G__6058 = chunk__6049_6053; + var G__6059 = count__6050_6054; + var G__6060 = i__6051_6055 + 1; + seq__6048_6052 = G__6057; + chunk__6049_6053 = G__6058; + count__6050_6054 = G__6059; + i__6051_6055 = G__6060; + continue; + } else { + var temp__4092__auto___6061 = cljs.core.seq.call(null, seq__6048_6052); + if (temp__4092__auto___6061) { + var seq__6048_6062__$1 = temp__4092__auto___6061; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6048_6062__$1)) { + var c__4191__auto___6063 = cljs.core.chunk_first.call(null, seq__6048_6062__$1); + var G__6064 = cljs.core.chunk_rest.call(null, seq__6048_6062__$1); + var G__6065 = c__4191__auto___6063; + var G__6066 = cljs.core.count.call(null, c__4191__auto___6063); + var G__6067 = 0; + seq__6048_6052 = G__6064; + chunk__6049_6053 = G__6065; + count__6050_6054 = G__6066; + i__6051_6055 = G__6067; + continue; + } else { + var n_6068 = cljs.core.first.call(null, seq__6048_6062__$1); + goog.style.setStyle(n_6068, cljs.core.name.call(null, name), cljs.core.apply.call(null, cljs.core.str, value)); + var G__6069 = cljs.core.next.call(null, seq__6048_6062__$1); + var G__6070 = null; + var G__6071 = 0; + var G__6072 = 0; + seq__6048_6052 = G__6069; + chunk__6049_6053 = G__6070; + count__6050_6054 = G__6071; + i__6051_6055 = G__6072; + continue; + } + } else { + } + } + break; + } + return content; + }; + var set_style_BANG_ = function(content, name, var_args) { + var value = null; + if (arguments.length > 2) { + value = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0); + } + return set_style_BANG___delegate.call(this, content, name, value); + }; + set_style_BANG_.cljs$lang$maxFixedArity = 2; + set_style_BANG_.cljs$lang$applyTo = function(arglist__6073) { + var content = cljs.core.first(arglist__6073); + arglist__6073 = cljs.core.next(arglist__6073); + var name = cljs.core.first(arglist__6073); + var value = cljs.core.rest(arglist__6073); + return set_style_BANG___delegate(content, name, value); + }; + set_style_BANG_.cljs$core$IFn$_invoke$arity$variadic = set_style_BANG___delegate; + return set_style_BANG_; +}(); +domina.set_attr_BANG_ = function() { + var set_attr_BANG___delegate = function(content, name, value) { + var seq__6078_6082 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6079_6083 = null; + var count__6080_6084 = 0; + var i__6081_6085 = 0; + while (true) { + if (i__6081_6085 < count__6080_6084) { + var n_6086 = cljs.core._nth.call(null, chunk__6079_6083, i__6081_6085); + n_6086.setAttribute(cljs.core.name.call(null, name), cljs.core.apply.call(null, cljs.core.str, value)); + var G__6087 = seq__6078_6082; + var G__6088 = chunk__6079_6083; + var G__6089 = count__6080_6084; + var G__6090 = i__6081_6085 + 1; + seq__6078_6082 = G__6087; + chunk__6079_6083 = G__6088; + count__6080_6084 = G__6089; + i__6081_6085 = G__6090; + continue; + } else { + var temp__4092__auto___6091 = cljs.core.seq.call(null, seq__6078_6082); + if (temp__4092__auto___6091) { + var seq__6078_6092__$1 = temp__4092__auto___6091; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6078_6092__$1)) { + var c__4191__auto___6093 = cljs.core.chunk_first.call(null, seq__6078_6092__$1); + var G__6094 = cljs.core.chunk_rest.call(null, seq__6078_6092__$1); + var G__6095 = c__4191__auto___6093; + var G__6096 = cljs.core.count.call(null, c__4191__auto___6093); + var G__6097 = 0; + seq__6078_6082 = G__6094; + chunk__6079_6083 = G__6095; + count__6080_6084 = G__6096; + i__6081_6085 = G__6097; + continue; + } else { + var n_6098 = cljs.core.first.call(null, seq__6078_6092__$1); + n_6098.setAttribute(cljs.core.name.call(null, name), cljs.core.apply.call(null, cljs.core.str, value)); + var G__6099 = cljs.core.next.call(null, seq__6078_6092__$1); + var G__6100 = null; + var G__6101 = 0; + var G__6102 = 0; + seq__6078_6082 = G__6099; + chunk__6079_6083 = G__6100; + count__6080_6084 = G__6101; + i__6081_6085 = G__6102; + continue; + } + } else { + } + } + break; + } + return content; + }; + var set_attr_BANG_ = function(content, name, var_args) { + var value = null; + if (arguments.length > 2) { + value = cljs.core.array_seq(Array.prototype.slice.call(arguments, 2), 0); + } + return set_attr_BANG___delegate.call(this, content, name, value); + }; + set_attr_BANG_.cljs$lang$maxFixedArity = 2; + set_attr_BANG_.cljs$lang$applyTo = function(arglist__6103) { + var content = cljs.core.first(arglist__6103); + arglist__6103 = cljs.core.next(arglist__6103); + var name = cljs.core.first(arglist__6103); + var value = cljs.core.rest(arglist__6103); + return set_attr_BANG___delegate(content, name, value); + }; + set_attr_BANG_.cljs$core$IFn$_invoke$arity$variadic = set_attr_BANG___delegate; + return set_attr_BANG_; +}(); +domina.remove_attr_BANG_ = function remove_attr_BANG_(content, name) { + var seq__6108_6112 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6109_6113 = null; + var count__6110_6114 = 0; + var i__6111_6115 = 0; + while (true) { + if (i__6111_6115 < count__6110_6114) { + var n_6116 = cljs.core._nth.call(null, chunk__6109_6113, i__6111_6115); + n_6116.removeAttribute(cljs.core.name.call(null, name)); + var G__6117 = seq__6108_6112; + var G__6118 = chunk__6109_6113; + var G__6119 = count__6110_6114; + var G__6120 = i__6111_6115 + 1; + seq__6108_6112 = G__6117; + chunk__6109_6113 = G__6118; + count__6110_6114 = G__6119; + i__6111_6115 = G__6120; + continue; + } else { + var temp__4092__auto___6121 = cljs.core.seq.call(null, seq__6108_6112); + if (temp__4092__auto___6121) { + var seq__6108_6122__$1 = temp__4092__auto___6121; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6108_6122__$1)) { + var c__4191__auto___6123 = cljs.core.chunk_first.call(null, seq__6108_6122__$1); + var G__6124 = cljs.core.chunk_rest.call(null, seq__6108_6122__$1); + var G__6125 = c__4191__auto___6123; + var G__6126 = cljs.core.count.call(null, c__4191__auto___6123); + var G__6127 = 0; + seq__6108_6112 = G__6124; + chunk__6109_6113 = G__6125; + count__6110_6114 = G__6126; + i__6111_6115 = G__6127; + continue; + } else { + var n_6128 = cljs.core.first.call(null, seq__6108_6122__$1); + n_6128.removeAttribute(cljs.core.name.call(null, name)); + var G__6129 = cljs.core.next.call(null, seq__6108_6122__$1); + var G__6130 = null; + var G__6131 = 0; + var G__6132 = 0; + seq__6108_6112 = G__6129; + chunk__6109_6113 = G__6130; + count__6110_6114 = G__6131; + i__6111_6115 = G__6132; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.parse_style_attributes = function parse_style_attributes(style) { + return cljs.core.reduce.call(null, function(acc, pair) { + var vec__6134 = pair.split(/\s*:\s*/); + var k = cljs.core.nth.call(null, vec__6134, 0, null); + var v = cljs.core.nth.call(null, vec__6134, 1, null); + if (cljs.core.truth_(function() { + var and__3431__auto__ = k; + if (cljs.core.truth_(and__3431__auto__)) { + return v; + } else { + return and__3431__auto__; + } + }())) { + return cljs.core.assoc.call(null, acc, cljs.core.keyword.call(null, k.toLowerCase()), v); + } else { + return acc; + } + }, cljs.core.PersistentArrayMap.EMPTY, style.split(/\s*;\s*/)); +}; +domina.styles = function styles(content) { + var style = domina.attr.call(null, content, "style"); + if (typeof style === "string") { + return domina.parse_style_attributes.call(null, style); + } else { + if (style == null) { + return cljs.core.PersistentArrayMap.EMPTY; + } else { + if (cljs.core.truth_(style.cssText)) { + return domina.parse_style_attributes.call(null, style.cssText); + } else { + if (new cljs.core.Keyword(null, "else", "else", 1017020587)) { + return cljs.core.PersistentArrayMap.EMPTY; + } else { + return null; + } + } + } + } +}; +domina.attrs = function attrs(content) { + var node = domina.single_node.call(null, content); + var attrs__$1 = node.attributes; + return cljs.core.reduce.call(null, cljs.core.conj, cljs.core.filter.call(null, cljs.core.complement.call(null, cljs.core.nil_QMARK_), cljs.core.map.call(null, function(p1__6135_SHARP_) { + var attr = attrs__$1.item(p1__6135_SHARP_); + var value = attr.nodeValue; + if (cljs.core.not_EQ_.call(null, null, value) && cljs.core.not_EQ_.call(null, "", value)) { + return new cljs.core.PersistentArrayMap.fromArray([cljs.core.keyword.call(null, attr.nodeName.toLowerCase()), attr.nodeValue], true, false); + } else { + return null; + } + }, cljs.core.range.call(null, attrs__$1.length)))); +}; +domina.set_styles_BANG_ = function set_styles_BANG_(content, styles) { + var seq__6142_6148 = cljs.core.seq.call(null, styles); + var chunk__6143_6149 = null; + var count__6144_6150 = 0; + var i__6145_6151 = 0; + while (true) { + if (i__6145_6151 < count__6144_6150) { + var vec__6146_6152 = cljs.core._nth.call(null, chunk__6143_6149, i__6145_6151); + var name_6153 = cljs.core.nth.call(null, vec__6146_6152, 0, null); + var value_6154 = cljs.core.nth.call(null, vec__6146_6152, 1, null); + domina.set_style_BANG_.call(null, content, name_6153, value_6154); + var G__6155 = seq__6142_6148; + var G__6156 = chunk__6143_6149; + var G__6157 = count__6144_6150; + var G__6158 = i__6145_6151 + 1; + seq__6142_6148 = G__6155; + chunk__6143_6149 = G__6156; + count__6144_6150 = G__6157; + i__6145_6151 = G__6158; + continue; + } else { + var temp__4092__auto___6159 = cljs.core.seq.call(null, seq__6142_6148); + if (temp__4092__auto___6159) { + var seq__6142_6160__$1 = temp__4092__auto___6159; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6142_6160__$1)) { + var c__4191__auto___6161 = cljs.core.chunk_first.call(null, seq__6142_6160__$1); + var G__6162 = cljs.core.chunk_rest.call(null, seq__6142_6160__$1); + var G__6163 = c__4191__auto___6161; + var G__6164 = cljs.core.count.call(null, c__4191__auto___6161); + var G__6165 = 0; + seq__6142_6148 = G__6162; + chunk__6143_6149 = G__6163; + count__6144_6150 = G__6164; + i__6145_6151 = G__6165; + continue; + } else { + var vec__6147_6166 = cljs.core.first.call(null, seq__6142_6160__$1); + var name_6167 = cljs.core.nth.call(null, vec__6147_6166, 0, null); + var value_6168 = cljs.core.nth.call(null, vec__6147_6166, 1, null); + domina.set_style_BANG_.call(null, content, name_6167, value_6168); + var G__6169 = cljs.core.next.call(null, seq__6142_6160__$1); + var G__6170 = null; + var G__6171 = 0; + var G__6172 = 0; + seq__6142_6148 = G__6169; + chunk__6143_6149 = G__6170; + count__6144_6150 = G__6171; + i__6145_6151 = G__6172; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.set_attrs_BANG_ = function set_attrs_BANG_(content, attrs) { + var seq__6179_6185 = cljs.core.seq.call(null, attrs); + var chunk__6180_6186 = null; + var count__6181_6187 = 0; + var i__6182_6188 = 0; + while (true) { + if (i__6182_6188 < count__6181_6187) { + var vec__6183_6189 = cljs.core._nth.call(null, chunk__6180_6186, i__6182_6188); + var name_6190 = cljs.core.nth.call(null, vec__6183_6189, 0, null); + var value_6191 = cljs.core.nth.call(null, vec__6183_6189, 1, null); + domina.set_attr_BANG_.call(null, content, name_6190, value_6191); + var G__6192 = seq__6179_6185; + var G__6193 = chunk__6180_6186; + var G__6194 = count__6181_6187; + var G__6195 = i__6182_6188 + 1; + seq__6179_6185 = G__6192; + chunk__6180_6186 = G__6193; + count__6181_6187 = G__6194; + i__6182_6188 = G__6195; + continue; + } else { + var temp__4092__auto___6196 = cljs.core.seq.call(null, seq__6179_6185); + if (temp__4092__auto___6196) { + var seq__6179_6197__$1 = temp__4092__auto___6196; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6179_6197__$1)) { + var c__4191__auto___6198 = cljs.core.chunk_first.call(null, seq__6179_6197__$1); + var G__6199 = cljs.core.chunk_rest.call(null, seq__6179_6197__$1); + var G__6200 = c__4191__auto___6198; + var G__6201 = cljs.core.count.call(null, c__4191__auto___6198); + var G__6202 = 0; + seq__6179_6185 = G__6199; + chunk__6180_6186 = G__6200; + count__6181_6187 = G__6201; + i__6182_6188 = G__6202; + continue; + } else { + var vec__6184_6203 = cljs.core.first.call(null, seq__6179_6197__$1); + var name_6204 = cljs.core.nth.call(null, vec__6184_6203, 0, null); + var value_6205 = cljs.core.nth.call(null, vec__6184_6203, 1, null); + domina.set_attr_BANG_.call(null, content, name_6204, value_6205); + var G__6206 = cljs.core.next.call(null, seq__6179_6197__$1); + var G__6207 = null; + var G__6208 = 0; + var G__6209 = 0; + seq__6179_6185 = G__6206; + chunk__6180_6186 = G__6207; + count__6181_6187 = G__6208; + i__6182_6188 = G__6209; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.has_class_QMARK_ = function has_class_QMARK_(content, class$) { + return goog.dom.classes.has(domina.single_node.call(null, content), class$); +}; +domina.add_class_BANG_ = function add_class_BANG_(content, class$) { + var seq__6214_6218 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6215_6219 = null; + var count__6216_6220 = 0; + var i__6217_6221 = 0; + while (true) { + if (i__6217_6221 < count__6216_6220) { + var node_6222 = cljs.core._nth.call(null, chunk__6215_6219, i__6217_6221); + goog.dom.classes.add(node_6222, class$); + var G__6223 = seq__6214_6218; + var G__6224 = chunk__6215_6219; + var G__6225 = count__6216_6220; + var G__6226 = i__6217_6221 + 1; + seq__6214_6218 = G__6223; + chunk__6215_6219 = G__6224; + count__6216_6220 = G__6225; + i__6217_6221 = G__6226; + continue; + } else { + var temp__4092__auto___6227 = cljs.core.seq.call(null, seq__6214_6218); + if (temp__4092__auto___6227) { + var seq__6214_6228__$1 = temp__4092__auto___6227; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6214_6228__$1)) { + var c__4191__auto___6229 = cljs.core.chunk_first.call(null, seq__6214_6228__$1); + var G__6230 = cljs.core.chunk_rest.call(null, seq__6214_6228__$1); + var G__6231 = c__4191__auto___6229; + var G__6232 = cljs.core.count.call(null, c__4191__auto___6229); + var G__6233 = 0; + seq__6214_6218 = G__6230; + chunk__6215_6219 = G__6231; + count__6216_6220 = G__6232; + i__6217_6221 = G__6233; + continue; + } else { + var node_6234 = cljs.core.first.call(null, seq__6214_6228__$1); + goog.dom.classes.add(node_6234, class$); + var G__6235 = cljs.core.next.call(null, seq__6214_6228__$1); + var G__6236 = null; + var G__6237 = 0; + var G__6238 = 0; + seq__6214_6218 = G__6235; + chunk__6215_6219 = G__6236; + count__6216_6220 = G__6237; + i__6217_6221 = G__6238; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.remove_class_BANG_ = function remove_class_BANG_(content, class$) { + var seq__6243_6247 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6244_6248 = null; + var count__6245_6249 = 0; + var i__6246_6250 = 0; + while (true) { + if (i__6246_6250 < count__6245_6249) { + var node_6251 = cljs.core._nth.call(null, chunk__6244_6248, i__6246_6250); + goog.dom.classes.remove(node_6251, class$); + var G__6252 = seq__6243_6247; + var G__6253 = chunk__6244_6248; + var G__6254 = count__6245_6249; + var G__6255 = i__6246_6250 + 1; + seq__6243_6247 = G__6252; + chunk__6244_6248 = G__6253; + count__6245_6249 = G__6254; + i__6246_6250 = G__6255; + continue; + } else { + var temp__4092__auto___6256 = cljs.core.seq.call(null, seq__6243_6247); + if (temp__4092__auto___6256) { + var seq__6243_6257__$1 = temp__4092__auto___6256; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6243_6257__$1)) { + var c__4191__auto___6258 = cljs.core.chunk_first.call(null, seq__6243_6257__$1); + var G__6259 = cljs.core.chunk_rest.call(null, seq__6243_6257__$1); + var G__6260 = c__4191__auto___6258; + var G__6261 = cljs.core.count.call(null, c__4191__auto___6258); + var G__6262 = 0; + seq__6243_6247 = G__6259; + chunk__6244_6248 = G__6260; + count__6245_6249 = G__6261; + i__6246_6250 = G__6262; + continue; + } else { + var node_6263 = cljs.core.first.call(null, seq__6243_6257__$1); + goog.dom.classes.remove(node_6263, class$); + var G__6264 = cljs.core.next.call(null, seq__6243_6257__$1); + var G__6265 = null; + var G__6266 = 0; + var G__6267 = 0; + seq__6243_6247 = G__6264; + chunk__6244_6248 = G__6265; + count__6245_6249 = G__6266; + i__6246_6250 = G__6267; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.toggle_class_BANG_ = function toggle_class_BANG_(content, class$) { + var seq__6272_6276 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6273_6277 = null; + var count__6274_6278 = 0; + var i__6275_6279 = 0; + while (true) { + if (i__6275_6279 < count__6274_6278) { + var node_6280 = cljs.core._nth.call(null, chunk__6273_6277, i__6275_6279); + goog.dom.classes.toggle(node_6280, class$); + var G__6281 = seq__6272_6276; + var G__6282 = chunk__6273_6277; + var G__6283 = count__6274_6278; + var G__6284 = i__6275_6279 + 1; + seq__6272_6276 = G__6281; + chunk__6273_6277 = G__6282; + count__6274_6278 = G__6283; + i__6275_6279 = G__6284; + continue; + } else { + var temp__4092__auto___6285 = cljs.core.seq.call(null, seq__6272_6276); + if (temp__4092__auto___6285) { + var seq__6272_6286__$1 = temp__4092__auto___6285; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6272_6286__$1)) { + var c__4191__auto___6287 = cljs.core.chunk_first.call(null, seq__6272_6286__$1); + var G__6288 = cljs.core.chunk_rest.call(null, seq__6272_6286__$1); + var G__6289 = c__4191__auto___6287; + var G__6290 = cljs.core.count.call(null, c__4191__auto___6287); + var G__6291 = 0; + seq__6272_6276 = G__6288; + chunk__6273_6277 = G__6289; + count__6274_6278 = G__6290; + i__6275_6279 = G__6291; + continue; + } else { + var node_6292 = cljs.core.first.call(null, seq__6272_6286__$1); + goog.dom.classes.toggle(node_6292, class$); + var G__6293 = cljs.core.next.call(null, seq__6272_6286__$1); + var G__6294 = null; + var G__6295 = 0; + var G__6296 = 0; + seq__6272_6276 = G__6293; + chunk__6273_6277 = G__6294; + count__6274_6278 = G__6295; + i__6275_6279 = G__6296; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.classes = function classes(content) { + return cljs.core.seq.call(null, goog.dom.classes.get(domina.single_node.call(null, content))); +}; +domina.set_classes_BANG_ = function set_classes_BANG_(content, classes) { + var classes_6305__$1 = cljs.core.coll_QMARK_.call(null, classes) ? clojure.string.join.call(null, " ", classes) : classes; + var seq__6301_6306 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6302_6307 = null; + var count__6303_6308 = 0; + var i__6304_6309 = 0; + while (true) { + if (i__6304_6309 < count__6303_6308) { + var node_6310 = cljs.core._nth.call(null, chunk__6302_6307, i__6304_6309); + goog.dom.classes.set(node_6310, classes_6305__$1); + var G__6311 = seq__6301_6306; + var G__6312 = chunk__6302_6307; + var G__6313 = count__6303_6308; + var G__6314 = i__6304_6309 + 1; + seq__6301_6306 = G__6311; + chunk__6302_6307 = G__6312; + count__6303_6308 = G__6313; + i__6304_6309 = G__6314; + continue; + } else { + var temp__4092__auto___6315 = cljs.core.seq.call(null, seq__6301_6306); + if (temp__4092__auto___6315) { + var seq__6301_6316__$1 = temp__4092__auto___6315; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6301_6316__$1)) { + var c__4191__auto___6317 = cljs.core.chunk_first.call(null, seq__6301_6316__$1); + var G__6318 = cljs.core.chunk_rest.call(null, seq__6301_6316__$1); + var G__6319 = c__4191__auto___6317; + var G__6320 = cljs.core.count.call(null, c__4191__auto___6317); + var G__6321 = 0; + seq__6301_6306 = G__6318; + chunk__6302_6307 = G__6319; + count__6303_6308 = G__6320; + i__6304_6309 = G__6321; + continue; + } else { + var node_6322 = cljs.core.first.call(null, seq__6301_6316__$1); + goog.dom.classes.set(node_6322, classes_6305__$1); + var G__6323 = cljs.core.next.call(null, seq__6301_6316__$1); + var G__6324 = null; + var G__6325 = 0; + var G__6326 = 0; + seq__6301_6306 = G__6323; + chunk__6302_6307 = G__6324; + count__6303_6308 = G__6325; + i__6304_6309 = G__6326; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.text = function text(content) { + return goog.string.trim(goog.dom.getTextContent(domina.single_node.call(null, content))); +}; +domina.set_text_BANG_ = function set_text_BANG_(content, value) { + var seq__6331_6335 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6332_6336 = null; + var count__6333_6337 = 0; + var i__6334_6338 = 0; + while (true) { + if (i__6334_6338 < count__6333_6337) { + var node_6339 = cljs.core._nth.call(null, chunk__6332_6336, i__6334_6338); + goog.dom.setTextContent(node_6339, value); + var G__6340 = seq__6331_6335; + var G__6341 = chunk__6332_6336; + var G__6342 = count__6333_6337; + var G__6343 = i__6334_6338 + 1; + seq__6331_6335 = G__6340; + chunk__6332_6336 = G__6341; + count__6333_6337 = G__6342; + i__6334_6338 = G__6343; + continue; + } else { + var temp__4092__auto___6344 = cljs.core.seq.call(null, seq__6331_6335); + if (temp__4092__auto___6344) { + var seq__6331_6345__$1 = temp__4092__auto___6344; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6331_6345__$1)) { + var c__4191__auto___6346 = cljs.core.chunk_first.call(null, seq__6331_6345__$1); + var G__6347 = cljs.core.chunk_rest.call(null, seq__6331_6345__$1); + var G__6348 = c__4191__auto___6346; + var G__6349 = cljs.core.count.call(null, c__4191__auto___6346); + var G__6350 = 0; + seq__6331_6335 = G__6347; + chunk__6332_6336 = G__6348; + count__6333_6337 = G__6349; + i__6334_6338 = G__6350; + continue; + } else { + var node_6351 = cljs.core.first.call(null, seq__6331_6345__$1); + goog.dom.setTextContent(node_6351, value); + var G__6352 = cljs.core.next.call(null, seq__6331_6345__$1); + var G__6353 = null; + var G__6354 = 0; + var G__6355 = 0; + seq__6331_6335 = G__6352; + chunk__6332_6336 = G__6353; + count__6333_6337 = G__6354; + i__6334_6338 = G__6355; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.value = function value(content) { + return goog.dom.forms.getValue(domina.single_node.call(null, content)); +}; +domina.set_value_BANG_ = function set_value_BANG_(content, value) { + var seq__6360_6364 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6361_6365 = null; + var count__6362_6366 = 0; + var i__6363_6367 = 0; + while (true) { + if (i__6363_6367 < count__6362_6366) { + var node_6368 = cljs.core._nth.call(null, chunk__6361_6365, i__6363_6367); + goog.dom.forms.setValue(node_6368, value); + var G__6369 = seq__6360_6364; + var G__6370 = chunk__6361_6365; + var G__6371 = count__6362_6366; + var G__6372 = i__6363_6367 + 1; + seq__6360_6364 = G__6369; + chunk__6361_6365 = G__6370; + count__6362_6366 = G__6371; + i__6363_6367 = G__6372; + continue; + } else { + var temp__4092__auto___6373 = cljs.core.seq.call(null, seq__6360_6364); + if (temp__4092__auto___6373) { + var seq__6360_6374__$1 = temp__4092__auto___6373; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6360_6374__$1)) { + var c__4191__auto___6375 = cljs.core.chunk_first.call(null, seq__6360_6374__$1); + var G__6376 = cljs.core.chunk_rest.call(null, seq__6360_6374__$1); + var G__6377 = c__4191__auto___6375; + var G__6378 = cljs.core.count.call(null, c__4191__auto___6375); + var G__6379 = 0; + seq__6360_6364 = G__6376; + chunk__6361_6365 = G__6377; + count__6362_6366 = G__6378; + i__6363_6367 = G__6379; + continue; + } else { + var node_6380 = cljs.core.first.call(null, seq__6360_6374__$1); + goog.dom.forms.setValue(node_6380, value); + var G__6381 = cljs.core.next.call(null, seq__6360_6374__$1); + var G__6382 = null; + var G__6383 = 0; + var G__6384 = 0; + seq__6360_6364 = G__6381; + chunk__6361_6365 = G__6382; + count__6362_6366 = G__6383; + i__6363_6367 = G__6384; + continue; + } + } else { + } + } + break; + } + return content; +}; +domina.html = function html(content) { + return domina.single_node.call(null, content).innerHTML; +}; +domina.replace_children_BANG_ = function replace_children_BANG_(content, inner_content) { + return domina.append_BANG_.call(null, domina.destroy_children_BANG_.call(null, content), inner_content); +}; +domina.set_inner_html_BANG_ = function set_inner_html_BANG_(content, html_string) { + var allows_inner_html_QMARK_ = cljs.core.not.call(null, cljs.core.re_find.call(null, domina.re_no_inner_html, html_string)); + var leading_whitespace_QMARK_ = cljs.core.re_find.call(null, domina.re_leading_whitespace, html_string); + var tag_name = [cljs.core.str(cljs.core.second.call(null, cljs.core.re_find.call(null, domina.re_tag_name, html_string)))].join("").toLowerCase(); + var special_tag_QMARK_ = cljs.core.contains_QMARK_.call(null, domina.wrap_map, tag_name); + if (cljs.core.truth_(function() { + var and__3431__auto__ = allows_inner_html_QMARK_; + if (and__3431__auto__) { + var and__3431__auto____$1 = function() { + var or__3443__auto__ = domina.support.leading_whitespace_QMARK_; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.not.call(null, leading_whitespace_QMARK_); + } + }(); + if (cljs.core.truth_(and__3431__auto____$1)) { + return!special_tag_QMARK_; + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } + }())) { + var value_6395 = clojure.string.replace.call(null, html_string, domina.re_xhtml_tag, "\x3c$1\x3e\x3c/$2\x3e"); + try { + var seq__6391_6396 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6392_6397 = null; + var count__6393_6398 = 0; + var i__6394_6399 = 0; + while (true) { + if (i__6394_6399 < count__6393_6398) { + var node_6400 = cljs.core._nth.call(null, chunk__6392_6397, i__6394_6399); + node_6400.innerHTML = value_6395; + var G__6401 = seq__6391_6396; + var G__6402 = chunk__6392_6397; + var G__6403 = count__6393_6398; + var G__6404 = i__6394_6399 + 1; + seq__6391_6396 = G__6401; + chunk__6392_6397 = G__6402; + count__6393_6398 = G__6403; + i__6394_6399 = G__6404; + continue; + } else { + var temp__4092__auto___6405 = cljs.core.seq.call(null, seq__6391_6396); + if (temp__4092__auto___6405) { + var seq__6391_6406__$1 = temp__4092__auto___6405; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6391_6406__$1)) { + var c__4191__auto___6407 = cljs.core.chunk_first.call(null, seq__6391_6406__$1); + var G__6408 = cljs.core.chunk_rest.call(null, seq__6391_6406__$1); + var G__6409 = c__4191__auto___6407; + var G__6410 = cljs.core.count.call(null, c__4191__auto___6407); + var G__6411 = 0; + seq__6391_6396 = G__6408; + chunk__6392_6397 = G__6409; + count__6393_6398 = G__6410; + i__6394_6399 = G__6411; + continue; + } else { + var node_6412 = cljs.core.first.call(null, seq__6391_6406__$1); + node_6412.innerHTML = value_6395; + var G__6413 = cljs.core.next.call(null, seq__6391_6406__$1); + var G__6414 = null; + var G__6415 = 0; + var G__6416 = 0; + seq__6391_6396 = G__6413; + chunk__6392_6397 = G__6414; + count__6393_6398 = G__6415; + i__6394_6399 = G__6416; + continue; + } + } else { + } + } + break; + } + } catch (e6390) { + if (e6390 instanceof Error) { + var e_6417 = e6390; + domina.replace_children_BANG_.call(null, content, value_6395); + } else { + if (new cljs.core.Keyword(null, "else", "else", 1017020587)) { + throw e6390; + } else { + } + } + } + } else { + domina.replace_children_BANG_.call(null, content, html_string); + } + return content; +}; +domina.set_html_BANG_ = function set_html_BANG_(content, inner_content) { + if (typeof inner_content === "string") { + return domina.set_inner_html_BANG_.call(null, content, inner_content); + } else { + return domina.replace_children_BANG_.call(null, content, inner_content); + } +}; +domina.get_data = function() { + var get_data = null; + var get_data__2 = function(node, key) { + return get_data.call(null, node, key, false); + }; + var get_data__3 = function(node, key, bubble) { + var m = domina.single_node.call(null, node).__domina_data; + var value = cljs.core.truth_(m) ? cljs.core.get.call(null, m, key) : null; + if (cljs.core.truth_(function() { + var and__3431__auto__ = bubble; + if (cljs.core.truth_(and__3431__auto__)) { + return value == null; + } else { + return and__3431__auto__; + } + }())) { + var temp__4092__auto__ = domina.single_node.call(null, node).parentNode; + if (cljs.core.truth_(temp__4092__auto__)) { + var parent = temp__4092__auto__; + return get_data.call(null, parent, key, true); + } else { + return null; + } + } else { + return value; + } + }; + get_data = function(node, key, bubble) { + switch(arguments.length) { + case 2: + return get_data__2.call(this, node, key); + case 3: + return get_data__3.call(this, node, key, bubble); + } + throw new Error("Invalid arity: " + arguments.length); + }; + get_data.cljs$core$IFn$_invoke$arity$2 = get_data__2; + get_data.cljs$core$IFn$_invoke$arity$3 = get_data__3; + return get_data; +}(); +domina.set_data_BANG_ = function set_data_BANG_(node, key, value) { + var m = function() { + var or__3443__auto__ = domina.single_node.call(null, node).__domina_data; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return cljs.core.PersistentArrayMap.EMPTY; + } + }(); + return domina.single_node.call(null, node).__domina_data = cljs.core.assoc.call(null, m, key, value); +}; +domina.apply_with_cloning = function apply_with_cloning(f, parent_content, child_content) { + var parents = domina.nodes.call(null, parent_content); + var children = domina.nodes.call(null, child_content); + var first_child = function() { + var frag = document.createDocumentFragment(); + var seq__6424_6428 = cljs.core.seq.call(null, children); + var chunk__6425_6429 = null; + var count__6426_6430 = 0; + var i__6427_6431 = 0; + while (true) { + if (i__6427_6431 < count__6426_6430) { + var child_6432 = cljs.core._nth.call(null, chunk__6425_6429, i__6427_6431); + frag.appendChild(child_6432); + var G__6433 = seq__6424_6428; + var G__6434 = chunk__6425_6429; + var G__6435 = count__6426_6430; + var G__6436 = i__6427_6431 + 1; + seq__6424_6428 = G__6433; + chunk__6425_6429 = G__6434; + count__6426_6430 = G__6435; + i__6427_6431 = G__6436; + continue; + } else { + var temp__4092__auto___6437 = cljs.core.seq.call(null, seq__6424_6428); + if (temp__4092__auto___6437) { + var seq__6424_6438__$1 = temp__4092__auto___6437; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6424_6438__$1)) { + var c__4191__auto___6439 = cljs.core.chunk_first.call(null, seq__6424_6438__$1); + var G__6440 = cljs.core.chunk_rest.call(null, seq__6424_6438__$1); + var G__6441 = c__4191__auto___6439; + var G__6442 = cljs.core.count.call(null, c__4191__auto___6439); + var G__6443 = 0; + seq__6424_6428 = G__6440; + chunk__6425_6429 = G__6441; + count__6426_6430 = G__6442; + i__6427_6431 = G__6443; + continue; + } else { + var child_6444 = cljs.core.first.call(null, seq__6424_6438__$1); + frag.appendChild(child_6444); + var G__6445 = cljs.core.next.call(null, seq__6424_6438__$1); + var G__6446 = null; + var G__6447 = 0; + var G__6448 = 0; + seq__6424_6428 = G__6445; + chunk__6425_6429 = G__6446; + count__6426_6430 = G__6447; + i__6427_6431 = G__6448; + continue; + } + } else { + } + } + break; + } + return frag; + }(); + var other_children = cljs.core.doall.call(null, cljs.core.repeatedly.call(null, cljs.core.count.call(null, parents) - 1, function(parents, children, first_child) { + return function() { + return first_child.cloneNode(true); + }; + }(parents, children, first_child))); + if (cljs.core.seq.call(null, parents)) { + f.call(null, cljs.core.first.call(null, parents), first_child); + return cljs.core.doall.call(null, cljs.core.map.call(null, function(p1__6418_SHARP_, p2__6419_SHARP_) { + return f.call(null, p1__6418_SHARP_, p2__6419_SHARP_); + }, cljs.core.rest.call(null, parents), other_children)); + } else { + return null; + } +}; +domina.lazy_nl_via_item = function() { + var lazy_nl_via_item = null; + var lazy_nl_via_item__1 = function(nl) { + return lazy_nl_via_item.call(null, nl, 0); + }; + var lazy_nl_via_item__2 = function(nl, n) { + if (n < nl.length) { + return new cljs.core.LazySeq(null, function() { + return cljs.core.cons.call(null, nl.item(n), lazy_nl_via_item.call(null, nl, n + 1)); + }, null, null); + } else { + return null; + } + }; + lazy_nl_via_item = function(nl, n) { + switch(arguments.length) { + case 1: + return lazy_nl_via_item__1.call(this, nl); + case 2: + return lazy_nl_via_item__2.call(this, nl, n); + } + throw new Error("Invalid arity: " + arguments.length); + }; + lazy_nl_via_item.cljs$core$IFn$_invoke$arity$1 = lazy_nl_via_item__1; + lazy_nl_via_item.cljs$core$IFn$_invoke$arity$2 = lazy_nl_via_item__2; + return lazy_nl_via_item; +}(); +domina.lazy_nl_via_array_ref = function() { + var lazy_nl_via_array_ref = null; + var lazy_nl_via_array_ref__1 = function(nl) { + return lazy_nl_via_array_ref.call(null, nl, 0); + }; + var lazy_nl_via_array_ref__2 = function(nl, n) { + if (n < nl.length) { + return new cljs.core.LazySeq(null, function() { + return cljs.core.cons.call(null, nl[n], lazy_nl_via_array_ref.call(null, nl, n + 1)); + }, null, null); + } else { + return null; + } + }; + lazy_nl_via_array_ref = function(nl, n) { + switch(arguments.length) { + case 1: + return lazy_nl_via_array_ref__1.call(this, nl); + case 2: + return lazy_nl_via_array_ref__2.call(this, nl, n); + } + throw new Error("Invalid arity: " + arguments.length); + }; + lazy_nl_via_array_ref.cljs$core$IFn$_invoke$arity$1 = lazy_nl_via_array_ref__1; + lazy_nl_via_array_ref.cljs$core$IFn$_invoke$arity$2 = lazy_nl_via_array_ref__2; + return lazy_nl_via_array_ref; +}(); +domina.lazy_nodelist = function lazy_nodelist(nl) { + if (cljs.core.truth_(nl.item)) { + return domina.lazy_nl_via_item.call(null, nl); + } else { + return domina.lazy_nl_via_array_ref.call(null, nl); + } +}; +domina.array_like_QMARK_ = function array_like_QMARK_(obj) { + var and__3431__auto__ = obj; + if (cljs.core.truth_(and__3431__auto__)) { + var and__3431__auto____$1 = cljs.core.not.call(null, obj.nodeName); + if (and__3431__auto____$1) { + return obj.length; + } else { + return and__3431__auto____$1; + } + } else { + return and__3431__auto__; + } +}; +domina.normalize_seq = function normalize_seq(list_thing) { + if (list_thing == null) { + return cljs.core.List.EMPTY; + } else { + if (function() { + var G__6450 = list_thing; + if (G__6450) { + var bit__4093__auto__ = G__6450.cljs$lang$protocol_mask$partition0$ & 8388608; + if (bit__4093__auto__ || G__6450.cljs$core$ISeqable$) { + return true; + } else { + if (!G__6450.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__6450); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__6450); + } + }()) { + return cljs.core.seq.call(null, list_thing); + } else { + if (cljs.core.truth_(domina.array_like_QMARK_.call(null, list_thing))) { + return domina.lazy_nodelist.call(null, list_thing); + } else { + if (new cljs.core.Keyword(null, "default", "default", 2558708147)) { + return cljs.core.seq.call(null, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [list_thing], null)); + } else { + return null; + } + } + } + } +}; +domina.DomContent["_"] = true; +domina.nodes["_"] = function(content) { + if (content == null) { + return cljs.core.List.EMPTY; + } else { + if (function() { + var G__6451 = content; + if (G__6451) { + var bit__4093__auto__ = G__6451.cljs$lang$protocol_mask$partition0$ & 8388608; + if (bit__4093__auto__ || G__6451.cljs$core$ISeqable$) { + return true; + } else { + if (!G__6451.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__6451); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__6451); + } + }()) { + return cljs.core.seq.call(null, content); + } else { + if (cljs.core.truth_(domina.array_like_QMARK_.call(null, content))) { + return domina.lazy_nodelist.call(null, content); + } else { + if (new cljs.core.Keyword(null, "default", "default", 2558708147)) { + return cljs.core.seq.call(null, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [content], null)); + } else { + return null; + } + } + } + } +}; +domina.single_node["_"] = function(content) { + if (content == null) { + return null; + } else { + if (function() { + var G__6452 = content; + if (G__6452) { + var bit__4093__auto__ = G__6452.cljs$lang$protocol_mask$partition0$ & 8388608; + if (bit__4093__auto__ || G__6452.cljs$core$ISeqable$) { + return true; + } else { + if (!G__6452.cljs$lang$protocol_mask$partition0$) { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__6452); + } else { + return false; + } + } + } else { + return cljs.core.native_satisfies_QMARK_.call(null, cljs.core.ISeqable, G__6452); + } + }()) { + return cljs.core.first.call(null, content); + } else { + if (cljs.core.truth_(domina.array_like_QMARK_.call(null, content))) { + return content.item(0); + } else { + if (new cljs.core.Keyword(null, "default", "default", 2558708147)) { + return content; + } else { + return null; + } + } + } + } +}; +domina.DomContent["string"] = true; +domina.nodes["string"] = function(s) { + return cljs.core.doall.call(null, domina.nodes.call(null, domina.string_to_dom.call(null, s))); +}; +domina.single_node["string"] = function(s) { + return domina.single_node.call(null, domina.string_to_dom.call(null, s)); +}; +if (cljs.core.truth_(typeof NodeList != "undefined")) { + NodeList.prototype.cljs$core$ISeqable$ = true; + NodeList.prototype.cljs$core$ISeqable$_seq$arity$1 = function(nodelist) { + var nodelist__$1 = this; + return domina.lazy_nodelist.call(null, nodelist__$1); + }; + NodeList.prototype.cljs$core$IIndexed$ = true; + NodeList.prototype.cljs$core$IIndexed$_nth$arity$2 = function(nodelist, n) { + var nodelist__$1 = this; + return nodelist__$1.item(n); + }; + NodeList.prototype.cljs$core$IIndexed$_nth$arity$3 = function(nodelist, n, not_found) { + var nodelist__$1 = this; + if (nodelist__$1.length <= n) { + return not_found; + } else { + return cljs.core.nth.call(null, nodelist__$1, n); + } + }; + NodeList.prototype.cljs$core$ICounted$ = true; + NodeList.prototype.cljs$core$ICounted$_count$arity$1 = function(nodelist) { + var nodelist__$1 = this; + return nodelist__$1.length; + }; +} else { +} +if (cljs.core.truth_(typeof StaticNodeList != "undefined")) { + StaticNodeList.prototype.cljs$core$ISeqable$ = true; + StaticNodeList.prototype.cljs$core$ISeqable$_seq$arity$1 = function(nodelist) { + var nodelist__$1 = this; + return domina.lazy_nodelist.call(null, nodelist__$1); + }; + StaticNodeList.prototype.cljs$core$IIndexed$ = true; + StaticNodeList.prototype.cljs$core$IIndexed$_nth$arity$2 = function(nodelist, n) { + var nodelist__$1 = this; + return nodelist__$1.item(n); + }; + StaticNodeList.prototype.cljs$core$IIndexed$_nth$arity$3 = function(nodelist, n, not_found) { + var nodelist__$1 = this; + if (nodelist__$1.length <= n) { + return not_found; + } else { + return cljs.core.nth.call(null, nodelist__$1, n); + } + }; + StaticNodeList.prototype.cljs$core$ICounted$ = true; + StaticNodeList.prototype.cljs$core$ICounted$_count$arity$1 = function(nodelist) { + var nodelist__$1 = this; + return nodelist__$1.length; + }; +} else { +} +if (cljs.core.truth_(typeof HTMLCollection != "undefined")) { + HTMLCollection.prototype.cljs$core$ISeqable$ = true; + HTMLCollection.prototype.cljs$core$ISeqable$_seq$arity$1 = function(coll) { + var coll__$1 = this; + return domina.lazy_nodelist.call(null, coll__$1); + }; + HTMLCollection.prototype.cljs$core$IIndexed$ = true; + HTMLCollection.prototype.cljs$core$IIndexed$_nth$arity$2 = function(coll, n) { + var coll__$1 = this; + return coll__$1.item(n); + }; + HTMLCollection.prototype.cljs$core$IIndexed$_nth$arity$3 = function(coll, n, not_found) { + var coll__$1 = this; + if (coll__$1.length <= n) { + return not_found; + } else { + return cljs.core.nth.call(null, coll__$1, n); + } + }; + HTMLCollection.prototype.cljs$core$ICounted$ = true; + HTMLCollection.prototype.cljs$core$ICounted$_count$arity$1 = function(coll) { + var coll__$1 = this; + return coll__$1.length; + }; +} else { +} +;goog.provide("domina.events"); +goog.require("cljs.core"); +goog.require("goog.events"); +goog.require("goog.events"); +goog.require("goog.object"); +goog.require("goog.object"); +goog.require("domina"); +domina.events.Event = function() { + var obj6190 = {}; + return obj6190; +}(); +domina.events.prevent_default = function prevent_default(evt) { + if (function() { + var and__3431__auto__ = evt; + if (and__3431__auto__) { + return evt.domina$events$Event$prevent_default$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return evt.domina$events$Event$prevent_default$arity$1(evt); + } else { + var x__4070__auto__ = evt == null ? null : evt; + return function() { + var or__3443__auto__ = domina.events.prevent_default[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.events.prevent_default["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "Event.prevent-default", evt); + } + } + }().call(null, evt); + } +}; +domina.events.stop_propagation = function stop_propagation(evt) { + if (function() { + var and__3431__auto__ = evt; + if (and__3431__auto__) { + return evt.domina$events$Event$stop_propagation$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return evt.domina$events$Event$stop_propagation$arity$1(evt); + } else { + var x__4070__auto__ = evt == null ? null : evt; + return function() { + var or__3443__auto__ = domina.events.stop_propagation[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.events.stop_propagation["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "Event.stop-propagation", evt); + } + } + }().call(null, evt); + } +}; +domina.events.target = function target(evt) { + if (function() { + var and__3431__auto__ = evt; + if (and__3431__auto__) { + return evt.domina$events$Event$target$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return evt.domina$events$Event$target$arity$1(evt); + } else { + var x__4070__auto__ = evt == null ? null : evt; + return function() { + var or__3443__auto__ = domina.events.target[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.events.target["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "Event.target", evt); + } + } + }().call(null, evt); + } +}; +domina.events.current_target = function current_target(evt) { + if (function() { + var and__3431__auto__ = evt; + if (and__3431__auto__) { + return evt.domina$events$Event$current_target$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return evt.domina$events$Event$current_target$arity$1(evt); + } else { + var x__4070__auto__ = evt == null ? null : evt; + return function() { + var or__3443__auto__ = domina.events.current_target[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.events.current_target["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "Event.current-target", evt); + } + } + }().call(null, evt); + } +}; +domina.events.event_type = function event_type(evt) { + if (function() { + var and__3431__auto__ = evt; + if (and__3431__auto__) { + return evt.domina$events$Event$event_type$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return evt.domina$events$Event$event_type$arity$1(evt); + } else { + var x__4070__auto__ = evt == null ? null : evt; + return function() { + var or__3443__auto__ = domina.events.event_type[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.events.event_type["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "Event.event-type", evt); + } + } + }().call(null, evt); + } +}; +domina.events.raw_event = function raw_event(evt) { + if (function() { + var and__3431__auto__ = evt; + if (and__3431__auto__) { + return evt.domina$events$Event$raw_event$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return evt.domina$events$Event$raw_event$arity$1(evt); + } else { + var x__4070__auto__ = evt == null ? null : evt; + return function() { + var or__3443__auto__ = domina.events.raw_event[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = domina.events.raw_event["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "Event.raw-event", evt); + } + } + }().call(null, evt); + } +}; +domina.events.root_element = window.document.documentElement; +domina.events.create_listener_function = function create_listener_function(f) { + return function(evt) { + f.call(null, function() { + if (typeof domina.events.t6194 !== "undefined") { + } else { + domina.events.t6194 = function(evt, f, create_listener_function, meta6195) { + this.evt = evt; + this.f = f; + this.create_listener_function = create_listener_function; + this.meta6195 = meta6195; + this.cljs$lang$protocol_mask$partition1$ = 0; + this.cljs$lang$protocol_mask$partition0$ = 393472; + }; + domina.events.t6194.cljs$lang$type = true; + domina.events.t6194.cljs$lang$ctorStr = "domina.events/t6194"; + domina.events.t6194.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__auto__, "domina.events/t6194"); + }; + domina.events.t6194.prototype.cljs$core$ILookup$_lookup$arity$2 = function(o, k) { + var self__ = this; + var o__$1 = this; + var temp__4090__auto__ = self__.evt[k]; + if (cljs.core.truth_(temp__4090__auto__)) { + var val = temp__4090__auto__; + return val; + } else { + return self__.evt[cljs.core.name.call(null, k)]; + } + }; + domina.events.t6194.prototype.cljs$core$ILookup$_lookup$arity$3 = function(o, k, not_found) { + var self__ = this; + var o__$1 = this; + var or__3443__auto__ = cljs.core._lookup.call(null, o__$1, k); + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return not_found; + } + }; + domina.events.t6194.prototype.domina$events$Event$ = true; + domina.events.t6194.prototype.domina$events$Event$prevent_default$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return self__.evt.preventDefault(); + }; + domina.events.t6194.prototype.domina$events$Event$stop_propagation$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return self__.evt.stopPropagation(); + }; + domina.events.t6194.prototype.domina$events$Event$target$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return self__.evt.target; + }; + domina.events.t6194.prototype.domina$events$Event$current_target$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return self__.evt.currentTarget; + }; + domina.events.t6194.prototype.domina$events$Event$event_type$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return self__.evt.type; + }; + domina.events.t6194.prototype.domina$events$Event$raw_event$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return self__.evt; + }; + domina.events.t6194.prototype.cljs$core$IMeta$_meta$arity$1 = function(_6196) { + var self__ = this; + var _6196__$1 = this; + return self__.meta6195; + }; + domina.events.t6194.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_6196, meta6195__$1) { + var self__ = this; + var _6196__$1 = this; + return new domina.events.t6194(self__.evt, self__.f, self__.create_listener_function, meta6195__$1); + }; + domina.events.__GT_t6194 = function __GT_t6194(evt__$1, f__$1, create_listener_function__$1, meta6195) { + return new domina.events.t6194(evt__$1, f__$1, create_listener_function__$1, meta6195); + }; + } + return new domina.events.t6194(evt, f, create_listener_function, null); + }()); + return true; + }; +}; +domina.events.listen_internal_BANG_ = function listen_internal_BANG_(content, type, listener, capture, once) { + var f = domina.events.create_listener_function.call(null, listener); + var t = cljs.core.name.call(null, type); + return cljs.core.doall.call(null, function() { + var iter__4160__auto__ = function iter__6201(s__6202) { + return new cljs.core.LazySeq(null, function() { + var s__6202__$1 = s__6202; + while (true) { + var temp__4092__auto__ = cljs.core.seq.call(null, s__6202__$1); + if (temp__4092__auto__) { + var s__6202__$2 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, s__6202__$2)) { + var c__4158__auto__ = cljs.core.chunk_first.call(null, s__6202__$2); + var size__4159__auto__ = cljs.core.count.call(null, c__4158__auto__); + var b__6204 = cljs.core.chunk_buffer.call(null, size__4159__auto__); + if (function() { + var i__6203 = 0; + while (true) { + if (i__6203 < size__4159__auto__) { + var node = cljs.core._nth.call(null, c__4158__auto__, i__6203); + cljs.core.chunk_append.call(null, b__6204, cljs.core.truth_(once) ? goog.events.listenOnce(node, t, f, capture) : goog.events.listen(node, t, f, capture)); + var G__6205 = i__6203 + 1; + i__6203 = G__6205; + continue; + } else { + return true; + } + break; + } + }()) { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__6204), iter__6201.call(null, cljs.core.chunk_rest.call(null, s__6202__$2))); + } else { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__6204), null); + } + } else { + var node = cljs.core.first.call(null, s__6202__$2); + return cljs.core.cons.call(null, cljs.core.truth_(once) ? goog.events.listenOnce(node, t, f, capture) : goog.events.listen(node, t, f, capture), iter__6201.call(null, cljs.core.rest.call(null, s__6202__$2))); + } + } else { + return null; + } + break; + } + }, null, null); + }; + return iter__4160__auto__.call(null, domina.nodes.call(null, content)); + }()); +}; +domina.events.listen_BANG_ = function() { + var listen_BANG_ = null; + var listen_BANG___2 = function(type, listener) { + return listen_BANG_.call(null, domina.events.root_element, type, listener); + }; + var listen_BANG___3 = function(content, type, listener) { + return domina.events.listen_internal_BANG_.call(null, content, type, listener, false, false); + }; + listen_BANG_ = function(content, type, listener) { + switch(arguments.length) { + case 2: + return listen_BANG___2.call(this, content, type); + case 3: + return listen_BANG___3.call(this, content, type, listener); + } + throw new Error("Invalid arity: " + arguments.length); + }; + listen_BANG_.cljs$core$IFn$_invoke$arity$2 = listen_BANG___2; + listen_BANG_.cljs$core$IFn$_invoke$arity$3 = listen_BANG___3; + return listen_BANG_; +}(); +domina.events.capture_BANG_ = function() { + var capture_BANG_ = null; + var capture_BANG___2 = function(type, listener) { + return capture_BANG_.call(null, domina.events.root_element, type, listener); + }; + var capture_BANG___3 = function(content, type, listener) { + return domina.events.listen_internal_BANG_.call(null, content, type, listener, true, false); + }; + capture_BANG_ = function(content, type, listener) { + switch(arguments.length) { + case 2: + return capture_BANG___2.call(this, content, type); + case 3: + return capture_BANG___3.call(this, content, type, listener); + } + throw new Error("Invalid arity: " + arguments.length); + }; + capture_BANG_.cljs$core$IFn$_invoke$arity$2 = capture_BANG___2; + capture_BANG_.cljs$core$IFn$_invoke$arity$3 = capture_BANG___3; + return capture_BANG_; +}(); +domina.events.listen_once_BANG_ = function() { + var listen_once_BANG_ = null; + var listen_once_BANG___2 = function(type, listener) { + return listen_once_BANG_.call(null, domina.events.root_element, type, listener); + }; + var listen_once_BANG___3 = function(content, type, listener) { + return domina.events.listen_internal_BANG_.call(null, content, type, listener, false, true); + }; + listen_once_BANG_ = function(content, type, listener) { + switch(arguments.length) { + case 2: + return listen_once_BANG___2.call(this, content, type); + case 3: + return listen_once_BANG___3.call(this, content, type, listener); + } + throw new Error("Invalid arity: " + arguments.length); + }; + listen_once_BANG_.cljs$core$IFn$_invoke$arity$2 = listen_once_BANG___2; + listen_once_BANG_.cljs$core$IFn$_invoke$arity$3 = listen_once_BANG___3; + return listen_once_BANG_; +}(); +domina.events.capture_once_BANG_ = function() { + var capture_once_BANG_ = null; + var capture_once_BANG___2 = function(type, listener) { + return capture_once_BANG_.call(null, domina.events.root_element, type, listener); + }; + var capture_once_BANG___3 = function(content, type, listener) { + return domina.events.listen_internal_BANG_.call(null, content, type, listener, true, true); + }; + capture_once_BANG_ = function(content, type, listener) { + switch(arguments.length) { + case 2: + return capture_once_BANG___2.call(this, content, type); + case 3: + return capture_once_BANG___3.call(this, content, type, listener); + } + throw new Error("Invalid arity: " + arguments.length); + }; + capture_once_BANG_.cljs$core$IFn$_invoke$arity$2 = capture_once_BANG___2; + capture_once_BANG_.cljs$core$IFn$_invoke$arity$3 = capture_once_BANG___3; + return capture_once_BANG_; +}(); +domina.events.unlisten_BANG_ = function() { + var unlisten_BANG_ = null; + var unlisten_BANG___0 = function() { + return unlisten_BANG_.call(null, domina.events.root_element); + }; + var unlisten_BANG___1 = function(content) { + var seq__6214 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6215 = null; + var count__6216 = 0; + var i__6217 = 0; + while (true) { + if (i__6217 < count__6216) { + var node = cljs.core._nth.call(null, chunk__6215, i__6217); + goog.events.removeAll(node); + var G__6222 = seq__6214; + var G__6223 = chunk__6215; + var G__6224 = count__6216; + var G__6225 = i__6217 + 1; + seq__6214 = G__6222; + chunk__6215 = G__6223; + count__6216 = G__6224; + i__6217 = G__6225; + continue; + } else { + var temp__4092__auto__ = cljs.core.seq.call(null, seq__6214); + if (temp__4092__auto__) { + var seq__6214__$1 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6214__$1)) { + var c__4191__auto__ = cljs.core.chunk_first.call(null, seq__6214__$1); + var G__6226 = cljs.core.chunk_rest.call(null, seq__6214__$1); + var G__6227 = c__4191__auto__; + var G__6228 = cljs.core.count.call(null, c__4191__auto__); + var G__6229 = 0; + seq__6214 = G__6226; + chunk__6215 = G__6227; + count__6216 = G__6228; + i__6217 = G__6229; + continue; + } else { + var node = cljs.core.first.call(null, seq__6214__$1); + goog.events.removeAll(node); + var G__6230 = cljs.core.next.call(null, seq__6214__$1); + var G__6231 = null; + var G__6232 = 0; + var G__6233 = 0; + seq__6214 = G__6230; + chunk__6215 = G__6231; + count__6216 = G__6232; + i__6217 = G__6233; + continue; + } + } else { + return null; + } + } + break; + } + }; + var unlisten_BANG___2 = function(content, type) { + var type__$1 = cljs.core.name.call(null, type); + var seq__6218 = cljs.core.seq.call(null, domina.nodes.call(null, content)); + var chunk__6219 = null; + var count__6220 = 0; + var i__6221 = 0; + while (true) { + if (i__6221 < count__6220) { + var node = cljs.core._nth.call(null, chunk__6219, i__6221); + goog.events.removeAll(node, type__$1); + var G__6234 = seq__6218; + var G__6235 = chunk__6219; + var G__6236 = count__6220; + var G__6237 = i__6221 + 1; + seq__6218 = G__6234; + chunk__6219 = G__6235; + count__6220 = G__6236; + i__6221 = G__6237; + continue; + } else { + var temp__4092__auto__ = cljs.core.seq.call(null, seq__6218); + if (temp__4092__auto__) { + var seq__6218__$1 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6218__$1)) { + var c__4191__auto__ = cljs.core.chunk_first.call(null, seq__6218__$1); + var G__6238 = cljs.core.chunk_rest.call(null, seq__6218__$1); + var G__6239 = c__4191__auto__; + var G__6240 = cljs.core.count.call(null, c__4191__auto__); + var G__6241 = 0; + seq__6218 = G__6238; + chunk__6219 = G__6239; + count__6220 = G__6240; + i__6221 = G__6241; + continue; + } else { + var node = cljs.core.first.call(null, seq__6218__$1); + goog.events.removeAll(node, type__$1); + var G__6242 = cljs.core.next.call(null, seq__6218__$1); + var G__6243 = null; + var G__6244 = 0; + var G__6245 = 0; + seq__6218 = G__6242; + chunk__6219 = G__6243; + count__6220 = G__6244; + i__6221 = G__6245; + continue; + } + } else { + return null; + } + } + break; + } + }; + unlisten_BANG_ = function(content, type) { + switch(arguments.length) { + case 0: + return unlisten_BANG___0.call(this); + case 1: + return unlisten_BANG___1.call(this, content); + case 2: + return unlisten_BANG___2.call(this, content, type); + } + throw new Error("Invalid arity: " + arguments.length); + }; + unlisten_BANG_.cljs$core$IFn$_invoke$arity$0 = unlisten_BANG___0; + unlisten_BANG_.cljs$core$IFn$_invoke$arity$1 = unlisten_BANG___1; + unlisten_BANG_.cljs$core$IFn$_invoke$arity$2 = unlisten_BANG___2; + return unlisten_BANG_; +}(); +domina.events.ancestor_nodes = function() { + var ancestor_nodes = null; + var ancestor_nodes__1 = function(n) { + return ancestor_nodes.call(null, n, new cljs.core.PersistentVector(null, 1, 5, cljs.core.PersistentVector.EMPTY_NODE, [n], null)); + }; + var ancestor_nodes__2 = function(n, so_far) { + while (true) { + var temp__4090__auto__ = n.parentNode; + if (cljs.core.truth_(temp__4090__auto__)) { + var parent = temp__4090__auto__; + var G__6246 = parent; + var G__6247 = cljs.core.cons.call(null, parent, so_far); + n = G__6246; + so_far = G__6247; + continue; + } else { + return so_far; + } + break; + } + }; + ancestor_nodes = function(n, so_far) { + switch(arguments.length) { + case 1: + return ancestor_nodes__1.call(this, n); + case 2: + return ancestor_nodes__2.call(this, n, so_far); + } + throw new Error("Invalid arity: " + arguments.length); + }; + ancestor_nodes.cljs$core$IFn$_invoke$arity$1 = ancestor_nodes__1; + ancestor_nodes.cljs$core$IFn$_invoke$arity$2 = ancestor_nodes__2; + return ancestor_nodes; +}(); +domina.events.dispatch_browser_BANG_ = function dispatch_browser_BANG_(source, evt) { + evt.target = domina.single_node.call(null, source); + var ancestors = domina.events.ancestor_nodes.call(null, domina.single_node.call(null, source)); + var seq__6256_6264 = cljs.core.seq.call(null, ancestors); + var chunk__6257_6265 = null; + var count__6258_6266 = 0; + var i__6259_6267 = 0; + while (true) { + if (i__6259_6267 < count__6258_6266) { + var n_6268 = cljs.core._nth.call(null, chunk__6257_6265, i__6259_6267); + if (cljs.core.truth_(evt.propagationStopped_)) { + } else { + evt.currentTarget = n_6268; + goog.events.fireListeners(n_6268, evt.type, true, evt); + } + var G__6269 = seq__6256_6264; + var G__6270 = chunk__6257_6265; + var G__6271 = count__6258_6266; + var G__6272 = i__6259_6267 + 1; + seq__6256_6264 = G__6269; + chunk__6257_6265 = G__6270; + count__6258_6266 = G__6271; + i__6259_6267 = G__6272; + continue; + } else { + var temp__4092__auto___6273 = cljs.core.seq.call(null, seq__6256_6264); + if (temp__4092__auto___6273) { + var seq__6256_6274__$1 = temp__4092__auto___6273; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6256_6274__$1)) { + var c__4191__auto___6275 = cljs.core.chunk_first.call(null, seq__6256_6274__$1); + var G__6276 = cljs.core.chunk_rest.call(null, seq__6256_6274__$1); + var G__6277 = c__4191__auto___6275; + var G__6278 = cljs.core.count.call(null, c__4191__auto___6275); + var G__6279 = 0; + seq__6256_6264 = G__6276; + chunk__6257_6265 = G__6277; + count__6258_6266 = G__6278; + i__6259_6267 = G__6279; + continue; + } else { + var n_6280 = cljs.core.first.call(null, seq__6256_6274__$1); + if (cljs.core.truth_(evt.propagationStopped_)) { + } else { + evt.currentTarget = n_6280; + goog.events.fireListeners(n_6280, evt.type, true, evt); + } + var G__6281 = cljs.core.next.call(null, seq__6256_6274__$1); + var G__6282 = null; + var G__6283 = 0; + var G__6284 = 0; + seq__6256_6264 = G__6281; + chunk__6257_6265 = G__6282; + count__6258_6266 = G__6283; + i__6259_6267 = G__6284; + continue; + } + } else { + } + } + break; + } + var seq__6260_6285 = cljs.core.seq.call(null, cljs.core.reverse.call(null, ancestors)); + var chunk__6261_6286 = null; + var count__6262_6287 = 0; + var i__6263_6288 = 0; + while (true) { + if (i__6263_6288 < count__6262_6287) { + var n_6289 = cljs.core._nth.call(null, chunk__6261_6286, i__6263_6288); + if (cljs.core.truth_(evt.propagationStopped_)) { + } else { + evt.currentTarget = n_6289; + goog.events.fireListeners(n_6289, evt.type, false, evt); + } + var G__6290 = seq__6260_6285; + var G__6291 = chunk__6261_6286; + var G__6292 = count__6262_6287; + var G__6293 = i__6263_6288 + 1; + seq__6260_6285 = G__6290; + chunk__6261_6286 = G__6291; + count__6262_6287 = G__6292; + i__6263_6288 = G__6293; + continue; + } else { + var temp__4092__auto___6294 = cljs.core.seq.call(null, seq__6260_6285); + if (temp__4092__auto___6294) { + var seq__6260_6295__$1 = temp__4092__auto___6294; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6260_6295__$1)) { + var c__4191__auto___6296 = cljs.core.chunk_first.call(null, seq__6260_6295__$1); + var G__6297 = cljs.core.chunk_rest.call(null, seq__6260_6295__$1); + var G__6298 = c__4191__auto___6296; + var G__6299 = cljs.core.count.call(null, c__4191__auto___6296); + var G__6300 = 0; + seq__6260_6285 = G__6297; + chunk__6261_6286 = G__6298; + count__6262_6287 = G__6299; + i__6263_6288 = G__6300; + continue; + } else { + var n_6301 = cljs.core.first.call(null, seq__6260_6295__$1); + if (cljs.core.truth_(evt.propagationStopped_)) { + } else { + evt.currentTarget = n_6301; + goog.events.fireListeners(n_6301, evt.type, false, evt); + } + var G__6302 = cljs.core.next.call(null, seq__6260_6295__$1); + var G__6303 = null; + var G__6304 = 0; + var G__6305 = 0; + seq__6260_6285 = G__6302; + chunk__6261_6286 = G__6303; + count__6262_6287 = G__6304; + i__6263_6288 = G__6305; + continue; + } + } else { + } + } + break; + } + return evt.returnValue_; +}; +domina.events.dispatch_event_target_BANG_ = function dispatch_event_target_BANG_(source, evt) { + return goog.events.dispatchEvent(source, evt); +}; +domina.events.is_event_target_QMARK_ = function is_event_target_QMARK_(o) { + var and__3431__auto__ = o.getParentEventTarget; + if (cljs.core.truth_(and__3431__auto__)) { + return o.dispatchEvent; + } else { + return and__3431__auto__; + } +}; +domina.events.dispatch_BANG_ = function() { + var dispatch_BANG_ = null; + var dispatch_BANG___2 = function(type, evt_map) { + return dispatch_BANG_.call(null, domina.events.root_element, type, evt_map); + }; + var dispatch_BANG___3 = function(source, type, evt_map) { + var evt = new goog.events.Event(cljs.core.name.call(null, type)); + var seq__6312_6318 = cljs.core.seq.call(null, evt_map); + var chunk__6313_6319 = null; + var count__6314_6320 = 0; + var i__6315_6321 = 0; + while (true) { + if (i__6315_6321 < count__6314_6320) { + var vec__6316_6322 = cljs.core._nth.call(null, chunk__6313_6319, i__6315_6321); + var k_6323 = cljs.core.nth.call(null, vec__6316_6322, 0, null); + var v_6324 = cljs.core.nth.call(null, vec__6316_6322, 1, null); + evt[k_6323] = v_6324; + var G__6325 = seq__6312_6318; + var G__6326 = chunk__6313_6319; + var G__6327 = count__6314_6320; + var G__6328 = i__6315_6321 + 1; + seq__6312_6318 = G__6325; + chunk__6313_6319 = G__6326; + count__6314_6320 = G__6327; + i__6315_6321 = G__6328; + continue; + } else { + var temp__4092__auto___6329 = cljs.core.seq.call(null, seq__6312_6318); + if (temp__4092__auto___6329) { + var seq__6312_6330__$1 = temp__4092__auto___6329; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__6312_6330__$1)) { + var c__4191__auto___6331 = cljs.core.chunk_first.call(null, seq__6312_6330__$1); + var G__6332 = cljs.core.chunk_rest.call(null, seq__6312_6330__$1); + var G__6333 = c__4191__auto___6331; + var G__6334 = cljs.core.count.call(null, c__4191__auto___6331); + var G__6335 = 0; + seq__6312_6318 = G__6332; + chunk__6313_6319 = G__6333; + count__6314_6320 = G__6334; + i__6315_6321 = G__6335; + continue; + } else { + var vec__6317_6336 = cljs.core.first.call(null, seq__6312_6330__$1); + var k_6337 = cljs.core.nth.call(null, vec__6317_6336, 0, null); + var v_6338 = cljs.core.nth.call(null, vec__6317_6336, 1, null); + evt[k_6337] = v_6338; + var G__6339 = cljs.core.next.call(null, seq__6312_6330__$1); + var G__6340 = null; + var G__6341 = 0; + var G__6342 = 0; + seq__6312_6318 = G__6339; + chunk__6313_6319 = G__6340; + count__6314_6320 = G__6341; + i__6315_6321 = G__6342; + continue; + } + } else { + } + } + break; + } + if (cljs.core.truth_(domina.events.is_event_target_QMARK_.call(null, source))) { + return domina.events.dispatch_event_target_BANG_.call(null, source, evt); + } else { + return domina.events.dispatch_browser_BANG_.call(null, source, evt); + } + }; + dispatch_BANG_ = function(source, type, evt_map) { + switch(arguments.length) { + case 2: + return dispatch_BANG___2.call(this, source, type); + case 3: + return dispatch_BANG___3.call(this, source, type, evt_map); + } + throw new Error("Invalid arity: " + arguments.length); + }; + dispatch_BANG_.cljs$core$IFn$_invoke$arity$2 = dispatch_BANG___2; + dispatch_BANG_.cljs$core$IFn$_invoke$arity$3 = dispatch_BANG___3; + return dispatch_BANG_; +}(); +domina.events.unlisten_by_key_BANG_ = function unlisten_by_key_BANG_(key) { + return goog.events.unlistenByKey(key); +}; +domina.events.get_listeners = function get_listeners(content, type) { + var type__$1 = cljs.core.name.call(null, type); + return cljs.core.mapcat.call(null, function(p1__6343_SHARP_) { + return goog.events.getListeners(p1__6343_SHARP_, type__$1, false); + }, domina.nodes.call(null, content)); +}; +goog.provide("hiccups.runtime"); +goog.require("cljs.core"); +goog.require("clojure.string"); +goog.require("clojure.string"); +hiccups.runtime.re_tag = /([^\s\.#]+)(?:#([^\s\.#]+))?(?:\.([^\s#]+))?/; +hiccups.runtime.character_escapes = new cljs.core.PersistentArrayMap(null, 4, ["\x26", "\x26amp;", "\x3c", "\x26lt;", "\x3e", "\x26gt;", '"', "\x26quot;"], null); +hiccups.runtime.container_tags = new cljs.core.PersistentHashSet(null, new cljs.core.PersistentArrayMap(null, 33, ["dd", null, "head", null, "a", null, "b", null, "body", null, "pre", null, "form", null, "iframe", null, "dl", null, "em", null, "fieldset", null, "i", null, "h1", null, "h2", null, "span", null, "h3", null, "script", null, "html", null, "h4", null, "h5", null, "h6", null, "table", null, "dt", null, "div", null, "style", null, "label", null, "option", null, "ul", null, "strong", null, +"canvas", null, "textarea", null, "li", null, "ol", null], null), null); +hiccups.runtime.as_str = function as_str(x) { + if (x instanceof cljs.core.Keyword || x instanceof cljs.core.Symbol) { + return cljs.core.name.call(null, x); + } else { + return[cljs.core.str(x)].join(""); + } +}; +hiccups.runtime._STAR_html_mode_STAR_ = new cljs.core.Keyword(null, "xml", "xml", 1014023049); +hiccups.runtime.xml_mode_QMARK_ = function xml_mode_QMARK_() { + return cljs.core._EQ_.call(null, hiccups.runtime._STAR_html_mode_STAR_, new cljs.core.Keyword(null, "xml", "xml", 1014023049)); +}; +hiccups.runtime.in_mode = function in_mode(mode, f) { + var _STAR_html_mode_STAR_5163 = hiccups.runtime._STAR_html_mode_STAR_; + try { + hiccups.runtime._STAR_html_mode_STAR_ = mode; + return f.call(null); + } finally { + hiccups.runtime._STAR_html_mode_STAR_ = _STAR_html_mode_STAR_5163; + } +}; +hiccups.runtime.escape_html = function escape_html(text) { + return clojure.string.escape.call(null, hiccups.runtime.as_str.call(null, text), hiccups.runtime.character_escapes); +}; +hiccups.runtime.h = hiccups.runtime.escape_html; +hiccups.runtime.end_tag = function end_tag() { + if (hiccups.runtime.xml_mode_QMARK_.call(null)) { + return " /\x3e"; + } else { + return "\x3e"; + } +}; +hiccups.runtime.xml_attribute = function xml_attribute(name, value) { + return[cljs.core.str(" "), cljs.core.str(hiccups.runtime.as_str.call(null, name)), cljs.core.str('\x3d"'), cljs.core.str(hiccups.runtime.escape_html.call(null, value)), cljs.core.str('"')].join(""); +}; +hiccups.runtime.render_attribute = function render_attribute(p__5164) { + var vec__5166 = p__5164; + var name = cljs.core.nth.call(null, vec__5166, 0, null); + var value = cljs.core.nth.call(null, vec__5166, 1, null); + if (value === true) { + if (hiccups.runtime.xml_mode_QMARK_.call(null)) { + return hiccups.runtime.xml_attribute.call(null, name, name); + } else { + return[cljs.core.str(" "), cljs.core.str(hiccups.runtime.as_str.call(null, name))].join(""); + } + } else { + if (cljs.core.not.call(null, value)) { + return ""; + } else { + if (new cljs.core.Keyword(null, "else", "else", 1017020587)) { + return hiccups.runtime.xml_attribute.call(null, name, value); + } else { + return null; + } + } + } +}; +hiccups.runtime.render_attr_map = function render_attr_map(attrs) { + return cljs.core.apply.call(null, cljs.core.str, cljs.core.sort.call(null, cljs.core.map.call(null, hiccups.runtime.render_attribute, attrs))); +}; +hiccups.runtime.normalize_element = function normalize_element(p__5167) { + var vec__5170 = p__5167; + var tag = cljs.core.nth.call(null, vec__5170, 0, null); + var content = cljs.core.nthnext.call(null, vec__5170, 1); + if (!(tag instanceof cljs.core.Keyword || (tag instanceof cljs.core.Symbol || typeof tag === "string"))) { + throw[cljs.core.str(tag), cljs.core.str(" is not a valid tag name")].join(""); + } else { + } + var vec__5171 = cljs.core.re_matches.call(null, hiccups.runtime.re_tag, hiccups.runtime.as_str.call(null, tag)); + var _ = cljs.core.nth.call(null, vec__5171, 0, null); + var tag__$1 = cljs.core.nth.call(null, vec__5171, 1, null); + var id = cljs.core.nth.call(null, vec__5171, 2, null); + var class$ = cljs.core.nth.call(null, vec__5171, 3, null); + var tag_attrs = new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "id", "id", 1013907597), id, new cljs.core.Keyword(null, "class", "class", 1108647146), cljs.core.truth_(class$) ? clojure.string.replace.call(null, class$, ".", " ") : null], null); + var map_attrs = cljs.core.first.call(null, content); + if (cljs.core.map_QMARK_.call(null, map_attrs)) { + return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [tag__$1, cljs.core.merge.call(null, tag_attrs, map_attrs), cljs.core.next.call(null, content)], null); + } else { + return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [tag__$1, tag_attrs, content], null); + } +}; +hiccups.runtime.render_element = function render_element(element) { + var vec__5173 = hiccups.runtime.normalize_element.call(null, element); + var tag = cljs.core.nth.call(null, vec__5173, 0, null); + var attrs = cljs.core.nth.call(null, vec__5173, 1, null); + var content = cljs.core.nth.call(null, vec__5173, 2, null); + if (cljs.core.truth_(function() { + var or__3443__auto__ = content; + if (cljs.core.truth_(or__3443__auto__)) { + return or__3443__auto__; + } else { + return hiccups.runtime.container_tags.call(null, tag); + } + }())) { + return[cljs.core.str("\x3c"), cljs.core.str(tag), cljs.core.str(hiccups.runtime.render_attr_map.call(null, attrs)), cljs.core.str("\x3e"), cljs.core.str(hiccups.runtime.render_html.call(null, content)), cljs.core.str("\x3c/"), cljs.core.str(tag), cljs.core.str("\x3e")].join(""); + } else { + return[cljs.core.str("\x3c"), cljs.core.str(tag), cljs.core.str(hiccups.runtime.render_attr_map.call(null, attrs)), cljs.core.str(hiccups.runtime.end_tag.call(null))].join(""); + } +}; +hiccups.runtime.render_html = function render_html(x) { + if (cljs.core.vector_QMARK_.call(null, x)) { + return hiccups.runtime.render_element.call(null, x); + } else { + if (cljs.core.seq_QMARK_.call(null, x)) { + return cljs.core.apply.call(null, cljs.core.str, cljs.core.map.call(null, render_html, x)); + } else { + if (new cljs.core.Keyword(null, "else", "else", 1017020587)) { + return hiccups.runtime.as_str.call(null, x); + } else { + return null; + } + } + } +}; +goog.provide("goog.functions"); +goog.functions.constant = function(retValue) { + return function() { + return retValue; + }; +}; +goog.functions.FALSE = goog.functions.constant(false); +goog.functions.TRUE = goog.functions.constant(true); +goog.functions.NULL = goog.functions.constant(null); +goog.functions.identity = function(opt_returnValue, var_args) { + return opt_returnValue; +}; +goog.functions.error = function(message) { + return function() { + throw Error(message); + }; +}; +goog.functions.lock = function(f, opt_numArgs) { + opt_numArgs = opt_numArgs || 0; + return function() { + return f.apply(this, Array.prototype.slice.call(arguments, 0, opt_numArgs)); + }; +}; +goog.functions.withReturnValue = function(f, retValue) { + return goog.functions.sequence(f, goog.functions.constant(retValue)); +}; +goog.functions.compose = function(fn, var_args) { + var functions = arguments; + var length = functions.length; + return function() { + var result; + if (length) { + result = functions[length - 1].apply(this, arguments); + } + for (var i = length - 2;i >= 0;i--) { + result = functions[i].call(this, result); + } + return result; + }; +}; +goog.functions.sequence = function(var_args) { + var functions = arguments; + var length = functions.length; + return function() { + var result; + for (var i = 0;i < length;i++) { + result = functions[i].apply(this, arguments); + } + return result; + }; +}; +goog.functions.and = function(var_args) { + var functions = arguments; + var length = functions.length; + return function() { + for (var i = 0;i < length;i++) { + if (!functions[i].apply(this, arguments)) { + return false; + } + } + return true; + }; +}; +goog.functions.or = function(var_args) { + var functions = arguments; + var length = functions.length; + return function() { + for (var i = 0;i < length;i++) { + if (functions[i].apply(this, arguments)) { + return true; + } + } + return false; + }; +}; +goog.functions.not = function(f) { + return function() { + return!f.apply(this, arguments); + }; +}; +goog.functions.create = function(constructor, var_args) { + var temp = function() { + }; + temp.prototype = constructor.prototype; + var obj = new temp; + constructor.apply(obj, Array.prototype.slice.call(arguments, 1)); + return obj; +}; +/* + Portions of this code are from the Dojo Toolkit, received by + The Closure Library Authors under the BSD license. All other code is + Copyright 2005-2009 The Closure Library Authors. All Rights Reserved. + +The "New" BSD License: + +Copyright (c) 2005-2009, The Dojo Foundation +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + Neither the name of the Dojo Foundation nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +goog.provide("goog.dom.query"); +goog.require("goog.array"); +goog.require("goog.dom"); +goog.require("goog.functions"); +goog.require("goog.string"); +goog.require("goog.userAgent"); +goog.dom.query = function() { + var cssCaseBug = goog.userAgent.WEBKIT && goog.dom.getDocument().compatMode == "BackCompat"; + var childNodesName = !!goog.dom.getDocument().firstChild["children"] ? "children" : "childNodes"; + var specials = "\x3e~+"; + var caseSensitive = false; + var getQueryParts = function(query) { + if (specials.indexOf(query.slice(-1)) >= 0) { + query += " * "; + } else { + query += " "; + } + var ts = function(s, e) { + return goog.string.trim(query.slice(s, e)); + }; + var queryParts = []; + var inBrackets = -1, inParens = -1, inMatchFor = -1, inPseudo = -1, inClass = -1, inId = -1, inTag = -1, lc = "", cc = "", pStart; + var x = 0, ql = query.length, currentPart = null, cp = null; + var endTag = function() { + if (inTag >= 0) { + var tv = inTag == x ? null : ts(inTag, x); + if (specials.indexOf(tv) < 0) { + currentPart.tag = tv; + } else { + currentPart.oper = tv; + } + inTag = -1; + } + }; + var endId = function() { + if (inId >= 0) { + currentPart.id = ts(inId, x).replace(/\\/g, ""); + inId = -1; + } + }; + var endClass = function() { + if (inClass >= 0) { + currentPart.classes.push(ts(inClass + 1, x).replace(/\\/g, "")); + inClass = -1; + } + }; + var endAll = function() { + endId(); + endTag(); + endClass(); + }; + var endPart = function() { + endAll(); + if (inPseudo >= 0) { + currentPart.pseudos.push({name:ts(inPseudo + 1, x)}); + } + currentPart.loops = currentPart.pseudos.length || (currentPart.attrs.length || currentPart.classes.length); + currentPart.oquery = currentPart.query = ts(pStart, x); + currentPart.otag = currentPart.tag = currentPart.oper ? null : currentPart.tag || "*"; + if (currentPart.tag) { + currentPart.tag = currentPart.tag.toUpperCase(); + } + if (queryParts.length && queryParts[queryParts.length - 1].oper) { + currentPart.infixOper = queryParts.pop(); + currentPart.query = currentPart.infixOper.query + " " + currentPart.query; + } + queryParts.push(currentPart); + currentPart = null; + }; + for (;lc = cc, cc = query.charAt(x), x < ql;x++) { + if (lc == "\\") { + continue; + } + if (!currentPart) { + pStart = x; + currentPart = {query:null, pseudos:[], attrs:[], classes:[], tag:null, oper:null, id:null, getTag:function() { + return caseSensitive ? this.otag : this.tag; + }}; + inTag = x; + } + if (inBrackets >= 0) { + if (cc == "]") { + if (!cp.attr) { + cp.attr = ts(inBrackets + 1, x); + } else { + cp.matchFor = ts(inMatchFor || inBrackets + 1, x); + } + var cmf = cp.matchFor; + if (cmf) { + if (cmf.charAt(0) == '"' || cmf.charAt(0) == "'") { + cp.matchFor = cmf.slice(1, -1); + } + } + currentPart.attrs.push(cp); + cp = null; + inBrackets = inMatchFor = -1; + } else { + if (cc == "\x3d") { + var addToCc = "|~^$*".indexOf(lc) >= 0 ? lc : ""; + cp.type = addToCc + cc; + cp.attr = ts(inBrackets + 1, x - addToCc.length); + inMatchFor = x + 1; + } + } + } else { + if (inParens >= 0) { + if (cc == ")") { + if (inPseudo >= 0) { + cp.value = ts(inParens + 1, x); + } + inPseudo = inParens = -1; + } + } else { + if (cc == "#") { + endAll(); + inId = x + 1; + } else { + if (cc == ".") { + endAll(); + inClass = x; + } else { + if (cc == ":") { + endAll(); + inPseudo = x; + } else { + if (cc == "[") { + endAll(); + inBrackets = x; + cp = {}; + } else { + if (cc == "(") { + if (inPseudo >= 0) { + cp = {name:ts(inPseudo + 1, x), value:null}; + currentPart.pseudos.push(cp); + } + inParens = x; + } else { + if (cc == " " && lc != cc) { + endPart(); + } + } + } + } + } + } + } + } + } + return queryParts; + }; + var agree = function(first, second) { + if (!first) { + return second; + } + if (!second) { + return first; + } + return function() { + return first.apply(window, arguments) && second.apply(window, arguments); + }; + }; + function getArr(i, opt_arr) { + var r = opt_arr || []; + if (i) { + r.push(i); + } + return r; + } + var isElement = function(n) { + return 1 == n.nodeType; + }; + var blank = ""; + var getAttr = function(elem, attr) { + if (!elem) { + return blank; + } + if (attr == "class") { + return elem.className || blank; + } + if (attr == "for") { + return elem.htmlFor || blank; + } + if (attr == "style") { + return elem.style.cssText || blank; + } + return(caseSensitive ? elem.getAttribute(attr) : elem.getAttribute(attr, 2)) || blank; + }; + var attrs = {"*\x3d":function(attr, value) { + return function(elem) { + return getAttr(elem, attr).indexOf(value) >= 0; + }; + }, "^\x3d":function(attr, value) { + return function(elem) { + return getAttr(elem, attr).indexOf(value) == 0; + }; + }, "$\x3d":function(attr, value) { + var tval = " " + value; + return function(elem) { + var ea = " " + getAttr(elem, attr); + return ea.lastIndexOf(value) == ea.length - value.length; + }; + }, "~\x3d":function(attr, value) { + var tval = " " + value + " "; + return function(elem) { + var ea = " " + getAttr(elem, attr) + " "; + return ea.indexOf(tval) >= 0; + }; + }, "|\x3d":function(attr, value) { + value = " " + value; + return function(elem) { + var ea = " " + getAttr(elem, attr); + return ea == value || ea.indexOf(value + "-") == 0; + }; + }, "\x3d":function(attr, value) { + return function(elem) { + return getAttr(elem, attr) == value; + }; + }}; + var noNextElementSibling = typeof goog.dom.getDocument().firstChild.nextElementSibling == "undefined"; + var nSibling = !noNextElementSibling ? "nextElementSibling" : "nextSibling"; + var pSibling = !noNextElementSibling ? "previousElementSibling" : "previousSibling"; + var simpleNodeTest = noNextElementSibling ? isElement : goog.functions.TRUE; + var _lookLeft = function(node) { + while (node = node[pSibling]) { + if (simpleNodeTest(node)) { + return false; + } + } + return true; + }; + var _lookRight = function(node) { + while (node = node[nSibling]) { + if (simpleNodeTest(node)) { + return false; + } + } + return true; + }; + var getNodeIndex = function(node) { + var root = node.parentNode; + var i = 0, tret = root[childNodesName], ci = node["_i"] || -1, cl = root["_l"] || -1; + if (!tret) { + return-1; + } + var l = tret.length; + if (cl == l && (ci >= 0 && cl >= 0)) { + return ci; + } + root["_l"] = l; + ci = -1; + var te = root["firstElementChild"] || root["firstChild"]; + for (;te;te = te[nSibling]) { + if (simpleNodeTest(te)) { + te["_i"] = ++i; + if (node === te) { + ci = i; + } + } + } + return ci; + }; + var isEven = function(elem) { + return!(getNodeIndex(elem) % 2); + }; + var isOdd = function(elem) { + return getNodeIndex(elem) % 2; + }; + var pseudos = {"checked":function(name, condition) { + return function(elem) { + return elem.checked || elem.attributes["checked"]; + }; + }, "first-child":function() { + return _lookLeft; + }, "last-child":function() { + return _lookRight; + }, "only-child":function(name, condition) { + return function(node) { + if (!_lookLeft(node)) { + return false; + } + if (!_lookRight(node)) { + return false; + } + return true; + }; + }, "empty":function(name, condition) { + return function(elem) { + var cn = elem.childNodes; + var cnl = elem.childNodes.length; + for (var x = cnl - 1;x >= 0;x--) { + var nt = cn[x].nodeType; + if (nt === 1 || nt == 3) { + return false; + } + } + return true; + }; + }, "contains":function(name, condition) { + var cz = condition.charAt(0); + if (cz == '"' || cz == "'") { + condition = condition.slice(1, -1); + } + return function(elem) { + return elem.innerHTML.indexOf(condition) >= 0; + }; + }, "not":function(name, condition) { + var p = getQueryParts(condition)[0]; + var ignores = {el:1}; + if (p.tag != "*") { + ignores.tag = 1; + } + if (!p.classes.length) { + ignores.classes = 1; + } + var ntf = getSimpleFilterFunc(p, ignores); + return function(elem) { + return!ntf(elem); + }; + }, "nth-child":function(name, condition) { + function pi(n) { + return parseInt(n, 10); + } + if (condition == "odd") { + return isOdd; + } else { + if (condition == "even") { + return isEven; + } + } + if (condition.indexOf("n") != -1) { + var tparts = condition.split("n", 2); + var pred = tparts[0] ? tparts[0] == "-" ? -1 : pi(tparts[0]) : 1; + var idx = tparts[1] ? pi(tparts[1]) : 0; + var lb = 0, ub = -1; + if (pred > 0) { + if (idx < 0) { + idx = idx % pred && pred + idx % pred; + } else { + if (idx > 0) { + if (idx >= pred) { + lb = idx - idx % pred; + } + idx = idx % pred; + } + } + } else { + if (pred < 0) { + pred *= -1; + if (idx > 0) { + ub = idx; + idx = idx % pred; + } + } + } + if (pred > 0) { + return function(elem) { + var i = getNodeIndex(elem); + return i >= lb && ((ub < 0 || i <= ub) && i % pred == idx); + }; + } else { + condition = idx; + } + } + var ncount = pi(condition); + return function(elem) { + return getNodeIndex(elem) == ncount; + }; + }}; + var defaultGetter = goog.userAgent.IE ? function(cond) { + var clc = cond.toLowerCase(); + if (clc == "class") { + cond = "className"; + } + return function(elem) { + return caseSensitive ? elem.getAttribute(cond) : elem[cond] || elem[clc]; + }; + } : function(cond) { + return function(elem) { + return elem && (elem.getAttribute && elem.hasAttribute(cond)); + }; + }; + var getSimpleFilterFunc = function(query, ignores) { + if (!query) { + return goog.functions.TRUE; + } + ignores = ignores || {}; + var ff = null; + if (!ignores.el) { + ff = agree(ff, isElement); + } + if (!ignores.tag) { + if (query.tag != "*") { + ff = agree(ff, function(elem) { + return elem && elem.tagName == query.getTag(); + }); + } + } + if (!ignores.classes) { + goog.array.forEach(query.classes, function(cname, idx, arr) { + var re = new RegExp("(?:^|\\s)" + cname + "(?:\\s|$)"); + ff = agree(ff, function(elem) { + return re.test(elem.className); + }); + ff.count = idx; + }); + } + if (!ignores.pseudos) { + goog.array.forEach(query.pseudos, function(pseudo) { + var pn = pseudo.name; + if (pseudos[pn]) { + ff = agree(ff, pseudos[pn](pn, pseudo.value)); + } + }); + } + if (!ignores.attrs) { + goog.array.forEach(query.attrs, function(attr) { + var matcher; + var a = attr.attr; + if (attr.type && attrs[attr.type]) { + matcher = attrs[attr.type](a, attr.matchFor); + } else { + if (a.length) { + matcher = defaultGetter(a); + } + } + if (matcher) { + ff = agree(ff, matcher); + } + }); + } + if (!ignores.id) { + if (query.id) { + ff = agree(ff, function(elem) { + return!!elem && elem.id == query.id; + }); + } + } + if (!ff) { + if (!("default" in ignores)) { + ff = goog.functions.TRUE; + } + } + return ff; + }; + var nextSiblingIterator = function(filterFunc) { + return function(node, ret, bag) { + while (node = node[nSibling]) { + if (noNextElementSibling && !isElement(node)) { + continue; + } + if ((!bag || _isUnique(node, bag)) && filterFunc(node)) { + ret.push(node); + } + break; + } + return ret; + }; + }; + var nextSiblingsIterator = function(filterFunc) { + return function(root, ret, bag) { + var te = root[nSibling]; + while (te) { + if (simpleNodeTest(te)) { + if (bag && !_isUnique(te, bag)) { + break; + } + if (filterFunc(te)) { + ret.push(te); + } + } + te = te[nSibling]; + } + return ret; + }; + }; + var _childElements = function(filterFunc) { + filterFunc = filterFunc || goog.functions.TRUE; + return function(root, ret, bag) { + var te, x = 0, tret = root[childNodesName]; + while (te = tret[x++]) { + if (simpleNodeTest(te) && ((!bag || _isUnique(te, bag)) && filterFunc(te, x))) { + ret.push(te); + } + } + return ret; + }; + }; + var _isDescendant = function(node, root) { + var pn = node.parentNode; + while (pn) { + if (pn == root) { + break; + } + pn = pn.parentNode; + } + return!!pn; + }; + var _getElementsFuncCache = {}; + var getElementsFunc = function(query) { + var retFunc = _getElementsFuncCache[query.query]; + if (retFunc) { + return retFunc; + } + var io = query.infixOper; + var oper = io ? io.oper : ""; + var filterFunc = getSimpleFilterFunc(query, {el:1}); + var qt = query.tag; + var wildcardTag = "*" == qt; + var ecs = goog.dom.getDocument()["getElementsByClassName"]; + if (!oper) { + if (query.id) { + filterFunc = !query.loops && wildcardTag ? goog.functions.TRUE : getSimpleFilterFunc(query, {el:1, id:1}); + retFunc = function(root, arr) { + var te = goog.dom.getDomHelper(root).getElement(query.id); + if (!te || !filterFunc(te)) { + return; + } + if (9 == root.nodeType) { + return getArr(te, arr); + } else { + if (_isDescendant(te, root)) { + return getArr(te, arr); + } + } + }; + } else { + if (ecs && (/\{\s*\[native code\]\s*\}/.test(String(ecs)) && (query.classes.length && !cssCaseBug))) { + filterFunc = getSimpleFilterFunc(query, {el:1, classes:1, id:1}); + var classesString = query.classes.join(" "); + retFunc = function(root, arr) { + var ret = getArr(0, arr), te, x = 0; + var tret = root.getElementsByClassName(classesString); + while (te = tret[x++]) { + if (filterFunc(te, root)) { + ret.push(te); + } + } + return ret; + }; + } else { + if (!wildcardTag && !query.loops) { + retFunc = function(root, arr) { + var ret = getArr(0, arr), te, x = 0; + var tret = root.getElementsByTagName(query.getTag()); + while (te = tret[x++]) { + ret.push(te); + } + return ret; + }; + } else { + filterFunc = getSimpleFilterFunc(query, {el:1, tag:1, id:1}); + retFunc = function(root, arr) { + var ret = getArr(0, arr), te, x = 0; + var tret = root.getElementsByTagName(query.getTag()); + while (te = tret[x++]) { + if (filterFunc(te, root)) { + ret.push(te); + } + } + return ret; + }; + } + } + } + } else { + var skipFilters = {el:1}; + if (wildcardTag) { + skipFilters.tag = 1; + } + filterFunc = getSimpleFilterFunc(query, skipFilters); + if ("+" == oper) { + retFunc = nextSiblingIterator(filterFunc); + } else { + if ("~" == oper) { + retFunc = nextSiblingsIterator(filterFunc); + } else { + if ("\x3e" == oper) { + retFunc = _childElements(filterFunc); + } + } + } + } + return _getElementsFuncCache[query.query] = retFunc; + }; + var filterDown = function(root, queryParts) { + var candidates = getArr(root), qp, x, te, qpl = queryParts.length, bag, ret; + for (var i = 0;i < qpl;i++) { + ret = []; + qp = queryParts[i]; + x = candidates.length - 1; + if (x > 0) { + bag = {}; + ret.nozip = true; + } + var gef = getElementsFunc(qp); + for (var j = 0;te = candidates[j];j++) { + gef(te, ret, bag); + } + if (!ret.length) { + break; + } + candidates = ret; + } + return ret; + }; + var _queryFuncCacheDOM = {}, _queryFuncCacheQSA = {}; + var getStepQueryFunc = function(query) { + var qparts = getQueryParts(goog.string.trim(query)); + if (qparts.length == 1) { + var tef = getElementsFunc(qparts[0]); + return function(root) { + var r = tef(root, []); + if (r) { + r.nozip = true; + } + return r; + }; + } + return function(root) { + return filterDown(root, qparts); + }; + }; + var qsa = "querySelectorAll"; + var qsaAvail = !!goog.dom.getDocument()[qsa] && (!goog.userAgent.WEBKIT || goog.userAgent.isVersion("526")); + var getQueryFunc = function(query, opt_forceDOM) { + if (qsaAvail) { + var qsaCached = _queryFuncCacheQSA[query]; + if (qsaCached && !opt_forceDOM) { + return qsaCached; + } + } + var domCached = _queryFuncCacheDOM[query]; + if (domCached) { + return domCached; + } + var qcz = query.charAt(0); + var nospace = -1 == query.indexOf(" "); + if (query.indexOf("#") >= 0 && nospace) { + opt_forceDOM = true; + } + var useQSA = qsaAvail && (!opt_forceDOM && (specials.indexOf(qcz) == -1 && ((!goog.userAgent.IE || query.indexOf(":") == -1) && (!(cssCaseBug && query.indexOf(".") >= 0) && (query.indexOf(":contains") == -1 && query.indexOf("|\x3d") == -1))))); + if (useQSA) { + var tq = specials.indexOf(query.charAt(query.length - 1)) >= 0 ? query + " *" : query; + return _queryFuncCacheQSA[query] = function(root) { + try { + if (!(9 == root.nodeType || nospace)) { + throw ""; + } + var r = root[qsa](tq); + if (goog.userAgent.IE) { + r.commentStrip = true; + } else { + r.nozip = true; + } + return r; + } catch (e) { + return getQueryFunc(query, true)(root); + } + }; + } else { + var parts = query.split(/\s*,\s*/); + return _queryFuncCacheDOM[query] = parts.length < 2 ? getStepQueryFunc(query) : function(root) { + var pindex = 0, ret = [], tp; + while (tp = parts[pindex++]) { + ret = ret.concat(getStepQueryFunc(tp)(root)); + } + return ret; + }; + } + }; + var _zipIdx = 0; + var _nodeUID = goog.userAgent.IE ? function(node) { + if (caseSensitive) { + return node.getAttribute("_uid") || (node.setAttribute("_uid", ++_zipIdx) || _zipIdx); + } else { + return node.uniqueID; + } + } : function(node) { + return node["_uid"] || (node["_uid"] = ++_zipIdx); + }; + var _isUnique = function(node, bag) { + if (!bag) { + return 1; + } + var id = _nodeUID(node); + if (!bag[id]) { + return bag[id] = 1; + } + return 0; + }; + var _zipIdxName = "_zipIdx"; + var _zip = function(arr) { + if (arr && arr.nozip) { + return arr; + } + var ret = []; + if (!arr || !arr.length) { + return ret; + } + if (arr[0]) { + ret.push(arr[0]); + } + if (arr.length < 2) { + return ret; + } + _zipIdx++; + if (goog.userAgent.IE && caseSensitive) { + var szidx = _zipIdx + ""; + arr[0].setAttribute(_zipIdxName, szidx); + for (var x = 1, te;te = arr[x];x++) { + if (arr[x].getAttribute(_zipIdxName) != szidx) { + ret.push(te); + } + te.setAttribute(_zipIdxName, szidx); + } + } else { + if (goog.userAgent.IE && arr.commentStrip) { + try { + for (var x = 1, te;te = arr[x];x++) { + if (isElement(te)) { + ret.push(te); + } + } + } catch (e) { + } + } else { + if (arr[0]) { + arr[0][_zipIdxName] = _zipIdx; + } + for (var x = 1, te;te = arr[x];x++) { + if (arr[x][_zipIdxName] != _zipIdx) { + ret.push(te); + } + te[_zipIdxName] = _zipIdx; + } + } + } + return ret; + }; + var query = function(query, root) { + if (!query) { + return[]; + } + if (query.constructor == Array) { + return(query); + } + if (!goog.isString(query)) { + return[query]; + } + if (goog.isString(root)) { + root = goog.dom.getElement(root); + if (!root) { + return[]; + } + } + root = root || goog.dom.getDocument(); + var od = root.ownerDocument || root.documentElement; + caseSensitive = root.contentType && root.contentType == "application/xml" || (goog.userAgent.OPERA && (root.doctype || od.toString() == "[object XMLDocument]") || !!od && (goog.userAgent.IE ? od.xml : root.xmlVersion || od.xmlVersion)); + var r = getQueryFunc(query)(root); + if (r && r.nozip) { + return r; + } + return _zip(r); + }; + query.pseudos = pseudos; + return query; +}(); +goog.exportSymbol("goog.dom.query", goog.dom.query); +goog.exportSymbol("goog.dom.query.pseudos", goog.dom.query.pseudos); +goog.provide("domina.css"); +goog.require("cljs.core"); +goog.require("goog.dom.query"); +goog.require("goog.dom.query"); +goog.require("goog.dom"); +goog.require("goog.dom"); +goog.require("domina"); +domina.css.root_element = function root_element() { + return goog.dom.getElementsByTagNameAndClass("html")[0]; +}; +domina.css.sel = function() { + var sel = null; + var sel__1 = function(expr) { + return sel.call(null, domina.css.root_element.call(null), expr); + }; + var sel__2 = function(base, expr) { + if (typeof domina.css.t6039 !== "undefined") { + } else { + domina.css.t6039 = function(expr, base, sel, meta6040) { + this.expr = expr; + this.base = base; + this.sel = sel; + this.meta6040 = meta6040; + this.cljs$lang$protocol_mask$partition1$ = 0; + this.cljs$lang$protocol_mask$partition0$ = 393216; + }; + domina.css.t6039.cljs$lang$type = true; + domina.css.t6039.cljs$lang$ctorStr = "domina.css/t6039"; + domina.css.t6039.cljs$lang$ctorPrWriter = function(this__4010__auto__, writer__4011__auto__, opt__4012__auto__) { + return cljs.core._write.call(null, writer__4011__auto__, "domina.css/t6039"); + }; + domina.css.t6039.prototype.domina$DomContent$ = true; + domina.css.t6039.prototype.domina$DomContent$nodes$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return cljs.core.mapcat.call(null, function(p1__6034_SHARP_) { + return domina.normalize_seq.call(null, goog.dom.query(self__.expr, p1__6034_SHARP_)); + }, domina.nodes.call(null, self__.base)); + }; + domina.css.t6039.prototype.domina$DomContent$single_node$arity$1 = function(_) { + var self__ = this; + var ___$1 = this; + return cljs.core.first.call(null, cljs.core.filter.call(null, cljs.core.complement.call(null, cljs.core.nil_QMARK_), cljs.core.mapcat.call(null, function(p1__6035_SHARP_) { + return domina.normalize_seq.call(null, goog.dom.query(self__.expr, p1__6035_SHARP_)); + }, domina.nodes.call(null, self__.base)))); + }; + domina.css.t6039.prototype.cljs$core$IMeta$_meta$arity$1 = function(_6041) { + var self__ = this; + var _6041__$1 = this; + return self__.meta6040; + }; + domina.css.t6039.prototype.cljs$core$IWithMeta$_with_meta$arity$2 = function(_6041, meta6040__$1) { + var self__ = this; + var _6041__$1 = this; + return new domina.css.t6039(self__.expr, self__.base, self__.sel, meta6040__$1); + }; + domina.css.__GT_t6039 = function __GT_t6039(expr__$1, base__$1, sel__$1, meta6040) { + return new domina.css.t6039(expr__$1, base__$1, sel__$1, meta6040); + }; + } + return new domina.css.t6039(expr, base, sel, null); + }; + sel = function(base, expr) { + switch(arguments.length) { + case 1: + return sel__1.call(this, base); + case 2: + return sel__2.call(this, base, expr); + } + throw new Error("Invalid arity: " + arguments.length); + }; + sel.cljs$core$IFn$_invoke$arity$1 = sel__1; + sel.cljs$core$IFn$_invoke$arity$2 = sel__2; + return sel; +}(); +goog.provide("sudorace.sudorace"); +goog.require("cljs.core"); +goog.require("domina.events"); +goog.require("domina.css"); +goog.require("domina"); +goog.require("hiccups.runtime"); +goog.require("hiccups.runtime"); +goog.require("domina.events"); +goog.require("domina.css"); +goog.require("domina"); +sudorace.sudorace.sudoku = "2461853793176498525897321646234175981785962434953287168542619377629534819318746.."; +sudorace.sudorace.selected_index = cljs.core.atom.call(null, 0); +sudorace.sudorace.move_right = function move_right() { + return cljs.core.swap_BANG_.call(null, sudorace.sudorace.selected_index, cljs.core.inc); +}; +sudorace.sudorace.index = function index(row, col) { + return 9 * row + col; +}; +sudorace.sudorace.value_at = function value_at(row, col) { + return cljs.core.get.call(null, sudorace.sudorace.sudoku, sudorace.sudorace.index.call(null, row, col)); +}; +sudorace.sudorace.cell_id = function cell_id(row, col) { + return[cljs.core.str("cell"), cljs.core.str(row), cljs.core.str("-"), cljs.core.str(col)].join(""); +}; +sudorace.sudorace.build_cell = function build_cell(row, col) { + var class_cell = cljs.core._EQ_.call(null, cljs.core.deref.call(null, sudorace.sudorace.selected_index), sudorace.sudorace.index.call(null, row, col)) ? "cell fixed target_cell" : "cell fixed non_target_cell"; + return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [new cljs.core.Keyword(null, "div", "div", 1014003715), new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "id", "id", 1013907597), sudorace.sudorace.cell_id.call(null, row, col), new cljs.core.Keyword(null, "class", "class", 1108647146), class_cell], null), sudorace.sudorace.value_at.call(null, row, col)], null); +}; +sudorace.sudorace.build_grid = function build_grid() { + return[cljs.core.str("\x3ctable"), cljs.core.str(""), cljs.core.str("\x3e"), cljs.core.str(cljs.core.apply.call(null, cljs.core.str, function() { + var iter__4160__auto__ = function iter__14346(s__14347) { + return new cljs.core.LazySeq(null, function() { + var s__14347__$1 = s__14347; + while (true) { + var temp__4092__auto__ = cljs.core.seq.call(null, s__14347__$1); + if (temp__4092__auto__) { + var s__14347__$2 = temp__4092__auto__; + if (cljs.core.chunked_seq_QMARK_.call(null, s__14347__$2)) { + var c__4158__auto__ = cljs.core.chunk_first.call(null, s__14347__$2); + var size__4159__auto__ = cljs.core.count.call(null, c__4158__auto__); + var b__14349 = cljs.core.chunk_buffer.call(null, size__4159__auto__); + if (function() { + var i__14348 = 0; + while (true) { + if (i__14348 < size__4159__auto__) { + var row = cljs.core._nth.call(null, c__4158__auto__, i__14348); + cljs.core.chunk_append.call(null, b__14349, [cljs.core.str("\x3ctr"), cljs.core.str(""), cljs.core.str("\x3e"), cljs.core.str(cljs.core.apply.call(null, cljs.core.str, function() { + var iter__4160__auto__ = function(i__14348, row, c__4158__auto__, size__4159__auto__, b__14349, s__14347__$2, temp__4092__auto__) { + return function iter__14366(s__14367) { + return new cljs.core.LazySeq(null, function(i__14348, row, c__4158__auto__, size__4159__auto__, b__14349, s__14347__$2, temp__4092__auto__) { + return function() { + var s__14367__$1 = s__14367; + while (true) { + var temp__4092__auto____$1 = cljs.core.seq.call(null, s__14367__$1); + if (temp__4092__auto____$1) { + var s__14367__$2 = temp__4092__auto____$1; + if (cljs.core.chunked_seq_QMARK_.call(null, s__14367__$2)) { + var c__4158__auto____$1 = cljs.core.chunk_first.call(null, s__14367__$2); + var size__4159__auto____$1 = cljs.core.count.call(null, c__4158__auto____$1); + var b__14369 = cljs.core.chunk_buffer.call(null, size__4159__auto____$1); + if (function() { + var i__14368 = 0; + while (true) { + if (i__14368 < size__4159__auto____$1) { + var col = cljs.core._nth.call(null, c__4158__auto____$1, i__14368); + cljs.core.chunk_append.call(null, b__14369, [cljs.core.str(function() { + var attrs14372 = sudorace.sudorace.build_cell.call(null, row, col); + if (cljs.core.map_QMARK_.call(null, attrs14372)) { + return[cljs.core.str("\x3ctd"), cljs.core.str(hiccups.runtime.render_attr_map.call(null, cljs.core.merge.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "id", "id", 1013907597), null, new cljs.core.Keyword(null, "class", "class", 1108647146), null], null), attrs14372))), cljs.core.str(" /\x3e")].join(""); + } else { + return[cljs.core.str("\x3ctd\x3e"), cljs.core.str(hiccups.runtime.render_html.call(null, attrs14372)), cljs.core.str("\x3c/td\x3e")].join(""); + } + }())].join("")); + var G__14382 = i__14368 + 1; + i__14368 = G__14382; + continue; + } else { + return true; + } + break; + } + }()) { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__14369), iter__14366.call(null, cljs.core.chunk_rest.call(null, s__14367__$2))); + } else { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__14369), null); + } + } else { + var col = cljs.core.first.call(null, s__14367__$2); + return cljs.core.cons.call(null, [cljs.core.str(function() { + var attrs14373 = sudorace.sudorace.build_cell.call(null, row, col); + if (cljs.core.map_QMARK_.call(null, attrs14373)) { + return[cljs.core.str("\x3ctd"), cljs.core.str(hiccups.runtime.render_attr_map.call(null, cljs.core.merge.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "id", "id", 1013907597), null, new cljs.core.Keyword(null, "class", "class", 1108647146), null], null), attrs14373))), cljs.core.str(" /\x3e")].join(""); + } else { + return[cljs.core.str("\x3ctd\x3e"), cljs.core.str(hiccups.runtime.render_html.call(null, attrs14373)), cljs.core.str("\x3c/td\x3e")].join(""); + } + }())].join(""), iter__14366.call(null, cljs.core.rest.call(null, s__14367__$2))); + } + } else { + return null; + } + break; + } + }; + }(i__14348, row, c__4158__auto__, size__4159__auto__, b__14349, s__14347__$2, temp__4092__auto__), null, null); + }; + }(i__14348, row, c__4158__auto__, size__4159__auto__, b__14349, s__14347__$2, temp__4092__auto__); + return iter__4160__auto__.call(null, cljs.core.range.call(null, 9)); + }())), cljs.core.str("\x3c/tr\x3e")].join("")); + var G__14383 = i__14348 + 1; + i__14348 = G__14383; + continue; + } else { + return true; + } + break; + } + }()) { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__14349), iter__14346.call(null, cljs.core.chunk_rest.call(null, s__14347__$2))); + } else { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__14349), null); + } + } else { + var row = cljs.core.first.call(null, s__14347__$2); + return cljs.core.cons.call(null, [cljs.core.str("\x3ctr"), cljs.core.str(""), cljs.core.str("\x3e"), cljs.core.str(cljs.core.apply.call(null, cljs.core.str, function() { + var iter__4160__auto__ = function(row, s__14347__$2, temp__4092__auto__) { + return function iter__14374(s__14375) { + return new cljs.core.LazySeq(null, function(row, s__14347__$2, temp__4092__auto__) { + return function() { + var s__14375__$1 = s__14375; + while (true) { + var temp__4092__auto____$1 = cljs.core.seq.call(null, s__14375__$1); + if (temp__4092__auto____$1) { + var s__14375__$2 = temp__4092__auto____$1; + if (cljs.core.chunked_seq_QMARK_.call(null, s__14375__$2)) { + var c__4158__auto__ = cljs.core.chunk_first.call(null, s__14375__$2); + var size__4159__auto__ = cljs.core.count.call(null, c__4158__auto__); + var b__14377 = cljs.core.chunk_buffer.call(null, size__4159__auto__); + if (function() { + var i__14376 = 0; + while (true) { + if (i__14376 < size__4159__auto__) { + var col = cljs.core._nth.call(null, c__4158__auto__, i__14376); + cljs.core.chunk_append.call(null, b__14377, [cljs.core.str(function() { + var attrs14380 = sudorace.sudorace.build_cell.call(null, row, col); + if (cljs.core.map_QMARK_.call(null, attrs14380)) { + return[cljs.core.str("\x3ctd"), cljs.core.str(hiccups.runtime.render_attr_map.call(null, cljs.core.merge.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "id", "id", 1013907597), null, new cljs.core.Keyword(null, "class", "class", 1108647146), null], null), attrs14380))), cljs.core.str(" /\x3e")].join(""); + } else { + return[cljs.core.str("\x3ctd\x3e"), cljs.core.str(hiccups.runtime.render_html.call(null, attrs14380)), cljs.core.str("\x3c/td\x3e")].join(""); + } + }())].join("")); + var G__14384 = i__14376 + 1; + i__14376 = G__14384; + continue; + } else { + return true; + } + break; + } + }()) { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__14377), iter__14374.call(null, cljs.core.chunk_rest.call(null, s__14375__$2))); + } else { + return cljs.core.chunk_cons.call(null, cljs.core.chunk.call(null, b__14377), null); + } + } else { + var col = cljs.core.first.call(null, s__14375__$2); + return cljs.core.cons.call(null, [cljs.core.str(function() { + var attrs14381 = sudorace.sudorace.build_cell.call(null, row, col); + if (cljs.core.map_QMARK_.call(null, attrs14381)) { + return[cljs.core.str("\x3ctd"), cljs.core.str(hiccups.runtime.render_attr_map.call(null, cljs.core.merge.call(null, new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "id", "id", 1013907597), null, new cljs.core.Keyword(null, "class", "class", 1108647146), null], null), attrs14381))), cljs.core.str(" /\x3e")].join(""); + } else { + return[cljs.core.str("\x3ctd\x3e"), cljs.core.str(hiccups.runtime.render_html.call(null, attrs14381)), cljs.core.str("\x3c/td\x3e")].join(""); + } + }())].join(""), iter__14374.call(null, cljs.core.rest.call(null, s__14375__$2))); + } + } else { + return null; + } + break; + } + }; + }(row, s__14347__$2, temp__4092__auto__), null, null); + }; + }(row, s__14347__$2, temp__4092__auto__); + return iter__4160__auto__.call(null, cljs.core.range.call(null, 9)); + }())), cljs.core.str("\x3c/tr\x3e")].join(""), iter__14346.call(null, cljs.core.rest.call(null, s__14347__$2))); + } + } else { + return null; + } + break; + } + }, null, null); + }; + return iter__4160__auto__.call(null, cljs.core.range.call(null, 9)); + }())), cljs.core.str("\x3c/table\x3e")].join(""); +}; +sudorace.sudorace.click_handler = function click_handler(row, col) { + var msg = [cljs.core.str("cell "), cljs.core.str(row), cljs.core.str("/"), cljs.core.str(col), cljs.core.str(" clicked")].join(""); + return function(evt) { + return alert(msg); + }; +}; +sudorace.sudorace.arrows = new cljs.core.PersistentArrayMap(null, 4, [37, new cljs.core.Keyword(null, "left", "left", 1017222009), 38, new cljs.core.Keyword(null, "up", "up", 1013907981), 39, new cljs.core.Keyword(null, "right", "right", 1122416014), 40, new cljs.core.Keyword(null, "down", "down", 1016993812)], null); +sudorace.sudorace.key_handler = function key_handler(evt) { + var code = (new cljs.core.Keyword(null, "keyCode", "keyCode", 4492913758)).cljs$core$IFn$_invoke$arity$1(evt); + if (36 < code && code < 41) { + return alert([cljs.core.str("arrow "), cljs.core.str(cljs.core.get.call(null, sudorace.sudorace.arrows, (new cljs.core.Keyword(null, "keyCode", "keyCode", 4492913758)).cljs$core$IFn$_invoke$arity$1(evt)))].join("")); + } else { + return null; + } +}; +sudorace.sudorace.register_listeners = function register_listeners() { + var seq__14397_14409 = cljs.core.seq.call(null, cljs.core.range.call(null, 9)); + var chunk__14402_14410 = null; + var count__14403_14411 = 0; + var i__14404_14412 = 0; + while (true) { + if (i__14404_14412 < count__14403_14411) { + var row_14413 = cljs.core._nth.call(null, chunk__14402_14410, i__14404_14412); + var seq__14405_14414 = cljs.core.seq.call(null, cljs.core.range.call(null, 9)); + var chunk__14406_14415 = null; + var count__14407_14416 = 0; + var i__14408_14417 = 0; + while (true) { + if (i__14408_14417 < count__14407_14416) { + var col_14418 = cljs.core._nth.call(null, chunk__14406_14415, i__14408_14417); + domina.events.listen_BANG_.call(null, domina.by_id.call(null, sudorace.sudorace.cell_id.call(null, row_14413, col_14418)), new cljs.core.Keyword(null, "click", "click", 1108654330), sudorace.sudorace.click_handler.call(null, row_14413, col_14418)); + var G__14419 = seq__14405_14414; + var G__14420 = chunk__14406_14415; + var G__14421 = count__14407_14416; + var G__14422 = i__14408_14417 + 1; + seq__14405_14414 = G__14419; + chunk__14406_14415 = G__14420; + count__14407_14416 = G__14421; + i__14408_14417 = G__14422; + continue; + } else { + var temp__4092__auto___14423 = cljs.core.seq.call(null, seq__14405_14414); + if (temp__4092__auto___14423) { + var seq__14405_14424__$1 = temp__4092__auto___14423; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__14405_14424__$1)) { + var c__4191__auto___14425 = cljs.core.chunk_first.call(null, seq__14405_14424__$1); + var G__14426 = cljs.core.chunk_rest.call(null, seq__14405_14424__$1); + var G__14427 = c__4191__auto___14425; + var G__14428 = cljs.core.count.call(null, c__4191__auto___14425); + var G__14429 = 0; + seq__14405_14414 = G__14426; + chunk__14406_14415 = G__14427; + count__14407_14416 = G__14428; + i__14408_14417 = G__14429; + continue; + } else { + var col_14430 = cljs.core.first.call(null, seq__14405_14424__$1); + domina.events.listen_BANG_.call(null, domina.by_id.call(null, sudorace.sudorace.cell_id.call(null, row_14413, col_14430)), new cljs.core.Keyword(null, "click", "click", 1108654330), sudorace.sudorace.click_handler.call(null, row_14413, col_14430)); + var G__14431 = cljs.core.next.call(null, seq__14405_14424__$1); + var G__14432 = null; + var G__14433 = 0; + var G__14434 = 0; + seq__14405_14414 = G__14431; + chunk__14406_14415 = G__14432; + count__14407_14416 = G__14433; + i__14408_14417 = G__14434; + continue; + } + } else { + } + } + break; + } + var G__14435 = seq__14397_14409; + var G__14436 = chunk__14402_14410; + var G__14437 = count__14403_14411; + var G__14438 = i__14404_14412 + 1; + seq__14397_14409 = G__14435; + chunk__14402_14410 = G__14436; + count__14403_14411 = G__14437; + i__14404_14412 = G__14438; + continue; + } else { + var temp__4092__auto___14439 = cljs.core.seq.call(null, seq__14397_14409); + if (temp__4092__auto___14439) { + var seq__14397_14440__$1 = temp__4092__auto___14439; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__14397_14440__$1)) { + var c__4191__auto___14441 = cljs.core.chunk_first.call(null, seq__14397_14440__$1); + var G__14442 = cljs.core.chunk_rest.call(null, seq__14397_14440__$1); + var G__14443 = c__4191__auto___14441; + var G__14444 = cljs.core.count.call(null, c__4191__auto___14441); + var G__14445 = 0; + seq__14397_14409 = G__14442; + chunk__14402_14410 = G__14443; + count__14403_14411 = G__14444; + i__14404_14412 = G__14445; + continue; + } else { + var row_14446 = cljs.core.first.call(null, seq__14397_14440__$1); + var seq__14398_14447 = cljs.core.seq.call(null, cljs.core.range.call(null, 9)); + var chunk__14399_14448 = null; + var count__14400_14449 = 0; + var i__14401_14450 = 0; + while (true) { + if (i__14401_14450 < count__14400_14449) { + var col_14451 = cljs.core._nth.call(null, chunk__14399_14448, i__14401_14450); + domina.events.listen_BANG_.call(null, domina.by_id.call(null, sudorace.sudorace.cell_id.call(null, row_14446, col_14451)), new cljs.core.Keyword(null, "click", "click", 1108654330), sudorace.sudorace.click_handler.call(null, row_14446, col_14451)); + var G__14452 = seq__14398_14447; + var G__14453 = chunk__14399_14448; + var G__14454 = count__14400_14449; + var G__14455 = i__14401_14450 + 1; + seq__14398_14447 = G__14452; + chunk__14399_14448 = G__14453; + count__14400_14449 = G__14454; + i__14401_14450 = G__14455; + continue; + } else { + var temp__4092__auto___14456__$1 = cljs.core.seq.call(null, seq__14398_14447); + if (temp__4092__auto___14456__$1) { + var seq__14398_14457__$1 = temp__4092__auto___14456__$1; + if (cljs.core.chunked_seq_QMARK_.call(null, seq__14398_14457__$1)) { + var c__4191__auto___14458 = cljs.core.chunk_first.call(null, seq__14398_14457__$1); + var G__14459 = cljs.core.chunk_rest.call(null, seq__14398_14457__$1); + var G__14460 = c__4191__auto___14458; + var G__14461 = cljs.core.count.call(null, c__4191__auto___14458); + var G__14462 = 0; + seq__14398_14447 = G__14459; + chunk__14399_14448 = G__14460; + count__14400_14449 = G__14461; + i__14401_14450 = G__14462; + continue; + } else { + var col_14463 = cljs.core.first.call(null, seq__14398_14457__$1); + domina.events.listen_BANG_.call(null, domina.by_id.call(null, sudorace.sudorace.cell_id.call(null, row_14446, col_14463)), new cljs.core.Keyword(null, "click", "click", 1108654330), sudorace.sudorace.click_handler.call(null, row_14446, col_14463)); + var G__14464 = cljs.core.next.call(null, seq__14398_14457__$1); + var G__14465 = null; + var G__14466 = 0; + var G__14467 = 0; + seq__14398_14447 = G__14464; + chunk__14399_14448 = G__14465; + count__14400_14449 = G__14466; + i__14401_14450 = G__14467; + continue; + } + } else { + } + } + break; + } + var G__14468 = cljs.core.next.call(null, seq__14397_14440__$1); + var G__14469 = null; + var G__14470 = 0; + var G__14471 = 0; + seq__14397_14409 = G__14468; + chunk__14402_14410 = G__14469; + count__14403_14411 = G__14470; + i__14404_14412 = G__14471; + continue; + } + } else { + } + } + break; + } + return domina.events.listen_BANG_.call(null, new cljs.core.Keyword(null, "keydown", "keydown", 4493897459), sudorace.sudorace.key_handler); +}; +sudorace.sudorace.init = function init() { + domina.append_BANG_.call(null, domina.by_id.call(null, "grid"), sudorace.sudorace.build_grid.call(null)); + return sudorace.sudorace.register_listeners.call(null); +}; +window.onload = sudorace.sudorace.init; +goog.provide("goog.events.EventTarget"); +goog.require("goog.Disposable"); +goog.require("goog.events"); +goog.require("goog.events.Event"); +goog.require("goog.events.Listenable"); +goog.require("goog.events.Listener"); +goog.require("goog.object"); +goog.events.EventTarget = function() { + goog.Disposable.call(this); + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE) { + this.eventTargetListeners_ = {}; + this.reallyDisposed_ = false; + this.actualEventTarget_ = this; + } +}; +goog.inherits(goog.events.EventTarget, goog.Disposable); +if (goog.events.Listenable.USE_LISTENABLE_INTERFACE) { + goog.events.Listenable.addImplementation(goog.events.EventTarget); +} +goog.events.EventTarget.MAX_ANCESTORS_ = 1E3; +goog.events.EventTarget.prototype.customEvent_ = true; +goog.events.EventTarget.prototype.parentEventTarget_ = null; +goog.events.EventTarget.prototype.getParentEventTarget = function() { + return this.parentEventTarget_; +}; +goog.events.EventTarget.prototype.setParentEventTarget = function(parent) { + this.parentEventTarget_ = parent; +}; +goog.events.EventTarget.prototype.addEventListener = function(type, handler, opt_capture, opt_handlerScope) { + goog.events.listen(this, type, handler, opt_capture, opt_handlerScope); +}; +goog.events.EventTarget.prototype.removeEventListener = function(type, handler, opt_capture, opt_handlerScope) { + goog.events.unlisten(this, type, handler, opt_capture, opt_handlerScope); +}; +goog.events.EventTarget.prototype.dispatchEvent = function(e) { + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE) { + if (this.reallyDisposed_) { + return true; + } + var ancestorsTree, ancestor = this.getParentEventTarget(); + if (ancestor) { + ancestorsTree = []; + var ancestorCount = 1; + for (;ancestor;ancestor = ancestor.getParentEventTarget()) { + ancestorsTree.push(ancestor); + goog.asserts.assert(++ancestorCount < goog.events.EventTarget.MAX_ANCESTORS_, "infinite loop"); + } + } + return goog.events.EventTarget.dispatchEventInternal_(this.actualEventTarget_, e, ancestorsTree); + } else { + return goog.events.dispatchEvent(this, e); + } +}; +goog.events.EventTarget.prototype.disposeInternal = function() { + goog.events.EventTarget.superClass_.disposeInternal.call(this); + if (goog.events.Listenable.USE_LISTENABLE_INTERFACE) { + this.removeAllListeners(); + this.reallyDisposed_ = true; + } else { + goog.events.removeAll(this); + } + this.parentEventTarget_ = null; +}; +if (goog.events.Listenable.USE_LISTENABLE_INTERFACE) { + goog.events.EventTarget.prototype.listen = function(type, listener, opt_useCapture, opt_listenerScope) { + return this.listenInternal_(type, listener, false, opt_useCapture, opt_listenerScope); + }; + goog.events.EventTarget.prototype.listenOnce = function(type, listener, opt_useCapture, opt_listenerScope) { + return this.listenInternal_(type, listener, true, opt_useCapture, opt_listenerScope); + }; + goog.events.EventTarget.prototype.listenInternal_ = function(type, listener, callOnce, opt_useCapture, opt_listenerScope) { + goog.asserts.assert(!this.reallyDisposed_, "Can not listen on disposed object."); + var listenerArray = this.eventTargetListeners_[type] || (this.eventTargetListeners_[type] = []); + var listenerObj; + var index = goog.events.EventTarget.findListenerIndex_(listenerArray, listener, opt_useCapture, opt_listenerScope); + if (index > -1) { + listenerObj = listenerArray[index]; + if (!callOnce) { + listenerObj.callOnce = false; + } + return listenerObj; + } + listenerObj = new goog.events.Listener; + listenerObj.init(listener, null, this, type, !!opt_useCapture, opt_listenerScope); + listenerObj.callOnce = callOnce; + listenerArray.push(listenerObj); + return listenerObj; + }; + goog.events.EventTarget.prototype.unlisten = function(type, listener, opt_useCapture, opt_listenerScope) { + if (!(type in this.eventTargetListeners_)) { + return false; + } + var listenerArray = this.eventTargetListeners_[type]; + var index = goog.events.EventTarget.findListenerIndex_(listenerArray, listener, opt_useCapture, opt_listenerScope); + if (index > -1) { + var listenerObj = listenerArray[index]; + goog.events.cleanUp(listenerObj); + listenerObj.removed = true; + return goog.array.removeAt(listenerArray, index); + } + return false; + }; + goog.events.EventTarget.prototype.unlistenByKey = function(key) { + var type = key.type; + if (!(type in this.eventTargetListeners_)) { + return false; + } + var removed = goog.array.remove(this.eventTargetListeners_[type], key); + if (removed) { + goog.events.cleanUp(key); + key.removed = true; + } + return removed; + }; + goog.events.EventTarget.prototype.removeAllListeners = function(opt_type, opt_capture) { + var count = 0; + for (var type in this.eventTargetListeners_) { + if (!opt_type || type == opt_type) { + var listenerArray = this.eventTargetListeners_[type]; + for (var i = 0;i < listenerArray.length;i++) { + ++count; + goog.events.cleanUp(listenerArray[i]); + listenerArray[i].removed = true; + } + listenerArray.length = 0; + } + } + return count; + }; + goog.events.EventTarget.prototype.fireListeners = function(type, capture, eventObject) { + goog.asserts.assert(!this.reallyDisposed_, "Can not fire listeners after dispose() completed."); + if (!(type in this.eventTargetListeners_)) { + return true; + } + var rv = true; + var listenerArray = goog.array.clone(this.eventTargetListeners_[type]); + for (var i = 0;i < listenerArray.length;++i) { + var listener = listenerArray[i]; + if (listener && (!listener.removed && listener.capture == capture)) { + if (listener.callOnce) { + this.unlistenByKey(listener); + } + rv = listener.handleEvent(eventObject) !== false && rv; + } + } + return rv && eventObject.returnValue_ != false; + }; + goog.events.EventTarget.prototype.getListeners = function(type, capture) { + var listenerArray = this.eventTargetListeners_[type]; + var rv = []; + if (listenerArray) { + for (var i = 0;i < listenerArray.length;++i) { + var listenerObj = listenerArray[i]; + if (listenerObj.capture == capture) { + rv.push(listenerObj); + } + } + } + return rv; + }; + goog.events.EventTarget.prototype.getListener = function(type, listener, capture, opt_listenerScope) { + var listenerArray = this.eventTargetListeners_[type]; + var i = -1; + if (listenerArray) { + i = goog.events.EventTarget.findListenerIndex_(listenerArray, listener, capture, opt_listenerScope); + } + return i > -1 ? listenerArray[i] : null; + }; + goog.events.EventTarget.prototype.hasListener = function(opt_type, opt_capture) { + var hasType = goog.isDef(opt_type); + var hasCapture = goog.isDef(opt_capture); + return goog.object.some(this.eventTargetListeners_, function(listenersArray, type) { + for (var i = 0;i < listenersArray.length;++i) { + if ((!hasType || listenersArray[i].type == opt_type) && (!hasCapture || listenersArray[i].capture == opt_capture)) { + return true; + } + } + return false; + }); + }; + goog.events.EventTarget.prototype.setTargetForTesting = function(target) { + this.actualEventTarget_ = target; + }; + goog.events.EventTarget.dispatchEventInternal_ = function(target, e, opt_ancestorsTree) { + var type = e.type || (e); + if (goog.isString(e)) { + e = new goog.events.Event(e, target); + } else { + if (!(e instanceof goog.events.Event)) { + var oldEvent = e; + e = new goog.events.Event(type, target); + goog.object.extend(e, oldEvent); + } else { + e.target = e.target || target; + } + } + var rv = true, currentTarget; + if (opt_ancestorsTree) { + for (var i = opt_ancestorsTree.length - 1;!e.propagationStopped_ && i >= 0;i--) { + currentTarget = e.currentTarget = opt_ancestorsTree[i]; + rv = currentTarget.fireListeners(type, true, e) && rv; + } + } + if (!e.propagationStopped_) { + currentTarget = e.currentTarget = target; + rv = currentTarget.fireListeners(type, true, e) && rv; + if (!e.propagationStopped_) { + rv = currentTarget.fireListeners(type, false, e) && rv; + } + } + if (opt_ancestorsTree) { + for (i = 0;!e.propagationStopped_ && i < opt_ancestorsTree.length;i++) { + currentTarget = e.currentTarget = opt_ancestorsTree[i]; + rv = currentTarget.fireListeners(type, false, e) && rv; + } + } + return rv; + }; + goog.events.EventTarget.findListenerIndex_ = function(listenerArray, listener, opt_useCapture, opt_listenerScope) { + for (var i = 0;i < listenerArray.length;++i) { + var listenerObj = listenerArray[i]; + if (listenerObj.listener == listener && (listenerObj.capture == !!opt_useCapture && listenerObj.handler == opt_listenerScope)) { + return i; + } + } + return-1; + }; +} +;goog.provide("goog.Timer"); +goog.require("goog.events.EventTarget"); +goog.Timer = function(opt_interval, opt_timerObject) { + goog.events.EventTarget.call(this); + this.interval_ = opt_interval || 1; + this.timerObject_ = opt_timerObject || goog.Timer.defaultTimerObject; + this.boundTick_ = goog.bind(this.tick_, this); + this.last_ = goog.now(); +}; +goog.inherits(goog.Timer, goog.events.EventTarget); +goog.Timer.MAX_TIMEOUT_ = 2147483647; +goog.Timer.prototype.enabled = false; +goog.Timer.defaultTimerObject = goog.global; +goog.Timer.intervalScale = 0.8; +goog.Timer.prototype.timer_ = null; +goog.Timer.prototype.getInterval = function() { + return this.interval_; +}; +goog.Timer.prototype.setInterval = function(interval) { + this.interval_ = interval; + if (this.timer_ && this.enabled) { + this.stop(); + this.start(); + } else { + if (this.timer_) { + this.stop(); + } + } +}; +goog.Timer.prototype.tick_ = function() { + if (this.enabled) { + var elapsed = goog.now() - this.last_; + if (elapsed > 0 && elapsed < this.interval_ * goog.Timer.intervalScale) { + this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_ - elapsed); + return; + } + this.dispatchTick(); + if (this.enabled) { + this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_); + this.last_ = goog.now(); + } + } +}; +goog.Timer.prototype.dispatchTick = function() { + this.dispatchEvent(goog.Timer.TICK); +}; +goog.Timer.prototype.start = function() { + this.enabled = true; + if (!this.timer_) { + this.timer_ = this.timerObject_.setTimeout(this.boundTick_, this.interval_); + this.last_ = goog.now(); + } +}; +goog.Timer.prototype.stop = function() { + this.enabled = false; + if (this.timer_) { + this.timerObject_.clearTimeout(this.timer_); + this.timer_ = null; + } +}; +goog.Timer.prototype.disposeInternal = function() { + goog.Timer.superClass_.disposeInternal.call(this); + this.stop(); + delete this.timerObject_; +}; +goog.Timer.TICK = "tick"; +goog.Timer.callOnce = function(listener, opt_delay, opt_handler) { + if (goog.isFunction(listener)) { + if (opt_handler) { + listener = goog.bind(listener, opt_handler); + } + } else { + if (listener && typeof listener.handleEvent == "function") { + listener = goog.bind(listener.handleEvent, listener); + } else { + throw Error("Invalid listener argument"); + } + } + if (opt_delay > goog.Timer.MAX_TIMEOUT_) { + return-1; + } else { + return goog.Timer.defaultTimerObject.setTimeout(listener, opt_delay || 0); + } +}; +goog.Timer.clear = function(timerId) { + goog.Timer.defaultTimerObject.clearTimeout(timerId); +}; +goog.provide("goog.structs.Collection"); +goog.structs.Collection = function() { +}; +goog.structs.Collection.prototype.add; +goog.structs.Collection.prototype.remove; +goog.structs.Collection.prototype.contains; +goog.structs.Collection.prototype.getCount; +goog.provide("goog.structs.Set"); +goog.require("goog.structs"); +goog.require("goog.structs.Collection"); +goog.require("goog.structs.Map"); +goog.structs.Set = function(opt_values) { + this.map_ = new goog.structs.Map; + if (opt_values) { + this.addAll(opt_values); + } +}; +goog.structs.Set.getKey_ = function(val) { + var type = typeof val; + if (type == "object" && val || type == "function") { + return "o" + goog.getUid((val)); + } else { + return type.substr(0, 1) + val; + } +}; +goog.structs.Set.prototype.getCount = function() { + return this.map_.getCount(); +}; +goog.structs.Set.prototype.add = function(element) { + this.map_.set(goog.structs.Set.getKey_(element), element); +}; +goog.structs.Set.prototype.addAll = function(col) { + var values = goog.structs.getValues(col); + var l = values.length; + for (var i = 0;i < l;i++) { + this.add(values[i]); + } +}; +goog.structs.Set.prototype.removeAll = function(col) { + var values = goog.structs.getValues(col); + var l = values.length; + for (var i = 0;i < l;i++) { + this.remove(values[i]); + } +}; +goog.structs.Set.prototype.remove = function(element) { + return this.map_.remove(goog.structs.Set.getKey_(element)); +}; +goog.structs.Set.prototype.clear = function() { + this.map_.clear(); +}; +goog.structs.Set.prototype.isEmpty = function() { + return this.map_.isEmpty(); +}; +goog.structs.Set.prototype.contains = function(element) { + return this.map_.containsKey(goog.structs.Set.getKey_(element)); +}; +goog.structs.Set.prototype.containsAll = function(col) { + return goog.structs.every(col, this.contains, this); +}; +goog.structs.Set.prototype.intersection = function(col) { + var result = new goog.structs.Set; + var values = goog.structs.getValues(col); + for (var i = 0;i < values.length;i++) { + var value = values[i]; + if (this.contains(value)) { + result.add(value); + } + } + return result; +}; +goog.structs.Set.prototype.difference = function(col) { + var result = this.clone(); + result.removeAll(col); + return result; +}; +goog.structs.Set.prototype.getValues = function() { + return this.map_.getValues(); +}; +goog.structs.Set.prototype.clone = function() { + return new goog.structs.Set(this); +}; +goog.structs.Set.prototype.equals = function(col) { + return this.getCount() == goog.structs.getCount(col) && this.isSubsetOf(col); +}; +goog.structs.Set.prototype.isSubsetOf = function(col) { + var colCount = goog.structs.getCount(col); + if (this.getCount() > colCount) { + return false; + } + if (!(col instanceof goog.structs.Set) && colCount > 5) { + col = new goog.structs.Set(col); + } + return goog.structs.every(this, function(value) { + return goog.structs.contains(col, value); + }); +}; +goog.structs.Set.prototype.__iterator__ = function(opt_keys) { + return this.map_.__iterator__(false); +}; +goog.provide("goog.debug"); +goog.require("goog.array"); +goog.require("goog.string"); +goog.require("goog.structs.Set"); +goog.require("goog.userAgent"); +goog.debug.catchErrors = function(logFunc, opt_cancel, opt_target) { + var target = opt_target || goog.global; + var oldErrorHandler = target.onerror; + var retVal = !!opt_cancel; + if (goog.userAgent.WEBKIT && !goog.userAgent.isVersion("535.3")) { + retVal = !retVal; + } + target.onerror = function(message, url, line) { + if (oldErrorHandler) { + oldErrorHandler(message, url, line); + } + logFunc({message:message, fileName:url, line:line}); + return retVal; + }; +}; +goog.debug.expose = function(obj, opt_showFn) { + if (typeof obj == "undefined") { + return "undefined"; + } + if (obj == null) { + return "NULL"; + } + var str = []; + for (var x in obj) { + if (!opt_showFn && goog.isFunction(obj[x])) { + continue; + } + var s = x + " \x3d "; + try { + s += obj[x]; + } catch (e) { + s += "*** " + e + " ***"; + } + str.push(s); + } + return str.join("\n"); +}; +goog.debug.deepExpose = function(obj, opt_showFn) { + var previous = new goog.structs.Set; + var str = []; + var helper = function(obj, space) { + var nestspace = space + " "; + var indentMultiline = function(str) { + return str.replace(/\n/g, "\n" + space); + }; + try { + if (!goog.isDef(obj)) { + str.push("undefined"); + } else { + if (goog.isNull(obj)) { + str.push("NULL"); + } else { + if (goog.isString(obj)) { + str.push('"' + indentMultiline(obj) + '"'); + } else { + if (goog.isFunction(obj)) { + str.push(indentMultiline(String(obj))); + } else { + if (goog.isObject(obj)) { + if (previous.contains(obj)) { + str.push("*** reference loop detected ***"); + } else { + previous.add(obj); + str.push("{"); + for (var x in obj) { + if (!opt_showFn && goog.isFunction(obj[x])) { + continue; + } + str.push("\n"); + str.push(nestspace); + str.push(x + " \x3d "); + helper(obj[x], nestspace); + } + str.push("\n" + space + "}"); + } + } else { + str.push(obj); + } + } + } + } + } + } catch (e) { + str.push("*** " + e + " ***"); + } + }; + helper(obj, ""); + return str.join(""); +}; +goog.debug.exposeArray = function(arr) { + var str = []; + for (var i = 0;i < arr.length;i++) { + if (goog.isArray(arr[i])) { + str.push(goog.debug.exposeArray(arr[i])); + } else { + str.push(arr[i]); + } + } + return "[ " + str.join(", ") + " ]"; +}; +goog.debug.exposeException = function(err, opt_fn) { + try { + var e = goog.debug.normalizeErrorObject(err); + var error = "Message: " + goog.string.htmlEscape(e.message) + '\nUrl: \x3ca href\x3d"view-source:' + e.fileName + '" target\x3d"_new"\x3e' + e.fileName + "\x3c/a\x3e\nLine: " + e.lineNumber + "\n\nBrowser stack:\n" + goog.string.htmlEscape(e.stack + "-\x3e ") + "[end]\n\nJS stack traversal:\n" + goog.string.htmlEscape(goog.debug.getStacktrace(opt_fn) + "-\x3e "); + return error; + } catch (e2) { + return "Exception trying to expose exception! You win, we lose. " + e2; + } +}; +goog.debug.normalizeErrorObject = function(err) { + var href = goog.getObjectByName("window.location.href"); + if (goog.isString(err)) { + return{"message":err, "name":"Unknown error", "lineNumber":"Not available", "fileName":href, "stack":"Not available"}; + } + var lineNumber, fileName; + var threwError = false; + try { + lineNumber = err.lineNumber || (err.line || "Not available"); + } catch (e) { + lineNumber = "Not available"; + threwError = true; + } + try { + fileName = err.fileName || (err.filename || (err.sourceURL || (goog.global["$googDebugFname"] || href))); + } catch (e) { + fileName = "Not available"; + threwError = true; + } + if (threwError || (!err.lineNumber || (!err.fileName || !err.stack))) { + return{"message":err.message, "name":err.name, "lineNumber":lineNumber, "fileName":fileName, "stack":err.stack || "Not available"}; + } + return err; +}; +goog.debug.enhanceError = function(err, opt_message) { + var error = typeof err == "string" ? Error(err) : err; + if (!error.stack) { + error.stack = goog.debug.getStacktrace(arguments.callee.caller); + } + if (opt_message) { + var x = 0; + while (error["message" + x]) { + ++x; + } + error["message" + x] = String(opt_message); + } + return error; +}; +goog.debug.getStacktraceSimple = function(opt_depth) { + var sb = []; + var fn = arguments.callee.caller; + var depth = 0; + while (fn && (!opt_depth || depth < opt_depth)) { + sb.push(goog.debug.getFunctionName(fn)); + sb.push("()\n"); + try { + fn = fn.caller; + } catch (e) { + sb.push("[exception trying to get caller]\n"); + break; + } + depth++; + if (depth >= goog.debug.MAX_STACK_DEPTH) { + sb.push("[...long stack...]"); + break; + } + } + if (opt_depth && depth >= opt_depth) { + sb.push("[...reached max depth limit...]"); + } else { + sb.push("[end]"); + } + return sb.join(""); +}; +goog.debug.MAX_STACK_DEPTH = 50; +goog.debug.getStacktrace = function(opt_fn) { + return goog.debug.getStacktraceHelper_(opt_fn || arguments.callee.caller, []); +}; +goog.debug.getStacktraceHelper_ = function(fn, visited) { + var sb = []; + if (goog.array.contains(visited, fn)) { + sb.push("[...circular reference...]"); + } else { + if (fn && visited.length < goog.debug.MAX_STACK_DEPTH) { + sb.push(goog.debug.getFunctionName(fn) + "("); + var args = fn.arguments; + for (var i = 0;i < args.length;i++) { + if (i > 0) { + sb.push(", "); + } + var argDesc; + var arg = args[i]; + switch(typeof arg) { + case "object": + argDesc = arg ? "object" : "null"; + break; + case "string": + argDesc = arg; + break; + case "number": + argDesc = String(arg); + break; + case "boolean": + argDesc = arg ? "true" : "false"; + break; + case "function": + argDesc = goog.debug.getFunctionName(arg); + argDesc = argDesc ? argDesc : "[fn]"; + break; + case "undefined": + ; + default: + argDesc = typeof arg; + break; + } + if (argDesc.length > 40) { + argDesc = argDesc.substr(0, 40) + "..."; + } + sb.push(argDesc); + } + visited.push(fn); + sb.push(")\n"); + try { + sb.push(goog.debug.getStacktraceHelper_(fn.caller, visited)); + } catch (e) { + sb.push("[exception trying to get caller]\n"); + } + } else { + if (fn) { + sb.push("[...long stack...]"); + } else { + sb.push("[end]"); + } + } + } + return sb.join(""); +}; +goog.debug.setFunctionResolver = function(resolver) { + goog.debug.fnNameResolver_ = resolver; +}; +goog.debug.getFunctionName = function(fn) { + if (goog.debug.fnNameCache_[fn]) { + return goog.debug.fnNameCache_[fn]; + } + if (goog.debug.fnNameResolver_) { + var name = goog.debug.fnNameResolver_(fn); + if (name) { + goog.debug.fnNameCache_[fn] = name; + return name; + } + } + var functionSource = String(fn); + if (!goog.debug.fnNameCache_[functionSource]) { + var matches = /function ([^\(]+)/.exec(functionSource); + if (matches) { + var method = matches[1]; + goog.debug.fnNameCache_[functionSource] = method; + } else { + goog.debug.fnNameCache_[functionSource] = "[Anonymous]"; + } + } + return goog.debug.fnNameCache_[functionSource]; +}; +goog.debug.makeWhitespaceVisible = function(string) { + return string.replace(/ /g, "[_]").replace(/\f/g, "[f]").replace(/\n/g, "[n]\n").replace(/\r/g, "[r]").replace(/\t/g, "[t]"); +}; +goog.debug.fnNameCache_ = {}; +goog.debug.fnNameResolver_; +goog.provide("goog.debug.LogRecord"); +goog.debug.LogRecord = function(level, msg, loggerName, opt_time, opt_sequenceNumber) { + this.reset(level, msg, loggerName, opt_time, opt_sequenceNumber); +}; +goog.debug.LogRecord.prototype.time_; +goog.debug.LogRecord.prototype.level_; +goog.debug.LogRecord.prototype.msg_; +goog.debug.LogRecord.prototype.loggerName_; +goog.debug.LogRecord.prototype.sequenceNumber_ = 0; +goog.debug.LogRecord.prototype.exception_ = null; +goog.debug.LogRecord.prototype.exceptionText_ = null; +goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS = true; +goog.debug.LogRecord.nextSequenceNumber_ = 0; +goog.debug.LogRecord.prototype.reset = function(level, msg, loggerName, opt_time, opt_sequenceNumber) { + if (goog.debug.LogRecord.ENABLE_SEQUENCE_NUMBERS) { + this.sequenceNumber_ = typeof opt_sequenceNumber == "number" ? opt_sequenceNumber : goog.debug.LogRecord.nextSequenceNumber_++; + } + this.time_ = opt_time || goog.now(); + this.level_ = level; + this.msg_ = msg; + this.loggerName_ = loggerName; + delete this.exception_; + delete this.exceptionText_; +}; +goog.debug.LogRecord.prototype.getLoggerName = function() { + return this.loggerName_; +}; +goog.debug.LogRecord.prototype.getException = function() { + return this.exception_; +}; +goog.debug.LogRecord.prototype.setException = function(exception) { + this.exception_ = exception; +}; +goog.debug.LogRecord.prototype.getExceptionText = function() { + return this.exceptionText_; +}; +goog.debug.LogRecord.prototype.setExceptionText = function(text) { + this.exceptionText_ = text; +}; +goog.debug.LogRecord.prototype.setLoggerName = function(loggerName) { + this.loggerName_ = loggerName; +}; +goog.debug.LogRecord.prototype.getLevel = function() { + return this.level_; +}; +goog.debug.LogRecord.prototype.setLevel = function(level) { + this.level_ = level; +}; +goog.debug.LogRecord.prototype.getMessage = function() { + return this.msg_; +}; +goog.debug.LogRecord.prototype.setMessage = function(msg) { + this.msg_ = msg; +}; +goog.debug.LogRecord.prototype.getMillis = function() { + return this.time_; +}; +goog.debug.LogRecord.prototype.setMillis = function(time) { + this.time_ = time; +}; +goog.debug.LogRecord.prototype.getSequenceNumber = function() { + return this.sequenceNumber_; +}; +goog.provide("goog.debug.LogBuffer"); +goog.require("goog.asserts"); +goog.require("goog.debug.LogRecord"); +goog.debug.LogBuffer = function() { + goog.asserts.assert(goog.debug.LogBuffer.isBufferingEnabled(), "Cannot use goog.debug.LogBuffer without defining " + "goog.debug.LogBuffer.CAPACITY."); + this.clear(); +}; +goog.debug.LogBuffer.getInstance = function() { + if (!goog.debug.LogBuffer.instance_) { + goog.debug.LogBuffer.instance_ = new goog.debug.LogBuffer; + } + return goog.debug.LogBuffer.instance_; +}; +goog.debug.LogBuffer.CAPACITY = 0; +goog.debug.LogBuffer.prototype.buffer_; +goog.debug.LogBuffer.prototype.curIndex_; +goog.debug.LogBuffer.prototype.isFull_; +goog.debug.LogBuffer.prototype.addRecord = function(level, msg, loggerName) { + var curIndex = (this.curIndex_ + 1) % goog.debug.LogBuffer.CAPACITY; + this.curIndex_ = curIndex; + if (this.isFull_) { + var ret = this.buffer_[curIndex]; + ret.reset(level, msg, loggerName); + return ret; + } + this.isFull_ = curIndex == goog.debug.LogBuffer.CAPACITY - 1; + return this.buffer_[curIndex] = new goog.debug.LogRecord(level, msg, loggerName); +}; +goog.debug.LogBuffer.isBufferingEnabled = function() { + return goog.debug.LogBuffer.CAPACITY > 0; +}; +goog.debug.LogBuffer.prototype.clear = function() { + this.buffer_ = new Array(goog.debug.LogBuffer.CAPACITY); + this.curIndex_ = -1; + this.isFull_ = false; +}; +goog.debug.LogBuffer.prototype.forEachRecord = function(func) { + var buffer = this.buffer_; + if (!buffer[0]) { + return; + } + var curIndex = this.curIndex_; + var i = this.isFull_ ? curIndex : -1; + do { + i = (i + 1) % goog.debug.LogBuffer.CAPACITY; + func((buffer[i])); + } while (i != curIndex); +}; +goog.provide("goog.debug.LogManager"); +goog.provide("goog.debug.Logger"); +goog.provide("goog.debug.Logger.Level"); +goog.require("goog.array"); +goog.require("goog.asserts"); +goog.require("goog.debug"); +goog.require("goog.debug.LogBuffer"); +goog.require("goog.debug.LogRecord"); +goog.debug.Logger = function(name) { + this.name_ = name; +}; +goog.debug.Logger.prototype.parent_ = null; +goog.debug.Logger.prototype.level_ = null; +goog.debug.Logger.prototype.children_ = null; +goog.debug.Logger.prototype.handlers_ = null; +goog.debug.Logger.ENABLE_HIERARCHY = true; +if (!goog.debug.Logger.ENABLE_HIERARCHY) { + goog.debug.Logger.rootHandlers_ = []; + goog.debug.Logger.rootLevel_; +} +goog.debug.Logger.Level = function(name, value) { + this.name = name; + this.value = value; +}; +goog.debug.Logger.Level.prototype.toString = function() { + return this.name; +}; +goog.debug.Logger.Level.OFF = new goog.debug.Logger.Level("OFF", Infinity); +goog.debug.Logger.Level.SHOUT = new goog.debug.Logger.Level("SHOUT", 1200); +goog.debug.Logger.Level.SEVERE = new goog.debug.Logger.Level("SEVERE", 1E3); +goog.debug.Logger.Level.WARNING = new goog.debug.Logger.Level("WARNING", 900); +goog.debug.Logger.Level.INFO = new goog.debug.Logger.Level("INFO", 800); +goog.debug.Logger.Level.CONFIG = new goog.debug.Logger.Level("CONFIG", 700); +goog.debug.Logger.Level.FINE = new goog.debug.Logger.Level("FINE", 500); +goog.debug.Logger.Level.FINER = new goog.debug.Logger.Level("FINER", 400); +goog.debug.Logger.Level.FINEST = new goog.debug.Logger.Level("FINEST", 300); +goog.debug.Logger.Level.ALL = new goog.debug.Logger.Level("ALL", 0); +goog.debug.Logger.Level.PREDEFINED_LEVELS = [goog.debug.Logger.Level.OFF, goog.debug.Logger.Level.SHOUT, goog.debug.Logger.Level.SEVERE, goog.debug.Logger.Level.WARNING, goog.debug.Logger.Level.INFO, goog.debug.Logger.Level.CONFIG, goog.debug.Logger.Level.FINE, goog.debug.Logger.Level.FINER, goog.debug.Logger.Level.FINEST, goog.debug.Logger.Level.ALL]; +goog.debug.Logger.Level.predefinedLevelsCache_ = null; +goog.debug.Logger.Level.createPredefinedLevelsCache_ = function() { + goog.debug.Logger.Level.predefinedLevelsCache_ = {}; + for (var i = 0, level;level = goog.debug.Logger.Level.PREDEFINED_LEVELS[i];i++) { + goog.debug.Logger.Level.predefinedLevelsCache_[level.value] = level; + goog.debug.Logger.Level.predefinedLevelsCache_[level.name] = level; + } +}; +goog.debug.Logger.Level.getPredefinedLevel = function(name) { + if (!goog.debug.Logger.Level.predefinedLevelsCache_) { + goog.debug.Logger.Level.createPredefinedLevelsCache_(); + } + return goog.debug.Logger.Level.predefinedLevelsCache_[name] || null; +}; +goog.debug.Logger.Level.getPredefinedLevelByValue = function(value) { + if (!goog.debug.Logger.Level.predefinedLevelsCache_) { + goog.debug.Logger.Level.createPredefinedLevelsCache_(); + } + if (value in goog.debug.Logger.Level.predefinedLevelsCache_) { + return goog.debug.Logger.Level.predefinedLevelsCache_[value]; + } + for (var i = 0;i < goog.debug.Logger.Level.PREDEFINED_LEVELS.length;++i) { + var level = goog.debug.Logger.Level.PREDEFINED_LEVELS[i]; + if (level.value <= value) { + return level; + } + } + return null; +}; +goog.debug.Logger.getLogger = function(name) { + return goog.debug.LogManager.getLogger(name); +}; +goog.debug.Logger.logToProfilers = function(msg) { + if (goog.global["console"]) { + if (goog.global["console"]["timeStamp"]) { + goog.global["console"]["timeStamp"](msg); + } else { + if (goog.global["console"]["markTimeline"]) { + goog.global["console"]["markTimeline"](msg); + } + } + } + if (goog.global["msWriteProfilerMark"]) { + goog.global["msWriteProfilerMark"](msg); + } +}; +goog.debug.Logger.prototype.getName = function() { + return this.name_; +}; +goog.debug.Logger.prototype.addHandler = function(handler) { + if (goog.debug.Logger.ENABLE_HIERARCHY) { + if (!this.handlers_) { + this.handlers_ = []; + } + this.handlers_.push(handler); + } else { + goog.asserts.assert(!this.name_, "Cannot call addHandler on a non-root logger when " + "goog.debug.Logger.ENABLE_HIERARCHY is false."); + goog.debug.Logger.rootHandlers_.push(handler); + } +}; +goog.debug.Logger.prototype.removeHandler = function(handler) { + var handlers = goog.debug.Logger.ENABLE_HIERARCHY ? this.handlers_ : goog.debug.Logger.rootHandlers_; + return!!handlers && goog.array.remove(handlers, handler); +}; +goog.debug.Logger.prototype.getParent = function() { + return this.parent_; +}; +goog.debug.Logger.prototype.getChildren = function() { + if (!this.children_) { + this.children_ = {}; + } + return this.children_; +}; +goog.debug.Logger.prototype.setLevel = function(level) { + if (goog.debug.Logger.ENABLE_HIERARCHY) { + this.level_ = level; + } else { + goog.asserts.assert(!this.name_, "Cannot call setLevel() on a non-root logger when " + "goog.debug.Logger.ENABLE_HIERARCHY is false."); + goog.debug.Logger.rootLevel_ = level; + } +}; +goog.debug.Logger.prototype.getLevel = function() { + return this.level_; +}; +goog.debug.Logger.prototype.getEffectiveLevel = function() { + if (!goog.debug.Logger.ENABLE_HIERARCHY) { + return goog.debug.Logger.rootLevel_; + } + if (this.level_) { + return this.level_; + } + if (this.parent_) { + return this.parent_.getEffectiveLevel(); + } + goog.asserts.fail("Root logger has no level set."); + return null; +}; +goog.debug.Logger.prototype.isLoggable = function(level) { + return level.value >= this.getEffectiveLevel().value; +}; +goog.debug.Logger.prototype.log = function(level, msg, opt_exception) { + if (this.isLoggable(level)) { + this.doLogRecord_(this.getLogRecord(level, msg, opt_exception)); + } +}; +goog.debug.Logger.prototype.getLogRecord = function(level, msg, opt_exception) { + if (goog.debug.LogBuffer.isBufferingEnabled()) { + var logRecord = goog.debug.LogBuffer.getInstance().addRecord(level, msg, this.name_) + } else { + logRecord = new goog.debug.LogRecord(level, String(msg), this.name_); + } + if (opt_exception) { + logRecord.setException(opt_exception); + logRecord.setExceptionText(goog.debug.exposeException(opt_exception, arguments.callee.caller)); + } + return logRecord; +}; +goog.debug.Logger.prototype.shout = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.SHOUT, msg, opt_exception); +}; +goog.debug.Logger.prototype.severe = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.SEVERE, msg, opt_exception); +}; +goog.debug.Logger.prototype.warning = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.WARNING, msg, opt_exception); +}; +goog.debug.Logger.prototype.info = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.INFO, msg, opt_exception); +}; +goog.debug.Logger.prototype.config = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.CONFIG, msg, opt_exception); +}; +goog.debug.Logger.prototype.fine = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.FINE, msg, opt_exception); +}; +goog.debug.Logger.prototype.finer = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.FINER, msg, opt_exception); +}; +goog.debug.Logger.prototype.finest = function(msg, opt_exception) { + this.log(goog.debug.Logger.Level.FINEST, msg, opt_exception); +}; +goog.debug.Logger.prototype.logRecord = function(logRecord) { + if (this.isLoggable(logRecord.getLevel())) { + this.doLogRecord_(logRecord); + } +}; +goog.debug.Logger.prototype.doLogRecord_ = function(logRecord) { + goog.debug.Logger.logToProfilers("log:" + logRecord.getMessage()); + if (goog.debug.Logger.ENABLE_HIERARCHY) { + var target = this; + while (target) { + target.callPublish_(logRecord); + target = target.getParent(); + } + } else { + for (var i = 0, handler;handler = goog.debug.Logger.rootHandlers_[i++];) { + handler(logRecord); + } + } +}; +goog.debug.Logger.prototype.callPublish_ = function(logRecord) { + if (this.handlers_) { + for (var i = 0, handler;handler = this.handlers_[i];i++) { + handler(logRecord); + } + } +}; +goog.debug.Logger.prototype.setParent_ = function(parent) { + this.parent_ = parent; +}; +goog.debug.Logger.prototype.addChild_ = function(name, logger) { + this.getChildren()[name] = logger; +}; +goog.debug.LogManager = {}; +goog.debug.LogManager.loggers_ = {}; +goog.debug.LogManager.rootLogger_ = null; +goog.debug.LogManager.initialize = function() { + if (!goog.debug.LogManager.rootLogger_) { + goog.debug.LogManager.rootLogger_ = new goog.debug.Logger(""); + goog.debug.LogManager.loggers_[""] = goog.debug.LogManager.rootLogger_; + goog.debug.LogManager.rootLogger_.setLevel(goog.debug.Logger.Level.CONFIG); + } +}; +goog.debug.LogManager.getLoggers = function() { + return goog.debug.LogManager.loggers_; +}; +goog.debug.LogManager.getRoot = function() { + goog.debug.LogManager.initialize(); + return(goog.debug.LogManager.rootLogger_); +}; +goog.debug.LogManager.getLogger = function(name) { + goog.debug.LogManager.initialize(); + var ret = goog.debug.LogManager.loggers_[name]; + return ret || goog.debug.LogManager.createLogger_(name); +}; +goog.debug.LogManager.createFunctionForCatchErrors = function(opt_logger) { + return function(info) { + var logger = opt_logger || goog.debug.LogManager.getRoot(); + logger.severe("Error: " + info.message + " (" + info.fileName + " @ Line: " + info.line + ")"); + }; +}; +goog.debug.LogManager.createLogger_ = function(name) { + var logger = new goog.debug.Logger(name); + if (goog.debug.Logger.ENABLE_HIERARCHY) { + var lastDotIndex = name.lastIndexOf("."); + var parentName = name.substr(0, lastDotIndex); + var leafName = name.substr(lastDotIndex + 1); + var parentLogger = goog.debug.LogManager.getLogger(parentName); + parentLogger.addChild_(leafName, logger); + logger.setParent_(parentLogger); + } + goog.debug.LogManager.loggers_[name] = logger; + return logger; +}; +goog.provide("goog.json"); +goog.provide("goog.json.Serializer"); +goog.json.isValid_ = function(s) { + if (/^\s*$/.test(s)) { + return false; + } + var backslashesRe = /\\["\\\/bfnrtu]/g; + var simpleValuesRe = /"[^"\\\n\r\u2028\u2029\x00-\x08\x0a-\x1f]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g; + var openBracketsRe = /(?:^|:|,)(?:[\s\u2028\u2029]*\[)+/g; + var remainderRe = /^[\],:{}\s\u2028\u2029]*$/; + return remainderRe.test(s.replace(backslashesRe, "@").replace(simpleValuesRe, "]").replace(openBracketsRe, "")); +}; +goog.json.parse = function(s) { + var o = String(s); + if (goog.json.isValid_(o)) { + try { + return(eval("(" + o + ")")); + } catch (ex) { + } + } + throw Error("Invalid JSON string: " + o); +}; +goog.json.unsafeParse = function(s) { + return(eval("(" + s + ")")); +}; +goog.json.Replacer; +goog.json.Reviver; +goog.json.serialize = function(object, opt_replacer) { + return(new goog.json.Serializer(opt_replacer)).serialize(object); +}; +goog.json.Serializer = function(opt_replacer) { + this.replacer_ = opt_replacer; +}; +goog.json.Serializer.prototype.serialize = function(object) { + var sb = []; + this.serialize_(object, sb); + return sb.join(""); +}; +goog.json.Serializer.prototype.serialize_ = function(object, sb) { + switch(typeof object) { + case "string": + this.serializeString_((object), sb); + break; + case "number": + this.serializeNumber_((object), sb); + break; + case "boolean": + sb.push(object); + break; + case "undefined": + sb.push("null"); + break; + case "object": + if (object == null) { + sb.push("null"); + break; + } + if (goog.isArray(object)) { + this.serializeArray((object), sb); + break; + } + this.serializeObject_((object), sb); + break; + case "function": + break; + default: + throw Error("Unknown type: " + typeof object);; + } +}; +goog.json.Serializer.charToJsonCharCache_ = {'"':'\\"', "\\":"\\\\", "/":"\\/", "\b":"\\b", "\f":"\\f", "\n":"\\n", "\r":"\\r", "\t":"\\t", "\x0B":"\\u000b"}; +goog.json.Serializer.charsToReplace_ = /\uffff/.test("\uffff") ? /[\\\"\x00-\x1f\x7f-\uffff]/g : /[\\\"\x00-\x1f\x7f-\xff]/g; +goog.json.Serializer.prototype.serializeString_ = function(s, sb) { + sb.push('"', s.replace(goog.json.Serializer.charsToReplace_, function(c) { + if (c in goog.json.Serializer.charToJsonCharCache_) { + return goog.json.Serializer.charToJsonCharCache_[c]; + } + var cc = c.charCodeAt(0); + var rv = "\\u"; + if (cc < 16) { + rv += "000"; + } else { + if (cc < 256) { + rv += "00"; + } else { + if (cc < 4096) { + rv += "0"; + } + } + } + return goog.json.Serializer.charToJsonCharCache_[c] = rv + cc.toString(16); + }), '"'); +}; +goog.json.Serializer.prototype.serializeNumber_ = function(n, sb) { + sb.push(isFinite(n) && !isNaN(n) ? n : "null"); +}; +goog.json.Serializer.prototype.serializeArray = function(arr, sb) { + var l = arr.length; + sb.push("["); + var sep = ""; + for (var i = 0;i < l;i++) { + sb.push(sep); + var value = arr[i]; + this.serialize_(this.replacer_ ? this.replacer_.call(arr, String(i), value) : value, sb); + sep = ","; + } + sb.push("]"); +}; +goog.json.Serializer.prototype.serializeObject_ = function(obj, sb) { + sb.push("{"); + var sep = ""; + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var value = obj[key]; + if (typeof value != "function") { + sb.push(sep); + this.serializeString_(key, sb); + sb.push(":"); + this.serialize_(this.replacer_ ? this.replacer_.call(obj, key, value) : value, sb); + sep = ","; + } + } + } + sb.push("}"); +}; +goog.provide("goog.net.ErrorCode"); +goog.net.ErrorCode = {NO_ERROR:0, ACCESS_DENIED:1, FILE_NOT_FOUND:2, FF_SILENT_ERROR:3, CUSTOM_ERROR:4, EXCEPTION:5, HTTP_ERROR:6, ABORT:7, TIMEOUT:8, OFFLINE:9}; +goog.net.ErrorCode.getDebugMessage = function(errorCode) { + switch(errorCode) { + case goog.net.ErrorCode.NO_ERROR: + return "No Error"; + case goog.net.ErrorCode.ACCESS_DENIED: + return "Access denied to content document"; + case goog.net.ErrorCode.FILE_NOT_FOUND: + return "File not found"; + case goog.net.ErrorCode.FF_SILENT_ERROR: + return "Firefox silently errored"; + case goog.net.ErrorCode.CUSTOM_ERROR: + return "Application custom error"; + case goog.net.ErrorCode.EXCEPTION: + return "An exception occurred"; + case goog.net.ErrorCode.HTTP_ERROR: + return "Http response at 400 or 500 level"; + case goog.net.ErrorCode.ABORT: + return "Request was aborted"; + case goog.net.ErrorCode.TIMEOUT: + return "Request timed out"; + case goog.net.ErrorCode.OFFLINE: + return "The resource is not available offline"; + default: + return "Unrecognized error code"; + } +}; +goog.provide("goog.net.EventType"); +goog.net.EventType = {COMPLETE:"complete", SUCCESS:"success", ERROR:"error", ABORT:"abort", READY:"ready", READY_STATE_CHANGE:"readystatechange", TIMEOUT:"timeout", INCREMENTAL_DATA:"incrementaldata", PROGRESS:"progress"}; +goog.provide("goog.net.HttpStatus"); +goog.net.HttpStatus = {CONTINUE:100, SWITCHING_PROTOCOLS:101, OK:200, CREATED:201, ACCEPTED:202, NON_AUTHORITATIVE_INFORMATION:203, NO_CONTENT:204, RESET_CONTENT:205, PARTIAL_CONTENT:206, MULTIPLE_CHOICES:300, MOVED_PERMANENTLY:301, FOUND:302, SEE_OTHER:303, NOT_MODIFIED:304, USE_PROXY:305, TEMPORARY_REDIRECT:307, BAD_REQUEST:400, UNAUTHORIZED:401, PAYMENT_REQUIRED:402, FORBIDDEN:403, NOT_FOUND:404, METHOD_NOT_ALLOWED:405, NOT_ACCEPTABLE:406, PROXY_AUTHENTICATION_REQUIRED:407, REQUEST_TIMEOUT:408, +CONFLICT:409, GONE:410, LENGTH_REQUIRED:411, PRECONDITION_FAILED:412, REQUEST_ENTITY_TOO_LARGE:413, REQUEST_URI_TOO_LONG:414, UNSUPPORTED_MEDIA_TYPE:415, REQUEST_RANGE_NOT_SATISFIABLE:416, EXPECTATION_FAILED:417, INTERNAL_SERVER_ERROR:500, NOT_IMPLEMENTED:501, BAD_GATEWAY:502, SERVICE_UNAVAILABLE:503, GATEWAY_TIMEOUT:504, HTTP_VERSION_NOT_SUPPORTED:505, QUIRK_IE_NO_CONTENT:1223}; +goog.net.HttpStatus.isSuccess = function(status) { + switch(status) { + case goog.net.HttpStatus.OK: + ; + case goog.net.HttpStatus.CREATED: + ; + case goog.net.HttpStatus.ACCEPTED: + ; + case goog.net.HttpStatus.NO_CONTENT: + ; + case goog.net.HttpStatus.PARTIAL_CONTENT: + ; + case goog.net.HttpStatus.NOT_MODIFIED: + ; + case goog.net.HttpStatus.QUIRK_IE_NO_CONTENT: + return true; + default: + return false; + } +}; +goog.provide("goog.net.XmlHttpFactory"); +goog.net.XmlHttpFactory = function() { +}; +goog.net.XmlHttpFactory.prototype.cachedOptions_ = null; +goog.net.XmlHttpFactory.prototype.createInstance = goog.abstractMethod; +goog.net.XmlHttpFactory.prototype.getOptions = function() { + return this.cachedOptions_ || (this.cachedOptions_ = this.internalGetOptions()); +}; +goog.net.XmlHttpFactory.prototype.internalGetOptions = goog.abstractMethod; +goog.provide("goog.net.WrapperXmlHttpFactory"); +goog.require("goog.net.XmlHttpFactory"); +goog.net.WrapperXmlHttpFactory = function(xhrFactory, optionsFactory) { + goog.net.XmlHttpFactory.call(this); + this.xhrFactory_ = xhrFactory; + this.optionsFactory_ = optionsFactory; +}; +goog.inherits(goog.net.WrapperXmlHttpFactory, goog.net.XmlHttpFactory); +goog.net.WrapperXmlHttpFactory.prototype.createInstance = function() { + return this.xhrFactory_(); +}; +goog.net.WrapperXmlHttpFactory.prototype.getOptions = function() { + return this.optionsFactory_(); +}; +goog.provide("goog.net.DefaultXmlHttpFactory"); +goog.provide("goog.net.XmlHttp"); +goog.provide("goog.net.XmlHttp.OptionType"); +goog.provide("goog.net.XmlHttp.ReadyState"); +goog.require("goog.net.WrapperXmlHttpFactory"); +goog.require("goog.net.XmlHttpFactory"); +goog.net.XmlHttp = function() { + return goog.net.XmlHttp.factory_.createInstance(); +}; +goog.net.XmlHttp.ASSUME_NATIVE_XHR = false; +goog.net.XmlHttp.getOptions = function() { + return goog.net.XmlHttp.factory_.getOptions(); +}; +goog.net.XmlHttp.OptionType = {USE_NULL_FUNCTION:0, LOCAL_REQUEST_ERROR:1}; +goog.net.XmlHttp.ReadyState = {UNINITIALIZED:0, LOADING:1, LOADED:2, INTERACTIVE:3, COMPLETE:4}; +goog.net.XmlHttp.factory_; +goog.net.XmlHttp.setFactory = function(factory, optionsFactory) { + goog.net.XmlHttp.setGlobalFactory(new goog.net.WrapperXmlHttpFactory((factory), (optionsFactory))); +}; +goog.net.XmlHttp.setGlobalFactory = function(factory) { + goog.net.XmlHttp.factory_ = factory; +}; +goog.net.DefaultXmlHttpFactory = function() { + goog.net.XmlHttpFactory.call(this); +}; +goog.inherits(goog.net.DefaultXmlHttpFactory, goog.net.XmlHttpFactory); +goog.net.DefaultXmlHttpFactory.prototype.createInstance = function() { + var progId = this.getProgId_(); + if (progId) { + return new ActiveXObject(progId); + } else { + return new XMLHttpRequest; + } +}; +goog.net.DefaultXmlHttpFactory.prototype.internalGetOptions = function() { + var progId = this.getProgId_(); + var options = {}; + if (progId) { + options[goog.net.XmlHttp.OptionType.USE_NULL_FUNCTION] = true; + options[goog.net.XmlHttp.OptionType.LOCAL_REQUEST_ERROR] = true; + } + return options; +}; +goog.net.DefaultXmlHttpFactory.prototype.ieProgId_; +goog.net.DefaultXmlHttpFactory.prototype.getProgId_ = function() { + if (goog.net.XmlHttp.ASSUME_NATIVE_XHR) { + return ""; + } + if (!this.ieProgId_ && (typeof XMLHttpRequest == "undefined" && typeof ActiveXObject != "undefined")) { + var ACTIVE_X_IDENTS = ["MSXML2.XMLHTTP.6.0", "MSXML2.XMLHTTP.3.0", "MSXML2.XMLHTTP", "Microsoft.XMLHTTP"]; + for (var i = 0;i < ACTIVE_X_IDENTS.length;i++) { + var candidate = ACTIVE_X_IDENTS[i]; + try { + new ActiveXObject(candidate); + this.ieProgId_ = candidate; + return candidate; + } catch (e) { + } + } + throw Error("Could not create ActiveXObject. ActiveX might be disabled," + " or MSXML might not be installed"); + } + return(this.ieProgId_); +}; +goog.net.XmlHttp.setGlobalFactory(new goog.net.DefaultXmlHttpFactory); +goog.provide("goog.uri.utils"); +goog.provide("goog.uri.utils.ComponentIndex"); +goog.provide("goog.uri.utils.QueryArray"); +goog.provide("goog.uri.utils.QueryValue"); +goog.provide("goog.uri.utils.StandardQueryParam"); +goog.require("goog.asserts"); +goog.require("goog.string"); +goog.require("goog.userAgent"); +goog.uri.utils.CharCode_ = {AMPERSAND:38, EQUAL:61, HASH:35, QUESTION:63}; +goog.uri.utils.buildFromEncodedParts = function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_queryData, opt_fragment) { + var out = ""; + if (opt_scheme) { + out += opt_scheme + ":"; + } + if (opt_domain) { + out += "//"; + if (opt_userInfo) { + out += opt_userInfo + "@"; + } + out += opt_domain; + if (opt_port) { + out += ":" + opt_port; + } + } + if (opt_path) { + out += opt_path; + } + if (opt_queryData) { + out += "?" + opt_queryData; + } + if (opt_fragment) { + out += "#" + opt_fragment; + } + return out; +}; +goog.uri.utils.splitRe_ = new RegExp("^" + "(?:" + "([^:/?#.]+)" + ":)?" + "(?://" + "(?:([^/?#]*)@)?" + "([^/#?]*?)" + "(?::([0-9]+))?" + "(?\x3d[/#?]|$)" + ")?" + "([^?#]+)?" + "(?:\\?([^#]*))?" + "(?:#(.*))?" + "$"); +goog.uri.utils.ComponentIndex = {SCHEME:1, USER_INFO:2, DOMAIN:3, PORT:4, PATH:5, QUERY_DATA:6, FRAGMENT:7}; +goog.uri.utils.split = function(uri) { + return(uri.match(goog.uri.utils.splitRe_)); +}; +goog.uri.utils.decodeIfPossible_ = function(uri) { + return uri && decodeURIComponent(uri); +}; +goog.uri.utils.getComponentByIndex_ = function(componentIndex, uri) { + return goog.uri.utils.split(uri)[componentIndex] || null; +}; +goog.uri.utils.getScheme = function(uri) { + return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.SCHEME, uri); +}; +goog.uri.utils.getEffectiveScheme = function(uri) { + var scheme = goog.uri.utils.getScheme(uri); + if (!scheme && self.location) { + var protocol = self.location.protocol; + scheme = protocol.substr(0, protocol.length - 1); + } + return scheme ? scheme.toLowerCase() : ""; +}; +goog.uri.utils.getUserInfoEncoded = function(uri) { + return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.USER_INFO, uri); +}; +goog.uri.utils.getUserInfo = function(uri) { + return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getUserInfoEncoded(uri)); +}; +goog.uri.utils.getDomainEncoded = function(uri) { + return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.DOMAIN, uri); +}; +goog.uri.utils.getDomain = function(uri) { + return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getDomainEncoded(uri)); +}; +goog.uri.utils.getPort = function(uri) { + return Number(goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PORT, uri)) || null; +}; +goog.uri.utils.getPathEncoded = function(uri) { + return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.PATH, uri); +}; +goog.uri.utils.getPath = function(uri) { + return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getPathEncoded(uri)); +}; +goog.uri.utils.getQueryData = function(uri) { + return goog.uri.utils.getComponentByIndex_(goog.uri.utils.ComponentIndex.QUERY_DATA, uri); +}; +goog.uri.utils.getFragmentEncoded = function(uri) { + var hashIndex = uri.indexOf("#"); + return hashIndex < 0 ? null : uri.substr(hashIndex + 1); +}; +goog.uri.utils.setFragmentEncoded = function(uri, fragment) { + return goog.uri.utils.removeFragment(uri) + (fragment ? "#" + fragment : ""); +}; +goog.uri.utils.getFragment = function(uri) { + return goog.uri.utils.decodeIfPossible_(goog.uri.utils.getFragmentEncoded(uri)); +}; +goog.uri.utils.getHost = function(uri) { + var pieces = goog.uri.utils.split(uri); + return goog.uri.utils.buildFromEncodedParts(pieces[goog.uri.utils.ComponentIndex.SCHEME], pieces[goog.uri.utils.ComponentIndex.USER_INFO], pieces[goog.uri.utils.ComponentIndex.DOMAIN], pieces[goog.uri.utils.ComponentIndex.PORT]); +}; +goog.uri.utils.getPathAndAfter = function(uri) { + var pieces = goog.uri.utils.split(uri); + return goog.uri.utils.buildFromEncodedParts(null, null, null, null, pieces[goog.uri.utils.ComponentIndex.PATH], pieces[goog.uri.utils.ComponentIndex.QUERY_DATA], pieces[goog.uri.utils.ComponentIndex.FRAGMENT]); +}; +goog.uri.utils.removeFragment = function(uri) { + var hashIndex = uri.indexOf("#"); + return hashIndex < 0 ? uri : uri.substr(0, hashIndex); +}; +goog.uri.utils.haveSameDomain = function(uri1, uri2) { + var pieces1 = goog.uri.utils.split(uri1); + var pieces2 = goog.uri.utils.split(uri2); + return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] == pieces2[goog.uri.utils.ComponentIndex.DOMAIN] && (pieces1[goog.uri.utils.ComponentIndex.SCHEME] == pieces2[goog.uri.utils.ComponentIndex.SCHEME] && pieces1[goog.uri.utils.ComponentIndex.PORT] == pieces2[goog.uri.utils.ComponentIndex.PORT]); +}; +goog.uri.utils.assertNoFragmentsOrQueries_ = function(uri) { + if (goog.DEBUG && (uri.indexOf("#") >= 0 || uri.indexOf("?") >= 0)) { + throw Error("goog.uri.utils: Fragment or query identifiers are not " + "supported: [" + uri + "]"); + } +}; +goog.uri.utils.QueryValue; +goog.uri.utils.QueryArray; +goog.uri.utils.appendQueryData_ = function(buffer) { + if (buffer[1]) { + var baseUri = (buffer[0]); + var hashIndex = baseUri.indexOf("#"); + if (hashIndex >= 0) { + buffer.push(baseUri.substr(hashIndex)); + buffer[0] = baseUri = baseUri.substr(0, hashIndex); + } + var questionIndex = baseUri.indexOf("?"); + if (questionIndex < 0) { + buffer[1] = "?"; + } else { + if (questionIndex == baseUri.length - 1) { + buffer[1] = undefined; + } + } + } + return buffer.join(""); +}; +goog.uri.utils.appendKeyValuePairs_ = function(key, value, pairs) { + if (goog.isArray(value)) { + goog.asserts.assertArray(value); + for (var j = 0;j < value.length;j++) { + goog.uri.utils.appendKeyValuePairs_(key, String(value[j]), pairs); + } + } else { + if (value != null) { + pairs.push("\x26", key, value === "" ? "" : "\x3d", goog.string.urlEncode(value)); + } + } +}; +goog.uri.utils.buildQueryDataBuffer_ = function(buffer, keysAndValues, opt_startIndex) { + goog.asserts.assert(Math.max(keysAndValues.length - (opt_startIndex || 0), 0) % 2 == 0, "goog.uri.utils: Key/value lists must be even in length."); + for (var i = opt_startIndex || 0;i < keysAndValues.length;i += 2) { + goog.uri.utils.appendKeyValuePairs_(keysAndValues[i], keysAndValues[i + 1], buffer); + } + return buffer; +}; +goog.uri.utils.buildQueryData = function(keysAndValues, opt_startIndex) { + var buffer = goog.uri.utils.buildQueryDataBuffer_([], keysAndValues, opt_startIndex); + buffer[0] = ""; + return buffer.join(""); +}; +goog.uri.utils.buildQueryDataBufferFromMap_ = function(buffer, map) { + for (var key in map) { + goog.uri.utils.appendKeyValuePairs_(key, map[key], buffer); + } + return buffer; +}; +goog.uri.utils.buildQueryDataFromMap = function(map) { + var buffer = goog.uri.utils.buildQueryDataBufferFromMap_([], map); + buffer[0] = ""; + return buffer.join(""); +}; +goog.uri.utils.appendParams = function(uri, var_args) { + return goog.uri.utils.appendQueryData_(arguments.length == 2 ? goog.uri.utils.buildQueryDataBuffer_([uri], arguments[1], 0) : goog.uri.utils.buildQueryDataBuffer_([uri], arguments, 1)); +}; +goog.uri.utils.appendParamsFromMap = function(uri, map) { + return goog.uri.utils.appendQueryData_(goog.uri.utils.buildQueryDataBufferFromMap_([uri], map)); +}; +goog.uri.utils.appendParam = function(uri, key, value) { + return goog.uri.utils.appendQueryData_([uri, "\x26", key, "\x3d", goog.string.urlEncode(value)]); +}; +goog.uri.utils.findParam_ = function(uri, startIndex, keyEncoded, hashOrEndIndex) { + var index = startIndex; + var keyLength = keyEncoded.length; + while ((index = uri.indexOf(keyEncoded, index)) >= 0 && index < hashOrEndIndex) { + var precedingChar = uri.charCodeAt(index - 1); + if (precedingChar == goog.uri.utils.CharCode_.AMPERSAND || precedingChar == goog.uri.utils.CharCode_.QUESTION) { + var followingChar = uri.charCodeAt(index + keyLength); + if (!followingChar || (followingChar == goog.uri.utils.CharCode_.EQUAL || (followingChar == goog.uri.utils.CharCode_.AMPERSAND || followingChar == goog.uri.utils.CharCode_.HASH))) { + return index; + } + } + index += keyLength + 1; + } + return-1; +}; +goog.uri.utils.hashOrEndRe_ = /#|$/; +goog.uri.utils.hasParam = function(uri, keyEncoded) { + return goog.uri.utils.findParam_(uri, 0, keyEncoded, uri.search(goog.uri.utils.hashOrEndRe_)) >= 0; +}; +goog.uri.utils.getParamValue = function(uri, keyEncoded) { + var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_); + var foundIndex = goog.uri.utils.findParam_(uri, 0, keyEncoded, hashOrEndIndex); + if (foundIndex < 0) { + return null; + } else { + var endPosition = uri.indexOf("\x26", foundIndex); + if (endPosition < 0 || endPosition > hashOrEndIndex) { + endPosition = hashOrEndIndex; + } + foundIndex += keyEncoded.length + 1; + return goog.string.urlDecode(uri.substr(foundIndex, endPosition - foundIndex)); + } +}; +goog.uri.utils.getParamValues = function(uri, keyEncoded) { + var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_); + var position = 0; + var foundIndex; + var result = []; + while ((foundIndex = goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex)) >= 0) { + position = uri.indexOf("\x26", foundIndex); + if (position < 0 || position > hashOrEndIndex) { + position = hashOrEndIndex; + } + foundIndex += keyEncoded.length + 1; + result.push(goog.string.urlDecode(uri.substr(foundIndex, position - foundIndex))); + } + return result; +}; +goog.uri.utils.trailingQueryPunctuationRe_ = /[?&]($|#)/; +goog.uri.utils.removeParam = function(uri, keyEncoded) { + var hashOrEndIndex = uri.search(goog.uri.utils.hashOrEndRe_); + var position = 0; + var foundIndex; + var buffer = []; + while ((foundIndex = goog.uri.utils.findParam_(uri, position, keyEncoded, hashOrEndIndex)) >= 0) { + buffer.push(uri.substring(position, foundIndex)); + position = Math.min(uri.indexOf("\x26", foundIndex) + 1 || hashOrEndIndex, hashOrEndIndex); + } + buffer.push(uri.substr(position)); + return buffer.join("").replace(goog.uri.utils.trailingQueryPunctuationRe_, "$1"); +}; +goog.uri.utils.setParam = function(uri, keyEncoded, value) { + return goog.uri.utils.appendParam(goog.uri.utils.removeParam(uri, keyEncoded), keyEncoded, value); +}; +goog.uri.utils.appendPath = function(baseUri, path) { + goog.uri.utils.assertNoFragmentsOrQueries_(baseUri); + if (goog.string.endsWith(baseUri, "/")) { + baseUri = baseUri.substr(0, baseUri.length - 1); + } + if (goog.string.startsWith(path, "/")) { + path = path.substr(1); + } + return goog.string.buildString(baseUri, "/", path); +}; +goog.uri.utils.StandardQueryParam = {RANDOM:"zx"}; +goog.uri.utils.makeUnique = function(uri) { + return goog.uri.utils.setParam(uri, goog.uri.utils.StandardQueryParam.RANDOM, goog.string.getRandomString()); +}; +goog.provide("goog.net.XhrIo"); +goog.provide("goog.net.XhrIo.ResponseType"); +goog.require("goog.Timer"); +goog.require("goog.array"); +goog.require("goog.debug.Logger"); +goog.require("goog.debug.entryPointRegistry"); +goog.require("goog.events"); +goog.require("goog.events.EventTarget"); +goog.require("goog.json"); +goog.require("goog.net.ErrorCode"); +goog.require("goog.net.EventType"); +goog.require("goog.net.HttpStatus"); +goog.require("goog.net.XmlHttp"); +goog.require("goog.object"); +goog.require("goog.structs"); +goog.require("goog.structs.Map"); +goog.require("goog.uri.utils"); +goog.net.XhrIo = function(opt_xmlHttpFactory) { + goog.events.EventTarget.call(this); + this.headers = new goog.structs.Map; + this.xmlHttpFactory_ = opt_xmlHttpFactory || null; +}; +goog.inherits(goog.net.XhrIo, goog.events.EventTarget); +goog.net.XhrIo.ResponseType = {DEFAULT:"", TEXT:"text", DOCUMENT:"document", BLOB:"blob", ARRAY_BUFFER:"arraybuffer"}; +goog.net.XhrIo.prototype.logger_ = goog.debug.Logger.getLogger("goog.net.XhrIo"); +goog.net.XhrIo.CONTENT_TYPE_HEADER = "Content-Type"; +goog.net.XhrIo.HTTP_SCHEME_PATTERN = /^https?$/i; +goog.net.XhrIo.FORM_CONTENT_TYPE = "application/x-www-form-urlencoded;charset\x3dutf-8"; +goog.net.XhrIo.sendInstances_ = []; +goog.net.XhrIo.send = function(url, opt_callback, opt_method, opt_content, opt_headers, opt_timeoutInterval, opt_withCredentials) { + var x = new goog.net.XhrIo; + goog.net.XhrIo.sendInstances_.push(x); + if (opt_callback) { + goog.events.listen(x, goog.net.EventType.COMPLETE, opt_callback); + } + goog.events.listen(x, goog.net.EventType.READY, goog.partial(goog.net.XhrIo.cleanupSend_, x)); + if (opt_timeoutInterval) { + x.setTimeoutInterval(opt_timeoutInterval); + } + if (opt_withCredentials) { + x.setWithCredentials(opt_withCredentials); + } + x.send(url, opt_method, opt_content, opt_headers); +}; +goog.net.XhrIo.cleanup = function() { + var instances = goog.net.XhrIo.sendInstances_; + while (instances.length) { + instances.pop().dispose(); + } +}; +goog.net.XhrIo.protectEntryPoints = function(errorHandler) { + goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_ = errorHandler.protectEntryPoint(goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_); +}; +goog.net.XhrIo.cleanupSend_ = function(XhrIo) { + XhrIo.dispose(); + goog.array.remove(goog.net.XhrIo.sendInstances_, XhrIo); +}; +goog.net.XhrIo.prototype.active_ = false; +goog.net.XhrIo.prototype.xhr_ = null; +goog.net.XhrIo.prototype.xhrOptions_ = null; +goog.net.XhrIo.prototype.lastUri_ = ""; +goog.net.XhrIo.prototype.lastMethod_ = ""; +goog.net.XhrIo.prototype.lastErrorCode_ = goog.net.ErrorCode.NO_ERROR; +goog.net.XhrIo.prototype.lastError_ = ""; +goog.net.XhrIo.prototype.errorDispatched_ = false; +goog.net.XhrIo.prototype.inSend_ = false; +goog.net.XhrIo.prototype.inOpen_ = false; +goog.net.XhrIo.prototype.inAbort_ = false; +goog.net.XhrIo.prototype.timeoutInterval_ = 0; +goog.net.XhrIo.prototype.timeoutId_ = null; +goog.net.XhrIo.prototype.responseType_ = goog.net.XhrIo.ResponseType.DEFAULT; +goog.net.XhrIo.prototype.withCredentials_ = false; +goog.net.XhrIo.prototype.getTimeoutInterval = function() { + return this.timeoutInterval_; +}; +goog.net.XhrIo.prototype.setTimeoutInterval = function(ms) { + this.timeoutInterval_ = Math.max(0, ms); +}; +goog.net.XhrIo.prototype.setResponseType = function(type) { + this.responseType_ = type; +}; +goog.net.XhrIo.prototype.getResponseType = function() { + return this.responseType_; +}; +goog.net.XhrIo.prototype.setWithCredentials = function(withCredentials) { + this.withCredentials_ = withCredentials; +}; +goog.net.XhrIo.prototype.getWithCredentials = function() { + return this.withCredentials_; +}; +goog.net.XhrIo.prototype.send = function(url, opt_method, opt_content, opt_headers) { + if (this.xhr_) { + throw Error("[goog.net.XhrIo] Object is active with another request\x3d" + this.lastUri_ + "; newUri\x3d" + url); + } + var method = opt_method ? opt_method.toUpperCase() : "GET"; + this.lastUri_ = url; + this.lastError_ = ""; + this.lastErrorCode_ = goog.net.ErrorCode.NO_ERROR; + this.lastMethod_ = method; + this.errorDispatched_ = false; + this.active_ = true; + this.xhr_ = this.createXhr(); + this.xhrOptions_ = this.xmlHttpFactory_ ? this.xmlHttpFactory_.getOptions() : goog.net.XmlHttp.getOptions(); + this.xhr_.onreadystatechange = goog.bind(this.onReadyStateChange_, this); + try { + this.logger_.fine(this.formatMsg_("Opening Xhr")); + this.inOpen_ = true; + this.xhr_.open(method, url, true); + this.inOpen_ = false; + } catch (err) { + this.logger_.fine(this.formatMsg_("Error opening Xhr: " + err.message)); + this.error_(goog.net.ErrorCode.EXCEPTION, err); + return; + } + var content = opt_content || ""; + var headers = this.headers.clone(); + if (opt_headers) { + goog.structs.forEach(opt_headers, function(value, key) { + headers.set(key, value); + }); + } + var contentIsFormData = goog.global["FormData"] && content instanceof goog.global["FormData"]; + if (method == "POST" && (!headers.containsKey(goog.net.XhrIo.CONTENT_TYPE_HEADER) && !contentIsFormData)) { + headers.set(goog.net.XhrIo.CONTENT_TYPE_HEADER, goog.net.XhrIo.FORM_CONTENT_TYPE); + } + goog.structs.forEach(headers, function(value, key) { + this.xhr_.setRequestHeader(key, value); + }, this); + if (this.responseType_) { + this.xhr_.responseType = this.responseType_; + } + if (goog.object.containsKey(this.xhr_, "withCredentials")) { + this.xhr_.withCredentials = this.withCredentials_; + } + try { + if (this.timeoutId_) { + goog.Timer.defaultTimerObject.clearTimeout(this.timeoutId_); + this.timeoutId_ = null; + } + if (this.timeoutInterval_ > 0) { + this.logger_.fine(this.formatMsg_("Will abort after " + this.timeoutInterval_ + "ms if incomplete")); + this.timeoutId_ = goog.Timer.defaultTimerObject.setTimeout(goog.bind(this.timeout_, this), this.timeoutInterval_); + } + this.logger_.fine(this.formatMsg_("Sending request")); + this.inSend_ = true; + this.xhr_.send(content); + this.inSend_ = false; + } catch (err) { + this.logger_.fine(this.formatMsg_("Send error: " + err.message)); + this.error_(goog.net.ErrorCode.EXCEPTION, err); + } +}; +goog.net.XhrIo.prototype.createXhr = function() { + return this.xmlHttpFactory_ ? this.xmlHttpFactory_.createInstance() : goog.net.XmlHttp(); +}; +goog.net.XhrIo.prototype.timeout_ = function() { + if (typeof goog == "undefined") { + } else { + if (this.xhr_) { + this.lastError_ = "Timed out after " + this.timeoutInterval_ + "ms, aborting"; + this.lastErrorCode_ = goog.net.ErrorCode.TIMEOUT; + this.logger_.fine(this.formatMsg_(this.lastError_)); + this.dispatchEvent(goog.net.EventType.TIMEOUT); + this.abort(goog.net.ErrorCode.TIMEOUT); + } + } +}; +goog.net.XhrIo.prototype.error_ = function(errorCode, err) { + this.active_ = false; + if (this.xhr_) { + this.inAbort_ = true; + this.xhr_.abort(); + this.inAbort_ = false; + } + this.lastError_ = err; + this.lastErrorCode_ = errorCode; + this.dispatchErrors_(); + this.cleanUpXhr_(); +}; +goog.net.XhrIo.prototype.dispatchErrors_ = function() { + if (!this.errorDispatched_) { + this.errorDispatched_ = true; + this.dispatchEvent(goog.net.EventType.COMPLETE); + this.dispatchEvent(goog.net.EventType.ERROR); + } +}; +goog.net.XhrIo.prototype.abort = function(opt_failureCode) { + if (this.xhr_ && this.active_) { + this.logger_.fine(this.formatMsg_("Aborting")); + this.active_ = false; + this.inAbort_ = true; + this.xhr_.abort(); + this.inAbort_ = false; + this.lastErrorCode_ = opt_failureCode || goog.net.ErrorCode.ABORT; + this.dispatchEvent(goog.net.EventType.COMPLETE); + this.dispatchEvent(goog.net.EventType.ABORT); + this.cleanUpXhr_(); + } +}; +goog.net.XhrIo.prototype.disposeInternal = function() { + if (this.xhr_) { + if (this.active_) { + this.active_ = false; + this.inAbort_ = true; + this.xhr_.abort(); + this.inAbort_ = false; + } + this.cleanUpXhr_(true); + } + goog.net.XhrIo.superClass_.disposeInternal.call(this); +}; +goog.net.XhrIo.prototype.onReadyStateChange_ = function() { + if (!this.inOpen_ && (!this.inSend_ && !this.inAbort_)) { + this.onReadyStateChangeEntryPoint_(); + } else { + this.onReadyStateChangeHelper_(); + } +}; +goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_ = function() { + this.onReadyStateChangeHelper_(); +}; +goog.net.XhrIo.prototype.onReadyStateChangeHelper_ = function() { + if (!this.active_) { + return; + } + if (typeof goog == "undefined") { + } else { + if (this.xhrOptions_[goog.net.XmlHttp.OptionType.LOCAL_REQUEST_ERROR] && (this.getReadyState() == goog.net.XmlHttp.ReadyState.COMPLETE && this.getStatus() == 2)) { + this.logger_.fine(this.formatMsg_("Local request error detected and ignored")); + } else { + if (this.inSend_ && this.getReadyState() == goog.net.XmlHttp.ReadyState.COMPLETE) { + goog.Timer.defaultTimerObject.setTimeout(goog.bind(this.onReadyStateChange_, this), 0); + return; + } + this.dispatchEvent(goog.net.EventType.READY_STATE_CHANGE); + if (this.isComplete()) { + this.logger_.fine(this.formatMsg_("Request complete")); + this.active_ = false; + try { + if (this.isSuccess()) { + this.dispatchEvent(goog.net.EventType.COMPLETE); + this.dispatchEvent(goog.net.EventType.SUCCESS); + } else { + this.lastErrorCode_ = goog.net.ErrorCode.HTTP_ERROR; + this.lastError_ = this.getStatusText() + " [" + this.getStatus() + "]"; + this.dispatchErrors_(); + } + } finally { + this.cleanUpXhr_(); + } + } + } + } +}; +goog.net.XhrIo.prototype.cleanUpXhr_ = function(opt_fromDispose) { + if (this.xhr_) { + var xhr = this.xhr_; + var clearedOnReadyStateChange = this.xhrOptions_[goog.net.XmlHttp.OptionType.USE_NULL_FUNCTION] ? goog.nullFunction : null; + this.xhr_ = null; + this.xhrOptions_ = null; + if (this.timeoutId_) { + goog.Timer.defaultTimerObject.clearTimeout(this.timeoutId_); + this.timeoutId_ = null; + } + if (!opt_fromDispose) { + this.dispatchEvent(goog.net.EventType.READY); + } + try { + xhr.onreadystatechange = clearedOnReadyStateChange; + } catch (e) { + this.logger_.severe("Problem encountered resetting onreadystatechange: " + e.message); + } + } +}; +goog.net.XhrIo.prototype.isActive = function() { + return!!this.xhr_; +}; +goog.net.XhrIo.prototype.isComplete = function() { + return this.getReadyState() == goog.net.XmlHttp.ReadyState.COMPLETE; +}; +goog.net.XhrIo.prototype.isSuccess = function() { + var status = this.getStatus(); + return goog.net.HttpStatus.isSuccess(status) || status === 0 && !this.isLastUriEffectiveSchemeHttp_(); +}; +goog.net.XhrIo.prototype.isLastUriEffectiveSchemeHttp_ = function() { + var scheme = goog.uri.utils.getEffectiveScheme(String(this.lastUri_)); + return goog.net.XhrIo.HTTP_SCHEME_PATTERN.test(scheme); +}; +goog.net.XhrIo.prototype.getReadyState = function() { + return this.xhr_ ? (this.xhr_.readyState) : goog.net.XmlHttp.ReadyState.UNINITIALIZED; +}; +goog.net.XhrIo.prototype.getStatus = function() { + try { + return this.getReadyState() > goog.net.XmlHttp.ReadyState.LOADED ? this.xhr_.status : -1; + } catch (e) { + this.logger_.warning("Can not get status: " + e.message); + return-1; + } +}; +goog.net.XhrIo.prototype.getStatusText = function() { + try { + return this.getReadyState() > goog.net.XmlHttp.ReadyState.LOADED ? this.xhr_.statusText : ""; + } catch (e) { + this.logger_.fine("Can not get status: " + e.message); + return ""; + } +}; +goog.net.XhrIo.prototype.getLastUri = function() { + return String(this.lastUri_); +}; +goog.net.XhrIo.prototype.getResponseText = function() { + try { + return this.xhr_ ? this.xhr_.responseText : ""; + } catch (e) { + this.logger_.fine("Can not get responseText: " + e.message); + return ""; + } +}; +goog.net.XhrIo.prototype.getResponseBody = function() { + try { + if (this.xhr_ && "responseBody" in this.xhr_) { + return this.xhr_["responseBody"]; + } + } catch (e) { + this.logger_.fine("Can not get responseBody: " + e.message); + } + return null; +}; +goog.net.XhrIo.prototype.getResponseXml = function() { + try { + return this.xhr_ ? this.xhr_.responseXML : null; + } catch (e) { + this.logger_.fine("Can not get responseXML: " + e.message); + return null; + } +}; +goog.net.XhrIo.prototype.getResponseJson = function(opt_xssiPrefix) { + if (!this.xhr_) { + return undefined; + } + var responseText = this.xhr_.responseText; + if (opt_xssiPrefix && responseText.indexOf(opt_xssiPrefix) == 0) { + responseText = responseText.substring(opt_xssiPrefix.length); + } + return goog.json.parse(responseText); +}; +goog.net.XhrIo.prototype.getResponse = function() { + try { + if (!this.xhr_) { + return null; + } + if ("response" in this.xhr_) { + return this.xhr_.response; + } + switch(this.responseType_) { + case goog.net.XhrIo.ResponseType.DEFAULT: + ; + case goog.net.XhrIo.ResponseType.TEXT: + return this.xhr_.responseText; + case goog.net.XhrIo.ResponseType.ARRAY_BUFFER: + if ("mozResponseArrayBuffer" in this.xhr_) { + return this.xhr_.mozResponseArrayBuffer; + } + ; + } + this.logger_.severe("Response type " + this.responseType_ + " is not " + "supported on this browser"); + return null; + } catch (e) { + this.logger_.fine("Can not get response: " + e.message); + return null; + } +}; +goog.net.XhrIo.prototype.getResponseHeader = function(key) { + return this.xhr_ && this.isComplete() ? this.xhr_.getResponseHeader(key) : undefined; +}; +goog.net.XhrIo.prototype.getAllResponseHeaders = function() { + return this.xhr_ && this.isComplete() ? this.xhr_.getAllResponseHeaders() : ""; +}; +goog.net.XhrIo.prototype.getLastErrorCode = function() { + return this.lastErrorCode_; +}; +goog.net.XhrIo.prototype.getLastError = function() { + return goog.isString(this.lastError_) ? this.lastError_ : String(this.lastError_); +}; +goog.net.XhrIo.prototype.formatMsg_ = function(msg) { + return msg + " [" + this.lastMethod_ + " " + this.lastUri_ + " " + this.getStatus() + "]"; +}; +goog.debug.entryPointRegistry.register(function(transformer) { + goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_ = transformer(goog.net.XhrIo.prototype.onReadyStateChangeEntryPoint_); +}); +goog.provide("goog.net.xpc"); +goog.provide("goog.net.xpc.CfgFields"); +goog.provide("goog.net.xpc.ChannelStates"); +goog.provide("goog.net.xpc.TransportNames"); +goog.provide("goog.net.xpc.TransportTypes"); +goog.provide("goog.net.xpc.UriCfgFields"); +goog.require("goog.debug.Logger"); +goog.net.xpc.TransportTypes = {NATIVE_MESSAGING:1, FRAME_ELEMENT_METHOD:2, IFRAME_RELAY:3, IFRAME_POLLING:4, FLASH:5, NIX:6}; +goog.net.xpc.TransportNames = {1:"NativeMessagingTransport", 2:"FrameElementMethodTransport", 3:"IframeRelayTransport", 4:"IframePollingTransport", 5:"FlashTransport", 6:"NixTransport"}; +goog.net.xpc.CfgFields = {CHANNEL_NAME:"cn", AUTH_TOKEN:"at", REMOTE_AUTH_TOKEN:"rat", PEER_URI:"pu", IFRAME_ID:"ifrid", TRANSPORT:"tp", LOCAL_RELAY_URI:"lru", PEER_RELAY_URI:"pru", LOCAL_POLL_URI:"lpu", PEER_POLL_URI:"ppu", PEER_HOSTNAME:"ph", ONE_SIDED_HANDSHAKE:"osh", ROLE:"role", NATIVE_TRANSPORT_PROTOCOL_VERSION:"nativeProtocolVersion"}; +goog.net.xpc.UriCfgFields = [goog.net.xpc.CfgFields.PEER_URI, goog.net.xpc.CfgFields.LOCAL_RELAY_URI, goog.net.xpc.CfgFields.PEER_RELAY_URI, goog.net.xpc.CfgFields.LOCAL_POLL_URI, goog.net.xpc.CfgFields.PEER_POLL_URI]; +goog.net.xpc.ChannelStates = {NOT_CONNECTED:1, CONNECTED:2, CLOSED:3}; +goog.net.xpc.TRANSPORT_SERVICE_ = "tp"; +goog.net.xpc.SETUP = "SETUP"; +goog.net.xpc.SETUP_NTPV2 = "SETUP_NTPV2"; +goog.net.xpc.SETUP_ACK_ = "SETUP_ACK"; +goog.net.xpc.SETUP_ACK_NTPV2 = "SETUP_ACK_NTPV2"; +goog.net.xpc.channels = {}; +goog.net.xpc.getRandomString = function(length, opt_characters) { + var chars = opt_characters || goog.net.xpc.randomStringCharacters_; + var charsLength = chars.length; + var s = ""; + while (length-- > 0) { + s += chars.charAt(Math.floor(Math.random() * charsLength)); + } + return s; +}; +goog.net.xpc.randomStringCharacters_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; +goog.net.xpc.logger = goog.debug.Logger.getLogger("goog.net.xpc"); +/* + Portions of this code are from MochiKit, received by + The Closure Authors under the MIT license. All other code is Copyright + 2005-2009 The Closure Authors. All Rights Reserved. +*/ +goog.provide("goog.async.Deferred"); +goog.provide("goog.async.Deferred.AlreadyCalledError"); +goog.provide("goog.async.Deferred.CancelledError"); +goog.require("goog.array"); +goog.require("goog.asserts"); +goog.require("goog.debug.Error"); +goog.async.Deferred = function(opt_onCancelFunction, opt_defaultScope) { + this.sequence_ = []; + this.onCancelFunction_ = opt_onCancelFunction; + this.defaultScope_ = opt_defaultScope || null; +}; +goog.async.Deferred.prototype.fired_ = false; +goog.async.Deferred.prototype.hadError_ = false; +goog.async.Deferred.prototype.result_; +goog.async.Deferred.prototype.blocked_ = false; +goog.async.Deferred.prototype.blocking_ = false; +goog.async.Deferred.prototype.silentlyCancelled_ = false; +goog.async.Deferred.prototype.unhandledExceptionTimeoutId_; +goog.async.Deferred.prototype.parent_; +goog.async.Deferred.prototype.branches_ = 0; +goog.async.Deferred.prototype.cancel = function(opt_deepCancel) { + if (!this.hasFired()) { + if (this.parent_) { + var parent = this.parent_; + delete this.parent_; + if (opt_deepCancel) { + parent.cancel(opt_deepCancel); + } else { + parent.branchCancel_(); + } + } + if (this.onCancelFunction_) { + this.onCancelFunction_.call(this.defaultScope_, this); + } else { + this.silentlyCancelled_ = true; + } + if (!this.hasFired()) { + this.errback(new goog.async.Deferred.CancelledError(this)); + } + } else { + if (this.result_ instanceof goog.async.Deferred) { + this.result_.cancel(); + } + } +}; +goog.async.Deferred.prototype.branchCancel_ = function() { + this.branches_--; + if (this.branches_ <= 0) { + this.cancel(); + } +}; +goog.async.Deferred.prototype.continue_ = function(isSuccess, res) { + this.blocked_ = false; + this.updateResult_(isSuccess, res); +}; +goog.async.Deferred.prototype.updateResult_ = function(isSuccess, res) { + this.fired_ = true; + this.result_ = res; + this.hadError_ = !isSuccess; + this.fire_(); +}; +goog.async.Deferred.prototype.check_ = function() { + if (this.hasFired()) { + if (!this.silentlyCancelled_) { + throw new goog.async.Deferred.AlreadyCalledError(this); + } + this.silentlyCancelled_ = false; + } +}; +goog.async.Deferred.prototype.callback = function(opt_result) { + this.check_(); + this.assertNotDeferred_(opt_result); + this.updateResult_(true, opt_result); +}; +goog.async.Deferred.prototype.errback = function(opt_result) { + this.check_(); + this.assertNotDeferred_(opt_result); + this.updateResult_(false, opt_result); +}; +goog.async.Deferred.prototype.assertNotDeferred_ = function(obj) { + goog.asserts.assert(!(obj instanceof goog.async.Deferred), "An execution sequence may not be initiated with a blocking Deferred."); +}; +goog.async.Deferred.prototype.addCallback = function(cb, opt_scope) { + return this.addCallbacks(cb, null, opt_scope); +}; +goog.async.Deferred.prototype.addErrback = function(eb, opt_scope) { + return this.addCallbacks(null, eb, opt_scope); +}; +goog.async.Deferred.prototype.addBoth = function(f, opt_scope) { + return this.addCallbacks(f, f, opt_scope); +}; +goog.async.Deferred.prototype.addCallbacks = function(cb, eb, opt_scope) { + goog.asserts.assert(!this.blocking_, "Blocking Deferreds can not be re-used"); + this.sequence_.push([cb, eb, opt_scope]); + if (this.hasFired()) { + this.fire_(); + } + return this; +}; +goog.async.Deferred.prototype.chainDeferred = function(otherDeferred) { + this.addCallbacks(otherDeferred.callback, otherDeferred.errback, otherDeferred); + return this; +}; +goog.async.Deferred.prototype.awaitDeferred = function(otherDeferred) { + return this.addCallback(goog.bind(otherDeferred.branch, otherDeferred)); +}; +goog.async.Deferred.prototype.branch = function(opt_propagateCancel) { + var d = new goog.async.Deferred; + this.chainDeferred(d); + if (opt_propagateCancel) { + d.parent_ = this; + this.branches_++; + } + return d; +}; +goog.async.Deferred.prototype.hasFired = function() { + return this.fired_; +}; +goog.async.Deferred.prototype.isError = function(res) { + return res instanceof Error; +}; +goog.async.Deferred.prototype.hasErrback_ = function() { + return goog.array.some(this.sequence_, function(sequenceRow) { + return goog.isFunction(sequenceRow[1]); + }); +}; +goog.async.Deferred.prototype.fire_ = function() { + if (this.unhandledExceptionTimeoutId_ && (this.hasFired() && this.hasErrback_())) { + goog.global.clearTimeout(this.unhandledExceptionTimeoutId_); + delete this.unhandledExceptionTimeoutId_; + } + if (this.parent_) { + this.parent_.branches_--; + delete this.parent_; + } + var res = this.result_; + var unhandledException = false; + var isNewlyBlocked = false; + while (this.sequence_.length && !this.blocked_) { + var sequenceEntry = this.sequence_.shift(); + var callback = sequenceEntry[0]; + var errback = sequenceEntry[1]; + var scope = sequenceEntry[2]; + var f = this.hadError_ ? errback : callback; + if (f) { + try { + var ret = f.call(scope || this.defaultScope_, res); + if (goog.isDef(ret)) { + this.hadError_ = this.hadError_ && (ret == res || this.isError(ret)); + this.result_ = res = ret; + } + if (res instanceof goog.async.Deferred) { + isNewlyBlocked = true; + this.blocked_ = true; + } + } catch (ex) { + res = ex; + this.hadError_ = true; + if (!this.hasErrback_()) { + unhandledException = true; + } + } + } + } + this.result_ = res; + if (isNewlyBlocked) { + res.addCallbacks(goog.bind(this.continue_, this, true), goog.bind(this.continue_, this, false)); + res.blocking_ = true; + } + if (unhandledException) { + this.unhandledExceptionTimeoutId_ = goog.global.setTimeout(function() { + throw res; + }, 0); + } +}; +goog.async.Deferred.succeed = function(opt_result) { + var d = new goog.async.Deferred; + d.callback(opt_result); + return d; +}; +goog.async.Deferred.fail = function(res) { + var d = new goog.async.Deferred; + d.errback(res); + return d; +}; +goog.async.Deferred.cancelled = function() { + var d = new goog.async.Deferred; + d.cancel(); + return d; +}; +goog.async.Deferred.when = function(value, callback, opt_scope) { + if (value instanceof goog.async.Deferred) { + return value.branch(true).addCallback(callback, opt_scope); + } else { + return goog.async.Deferred.succeed(value).addCallback(callback, opt_scope); + } +}; +goog.async.Deferred.AlreadyCalledError = function(deferred) { + goog.debug.Error.call(this); + this.deferred = deferred; +}; +goog.inherits(goog.async.Deferred.AlreadyCalledError, goog.debug.Error); +goog.async.Deferred.AlreadyCalledError.prototype.message = "Deferred has already fired"; +goog.async.Deferred.AlreadyCalledError.prototype.name = "AlreadyCalledError"; +goog.async.Deferred.CancelledError = function(deferred) { + goog.debug.Error.call(this); + this.deferred = deferred; +}; +goog.inherits(goog.async.Deferred.CancelledError, goog.debug.Error); +goog.async.Deferred.CancelledError.prototype.message = "Deferred was cancelled"; +goog.async.Deferred.CancelledError.prototype.name = "CancelledError"; +goog.provide("goog.Uri"); +goog.provide("goog.Uri.QueryData"); +goog.require("goog.array"); +goog.require("goog.string"); +goog.require("goog.structs"); +goog.require("goog.structs.Map"); +goog.require("goog.uri.utils"); +goog.require("goog.uri.utils.ComponentIndex"); +goog.Uri = function(opt_uri, opt_ignoreCase) { + var m; + if (opt_uri instanceof goog.Uri) { + this.ignoreCase_ = goog.isDef(opt_ignoreCase) ? opt_ignoreCase : opt_uri.getIgnoreCase(); + this.setScheme(opt_uri.getScheme()); + this.setUserInfo(opt_uri.getUserInfo()); + this.setDomain(opt_uri.getDomain()); + this.setPort(opt_uri.getPort()); + this.setPath(opt_uri.getPath()); + this.setQueryData(opt_uri.getQueryData().clone()); + this.setFragment(opt_uri.getFragment()); + } else { + if (opt_uri && (m = goog.uri.utils.split(String(opt_uri)))) { + this.ignoreCase_ = !!opt_ignoreCase; + this.setScheme(m[goog.uri.utils.ComponentIndex.SCHEME] || "", true); + this.setUserInfo(m[goog.uri.utils.ComponentIndex.USER_INFO] || "", true); + this.setDomain(m[goog.uri.utils.ComponentIndex.DOMAIN] || "", true); + this.setPort(m[goog.uri.utils.ComponentIndex.PORT]); + this.setPath(m[goog.uri.utils.ComponentIndex.PATH] || "", true); + this.setQueryData(m[goog.uri.utils.ComponentIndex.QUERY_DATA] || "", true); + this.setFragment(m[goog.uri.utils.ComponentIndex.FRAGMENT] || "", true); + } else { + this.ignoreCase_ = !!opt_ignoreCase; + this.queryData_ = new goog.Uri.QueryData(null, null, this.ignoreCase_); + } + } +}; +goog.Uri.preserveParameterTypesCompatibilityFlag = false; +goog.Uri.RANDOM_PARAM = goog.uri.utils.StandardQueryParam.RANDOM; +goog.Uri.prototype.scheme_ = ""; +goog.Uri.prototype.userInfo_ = ""; +goog.Uri.prototype.domain_ = ""; +goog.Uri.prototype.port_ = null; +goog.Uri.prototype.path_ = ""; +goog.Uri.prototype.queryData_; +goog.Uri.prototype.fragment_ = ""; +goog.Uri.prototype.isReadOnly_ = false; +goog.Uri.prototype.ignoreCase_ = false; +goog.Uri.prototype.toString = function() { + var out = []; + var scheme = this.getScheme(); + if (scheme) { + out.push(goog.Uri.encodeSpecialChars_(scheme, goog.Uri.reDisallowedInSchemeOrUserInfo_), ":"); + } + var domain = this.getDomain(); + if (domain) { + out.push("//"); + var userInfo = this.getUserInfo(); + if (userInfo) { + out.push(goog.Uri.encodeSpecialChars_(userInfo, goog.Uri.reDisallowedInSchemeOrUserInfo_), "@"); + } + out.push(goog.string.urlEncode(domain)); + var port = this.getPort(); + if (port != null) { + out.push(":", String(port)); + } + } + var path = this.getPath(); + if (path) { + if (this.hasDomain() && path.charAt(0) != "/") { + out.push("/"); + } + out.push(goog.Uri.encodeSpecialChars_(path, path.charAt(0) == "/" ? goog.Uri.reDisallowedInAbsolutePath_ : goog.Uri.reDisallowedInRelativePath_)); + } + var query = this.getEncodedQuery(); + if (query) { + out.push("?", query); + } + var fragment = this.getFragment(); + if (fragment) { + out.push("#", goog.Uri.encodeSpecialChars_(fragment, goog.Uri.reDisallowedInFragment_)); + } + return out.join(""); +}; +goog.Uri.prototype.resolve = function(relativeUri) { + var absoluteUri = this.clone(); + var overridden = relativeUri.hasScheme(); + if (overridden) { + absoluteUri.setScheme(relativeUri.getScheme()); + } else { + overridden = relativeUri.hasUserInfo(); + } + if (overridden) { + absoluteUri.setUserInfo(relativeUri.getUserInfo()); + } else { + overridden = relativeUri.hasDomain(); + } + if (overridden) { + absoluteUri.setDomain(relativeUri.getDomain()); + } else { + overridden = relativeUri.hasPort(); + } + var path = relativeUri.getPath(); + if (overridden) { + absoluteUri.setPort(relativeUri.getPort()); + } else { + overridden = relativeUri.hasPath(); + if (overridden) { + if (path.charAt(0) != "/") { + if (this.hasDomain() && !this.hasPath()) { + path = "/" + path; + } else { + var lastSlashIndex = absoluteUri.getPath().lastIndexOf("/"); + if (lastSlashIndex != -1) { + path = absoluteUri.getPath().substr(0, lastSlashIndex + 1) + path; + } + } + } + path = goog.Uri.removeDotSegments(path); + } + } + if (overridden) { + absoluteUri.setPath(path); + } else { + overridden = relativeUri.hasQuery(); + } + if (overridden) { + absoluteUri.setQueryData(relativeUri.getDecodedQuery()); + } else { + overridden = relativeUri.hasFragment(); + } + if (overridden) { + absoluteUri.setFragment(relativeUri.getFragment()); + } + return absoluteUri; +}; +goog.Uri.prototype.clone = function() { + return new goog.Uri(this); +}; +goog.Uri.prototype.getScheme = function() { + return this.scheme_; +}; +goog.Uri.prototype.setScheme = function(newScheme, opt_decode) { + this.enforceReadOnly(); + this.scheme_ = opt_decode ? goog.Uri.decodeOrEmpty_(newScheme) : newScheme; + if (this.scheme_) { + this.scheme_ = this.scheme_.replace(/:$/, ""); + } + return this; +}; +goog.Uri.prototype.hasScheme = function() { + return!!this.scheme_; +}; +goog.Uri.prototype.getUserInfo = function() { + return this.userInfo_; +}; +goog.Uri.prototype.setUserInfo = function(newUserInfo, opt_decode) { + this.enforceReadOnly(); + this.userInfo_ = opt_decode ? goog.Uri.decodeOrEmpty_(newUserInfo) : newUserInfo; + return this; +}; +goog.Uri.prototype.hasUserInfo = function() { + return!!this.userInfo_; +}; +goog.Uri.prototype.getDomain = function() { + return this.domain_; +}; +goog.Uri.prototype.setDomain = function(newDomain, opt_decode) { + this.enforceReadOnly(); + this.domain_ = opt_decode ? goog.Uri.decodeOrEmpty_(newDomain) : newDomain; + return this; +}; +goog.Uri.prototype.hasDomain = function() { + return!!this.domain_; +}; +goog.Uri.prototype.getPort = function() { + return this.port_; +}; +goog.Uri.prototype.setPort = function(newPort) { + this.enforceReadOnly(); + if (newPort) { + newPort = Number(newPort); + if (isNaN(newPort) || newPort < 0) { + throw Error("Bad port number " + newPort); + } + this.port_ = newPort; + } else { + this.port_ = null; + } + return this; +}; +goog.Uri.prototype.hasPort = function() { + return this.port_ != null; +}; +goog.Uri.prototype.getPath = function() { + return this.path_; +}; +goog.Uri.prototype.setPath = function(newPath, opt_decode) { + this.enforceReadOnly(); + this.path_ = opt_decode ? goog.Uri.decodeOrEmpty_(newPath) : newPath; + return this; +}; +goog.Uri.prototype.hasPath = function() { + return!!this.path_; +}; +goog.Uri.prototype.hasQuery = function() { + return this.queryData_.toString() !== ""; +}; +goog.Uri.prototype.setQueryData = function(queryData, opt_decode) { + this.enforceReadOnly(); + if (queryData instanceof goog.Uri.QueryData) { + this.queryData_ = queryData; + this.queryData_.setIgnoreCase(this.ignoreCase_); + } else { + if (!opt_decode) { + queryData = goog.Uri.encodeSpecialChars_(queryData, goog.Uri.reDisallowedInQuery_); + } + this.queryData_ = new goog.Uri.QueryData(queryData, null, this.ignoreCase_); + } + return this; +}; +goog.Uri.prototype.setQuery = function(newQuery, opt_decode) { + return this.setQueryData(newQuery, opt_decode); +}; +goog.Uri.prototype.getEncodedQuery = function() { + return this.queryData_.toString(); +}; +goog.Uri.prototype.getDecodedQuery = function() { + return this.queryData_.toDecodedString(); +}; +goog.Uri.prototype.getQueryData = function() { + return this.queryData_; +}; +goog.Uri.prototype.getQuery = function() { + return this.getEncodedQuery(); +}; +goog.Uri.prototype.setParameterValue = function(key, value) { + this.enforceReadOnly(); + this.queryData_.set(key, value); + return this; +}; +goog.Uri.prototype.setParameterValues = function(key, values) { + this.enforceReadOnly(); + if (!goog.isArray(values)) { + values = [String(values)]; + } + this.queryData_.setValues(key, (values)); + return this; +}; +goog.Uri.prototype.getParameterValues = function(name) { + return this.queryData_.getValues(name); +}; +goog.Uri.prototype.getParameterValue = function(paramName) { + return(this.queryData_.get(paramName)); +}; +goog.Uri.prototype.getFragment = function() { + return this.fragment_; +}; +goog.Uri.prototype.setFragment = function(newFragment, opt_decode) { + this.enforceReadOnly(); + this.fragment_ = opt_decode ? goog.Uri.decodeOrEmpty_(newFragment) : newFragment; + return this; +}; +goog.Uri.prototype.hasFragment = function() { + return!!this.fragment_; +}; +goog.Uri.prototype.hasSameDomainAs = function(uri2) { + return(!this.hasDomain() && !uri2.hasDomain() || this.getDomain() == uri2.getDomain()) && (!this.hasPort() && !uri2.hasPort() || this.getPort() == uri2.getPort()); +}; +goog.Uri.prototype.makeUnique = function() { + this.enforceReadOnly(); + this.setParameterValue(goog.Uri.RANDOM_PARAM, goog.string.getRandomString()); + return this; +}; +goog.Uri.prototype.removeParameter = function(key) { + this.enforceReadOnly(); + this.queryData_.remove(key); + return this; +}; +goog.Uri.prototype.setReadOnly = function(isReadOnly) { + this.isReadOnly_ = isReadOnly; + return this; +}; +goog.Uri.prototype.isReadOnly = function() { + return this.isReadOnly_; +}; +goog.Uri.prototype.enforceReadOnly = function() { + if (this.isReadOnly_) { + throw Error("Tried to modify a read-only Uri"); + } +}; +goog.Uri.prototype.setIgnoreCase = function(ignoreCase) { + this.ignoreCase_ = ignoreCase; + if (this.queryData_) { + this.queryData_.setIgnoreCase(ignoreCase); + } + return this; +}; +goog.Uri.prototype.getIgnoreCase = function() { + return this.ignoreCase_; +}; +goog.Uri.parse = function(uri, opt_ignoreCase) { + return uri instanceof goog.Uri ? uri.clone() : new goog.Uri(uri, opt_ignoreCase); +}; +goog.Uri.create = function(opt_scheme, opt_userInfo, opt_domain, opt_port, opt_path, opt_query, opt_fragment, opt_ignoreCase) { + var uri = new goog.Uri(null, opt_ignoreCase); + opt_scheme && uri.setScheme(opt_scheme); + opt_userInfo && uri.setUserInfo(opt_userInfo); + opt_domain && uri.setDomain(opt_domain); + opt_port && uri.setPort(opt_port); + opt_path && uri.setPath(opt_path); + opt_query && uri.setQueryData(opt_query); + opt_fragment && uri.setFragment(opt_fragment); + return uri; +}; +goog.Uri.resolve = function(base, rel) { + if (!(base instanceof goog.Uri)) { + base = goog.Uri.parse(base); + } + if (!(rel instanceof goog.Uri)) { + rel = goog.Uri.parse(rel); + } + return base.resolve(rel); +}; +goog.Uri.removeDotSegments = function(path) { + if (path == ".." || path == ".") { + return ""; + } else { + if (!goog.string.contains(path, "./") && !goog.string.contains(path, "/.")) { + return path; + } else { + var leadingSlash = goog.string.startsWith(path, "/"); + var segments = path.split("/"); + var out = []; + for (var pos = 0;pos < segments.length;) { + var segment = segments[pos++]; + if (segment == ".") { + if (leadingSlash && pos == segments.length) { + out.push(""); + } + } else { + if (segment == "..") { + if (out.length > 1 || out.length == 1 && out[0] != "") { + out.pop(); + } + if (leadingSlash && pos == segments.length) { + out.push(""); + } + } else { + out.push(segment); + leadingSlash = true; + } + } + } + return out.join("/"); + } + } +}; +goog.Uri.decodeOrEmpty_ = function(val) { + return val ? decodeURIComponent(val) : ""; +}; +goog.Uri.encodeSpecialChars_ = function(unescapedPart, extra) { + if (goog.isString(unescapedPart)) { + return encodeURI(unescapedPart).replace(extra, goog.Uri.encodeChar_); + } + return null; +}; +goog.Uri.encodeChar_ = function(ch) { + var n = ch.charCodeAt(0); + return "%" + (n >> 4 & 15).toString(16) + (n & 15).toString(16); +}; +goog.Uri.reDisallowedInSchemeOrUserInfo_ = /[#\/\?@]/g; +goog.Uri.reDisallowedInRelativePath_ = /[\#\?:]/g; +goog.Uri.reDisallowedInAbsolutePath_ = /[\#\?]/g; +goog.Uri.reDisallowedInQuery_ = /[\#\?@]/g; +goog.Uri.reDisallowedInFragment_ = /#/g; +goog.Uri.haveSameDomain = function(uri1String, uri2String) { + var pieces1 = goog.uri.utils.split(uri1String); + var pieces2 = goog.uri.utils.split(uri2String); + return pieces1[goog.uri.utils.ComponentIndex.DOMAIN] == pieces2[goog.uri.utils.ComponentIndex.DOMAIN] && pieces1[goog.uri.utils.ComponentIndex.PORT] == pieces2[goog.uri.utils.ComponentIndex.PORT]; +}; +goog.Uri.QueryData = function(opt_query, opt_uri, opt_ignoreCase) { + this.encodedQuery_ = opt_query || null; + this.ignoreCase_ = !!opt_ignoreCase; +}; +goog.Uri.QueryData.prototype.ensureKeyMapInitialized_ = function() { + if (!this.keyMap_) { + this.keyMap_ = new goog.structs.Map; + this.count_ = 0; + if (this.encodedQuery_) { + var pairs = this.encodedQuery_.split("\x26"); + for (var i = 0;i < pairs.length;i++) { + var indexOfEquals = pairs[i].indexOf("\x3d"); + var name = null; + var value = null; + if (indexOfEquals >= 0) { + name = pairs[i].substring(0, indexOfEquals); + value = pairs[i].substring(indexOfEquals + 1); + } else { + name = pairs[i]; + } + name = goog.string.urlDecode(name); + name = this.getKeyName_(name); + this.add(name, value ? goog.string.urlDecode(value) : ""); + } + } + } +}; +goog.Uri.QueryData.createFromMap = function(map, opt_uri, opt_ignoreCase) { + var keys = goog.structs.getKeys(map); + if (typeof keys == "undefined") { + throw Error("Keys are undefined"); + } + var queryData = new goog.Uri.QueryData(null, null, opt_ignoreCase); + var values = goog.structs.getValues(map); + for (var i = 0;i < keys.length;i++) { + var key = keys[i]; + var value = values[i]; + if (!goog.isArray(value)) { + queryData.add(key, value); + } else { + queryData.setValues(key, value); + } + } + return queryData; +}; +goog.Uri.QueryData.createFromKeysValues = function(keys, values, opt_uri, opt_ignoreCase) { + if (keys.length != values.length) { + throw Error("Mismatched lengths for keys/values"); + } + var queryData = new goog.Uri.QueryData(null, null, opt_ignoreCase); + for (var i = 0;i < keys.length;i++) { + queryData.add(keys[i], values[i]); + } + return queryData; +}; +goog.Uri.QueryData.prototype.keyMap_ = null; +goog.Uri.QueryData.prototype.count_ = null; +goog.Uri.QueryData.prototype.getCount = function() { + this.ensureKeyMapInitialized_(); + return this.count_; +}; +goog.Uri.QueryData.prototype.add = function(key, value) { + this.ensureKeyMapInitialized_(); + this.invalidateCache_(); + key = this.getKeyName_(key); + var values = this.keyMap_.get(key); + if (!values) { + this.keyMap_.set(key, values = []); + } + values.push(value); + this.count_++; + return this; +}; +goog.Uri.QueryData.prototype.remove = function(key) { + this.ensureKeyMapInitialized_(); + key = this.getKeyName_(key); + if (this.keyMap_.containsKey(key)) { + this.invalidateCache_(); + this.count_ -= this.keyMap_.get(key).length; + return this.keyMap_.remove(key); + } + return false; +}; +goog.Uri.QueryData.prototype.clear = function() { + this.invalidateCache_(); + this.keyMap_ = null; + this.count_ = 0; +}; +goog.Uri.QueryData.prototype.isEmpty = function() { + this.ensureKeyMapInitialized_(); + return this.count_ == 0; +}; +goog.Uri.QueryData.prototype.containsKey = function(key) { + this.ensureKeyMapInitialized_(); + key = this.getKeyName_(key); + return this.keyMap_.containsKey(key); +}; +goog.Uri.QueryData.prototype.containsValue = function(value) { + var vals = this.getValues(); + return goog.array.contains(vals, value); +}; +goog.Uri.QueryData.prototype.getKeys = function() { + this.ensureKeyMapInitialized_(); + var vals = (this.keyMap_.getValues()); + var keys = this.keyMap_.getKeys(); + var rv = []; + for (var i = 0;i < keys.length;i++) { + var val = vals[i]; + for (var j = 0;j < val.length;j++) { + rv.push(keys[i]); + } + } + return rv; +}; +goog.Uri.QueryData.prototype.getValues = function(opt_key) { + this.ensureKeyMapInitialized_(); + var rv = []; + if (opt_key) { + if (this.containsKey(opt_key)) { + rv = goog.array.concat(rv, this.keyMap_.get(this.getKeyName_(opt_key))); + } + } else { + var values = (this.keyMap_.getValues()); + for (var i = 0;i < values.length;i++) { + rv = goog.array.concat(rv, values[i]); + } + } + return rv; +}; +goog.Uri.QueryData.prototype.set = function(key, value) { + this.ensureKeyMapInitialized_(); + this.invalidateCache_(); + key = this.getKeyName_(key); + if (this.containsKey(key)) { + this.count_ -= this.keyMap_.get(key).length; + } + this.keyMap_.set(key, [value]); + this.count_++; + return this; +}; +goog.Uri.QueryData.prototype.get = function(key, opt_default) { + var values = key ? this.getValues(key) : []; + if (goog.Uri.preserveParameterTypesCompatibilityFlag) { + return values.length > 0 ? values[0] : opt_default; + } else { + return values.length > 0 ? String(values[0]) : opt_default; + } +}; +goog.Uri.QueryData.prototype.setValues = function(key, values) { + this.remove(key); + if (values.length > 0) { + this.invalidateCache_(); + this.keyMap_.set(this.getKeyName_(key), goog.array.clone(values)); + this.count_ += values.length; + } +}; +goog.Uri.QueryData.prototype.toString = function() { + if (this.encodedQuery_) { + return this.encodedQuery_; + } + if (!this.keyMap_) { + return ""; + } + var sb = []; + var keys = this.keyMap_.getKeys(); + for (var i = 0;i < keys.length;i++) { + var key = keys[i]; + var encodedKey = goog.string.urlEncode(key); + var val = this.getValues(key); + for (var j = 0;j < val.length;j++) { + var param = encodedKey; + if (val[j] !== "") { + param += "\x3d" + goog.string.urlEncode(val[j]); + } + sb.push(param); + } + } + return this.encodedQuery_ = sb.join("\x26"); +}; +goog.Uri.QueryData.prototype.toDecodedString = function() { + return goog.Uri.decodeOrEmpty_(this.toString()); +}; +goog.Uri.QueryData.prototype.invalidateCache_ = function() { + this.encodedQuery_ = null; +}; +goog.Uri.QueryData.prototype.filterKeys = function(keys) { + this.ensureKeyMapInitialized_(); + goog.structs.forEach(this.keyMap_, function(value, key, map) { + if (!goog.array.contains(keys, key)) { + this.remove(key); + } + }, this); + return this; +}; +goog.Uri.QueryData.prototype.clone = function() { + var rv = new goog.Uri.QueryData; + rv.encodedQuery_ = this.encodedQuery_; + if (this.keyMap_) { + rv.keyMap_ = this.keyMap_.clone(); + rv.count_ = this.count_; + } + return rv; +}; +goog.Uri.QueryData.prototype.getKeyName_ = function(arg) { + var keyName = String(arg); + if (this.ignoreCase_) { + keyName = keyName.toLowerCase(); + } + return keyName; +}; +goog.Uri.QueryData.prototype.setIgnoreCase = function(ignoreCase) { + var resetKeys = ignoreCase && !this.ignoreCase_; + if (resetKeys) { + this.ensureKeyMapInitialized_(); + this.invalidateCache_(); + goog.structs.forEach(this.keyMap_, function(value, key) { + var lowerCase = key.toLowerCase(); + if (key != lowerCase) { + this.remove(key); + this.setValues(lowerCase, value); + } + }, this); + } + this.ignoreCase_ = ignoreCase; +}; +goog.Uri.QueryData.prototype.extend = function(var_args) { + for (var i = 0;i < arguments.length;i++) { + var data = arguments[i]; + goog.structs.forEach(data, function(value, key) { + this.add(key, value); + }, this); + } +}; +goog.provide("goog.Delay"); +goog.provide("goog.async.Delay"); +goog.require("goog.Disposable"); +goog.require("goog.Timer"); +goog.async.Delay = function(listener, opt_interval, opt_handler) { + goog.Disposable.call(this); + this.listener_ = listener; + this.interval_ = opt_interval || 0; + this.handler_ = opt_handler; + this.callback_ = goog.bind(this.doAction_, this); +}; +goog.inherits(goog.async.Delay, goog.Disposable); +goog.Delay = goog.async.Delay; +goog.async.Delay.prototype.id_ = 0; +goog.async.Delay.prototype.disposeInternal = function() { + goog.async.Delay.superClass_.disposeInternal.call(this); + this.stop(); + delete this.listener_; + delete this.handler_; +}; +goog.async.Delay.prototype.start = function(opt_interval) { + this.stop(); + this.id_ = goog.Timer.callOnce(this.callback_, goog.isDef(opt_interval) ? opt_interval : this.interval_); +}; +goog.async.Delay.prototype.stop = function() { + if (this.isActive()) { + goog.Timer.clear(this.id_); + } + this.id_ = 0; +}; +goog.async.Delay.prototype.fire = function() { + this.stop(); + this.doAction_(); +}; +goog.async.Delay.prototype.fireIfActive = function() { + if (this.isActive()) { + this.fire(); + } +}; +goog.async.Delay.prototype.isActive = function() { + return this.id_ != 0; +}; +goog.async.Delay.prototype.doAction_ = function() { + this.id_ = 0; + if (this.listener_) { + this.listener_.call(this.handler_); + } +}; +goog.provide("goog.net.xpc.Transport"); +goog.require("goog.Disposable"); +goog.require("goog.dom"); +goog.require("goog.net.xpc"); +goog.net.xpc.Transport = function(opt_domHelper) { + goog.Disposable.call(this); + this.domHelper_ = opt_domHelper || goog.dom.getDomHelper(); +}; +goog.inherits(goog.net.xpc.Transport, goog.Disposable); +goog.net.xpc.Transport.prototype.transportType = 0; +goog.net.xpc.Transport.prototype.getType = function() { + return this.transportType; +}; +goog.net.xpc.Transport.prototype.getWindow = function() { + return this.domHelper_.getWindow(); +}; +goog.net.xpc.Transport.prototype.getName = function() { + return goog.net.xpc.TransportNames[this.transportType] || ""; +}; +goog.net.xpc.Transport.prototype.transportServiceHandler = goog.abstractMethod; +goog.net.xpc.Transport.prototype.connect = goog.abstractMethod; +goog.net.xpc.Transport.prototype.send = goog.abstractMethod; +goog.provide("goog.messaging.MessageChannel"); +goog.messaging.MessageChannel = function() { +}; +goog.messaging.MessageChannel.prototype.connect = function(opt_connectCb) { +}; +goog.messaging.MessageChannel.prototype.isConnected = function() { +}; +goog.messaging.MessageChannel.prototype.registerService = function(serviceName, callback, opt_objectPayload) { +}; +goog.messaging.MessageChannel.prototype.registerDefaultService = function(callback) { +}; +goog.messaging.MessageChannel.prototype.send = function(serviceName, payload) { +}; +goog.provide("goog.messaging.AbstractChannel"); +goog.require("goog.Disposable"); +goog.require("goog.debug"); +goog.require("goog.debug.Logger"); +goog.require("goog.json"); +goog.require("goog.messaging.MessageChannel"); +goog.messaging.AbstractChannel = function() { + goog.base(this); + this.services_ = {}; +}; +goog.inherits(goog.messaging.AbstractChannel, goog.Disposable); +goog.messaging.AbstractChannel.prototype.defaultService_; +goog.messaging.AbstractChannel.prototype.logger = goog.debug.Logger.getLogger("goog.messaging.AbstractChannel"); +goog.messaging.AbstractChannel.prototype.connect = function(opt_connectCb) { + if (opt_connectCb) { + opt_connectCb(); + } +}; +goog.messaging.AbstractChannel.prototype.isConnected = function() { + return true; +}; +goog.messaging.AbstractChannel.prototype.registerService = function(serviceName, callback, opt_objectPayload) { + this.services_[serviceName] = {callback:callback, objectPayload:!!opt_objectPayload}; +}; +goog.messaging.AbstractChannel.prototype.registerDefaultService = function(callback) { + this.defaultService_ = callback; +}; +goog.messaging.AbstractChannel.prototype.send = goog.abstractMethod; +goog.messaging.AbstractChannel.prototype.deliver = function(serviceName, payload) { + var service = this.getService(serviceName, payload); + if (!service) { + return; + } + var decodedPayload = this.decodePayload(serviceName, payload, service.objectPayload); + if (goog.isDefAndNotNull(decodedPayload)) { + service.callback(decodedPayload); + } +}; +goog.messaging.AbstractChannel.prototype.getService = function(serviceName, payload) { + var service = this.services_[serviceName]; + if (service) { + return service; + } else { + if (this.defaultService_) { + var callback = goog.partial(this.defaultService_, serviceName); + var objectPayload = goog.isObject(payload); + return{callback:callback, objectPayload:objectPayload}; + } + } + this.logger.warning('Unknown service name "' + serviceName + '"'); + return null; +}; +goog.messaging.AbstractChannel.prototype.decodePayload = function(serviceName, payload, objectPayload) { + if (objectPayload && goog.isString(payload)) { + try { + return goog.json.parse(payload); + } catch (err) { + this.logger.warning("Expected JSON payload for " + serviceName + ', was "' + payload + '"'); + return null; + } + } else { + if (!objectPayload && !goog.isString(payload)) { + return goog.json.serialize(payload); + } + } + return payload; +}; +goog.messaging.AbstractChannel.prototype.disposeInternal = function() { + goog.base(this, "disposeInternal"); + delete this.logger; + delete this.services_; + delete this.defaultService_; +}; +goog.provide("clojure.browser.event"); +goog.require("cljs.core"); +goog.require("goog.events.EventType"); +goog.require("goog.events.EventType"); +goog.require("goog.events.EventTarget"); +goog.require("goog.events.EventTarget"); +goog.require("goog.events"); +goog.require("goog.events"); +clojure.browser.event.EventType = function() { + var obj5252 = {}; + return obj5252; +}(); +clojure.browser.event.event_types = function event_types(this$) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$event$EventType$event_types$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$event$EventType$event_types$arity$1(this$); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.event.event_types[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.event.event_types["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "EventType.event-types", this$); + } + } + }().call(null, this$); + } +}; +Element.prototype.clojure$browser$event$EventType$ = true; +Element.prototype.clojure$browser$event$EventType$event_types$arity$1 = function(this$) { + var this$__$1 = this; + return cljs.core.into.call(null, cljs.core.PersistentArrayMap.EMPTY, cljs.core.map.call(null, function(p__5253) { + var vec__5254 = p__5253; + var k = cljs.core.nth.call(null, vec__5254, 0, null); + var v = cljs.core.nth.call(null, vec__5254, 1, null); + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k.toLowerCase()), v], null); + }, cljs.core.merge.call(null, cljs.core.js__GT_clj.call(null, goog.events.EventType)))); +}; +goog.events.EventTarget.prototype.clojure$browser$event$EventType$ = true; +goog.events.EventTarget.prototype.clojure$browser$event$EventType$event_types$arity$1 = function(this$) { + var this$__$1 = this; + return cljs.core.into.call(null, cljs.core.PersistentArrayMap.EMPTY, cljs.core.map.call(null, function(p__5255) { + var vec__5256 = p__5255; + var k = cljs.core.nth.call(null, vec__5256, 0, null); + var v = cljs.core.nth.call(null, vec__5256, 1, null); + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k.toLowerCase()), v], null); + }, cljs.core.merge.call(null, cljs.core.js__GT_clj.call(null, goog.events.EventType)))); +}; +clojure.browser.event.listen = function() { + var listen = null; + var listen__3 = function(src, type, fn) { + return listen.call(null, src, type, fn, false); + }; + var listen__4 = function(src, type, fn, capture_QMARK_) { + return goog.events.listen(src, cljs.core.get.call(null, clojure.browser.event.event_types.call(null, src), type, type), fn, capture_QMARK_); + }; + listen = function(src, type, fn, capture_QMARK_) { + switch(arguments.length) { + case 3: + return listen__3.call(this, src, type, fn); + case 4: + return listen__4.call(this, src, type, fn, capture_QMARK_); + } + throw new Error("Invalid arity: " + arguments.length); + }; + listen.cljs$core$IFn$_invoke$arity$3 = listen__3; + listen.cljs$core$IFn$_invoke$arity$4 = listen__4; + return listen; +}(); +clojure.browser.event.listen_once = function() { + var listen_once = null; + var listen_once__3 = function(src, type, fn) { + return listen_once.call(null, src, type, fn, false); + }; + var listen_once__4 = function(src, type, fn, capture_QMARK_) { + return goog.events.listenOnce(src, cljs.core.get.call(null, clojure.browser.event.event_types.call(null, src), type, type), fn, capture_QMARK_); + }; + listen_once = function(src, type, fn, capture_QMARK_) { + switch(arguments.length) { + case 3: + return listen_once__3.call(this, src, type, fn); + case 4: + return listen_once__4.call(this, src, type, fn, capture_QMARK_); + } + throw new Error("Invalid arity: " + arguments.length); + }; + listen_once.cljs$core$IFn$_invoke$arity$3 = listen_once__3; + listen_once.cljs$core$IFn$_invoke$arity$4 = listen_once__4; + return listen_once; +}(); +clojure.browser.event.unlisten = function() { + var unlisten = null; + var unlisten__3 = function(src, type, fn) { + return unlisten.call(null, src, type, fn, false); + }; + var unlisten__4 = function(src, type, fn, capture_QMARK_) { + return goog.events.unlisten(src, cljs.core.get.call(null, clojure.browser.event.event_types.call(null, src), type, type), fn, capture_QMARK_); + }; + unlisten = function(src, type, fn, capture_QMARK_) { + switch(arguments.length) { + case 3: + return unlisten__3.call(this, src, type, fn); + case 4: + return unlisten__4.call(this, src, type, fn, capture_QMARK_); + } + throw new Error("Invalid arity: " + arguments.length); + }; + unlisten.cljs$core$IFn$_invoke$arity$3 = unlisten__3; + unlisten.cljs$core$IFn$_invoke$arity$4 = unlisten__4; + return unlisten; +}(); +clojure.browser.event.unlisten_by_key = function unlisten_by_key(key) { + return goog.events.unlistenByKey(key); +}; +clojure.browser.event.dispatch_event = function dispatch_event(src, event) { + return goog.events.dispatchEvent(src, event); +}; +clojure.browser.event.expose = function expose(e) { + return goog.events.expose(e); +}; +clojure.browser.event.fire_listeners = function fire_listeners(obj, type, capture, event) { + return null; +}; +clojure.browser.event.total_listener_count = function total_listener_count() { + return goog.events.getTotalListenerCount(); +}; +clojure.browser.event.get_listener = function get_listener(src, type, listener, opt_capt, opt_handler) { + return null; +}; +clojure.browser.event.all_listeners = function all_listeners(obj, type, capture) { + return null; +}; +clojure.browser.event.unique_event_id = function unique_event_id(event_type) { + return null; +}; +clojure.browser.event.has_listener = function has_listener(obj, opt_type, opt_capture) { + return null; +}; +clojure.browser.event.remove_all = function remove_all(opt_obj, opt_type, opt_capt) { + return null; +}; +goog.provide("goog.net.xpc.CrossPageChannelRole"); +goog.net.xpc.CrossPageChannelRole = {OUTER:0, INNER:1}; +goog.provide("goog.net.xpc.IframePollingTransport"); +goog.provide("goog.net.xpc.IframePollingTransport.Receiver"); +goog.provide("goog.net.xpc.IframePollingTransport.Sender"); +goog.require("goog.array"); +goog.require("goog.dom"); +goog.require("goog.net.xpc"); +goog.require("goog.net.xpc.CrossPageChannelRole"); +goog.require("goog.net.xpc.Transport"); +goog.require("goog.userAgent"); +goog.net.xpc.IframePollingTransport = function(channel, opt_domHelper) { + goog.base(this, opt_domHelper); + this.channel_ = channel; + this.sendUri_ = this.channel_.getConfig()[goog.net.xpc.CfgFields.PEER_POLL_URI]; + this.rcvUri_ = this.channel_.getConfig()[goog.net.xpc.CfgFields.LOCAL_POLL_URI]; + this.sendQueue_ = []; +}; +goog.inherits(goog.net.xpc.IframePollingTransport, goog.net.xpc.Transport); +goog.net.xpc.IframePollingTransport.prototype.pollsBeforeReconnect_ = 5; +goog.net.xpc.IframePollingTransport.prototype.transportType = goog.net.xpc.TransportTypes.IFRAME_POLLING; +goog.net.xpc.IframePollingTransport.prototype.sequence_ = 0; +goog.net.xpc.IframePollingTransport.prototype.waitForAck_ = false; +goog.net.xpc.IframePollingTransport.prototype.initialized_ = false; +goog.net.xpc.IframePollingTransport.prototype.reconnectFrame_ = null; +goog.net.xpc.IframePollingTransport.IFRAME_PREFIX = "googlexpc"; +goog.net.xpc.IframePollingTransport.prototype.getMsgFrameName_ = function() { + return goog.net.xpc.IframePollingTransport.IFRAME_PREFIX + "_" + this.channel_.name + "_msg"; +}; +goog.net.xpc.IframePollingTransport.prototype.getAckFrameName_ = function() { + return goog.net.xpc.IframePollingTransport.IFRAME_PREFIX + "_" + this.channel_.name + "_ack"; +}; +goog.net.xpc.IframePollingTransport.prototype.isChannelAvailable = function() { + return!this.isDisposed() && this.channel_.isPeerAvailable(); +}; +goog.net.xpc.IframePollingTransport.prototype.getPeerFrames_ = function() { + try { + if (this.isChannelAvailable()) { + return this.channel_.getPeerWindowObject().frames || {}; + } + } catch (e) { + goog.net.xpc.logger.fine("error retrieving peer frames"); + } + return{}; +}; +goog.net.xpc.IframePollingTransport.prototype.getPeerFrame_ = function(frameName) { + return this.getPeerFrames_()[frameName]; +}; +goog.net.xpc.IframePollingTransport.prototype.connect = function() { + if (!this.isChannelAvailable()) { + return; + } + goog.net.xpc.logger.fine("transport connect called"); + if (!this.initialized_) { + goog.net.xpc.logger.fine("initializing..."); + this.constructSenderFrames_(); + this.initialized_ = true; + } + this.checkForeignFramesReady_(); +}; +goog.net.xpc.IframePollingTransport.prototype.constructSenderFrames_ = function() { + var name = this.getMsgFrameName_(); + this.msgIframeElm_ = this.constructSenderFrame_(name); + this.msgWinObj_ = this.getWindow().frames[name]; + name = this.getAckFrameName_(); + this.ackIframeElm_ = this.constructSenderFrame_(name); + this.ackWinObj_ = this.getWindow().frames[name]; +}; +goog.net.xpc.IframePollingTransport.prototype.constructSenderFrame_ = function(id) { + goog.net.xpc.logger.finest("constructing sender frame: " + id); + var ifr = goog.dom.createElement("iframe"); + var s = ifr.style; + s.position = "absolute"; + s.top = "-10px"; + s.left = "10px"; + s.width = "1px"; + s.height = "1px"; + ifr.id = ifr.name = id; + ifr.src = this.sendUri_ + "#INITIAL"; + this.getWindow().document.body.appendChild(ifr); + return ifr; +}; +goog.net.xpc.IframePollingTransport.prototype.maybeInnerPeerReconnect_ = function() { + if (this.reconnectFrame_ || this.pollsBeforeReconnect_-- > 0) { + return; + } + goog.net.xpc.logger.finest("Inner peer reconnect triggered."); + this.channel_.name = goog.net.xpc.getRandomString(10); + goog.net.xpc.logger.finest("switching channels: " + this.channel_.name); + this.deconstructSenderFrames_(); + this.initialized_ = false; + this.reconnectFrame_ = this.constructSenderFrame_(goog.net.xpc.IframePollingTransport.IFRAME_PREFIX + "_reconnect_" + this.channel_.name); +}; +goog.net.xpc.IframePollingTransport.prototype.outerPeerReconnect_ = function() { + goog.net.xpc.logger.finest("outerPeerReconnect called"); + var frames = this.getPeerFrames_(); + var length = frames.length; + for (var i = 0;i < length;i++) { + var frameName; + try { + if (frames[i] && frames[i].name) { + frameName = frames[i].name; + } + } catch (e) { + } + if (!frameName) { + continue; + } + var message = frameName.split("_"); + if (message.length == 3 && (message[0] == goog.net.xpc.IframePollingTransport.IFRAME_PREFIX && message[1] == "reconnect")) { + this.channel_.name = message[2]; + this.deconstructSenderFrames_(); + this.initialized_ = false; + break; + } + } +}; +goog.net.xpc.IframePollingTransport.prototype.deconstructSenderFrames_ = function() { + goog.net.xpc.logger.finest("deconstructSenderFrames called"); + if (this.msgIframeElm_) { + this.msgIframeElm_.parentNode.removeChild(this.msgIframeElm_); + this.msgIframeElm_ = null; + this.msgWinObj_ = null; + } + if (this.ackIframeElm_) { + this.ackIframeElm_.parentNode.removeChild(this.ackIframeElm_); + this.ackIframeElm_ = null; + this.ackWinObj_ = null; + } +}; +goog.net.xpc.IframePollingTransport.prototype.checkForeignFramesReady_ = function() { + if (!(this.isRcvFrameReady_(this.getMsgFrameName_()) && this.isRcvFrameReady_(this.getAckFrameName_()))) { + goog.net.xpc.logger.finest("foreign frames not (yet) present"); + if (this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.INNER) { + this.maybeInnerPeerReconnect_(); + } else { + if (this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.OUTER) { + this.outerPeerReconnect_(); + } + } + this.getWindow().setTimeout(goog.bind(this.connect, this), 100); + } else { + goog.net.xpc.logger.fine("foreign frames present"); + this.msgReceiver_ = new goog.net.xpc.IframePollingTransport.Receiver(this, this.getPeerFrame_(this.getMsgFrameName_()), goog.bind(this.processIncomingMsg, this)); + this.ackReceiver_ = new goog.net.xpc.IframePollingTransport.Receiver(this, this.getPeerFrame_(this.getAckFrameName_()), goog.bind(this.processIncomingAck, this)); + this.checkLocalFramesPresent_(); + } +}; +goog.net.xpc.IframePollingTransport.prototype.isRcvFrameReady_ = function(frameName) { + goog.net.xpc.logger.finest("checking for receive frame: " + frameName); + try { + var winObj = this.getPeerFrame_(frameName); + if (!winObj || winObj.location.href.indexOf(this.rcvUri_) != 0) { + return false; + } + } catch (e) { + return false; + } + return true; +}; +goog.net.xpc.IframePollingTransport.prototype.checkLocalFramesPresent_ = function() { + var frames = this.getPeerFrames_(); + if (!(frames[this.getAckFrameName_()] && frames[this.getMsgFrameName_()])) { + if (!this.checkLocalFramesPresentCb_) { + this.checkLocalFramesPresentCb_ = goog.bind(this.checkLocalFramesPresent_, this); + } + this.getWindow().setTimeout(this.checkLocalFramesPresentCb_, 100); + goog.net.xpc.logger.fine("local frames not (yet) present"); + } else { + this.msgSender_ = new goog.net.xpc.IframePollingTransport.Sender(this.sendUri_, this.msgWinObj_); + this.ackSender_ = new goog.net.xpc.IframePollingTransport.Sender(this.sendUri_, this.ackWinObj_); + goog.net.xpc.logger.fine("local frames ready"); + this.getWindow().setTimeout(goog.bind(function() { + this.msgSender_.send(goog.net.xpc.SETUP); + this.sentConnectionSetup_ = true; + this.waitForAck_ = true; + goog.net.xpc.logger.fine("SETUP sent"); + }, this), 100); + } +}; +goog.net.xpc.IframePollingTransport.prototype.checkIfConnected_ = function() { + if (this.sentConnectionSetupAck_ && this.rcvdConnectionSetupAck_) { + this.channel_.notifyConnected(); + if (this.deliveryQueue_) { + goog.net.xpc.logger.fine("delivering queued messages " + "(" + this.deliveryQueue_.length + ")"); + for (var i = 0, m;i < this.deliveryQueue_.length;i++) { + m = this.deliveryQueue_[i]; + this.channel_.xpcDeliver(m.service, m.payload); + } + delete this.deliveryQueue_; + } + } else { + goog.net.xpc.logger.finest("checking if connected: " + "ack sent:" + this.sentConnectionSetupAck_ + ", ack rcvd: " + this.rcvdConnectionSetupAck_); + } +}; +goog.net.xpc.IframePollingTransport.prototype.processIncomingMsg = function(raw) { + goog.net.xpc.logger.finest("msg received: " + raw); + if (raw == goog.net.xpc.SETUP) { + if (!this.ackSender_) { + return; + } + this.ackSender_.send(goog.net.xpc.SETUP_ACK_); + goog.net.xpc.logger.finest("SETUP_ACK sent"); + this.sentConnectionSetupAck_ = true; + this.checkIfConnected_(); + } else { + if (this.channel_.isConnected() || this.sentConnectionSetupAck_) { + var pos = raw.indexOf("|"); + var head = raw.substring(0, pos); + var frame = raw.substring(pos + 1); + pos = head.indexOf(","); + if (pos == -1) { + var seq = head; + this.ackSender_.send("ACK:" + seq); + this.deliverPayload_(frame); + } else { + var seq = head.substring(0, pos); + this.ackSender_.send("ACK:" + seq); + var partInfo = head.substring(pos + 1).split("/"); + var part0 = parseInt(partInfo[0], 10); + var part1 = parseInt(partInfo[1], 10); + if (part0 == 1) { + this.parts_ = []; + } + this.parts_.push(frame); + if (part0 == part1) { + this.deliverPayload_(this.parts_.join("")); + delete this.parts_; + } + } + } else { + goog.net.xpc.logger.warning("received msg, but channel is not connected"); + } + } +}; +goog.net.xpc.IframePollingTransport.prototype.processIncomingAck = function(msgStr) { + goog.net.xpc.logger.finest("ack received: " + msgStr); + if (msgStr == goog.net.xpc.SETUP_ACK_) { + this.waitForAck_ = false; + this.rcvdConnectionSetupAck_ = true; + this.checkIfConnected_(); + } else { + if (this.channel_.isConnected()) { + if (!this.waitForAck_) { + goog.net.xpc.logger.warning("got unexpected ack"); + return; + } + var seq = parseInt(msgStr.split(":")[1], 10); + if (seq == this.sequence_) { + this.waitForAck_ = false; + this.sendNextFrame_(); + } else { + goog.net.xpc.logger.warning("got ack with wrong sequence"); + } + } else { + goog.net.xpc.logger.warning("received ack, but channel not connected"); + } + } +}; +goog.net.xpc.IframePollingTransport.prototype.sendNextFrame_ = function() { + if (this.waitForAck_ || !this.sendQueue_.length) { + return; + } + var s = this.sendQueue_.shift(); + ++this.sequence_; + this.msgSender_.send(this.sequence_ + s); + goog.net.xpc.logger.finest("msg sent: " + this.sequence_ + s); + this.waitForAck_ = true; +}; +goog.net.xpc.IframePollingTransport.prototype.deliverPayload_ = function(s) { + var pos = s.indexOf(":"); + var service = s.substr(0, pos); + var payload = s.substring(pos + 1); + if (!this.channel_.isConnected()) { + (this.deliveryQueue_ || (this.deliveryQueue_ = [])).push({service:service, payload:payload}); + goog.net.xpc.logger.finest("queued delivery"); + } else { + this.channel_.xpcDeliver(service, payload); + } +}; +goog.net.xpc.IframePollingTransport.prototype.MAX_FRAME_LENGTH_ = 3800; +goog.net.xpc.IframePollingTransport.prototype.send = function(service, payload) { + var frame = service + ":" + payload; + if (!goog.userAgent.IE || payload.length <= this.MAX_FRAME_LENGTH_) { + this.sendQueue_.push("|" + frame); + } else { + var l = payload.length; + var num = Math.ceil(l / this.MAX_FRAME_LENGTH_); + var pos = 0; + var i = 1; + while (pos < l) { + this.sendQueue_.push("," + i + "/" + num + "|" + frame.substr(pos, this.MAX_FRAME_LENGTH_)); + i++; + pos += this.MAX_FRAME_LENGTH_; + } + } + this.sendNextFrame_(); +}; +goog.net.xpc.IframePollingTransport.prototype.disposeInternal = function() { + goog.base(this, "disposeInternal"); + var receivers = goog.net.xpc.IframePollingTransport.receivers_; + goog.array.remove(receivers, this.msgReceiver_); + goog.array.remove(receivers, this.ackReceiver_); + this.msgReceiver_ = this.ackReceiver_ = null; + goog.dom.removeNode(this.msgIframeElm_); + goog.dom.removeNode(this.ackIframeElm_); + this.msgIframeElm_ = this.ackIframeElm_ = null; + this.msgWinObj_ = this.ackWinObj_ = null; +}; +goog.net.xpc.IframePollingTransport.receivers_ = []; +goog.net.xpc.IframePollingTransport.TIME_POLL_SHORT_ = 10; +goog.net.xpc.IframePollingTransport.TIME_POLL_LONG_ = 100; +goog.net.xpc.IframePollingTransport.TIME_SHORT_POLL_AFTER_ACTIVITY_ = 1E3; +goog.net.xpc.IframePollingTransport.receive_ = function() { + var receivers = goog.net.xpc.IframePollingTransport.receivers_; + var receiver; + var rcvd = false; + try { + for (var i = 0;receiver = receivers[i];i++) { + rcvd = rcvd || receiver.receive(); + } + } catch (e) { + goog.net.xpc.logger.info("receive_() failed: " + e); + receiver.transport_.channel_.notifyTransportError(); + if (!receivers.length) { + return; + } + } + var now = goog.now(); + if (rcvd) { + goog.net.xpc.IframePollingTransport.lastActivity_ = now; + } + var t = now - goog.net.xpc.IframePollingTransport.lastActivity_ < goog.net.xpc.IframePollingTransport.TIME_SHORT_POLL_AFTER_ACTIVITY_ ? goog.net.xpc.IframePollingTransport.TIME_POLL_SHORT_ : goog.net.xpc.IframePollingTransport.TIME_POLL_LONG_; + goog.net.xpc.IframePollingTransport.rcvTimer_ = window.setTimeout(goog.net.xpc.IframePollingTransport.receiveCb_, t); +}; +goog.net.xpc.IframePollingTransport.receiveCb_ = goog.bind(goog.net.xpc.IframePollingTransport.receive_, goog.net.xpc.IframePollingTransport); +goog.net.xpc.IframePollingTransport.startRcvTimer_ = function() { + goog.net.xpc.logger.fine("starting receive-timer"); + goog.net.xpc.IframePollingTransport.lastActivity_ = goog.now(); + if (goog.net.xpc.IframePollingTransport.rcvTimer_) { + window.clearTimeout(goog.net.xpc.IframePollingTransport.rcvTimer_); + } + goog.net.xpc.IframePollingTransport.rcvTimer_ = window.setTimeout(goog.net.xpc.IframePollingTransport.receiveCb_, goog.net.xpc.IframePollingTransport.TIME_POLL_SHORT_); +}; +goog.net.xpc.IframePollingTransport.Sender = function(url, windowObj) { + this.sendUri_ = url; + this.sendFrame_ = windowObj; + this.cycle_ = 0; +}; +goog.net.xpc.IframePollingTransport.Sender.prototype.send = function(payload) { + this.cycle_ = ++this.cycle_ % 2; + var url = this.sendUri_ + "#" + this.cycle_ + encodeURIComponent(payload); + try { + if (goog.userAgent.WEBKIT) { + this.sendFrame_.location.href = url; + } else { + this.sendFrame_.location.replace(url); + } + } catch (e) { + goog.net.xpc.logger.severe("sending failed", e); + } + goog.net.xpc.IframePollingTransport.startRcvTimer_(); +}; +goog.net.xpc.IframePollingTransport.Receiver = function(transport, windowObj, callback) { + this.transport_ = transport; + this.rcvFrame_ = windowObj; + this.cb_ = callback; + this.currentLoc_ = this.rcvFrame_.location.href.split("#")[0] + "#INITIAL"; + goog.net.xpc.IframePollingTransport.receivers_.push(this); + goog.net.xpc.IframePollingTransport.startRcvTimer_(); +}; +goog.net.xpc.IframePollingTransport.Receiver.prototype.receive = function() { + var loc = this.rcvFrame_.location.href; + if (loc != this.currentLoc_) { + this.currentLoc_ = loc; + var payload = loc.split("#")[1]; + if (payload) { + payload = payload.substr(1); + this.cb_(decodeURIComponent(payload)); + } + return true; + } else { + return false; + } +}; +goog.provide("goog.events.EventHandler"); +goog.require("goog.Disposable"); +goog.require("goog.array"); +goog.require("goog.events"); +goog.require("goog.events.EventWrapper"); +goog.events.EventHandler = function(opt_handler) { + goog.Disposable.call(this); + this.handler_ = opt_handler; + this.keys_ = []; +}; +goog.inherits(goog.events.EventHandler, goog.Disposable); +goog.events.EventHandler.typeArray_ = []; +goog.events.EventHandler.prototype.listen = function(src, type, opt_fn, opt_capture, opt_handler) { + if (!goog.isArray(type)) { + goog.events.EventHandler.typeArray_[0] = (type); + type = goog.events.EventHandler.typeArray_; + } + for (var i = 0;i < type.length;i++) { + var key = (goog.events.listen(src, type[i], opt_fn || this, opt_capture || false, opt_handler || (this.handler_ || this))); + this.keys_.push(key); + } + return this; +}; +goog.events.EventHandler.prototype.listenOnce = function(src, type, opt_fn, opt_capture, opt_handler) { + if (goog.isArray(type)) { + for (var i = 0;i < type.length;i++) { + this.listenOnce(src, type[i], opt_fn, opt_capture, opt_handler); + } + } else { + var key = (goog.events.listenOnce(src, type, opt_fn || this, opt_capture, opt_handler || (this.handler_ || this))); + this.keys_.push(key); + } + return this; +}; +goog.events.EventHandler.prototype.listenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) { + wrapper.listen(src, listener, opt_capt, opt_handler || (this.handler_ || this), this); + return this; +}; +goog.events.EventHandler.prototype.getListenerCount = function() { + return this.keys_.length; +}; +goog.events.EventHandler.prototype.unlisten = function(src, type, opt_fn, opt_capture, opt_handler) { + if (goog.isArray(type)) { + for (var i = 0;i < type.length;i++) { + this.unlisten(src, type[i], opt_fn, opt_capture, opt_handler); + } + } else { + var listener = goog.events.getListener(src, type, opt_fn || this, opt_capture, opt_handler || (this.handler_ || this)); + if (listener) { + var key = listener.key; + goog.events.unlistenByKey(key); + goog.array.remove(this.keys_, key); + } + } + return this; +}; +goog.events.EventHandler.prototype.unlistenWithWrapper = function(src, wrapper, listener, opt_capt, opt_handler) { + wrapper.unlisten(src, listener, opt_capt, opt_handler || (this.handler_ || this), this); + return this; +}; +goog.events.EventHandler.prototype.removeAll = function() { + goog.array.forEach(this.keys_, goog.events.unlistenByKey); + this.keys_.length = 0; +}; +goog.events.EventHandler.prototype.disposeInternal = function() { + goog.events.EventHandler.superClass_.disposeInternal.call(this); + this.removeAll(); +}; +goog.events.EventHandler.prototype.handleEvent = function(e) { + throw Error("EventHandler.handleEvent not implemented"); +}; +goog.provide("goog.net.xpc.FrameElementMethodTransport"); +goog.require("goog.net.xpc"); +goog.require("goog.net.xpc.CrossPageChannelRole"); +goog.require("goog.net.xpc.Transport"); +goog.net.xpc.FrameElementMethodTransport = function(channel, opt_domHelper) { + goog.base(this, opt_domHelper); + this.channel_ = channel; + this.queue_ = []; + this.deliverQueuedCb_ = goog.bind(this.deliverQueued_, this); +}; +goog.inherits(goog.net.xpc.FrameElementMethodTransport, goog.net.xpc.Transport); +goog.net.xpc.FrameElementMethodTransport.prototype.transportType = goog.net.xpc.TransportTypes.FRAME_ELEMENT_METHOD; +goog.net.xpc.FrameElementMethodTransport.prototype.recursive_ = false; +goog.net.xpc.FrameElementMethodTransport.prototype.timer_ = 0; +goog.net.xpc.FrameElementMethodTransport.outgoing_ = null; +goog.net.xpc.FrameElementMethodTransport.prototype.connect = function() { + if (this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.OUTER) { + this.iframeElm_ = this.channel_.getIframeElement(); + this.iframeElm_["XPC_toOuter"] = goog.bind(this.incoming_, this); + } else { + this.attemptSetup_(); + } +}; +goog.net.xpc.FrameElementMethodTransport.prototype.attemptSetup_ = function() { + var retry = true; + try { + if (!this.iframeElm_) { + this.iframeElm_ = this.getWindow().frameElement; + } + if (this.iframeElm_ && this.iframeElm_["XPC_toOuter"]) { + this.outgoing_ = this.iframeElm_["XPC_toOuter"]; + this.iframeElm_["XPC_toOuter"]["XPC_toInner"] = goog.bind(this.incoming_, this); + retry = false; + this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP_ACK_); + this.channel_.notifyConnected(); + } + } catch (e) { + goog.net.xpc.logger.severe("exception caught while attempting setup: " + e); + } + if (retry) { + if (!this.attemptSetupCb_) { + this.attemptSetupCb_ = goog.bind(this.attemptSetup_, this); + } + this.getWindow().setTimeout(this.attemptSetupCb_, 100); + } +}; +goog.net.xpc.FrameElementMethodTransport.prototype.transportServiceHandler = function(payload) { + if (this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.OUTER && (!this.channel_.isConnected() && payload == goog.net.xpc.SETUP_ACK_)) { + this.outgoing_ = this.iframeElm_["XPC_toOuter"]["XPC_toInner"]; + this.channel_.notifyConnected(); + } else { + throw Error("Got unexpected transport message."); + } +}; +goog.net.xpc.FrameElementMethodTransport.prototype.incoming_ = function(serviceName, payload) { + if (!this.recursive_ && this.queue_.length == 0) { + this.channel_.xpcDeliver(serviceName, payload); + } else { + this.queue_.push({serviceName:serviceName, payload:payload}); + if (this.queue_.length == 1) { + this.timer_ = this.getWindow().setTimeout(this.deliverQueuedCb_, 1); + } + } +}; +goog.net.xpc.FrameElementMethodTransport.prototype.deliverQueued_ = function() { + while (this.queue_.length) { + var msg = this.queue_.shift(); + this.channel_.xpcDeliver(msg.serviceName, msg.payload); + } +}; +goog.net.xpc.FrameElementMethodTransport.prototype.send = function(service, payload) { + this.recursive_ = true; + this.outgoing_(service, payload); + this.recursive_ = false; +}; +goog.net.xpc.FrameElementMethodTransport.prototype.disposeInternal = function() { + goog.net.xpc.FrameElementMethodTransport.superClass_.disposeInternal.call(this); + this.outgoing_ = null; + this.iframeElm_ = null; +}; +goog.provide("goog.net.xpc.IframeRelayTransport"); +goog.require("goog.dom"); +goog.require("goog.events"); +goog.require("goog.net.xpc"); +goog.require("goog.net.xpc.Transport"); +goog.require("goog.userAgent"); +goog.net.xpc.IframeRelayTransport = function(channel, opt_domHelper) { + goog.base(this, opt_domHelper); + this.channel_ = channel; + this.peerRelayUri_ = this.channel_.getConfig()[goog.net.xpc.CfgFields.PEER_RELAY_URI]; + this.peerIframeId_ = this.channel_.getConfig()[goog.net.xpc.CfgFields.IFRAME_ID]; + if (goog.userAgent.WEBKIT) { + goog.net.xpc.IframeRelayTransport.startCleanupTimer_(); + } +}; +goog.inherits(goog.net.xpc.IframeRelayTransport, goog.net.xpc.Transport); +if (goog.userAgent.WEBKIT) { + goog.net.xpc.IframeRelayTransport.iframeRefs_ = []; + goog.net.xpc.IframeRelayTransport.CLEANUP_INTERVAL_ = 1E3; + goog.net.xpc.IframeRelayTransport.IFRAME_MAX_AGE_ = 3E3; + goog.net.xpc.IframeRelayTransport.cleanupTimer_ = 0; + goog.net.xpc.IframeRelayTransport.startCleanupTimer_ = function() { + if (!goog.net.xpc.IframeRelayTransport.cleanupTimer_) { + goog.net.xpc.IframeRelayTransport.cleanupTimer_ = window.setTimeout(function() { + goog.net.xpc.IframeRelayTransport.cleanup_(); + }, goog.net.xpc.IframeRelayTransport.CLEANUP_INTERVAL_); + } + }; + goog.net.xpc.IframeRelayTransport.cleanup_ = function(opt_maxAge) { + var now = goog.now(); + var maxAge = opt_maxAge || goog.net.xpc.IframeRelayTransport.IFRAME_MAX_AGE_; + while (goog.net.xpc.IframeRelayTransport.iframeRefs_.length && now - goog.net.xpc.IframeRelayTransport.iframeRefs_[0].timestamp >= maxAge) { + var ifr = goog.net.xpc.IframeRelayTransport.iframeRefs_.shift().iframeElement; + goog.dom.removeNode(ifr); + goog.net.xpc.logger.finest("iframe removed"); + } + goog.net.xpc.IframeRelayTransport.cleanupTimer_ = window.setTimeout(goog.net.xpc.IframeRelayTransport.cleanupCb_, goog.net.xpc.IframeRelayTransport.CLEANUP_INTERVAL_); + }; + goog.net.xpc.IframeRelayTransport.cleanupCb_ = function() { + goog.net.xpc.IframeRelayTransport.cleanup_(); + }; +} +goog.net.xpc.IframeRelayTransport.IE_PAYLOAD_MAX_SIZE_ = 1800; +goog.net.xpc.IframeRelayTransport.FragmentInfo; +goog.net.xpc.IframeRelayTransport.fragmentMap_ = {}; +goog.net.xpc.IframeRelayTransport.prototype.transportType = goog.net.xpc.TransportTypes.IFRAME_RELAY; +goog.net.xpc.IframeRelayTransport.prototype.connect = function() { + if (!this.getWindow()["xpcRelay"]) { + this.getWindow()["xpcRelay"] = goog.net.xpc.IframeRelayTransport.receiveMessage_; + } + this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP); +}; +goog.net.xpc.IframeRelayTransport.receiveMessage_ = function(channelName, frame) { + var pos = frame.indexOf(":"); + var header = frame.substr(0, pos); + var payload = frame.substr(pos + 1); + if (!goog.userAgent.IE || (pos = header.indexOf("|")) == -1) { + var service = header + } else { + var service = header.substr(0, pos); + var fragmentIdStr = header.substr(pos + 1); + pos = fragmentIdStr.indexOf("+"); + var messageIdStr = fragmentIdStr.substr(0, pos); + var fragmentNum = parseInt(fragmentIdStr.substr(pos + 1), 10); + var fragmentInfo = goog.net.xpc.IframeRelayTransport.fragmentMap_[messageIdStr]; + if (!fragmentInfo) { + fragmentInfo = goog.net.xpc.IframeRelayTransport.fragmentMap_[messageIdStr] = {fragments:[], received:0, expected:0}; + } + if (goog.string.contains(fragmentIdStr, "++")) { + fragmentInfo.expected = fragmentNum + 1; + } + fragmentInfo.fragments[fragmentNum] = payload; + fragmentInfo.received++; + if (fragmentInfo.received != fragmentInfo.expected) { + return; + } + payload = fragmentInfo.fragments.join(""); + delete goog.net.xpc.IframeRelayTransport.fragmentMap_[messageIdStr]; + } + goog.net.xpc.channels[channelName].xpcDeliver(service, decodeURIComponent(payload)); +}; +goog.net.xpc.IframeRelayTransport.prototype.transportServiceHandler = function(payload) { + if (payload == goog.net.xpc.SETUP) { + this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP_ACK_); + this.channel_.notifyConnected(); + } else { + if (payload == goog.net.xpc.SETUP_ACK_) { + this.channel_.notifyConnected(); + } + } +}; +goog.net.xpc.IframeRelayTransport.prototype.send = function(service, payload) { + var encodedPayload = encodeURIComponent(payload); + var encodedLen = encodedPayload.length; + var maxSize = goog.net.xpc.IframeRelayTransport.IE_PAYLOAD_MAX_SIZE_; + if (goog.userAgent.IE && encodedLen > maxSize) { + var messageIdStr = goog.string.getRandomString(); + for (var startIndex = 0, fragmentNum = 0;startIndex < encodedLen;fragmentNum++) { + var payloadFragment = encodedPayload.substr(startIndex, maxSize); + startIndex += maxSize; + var fragmentIdStr = messageIdStr + (startIndex >= encodedLen ? "++" : "+") + fragmentNum; + this.send_(service, payloadFragment, fragmentIdStr); + } + } else { + this.send_(service, encodedPayload); + } +}; +goog.net.xpc.IframeRelayTransport.prototype.send_ = function(service, encodedPayload, opt_fragmentIdStr) { + if (goog.userAgent.IE) { + var div = this.getWindow().document.createElement("div"); + div.innerHTML = '\x3ciframe onload\x3d"this.xpcOnload()"\x3e\x3c/iframe\x3e'; + var ifr = div.childNodes[0]; + div = null; + ifr["xpcOnload"] = goog.net.xpc.IframeRelayTransport.iframeLoadHandler_; + } else { + var ifr = this.getWindow().document.createElement("iframe"); + if (goog.userAgent.WEBKIT) { + goog.net.xpc.IframeRelayTransport.iframeRefs_.push({timestamp:goog.now(), iframeElement:ifr}); + } else { + goog.events.listen(ifr, "load", goog.net.xpc.IframeRelayTransport.iframeLoadHandler_); + } + } + var style = ifr.style; + style.visibility = "hidden"; + style.width = ifr.style.height = "0px"; + style.position = "absolute"; + var url = this.peerRelayUri_; + url += "#" + this.channel_.name; + if (this.peerIframeId_) { + url += "," + this.peerIframeId_; + } + url += "|" + service; + if (opt_fragmentIdStr) { + url += "|" + opt_fragmentIdStr; + } + url += ":" + encodedPayload; + ifr.src = url; + this.getWindow().document.body.appendChild(ifr); + goog.net.xpc.logger.finest("msg sent: " + url); +}; +goog.net.xpc.IframeRelayTransport.iframeLoadHandler_ = function() { + goog.net.xpc.logger.finest("iframe-load"); + goog.dom.removeNode(this); + this.xpcOnload = null; +}; +goog.net.xpc.IframeRelayTransport.prototype.disposeInternal = function() { + goog.base(this, "disposeInternal"); + if (goog.userAgent.WEBKIT) { + goog.net.xpc.IframeRelayTransport.cleanup_(0); + } +}; +goog.provide("goog.net.xpc.NativeMessagingTransport"); +goog.require("goog.Timer"); +goog.require("goog.asserts"); +goog.require("goog.async.Deferred"); +goog.require("goog.events"); +goog.require("goog.events.EventHandler"); +goog.require("goog.net.xpc"); +goog.require("goog.net.xpc.CrossPageChannelRole"); +goog.require("goog.net.xpc.Transport"); +goog.net.xpc.NativeMessagingTransport = function(channel, peerHostname, opt_domHelper, opt_oneSidedHandshake, opt_protocolVersion) { + goog.base(this, opt_domHelper); + this.channel_ = channel; + this.protocolVersion_ = opt_protocolVersion || 2; + goog.asserts.assert(this.protocolVersion_ >= 1); + goog.asserts.assert(this.protocolVersion_ <= 2); + this.peerHostname_ = peerHostname || "*"; + this.eventHandler_ = new goog.events.EventHandler(this); + this.maybeAttemptToConnectTimer_ = new goog.Timer(100, this.getWindow()); + this.oneSidedHandshake_ = !!opt_oneSidedHandshake; + this.setupAckReceived_ = new goog.async.Deferred; + this.setupAckSent_ = new goog.async.Deferred; + this.connected_ = new goog.async.Deferred; + this.endpointId_ = goog.net.xpc.getRandomString(10); + this.peerEndpointId_ = null; + if (this.oneSidedHandshake_) { + if (this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.INNER) { + this.connected_.awaitDeferred(this.setupAckReceived_); + } else { + this.connected_.awaitDeferred(this.setupAckSent_); + } + } else { + this.connected_.awaitDeferred(this.setupAckReceived_); + if (this.protocolVersion_ == 2) { + this.connected_.awaitDeferred(this.setupAckSent_); + } + } + this.connected_.addCallback(this.notifyConnected_, this); + this.connected_.callback(true); + this.eventHandler_.listen(this.maybeAttemptToConnectTimer_, goog.Timer.TICK, this.maybeAttemptToConnect_); + goog.net.xpc.logger.info("NativeMessagingTransport created. " + "protocolVersion\x3d" + this.protocolVersion_ + ", oneSidedHandshake\x3d" + this.oneSidedHandshake_ + ", role\x3d" + this.channel_.getRole()); +}; +goog.inherits(goog.net.xpc.NativeMessagingTransport, goog.net.xpc.Transport); +goog.net.xpc.NativeMessagingTransport.CONNECTION_DELAY_MS_ = 200; +goog.net.xpc.NativeMessagingTransport.prototype.peerProtocolVersion_ = null; +goog.net.xpc.NativeMessagingTransport.prototype.initialized_ = false; +goog.net.xpc.NativeMessagingTransport.prototype.transportType = goog.net.xpc.TransportTypes.NATIVE_MESSAGING; +goog.net.xpc.NativeMessagingTransport.MESSAGE_DELIMITER_ = ","; +goog.net.xpc.NativeMessagingTransport.activeCount_ = {}; +goog.net.xpc.NativeMessagingTransport.sendTimerId_ = 0; +goog.net.xpc.NativeMessagingTransport.prototype.couldPeerVersionBe_ = function(version) { + return this.peerProtocolVersion_ == null || this.peerProtocolVersion_ == version; +}; +goog.net.xpc.NativeMessagingTransport.initialize_ = function(listenWindow) { + var uid = goog.getUid(listenWindow); + var value = goog.net.xpc.NativeMessagingTransport.activeCount_[uid]; + if (!goog.isNumber(value)) { + value = 0; + } + if (value == 0) { + goog.events.listen(listenWindow.postMessage ? listenWindow : listenWindow.document, "message", goog.net.xpc.NativeMessagingTransport.messageReceived_, false, goog.net.xpc.NativeMessagingTransport); + } + goog.net.xpc.NativeMessagingTransport.activeCount_[uid] = value + 1; +}; +goog.net.xpc.NativeMessagingTransport.messageReceived_ = function(msgEvt) { + var data = msgEvt.getBrowserEvent().data; + if (!goog.isString(data)) { + return false; + } + var headDelim = data.indexOf("|"); + var serviceDelim = data.indexOf(":"); + if (headDelim == -1 || serviceDelim == -1) { + return false; + } + var channelName = data.substring(0, headDelim); + var service = data.substring(headDelim + 1, serviceDelim); + var payload = data.substring(serviceDelim + 1); + goog.net.xpc.logger.fine("messageReceived: channel\x3d" + channelName + ", service\x3d" + service + ", payload\x3d" + payload); + var channel = goog.net.xpc.channels[channelName]; + if (channel) { + channel.xpcDeliver(service, payload, msgEvt.getBrowserEvent().origin); + return true; + } + var transportMessageType = goog.net.xpc.NativeMessagingTransport.parseTransportPayload_(payload)[0]; + for (var staleChannelName in goog.net.xpc.channels) { + var staleChannel = goog.net.xpc.channels[staleChannelName]; + if (staleChannel.getRole() == goog.net.xpc.CrossPageChannelRole.INNER && (!staleChannel.isConnected() && (service == goog.net.xpc.TRANSPORT_SERVICE_ && (transportMessageType == goog.net.xpc.SETUP || transportMessageType == goog.net.xpc.SETUP_NTPV2)))) { + goog.net.xpc.logger.fine("changing channel name to " + channelName); + staleChannel.name = channelName; + delete goog.net.xpc.channels[staleChannelName]; + goog.net.xpc.channels[channelName] = staleChannel; + staleChannel.xpcDeliver(service, payload); + return true; + } + } + goog.net.xpc.logger.info('channel name mismatch; message ignored"'); + return false; +}; +goog.net.xpc.NativeMessagingTransport.prototype.transportServiceHandler = function(payload) { + var transportParts = goog.net.xpc.NativeMessagingTransport.parseTransportPayload_(payload); + var transportMessageType = transportParts[0]; + var peerEndpointId = transportParts[1]; + switch(transportMessageType) { + case goog.net.xpc.SETUP_ACK_: + this.setPeerProtocolVersion_(1); + if (!this.setupAckReceived_.hasFired()) { + this.setupAckReceived_.callback(true); + } + break; + case goog.net.xpc.SETUP_ACK_NTPV2: + if (this.protocolVersion_ == 2) { + this.setPeerProtocolVersion_(2); + if (!this.setupAckReceived_.hasFired()) { + this.setupAckReceived_.callback(true); + } + } + break; + case goog.net.xpc.SETUP: + this.setPeerProtocolVersion_(1); + this.sendSetupAckMessage_(1); + break; + case goog.net.xpc.SETUP_NTPV2: + if (this.protocolVersion_ == 2) { + var prevPeerProtocolVersion = this.peerProtocolVersion_; + this.setPeerProtocolVersion_(2); + this.sendSetupAckMessage_(2); + if ((prevPeerProtocolVersion == 1 || this.peerEndpointId_ != null) && this.peerEndpointId_ != peerEndpointId) { + goog.net.xpc.logger.info("Sending SETUP and changing peer ID to: " + peerEndpointId); + this.sendSetupMessage_(); + } + this.peerEndpointId_ = peerEndpointId; + } + break; + } +}; +goog.net.xpc.NativeMessagingTransport.prototype.sendSetupMessage_ = function() { + goog.asserts.assert(!(this.protocolVersion_ == 1 && this.peerProtocolVersion_ == 2)); + if (this.protocolVersion_ == 2 && this.couldPeerVersionBe_(2)) { + var payload = goog.net.xpc.SETUP_NTPV2; + payload += goog.net.xpc.NativeMessagingTransport.MESSAGE_DELIMITER_; + payload += this.endpointId_; + this.send(goog.net.xpc.TRANSPORT_SERVICE_, payload); + } + if (this.couldPeerVersionBe_(1)) { + this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP); + } +}; +goog.net.xpc.NativeMessagingTransport.prototype.sendSetupAckMessage_ = function(protocolVersion) { + goog.asserts.assert(this.protocolVersion_ != 1 || protocolVersion != 2, "Shouldn't try to send a v2 setup ack in v1 mode."); + if (this.protocolVersion_ == 2 && (this.couldPeerVersionBe_(2) && protocolVersion == 2)) { + this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP_ACK_NTPV2); + } else { + if (this.couldPeerVersionBe_(1) && protocolVersion == 1) { + this.send(goog.net.xpc.TRANSPORT_SERVICE_, goog.net.xpc.SETUP_ACK_); + } else { + return; + } + } + if (!this.setupAckSent_.hasFired()) { + this.setupAckSent_.callback(true); + } +}; +goog.net.xpc.NativeMessagingTransport.prototype.setPeerProtocolVersion_ = function(version) { + if (version > this.peerProtocolVersion_) { + this.peerProtocolVersion_ = version; + } + if (this.peerProtocolVersion_ == 1) { + if (!this.setupAckSent_.hasFired() && !this.oneSidedHandshake_) { + this.setupAckSent_.callback(true); + } + this.peerEndpointId_ = null; + } +}; +goog.net.xpc.NativeMessagingTransport.prototype.connect = function() { + goog.net.xpc.NativeMessagingTransport.initialize_(this.getWindow()); + this.initialized_ = true; + this.maybeAttemptToConnect_(); +}; +goog.net.xpc.NativeMessagingTransport.prototype.maybeAttemptToConnect_ = function() { + var outerFrame = this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.OUTER; + if (this.oneSidedHandshake_ && outerFrame || (this.channel_.isConnected() || this.isDisposed())) { + this.maybeAttemptToConnectTimer_.stop(); + return; + } + this.maybeAttemptToConnectTimer_.start(); + this.sendSetupMessage_(); +}; +goog.net.xpc.NativeMessagingTransport.prototype.send = function(service, payload) { + var win = this.channel_.getPeerWindowObject(); + if (!win) { + goog.net.xpc.logger.fine("send(): window not ready"); + return; + } + this.send = function(service, payload) { + var transport = this; + var channelName = this.channel_.name; + var sendFunctor = function() { + transport.sendTimerId_ = 0; + try { + var obj = win.postMessage ? win : win.document; + if (!obj.postMessage) { + goog.net.xpc.logger.warning("Peer window had no postMessage " + "function."); + return; + } + obj.postMessage(channelName + "|" + service + ":" + payload, transport.peerHostname_); + goog.net.xpc.logger.fine("send(): service\x3d" + service + " payload\x3d" + payload + " to hostname\x3d" + transport.peerHostname_); + } catch (error) { + goog.net.xpc.logger.warning("Error performing postMessage, ignoring.", error); + } + }; + this.sendTimerId_ = goog.Timer.callOnce(sendFunctor, 0); + }; + this.send(service, payload); +}; +goog.net.xpc.NativeMessagingTransport.prototype.notifyConnected_ = function() { + var delay = this.protocolVersion_ == 1 || this.peerProtocolVersion_ == 1 ? goog.net.xpc.NativeMessagingTransport.CONNECTION_DELAY_MS_ : undefined; + this.channel_.notifyConnected(delay); +}; +goog.net.xpc.NativeMessagingTransport.prototype.disposeInternal = function() { + if (this.initialized_) { + var listenWindow = this.getWindow(); + var uid = goog.getUid(listenWindow); + var value = goog.net.xpc.NativeMessagingTransport.activeCount_[uid]; + goog.net.xpc.NativeMessagingTransport.activeCount_[uid] = value - 1; + if (value == 1) { + goog.events.unlisten(listenWindow.postMessage ? listenWindow : listenWindow.document, "message", goog.net.xpc.NativeMessagingTransport.messageReceived_, false, goog.net.xpc.NativeMessagingTransport); + } + } + if (this.sendTimerId_) { + goog.Timer.clear(this.sendTimerId_); + this.sendTimerId_ = 0; + } + goog.dispose(this.eventHandler_); + delete this.eventHandler_; + goog.dispose(this.maybeAttemptToConnectTimer_); + delete this.maybeAttemptToConnectTimer_; + this.setupAckReceived_.cancel(); + delete this.setupAckReceived_; + this.setupAckSent_.cancel(); + delete this.setupAckSent_; + this.connected_.cancel(); + delete this.connected_; + delete this.send; + goog.base(this, "disposeInternal"); +}; +goog.net.xpc.NativeMessagingTransport.parseTransportPayload_ = function(payload) { + var transportParts = (payload.split(goog.net.xpc.NativeMessagingTransport.MESSAGE_DELIMITER_)); + transportParts[1] = transportParts[1] || null; + return transportParts; +}; +goog.provide("goog.net.xpc.NixTransport"); +goog.require("goog.net.xpc"); +goog.require("goog.net.xpc.CrossPageChannelRole"); +goog.require("goog.net.xpc.Transport"); +goog.require("goog.reflect"); +goog.net.xpc.NixTransport = function(channel, opt_domHelper) { + goog.base(this, opt_domHelper); + this.channel_ = channel; + this.authToken_ = channel[goog.net.xpc.CfgFields.AUTH_TOKEN] || ""; + this.remoteAuthToken_ = channel[goog.net.xpc.CfgFields.REMOTE_AUTH_TOKEN] || ""; + goog.net.xpc.NixTransport.conductGlobalSetup_(this.getWindow()); + this[goog.net.xpc.NixTransport.NIX_HANDLE_MESSAGE] = this.handleMessage_; + this[goog.net.xpc.NixTransport.NIX_CREATE_CHANNEL] = this.createChannel_; +}; +goog.inherits(goog.net.xpc.NixTransport, goog.net.xpc.Transport); +goog.net.xpc.NixTransport.NIX_WRAPPER = "GCXPC____NIXVBS_wrapper"; +goog.net.xpc.NixTransport.NIX_GET_WRAPPER = "GCXPC____NIXVBS_get_wrapper"; +goog.net.xpc.NixTransport.NIX_HANDLE_MESSAGE = "GCXPC____NIXJS_handle_message"; +goog.net.xpc.NixTransport.NIX_CREATE_CHANNEL = "GCXPC____NIXJS_create_channel"; +goog.net.xpc.NixTransport.NIX_ID_FIELD = "GCXPC____NIXVBS_container"; +goog.net.xpc.NixTransport.isNixSupported = function() { + var isSupported = false; + try { + var oldOpener = window.opener; + window.opener = ({}); + isSupported = goog.reflect.canAccessProperty(window, "opener"); + window.opener = oldOpener; + } catch (e) { + } + return isSupported; +}; +goog.net.xpc.NixTransport.conductGlobalSetup_ = function(listenWindow) { + if (listenWindow["nix_setup_complete"]) { + return; + } + var vbscript = "Class " + goog.net.xpc.NixTransport.NIX_WRAPPER + "\n " + "Private m_Transport\n" + "Private m_Auth\n" + "Public Sub SetTransport(transport)\n" + "If isEmpty(m_Transport) Then\n" + "Set m_Transport \x3d transport\n" + "End If\n" + "End Sub\n" + "Public Sub SetAuth(auth)\n" + "If isEmpty(m_Auth) Then\n" + "m_Auth \x3d auth\n" + "End If\n" + "End Sub\n" + "Public Function GetAuthToken()\n " + "GetAuthToken \x3d m_Auth\n" + "End Function\n" + "Public Sub SendMessage(service, payload)\n " + + "Call m_Transport." + goog.net.xpc.NixTransport.NIX_HANDLE_MESSAGE + "(service, payload)\n" + "End Sub\n" + "Public Sub CreateChannel(channel)\n " + "Call m_Transport." + goog.net.xpc.NixTransport.NIX_CREATE_CHANNEL + "(channel)\n" + "End Sub\n" + "Public Sub " + goog.net.xpc.NixTransport.NIX_ID_FIELD + "()\n " + "End Sub\n" + "End Class\n " + "Function " + goog.net.xpc.NixTransport.NIX_GET_WRAPPER + "(transport, auth)\n" + "Dim wrap\n" + "Set wrap \x3d New " + goog.net.xpc.NixTransport.NIX_WRAPPER + + "\n" + "wrap.SetTransport transport\n" + "wrap.SetAuth auth\n" + "Set " + goog.net.xpc.NixTransport.NIX_GET_WRAPPER + " \x3d wrap\n" + "End Function"; + try { + listenWindow.execScript(vbscript, "vbscript"); + listenWindow["nix_setup_complete"] = true; + } catch (e) { + goog.net.xpc.logger.severe("exception caught while attempting global setup: " + e); + } +}; +goog.net.xpc.NixTransport.prototype.transportType = goog.net.xpc.TransportTypes.NIX; +goog.net.xpc.NixTransport.prototype.localSetupCompleted_ = false; +goog.net.xpc.NixTransport.prototype.nixChannel_ = null; +goog.net.xpc.NixTransport.prototype.connect = function() { + if (this.channel_.getRole() == goog.net.xpc.CrossPageChannelRole.OUTER) { + this.attemptOuterSetup_(); + } else { + this.attemptInnerSetup_(); + } +}; +goog.net.xpc.NixTransport.prototype.attemptOuterSetup_ = function() { + if (this.localSetupCompleted_) { + return; + } + var innerFrame = this.channel_.getIframeElement(); + try { + var theWindow = this.getWindow(); + var getWrapper = theWindow[goog.net.xpc.NixTransport.NIX_GET_WRAPPER]; + innerFrame.contentWindow.opener = getWrapper(this, this.authToken_); + this.localSetupCompleted_ = true; + } catch (e) { + goog.net.xpc.logger.severe("exception caught while attempting setup: " + e); + } + if (!this.localSetupCompleted_) { + this.getWindow().setTimeout(goog.bind(this.attemptOuterSetup_, this), 100); + } +}; +goog.net.xpc.NixTransport.prototype.attemptInnerSetup_ = function() { + if (this.localSetupCompleted_) { + return; + } + try { + var opener = this.getWindow().opener; + if (opener && goog.net.xpc.NixTransport.NIX_ID_FIELD in opener) { + this.nixChannel_ = opener; + var remoteAuthToken = this.nixChannel_["GetAuthToken"](); + if (remoteAuthToken != this.remoteAuthToken_) { + goog.net.xpc.logger.severe("Invalid auth token from other party"); + return; + } + var theWindow = this.getWindow(); + var getWrapper = theWindow[goog.net.xpc.NixTransport.NIX_GET_WRAPPER]; + this.nixChannel_["CreateChannel"](getWrapper(this, this.authToken_)); + this.localSetupCompleted_ = true; + this.channel_.notifyConnected(); + } + } catch (e) { + goog.net.xpc.logger.severe("exception caught while attempting setup: " + e); + return; + } + if (!this.localSetupCompleted_) { + this.getWindow().setTimeout(goog.bind(this.attemptInnerSetup_, this), 100); + } +}; +goog.net.xpc.NixTransport.prototype.createChannel_ = function(channel) { + if (typeof channel != "unknown" || !(goog.net.xpc.NixTransport.NIX_ID_FIELD in channel)) { + goog.net.xpc.logger.severe("Invalid NIX channel given to createChannel_"); + } + this.nixChannel_ = channel; + var remoteAuthToken = this.nixChannel_["GetAuthToken"](); + if (remoteAuthToken != this.remoteAuthToken_) { + goog.net.xpc.logger.severe("Invalid auth token from other party"); + return; + } + this.channel_.notifyConnected(); +}; +goog.net.xpc.NixTransport.prototype.handleMessage_ = function(serviceName, payload) { + var deliveryHandler = function() { + this.channel_.xpcDeliver(serviceName, payload); + }; + this.getWindow().setTimeout(goog.bind(deliveryHandler, this), 1); +}; +goog.net.xpc.NixTransport.prototype.send = function(service, payload) { + if (typeof this.nixChannel_ !== "unknown") { + goog.net.xpc.logger.severe("NIX channel not connected"); + } + this.nixChannel_["SendMessage"](service, payload); +}; +goog.net.xpc.NixTransport.prototype.disposeInternal = function() { + goog.base(this, "disposeInternal"); + this.nixChannel_ = null; +}; +goog.provide("goog.net.xpc.CrossPageChannel"); +goog.require("goog.Disposable"); +goog.require("goog.Uri"); +goog.require("goog.async.Deferred"); +goog.require("goog.async.Delay"); +goog.require("goog.dom"); +goog.require("goog.events"); +goog.require("goog.events.EventHandler"); +goog.require("goog.json"); +goog.require("goog.messaging.AbstractChannel"); +goog.require("goog.net.xpc"); +goog.require("goog.net.xpc.CrossPageChannelRole"); +goog.require("goog.net.xpc.FrameElementMethodTransport"); +goog.require("goog.net.xpc.IframePollingTransport"); +goog.require("goog.net.xpc.IframeRelayTransport"); +goog.require("goog.net.xpc.NativeMessagingTransport"); +goog.require("goog.net.xpc.NixTransport"); +goog.require("goog.net.xpc.Transport"); +goog.require("goog.userAgent"); +goog.net.xpc.CrossPageChannel = function(cfg, opt_domHelper) { + goog.base(this); + for (var i = 0, uriField;uriField = goog.net.xpc.UriCfgFields[i];i++) { + if (uriField in cfg && !/^https?:\/\//.test(cfg[uriField])) { + throw Error("URI " + cfg[uriField] + " is invalid for field " + uriField); + } + } + this.cfg_ = cfg; + this.name = this.cfg_[goog.net.xpc.CfgFields.CHANNEL_NAME] || goog.net.xpc.getRandomString(10); + this.domHelper_ = opt_domHelper || goog.dom.getDomHelper(); + this.deferredDeliveries_ = []; + this.peerLoadHandler_ = new goog.events.EventHandler(this); + cfg[goog.net.xpc.CfgFields.LOCAL_POLL_URI] = cfg[goog.net.xpc.CfgFields.LOCAL_POLL_URI] || goog.uri.utils.getHost(this.domHelper_.getWindow().location.href) + "/robots.txt"; + cfg[goog.net.xpc.CfgFields.PEER_POLL_URI] = cfg[goog.net.xpc.CfgFields.PEER_POLL_URI] || goog.uri.utils.getHost(cfg[goog.net.xpc.CfgFields.PEER_URI] || "") + "/robots.txt"; + goog.net.xpc.channels[this.name] = this; + goog.events.listen(window, "unload", goog.net.xpc.CrossPageChannel.disposeAll_); + goog.net.xpc.logger.info("CrossPageChannel created: " + this.name); +}; +goog.inherits(goog.net.xpc.CrossPageChannel, goog.messaging.AbstractChannel); +goog.net.xpc.CrossPageChannel.TRANSPORT_SERVICE_ESCAPE_RE_ = new RegExp("^%*" + goog.net.xpc.TRANSPORT_SERVICE_ + "$"); +goog.net.xpc.CrossPageChannel.TRANSPORT_SERVICE_UNESCAPE_RE_ = new RegExp("^%+" + goog.net.xpc.TRANSPORT_SERVICE_ + "$"); +goog.net.xpc.CrossPageChannel.prototype.connectionDelay_ = null; +goog.net.xpc.CrossPageChannel.prototype.peerWindowDeferred_ = null; +goog.net.xpc.CrossPageChannel.prototype.transport_ = null; +goog.net.xpc.CrossPageChannel.prototype.state_ = goog.net.xpc.ChannelStates.NOT_CONNECTED; +goog.net.xpc.CrossPageChannel.prototype.isConnected = function() { + return this.state_ == goog.net.xpc.ChannelStates.CONNECTED; +}; +goog.net.xpc.CrossPageChannel.prototype.peerWindowObject_ = null; +goog.net.xpc.CrossPageChannel.prototype.iframeElement_ = null; +goog.net.xpc.CrossPageChannel.prototype.getConfig = function() { + return this.cfg_; +}; +goog.net.xpc.CrossPageChannel.prototype.getIframeElement = function() { + return this.iframeElement_; +}; +goog.net.xpc.CrossPageChannel.prototype.setPeerWindowObject = function(peerWindowObject) { + this.peerWindowObject_ = peerWindowObject; +}; +goog.net.xpc.CrossPageChannel.prototype.getPeerWindowObject = function() { + return this.peerWindowObject_; +}; +goog.net.xpc.CrossPageChannel.prototype.isPeerAvailable = function() { + try { + return!!this.peerWindowObject_ && !Boolean(this.peerWindowObject_.closed); + } catch (e) { + return false; + } +}; +goog.net.xpc.CrossPageChannel.prototype.determineTransportType_ = function() { + var transportType; + if (goog.isFunction(document.postMessage) || (goog.isFunction(window.postMessage) || goog.userAgent.IE && window.postMessage)) { + transportType = goog.net.xpc.TransportTypes.NATIVE_MESSAGING; + } else { + if (goog.userAgent.GECKO) { + transportType = goog.net.xpc.TransportTypes.FRAME_ELEMENT_METHOD; + } else { + if (goog.userAgent.IE && this.cfg_[goog.net.xpc.CfgFields.PEER_RELAY_URI]) { + transportType = goog.net.xpc.TransportTypes.IFRAME_RELAY; + } else { + if (goog.userAgent.IE && goog.net.xpc.NixTransport.isNixSupported()) { + transportType = goog.net.xpc.TransportTypes.NIX; + } else { + transportType = goog.net.xpc.TransportTypes.IFRAME_POLLING; + } + } + } + } + return transportType; +}; +goog.net.xpc.CrossPageChannel.prototype.createTransport_ = function() { + if (this.transport_) { + return; + } + if (!this.cfg_[goog.net.xpc.CfgFields.TRANSPORT]) { + this.cfg_[goog.net.xpc.CfgFields.TRANSPORT] = this.determineTransportType_(); + } + switch(this.cfg_[goog.net.xpc.CfgFields.TRANSPORT]) { + case goog.net.xpc.TransportTypes.NATIVE_MESSAGING: + var protocolVersion = this.cfg_[goog.net.xpc.CfgFields.NATIVE_TRANSPORT_PROTOCOL_VERSION] || 2; + this.transport_ = new goog.net.xpc.NativeMessagingTransport(this, this.cfg_[goog.net.xpc.CfgFields.PEER_HOSTNAME], this.domHelper_, !!this.cfg_[goog.net.xpc.CfgFields.ONE_SIDED_HANDSHAKE], protocolVersion); + break; + case goog.net.xpc.TransportTypes.NIX: + this.transport_ = new goog.net.xpc.NixTransport(this, this.domHelper_); + break; + case goog.net.xpc.TransportTypes.FRAME_ELEMENT_METHOD: + this.transport_ = new goog.net.xpc.FrameElementMethodTransport(this, this.domHelper_); + break; + case goog.net.xpc.TransportTypes.IFRAME_RELAY: + this.transport_ = new goog.net.xpc.IframeRelayTransport(this, this.domHelper_); + break; + case goog.net.xpc.TransportTypes.IFRAME_POLLING: + this.transport_ = new goog.net.xpc.IframePollingTransport(this, this.domHelper_); + break; + } + if (this.transport_) { + goog.net.xpc.logger.info("Transport created: " + this.transport_.getName()); + } else { + throw Error("CrossPageChannel: No suitable transport found!"); + } +}; +goog.net.xpc.CrossPageChannel.prototype.getTransportType = function() { + return this.transport_.getType(); +}; +goog.net.xpc.CrossPageChannel.prototype.getTransportName = function() { + return this.transport_.getName(); +}; +goog.net.xpc.CrossPageChannel.prototype.getPeerConfiguration = function() { + var peerCfg = {}; + peerCfg[goog.net.xpc.CfgFields.CHANNEL_NAME] = this.name; + peerCfg[goog.net.xpc.CfgFields.TRANSPORT] = this.cfg_[goog.net.xpc.CfgFields.TRANSPORT]; + peerCfg[goog.net.xpc.CfgFields.ONE_SIDED_HANDSHAKE] = this.cfg_[goog.net.xpc.CfgFields.ONE_SIDED_HANDSHAKE]; + if (this.cfg_[goog.net.xpc.CfgFields.LOCAL_RELAY_URI]) { + peerCfg[goog.net.xpc.CfgFields.PEER_RELAY_URI] = this.cfg_[goog.net.xpc.CfgFields.LOCAL_RELAY_URI]; + } + if (this.cfg_[goog.net.xpc.CfgFields.LOCAL_POLL_URI]) { + peerCfg[goog.net.xpc.CfgFields.PEER_POLL_URI] = this.cfg_[goog.net.xpc.CfgFields.LOCAL_POLL_URI]; + } + if (this.cfg_[goog.net.xpc.CfgFields.PEER_POLL_URI]) { + peerCfg[goog.net.xpc.CfgFields.LOCAL_POLL_URI] = this.cfg_[goog.net.xpc.CfgFields.PEER_POLL_URI]; + } + var role = this.cfg_[goog.net.xpc.CfgFields.ROLE]; + if (role) { + peerCfg[goog.net.xpc.CfgFields.ROLE] = role == goog.net.xpc.CrossPageChannelRole.INNER ? goog.net.xpc.CrossPageChannelRole.OUTER : goog.net.xpc.CrossPageChannelRole.INNER; + } + return peerCfg; +}; +goog.net.xpc.CrossPageChannel.prototype.createPeerIframe = function(parentElm, opt_configureIframeCb, opt_addCfgParam) { + goog.net.xpc.logger.info("createPeerIframe()"); + var iframeId = this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]; + if (!iframeId) { + iframeId = this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID] = "xpcpeer" + goog.net.xpc.getRandomString(4); + } + var iframeElm = goog.dom.getDomHelper(parentElm).createElement("IFRAME"); + iframeElm.id = iframeElm.name = iframeId; + if (opt_configureIframeCb) { + opt_configureIframeCb(iframeElm); + } else { + iframeElm.style.width = iframeElm.style.height = "100%"; + } + this.cleanUpIncompleteConnection_(); + this.peerWindowDeferred_ = new goog.async.Deferred(undefined, this); + var peerUri = this.getPeerUri(opt_addCfgParam); + this.peerLoadHandler_.listenOnce(iframeElm, "load", this.peerWindowDeferred_.callback, false, this.peerWindowDeferred_); + if (goog.userAgent.GECKO || goog.userAgent.WEBKIT) { + window.setTimeout(goog.bind(function() { + parentElm.appendChild(iframeElm); + iframeElm.src = peerUri.toString(); + goog.net.xpc.logger.info("peer iframe created (" + iframeId + ")"); + }, this), 1); + } else { + iframeElm.src = peerUri.toString(); + parentElm.appendChild(iframeElm); + goog.net.xpc.logger.info("peer iframe created (" + iframeId + ")"); + } + return(iframeElm); +}; +goog.net.xpc.CrossPageChannel.prototype.cleanUpIncompleteConnection_ = function() { + if (this.peerWindowDeferred_) { + this.peerWindowDeferred_.cancel(); + this.peerWindowDeferred_ = null; + } + this.deferredDeliveries_.length = 0; + this.peerLoadHandler_.removeAll(); +}; +goog.net.xpc.CrossPageChannel.prototype.getPeerUri = function(opt_addCfgParam) { + var peerUri = this.cfg_[goog.net.xpc.CfgFields.PEER_URI]; + if (goog.isString(peerUri)) { + peerUri = this.cfg_[goog.net.xpc.CfgFields.PEER_URI] = new goog.Uri(peerUri); + } + if (opt_addCfgParam !== false) { + peerUri.setParameterValue("xpc", goog.json.serialize(this.getPeerConfiguration())); + } + return peerUri; +}; +goog.net.xpc.CrossPageChannel.prototype.connect = function(opt_connectCb) { + this.connectCb_ = opt_connectCb || goog.nullFunction; + if (this.peerWindowDeferred_) { + this.peerWindowDeferred_.addCallback(this.continueConnection_); + } else { + this.continueConnection_(); + } +}; +goog.net.xpc.CrossPageChannel.prototype.continueConnection_ = function() { + goog.net.xpc.logger.info("continueConnection_()"); + this.peerWindowDeferred_ = null; + if (this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]) { + this.iframeElement_ = this.domHelper_.getElement(this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]); + } + if (this.iframeElement_) { + var winObj = this.iframeElement_.contentWindow; + if (!winObj) { + winObj = window.frames[this.cfg_[goog.net.xpc.CfgFields.IFRAME_ID]]; + } + this.setPeerWindowObject(winObj); + } + if (!this.peerWindowObject_) { + if (window == window.top) { + throw Error("CrossPageChannel: Can't connect, peer window-object not set."); + } else { + this.setPeerWindowObject(window.parent); + } + } + this.createTransport_(); + this.transport_.connect(); + while (this.deferredDeliveries_.length > 0) { + this.deferredDeliveries_.shift()(); + } +}; +goog.net.xpc.CrossPageChannel.prototype.close = function() { + this.cleanUpIncompleteConnection_(); + this.state_ = goog.net.xpc.ChannelStates.CLOSED; + goog.dispose(this.transport_); + this.transport_ = null; + this.connectCb_ = null; + goog.dispose(this.connectionDelay_); + this.connectionDelay_ = null; + goog.net.xpc.logger.info('Channel "' + this.name + '" closed'); +}; +goog.net.xpc.CrossPageChannel.prototype.notifyConnected = function(opt_delay) { + if (this.isConnected() || this.connectionDelay_ && this.connectionDelay_.isActive()) { + return; + } + this.state_ = goog.net.xpc.ChannelStates.CONNECTED; + goog.net.xpc.logger.info('Channel "' + this.name + '" connected'); + goog.dispose(this.connectionDelay_); + if (opt_delay) { + this.connectionDelay_ = new goog.async.Delay(this.connectCb_, opt_delay); + this.connectionDelay_.start(); + } else { + this.connectionDelay_ = null; + this.connectCb_(); + } +}; +goog.net.xpc.CrossPageChannel.prototype.notifyConnected_ = goog.net.xpc.CrossPageChannel.prototype.notifyConnected; +goog.net.xpc.CrossPageChannel.prototype.notifyTransportError = function() { + goog.net.xpc.logger.info("Transport Error"); + this.close(); +}; +goog.net.xpc.CrossPageChannel.prototype.send = function(serviceName, payload) { + if (!this.isConnected()) { + goog.net.xpc.logger.severe("Can't send. Channel not connected."); + return; + } + if (!this.isPeerAvailable()) { + goog.net.xpc.logger.severe("Peer has disappeared."); + this.close(); + return; + } + if (goog.isObject(payload)) { + payload = goog.json.serialize(payload); + } + this.transport_.send(this.escapeServiceName_(serviceName), payload); +}; +goog.net.xpc.CrossPageChannel.prototype.xpcDeliver = function(serviceName, payload, opt_origin) { + if (this.peerWindowDeferred_) { + this.deferredDeliveries_.push(goog.bind(this.xpcDeliver, this, serviceName, payload, opt_origin)); + return; + } + if (!this.isMessageOriginAcceptable_(opt_origin)) { + goog.net.xpc.logger.warning('Message received from unapproved origin "' + opt_origin + '" - rejected.'); + return; + } + if (this.isDisposed()) { + goog.net.xpc.logger.warning("CrossPageChannel::xpcDeliver(): Disposed."); + } else { + if (!serviceName || serviceName == goog.net.xpc.TRANSPORT_SERVICE_) { + this.transport_.transportServiceHandler(payload); + } else { + if (this.isConnected()) { + this.deliver(this.unescapeServiceName_(serviceName), payload); + } else { + goog.net.xpc.logger.info("CrossPageChannel::xpcDeliver(): Not connected."); + } + } + } +}; +goog.net.xpc.CrossPageChannel.prototype.escapeServiceName_ = function(name) { + if (goog.net.xpc.CrossPageChannel.TRANSPORT_SERVICE_ESCAPE_RE_.test(name)) { + name = "%" + name; + } + return name.replace(/[%:|]/g, encodeURIComponent); +}; +goog.net.xpc.CrossPageChannel.prototype.unescapeServiceName_ = function(name) { + name = name.replace(/%[0-9a-f]{2}/gi, decodeURIComponent); + if (goog.net.xpc.CrossPageChannel.TRANSPORT_SERVICE_UNESCAPE_RE_.test(name)) { + return name.substring(1); + } else { + return name; + } +}; +goog.net.xpc.CrossPageChannel.prototype.getRole = function() { + var role = this.cfg_[goog.net.xpc.CfgFields.ROLE]; + if (role) { + return role; + } else { + return window.parent == this.peerWindowObject_ ? goog.net.xpc.CrossPageChannelRole.INNER : goog.net.xpc.CrossPageChannelRole.OUTER; + } +}; +goog.net.xpc.CrossPageChannel.prototype.isMessageOriginAcceptable_ = function(opt_origin) { + var peerHostname = this.cfg_[goog.net.xpc.CfgFields.PEER_HOSTNAME]; + return goog.string.isEmptySafe(opt_origin) || (goog.string.isEmptySafe(peerHostname) || opt_origin == this.cfg_[goog.net.xpc.CfgFields.PEER_HOSTNAME]); +}; +goog.net.xpc.CrossPageChannel.prototype.disposeInternal = function() { + this.close(); + this.peerWindowObject_ = null; + this.iframeElement_ = null; + delete goog.net.xpc.channels[this.name]; + goog.dispose(this.peerLoadHandler_); + delete this.peerLoadHandler_; + goog.base(this, "disposeInternal"); +}; +goog.net.xpc.CrossPageChannel.disposeAll_ = function() { + for (var name in goog.net.xpc.channels) { + goog.dispose(goog.net.xpc.channels[name]); + } +}; +goog.provide("clojure.browser.net"); +goog.require("cljs.core"); +goog.require("goog.net.XhrIo"); +goog.require("goog.net.xpc.CrossPageChannel"); +goog.require("clojure.browser.event"); +goog.require("goog.json"); +goog.require("goog.net.xpc.CfgFields"); +goog.require("clojure.browser.event"); +goog.require("goog.net.EventType"); +goog.require("goog.net.EventType"); +goog.require("goog.net.xpc.CrossPageChannel"); +goog.require("goog.json"); +goog.require("goog.net.XhrIo"); +goog.require("goog.net.xpc.CfgFields"); +clojure.browser.net._STAR_timeout_STAR_ = 1E4; +clojure.browser.net.event_types = cljs.core.into.call(null, cljs.core.PersistentArrayMap.EMPTY, cljs.core.map.call(null, function(p__5231) { + var vec__5232 = p__5231; + var k = cljs.core.nth.call(null, vec__5232, 0, null); + var v = cljs.core.nth.call(null, vec__5232, 1, null); + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k.toLowerCase()), v], null); +}, cljs.core.merge.call(null, cljs.core.js__GT_clj.call(null, goog.net.EventType)))); +clojure.browser.net.IConnection = function() { + var obj5234 = {}; + return obj5234; +}(); +clojure.browser.net.connect = function() { + var connect = null; + var connect__1 = function(this$) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$connect$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$connect$arity$1(this$); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.connect[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.connect["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.connect", this$); + } + } + }().call(null, this$); + } + }; + var connect__2 = function(this$, opt1) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$connect$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$connect$arity$2(this$, opt1); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.connect[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.connect["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.connect", this$); + } + } + }().call(null, this$, opt1); + } + }; + var connect__3 = function(this$, opt1, opt2) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$connect$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$connect$arity$3(this$, opt1, opt2); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.connect[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.connect["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.connect", this$); + } + } + }().call(null, this$, opt1, opt2); + } + }; + var connect__4 = function(this$, opt1, opt2, opt3) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$connect$arity$4; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$connect$arity$4(this$, opt1, opt2, opt3); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.connect[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.connect["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.connect", this$); + } + } + }().call(null, this$, opt1, opt2, opt3); + } + }; + connect = function(this$, opt1, opt2, opt3) { + switch(arguments.length) { + case 1: + return connect__1.call(this, this$); + case 2: + return connect__2.call(this, this$, opt1); + case 3: + return connect__3.call(this, this$, opt1, opt2); + case 4: + return connect__4.call(this, this$, opt1, opt2, opt3); + } + throw new Error("Invalid arity: " + arguments.length); + }; + connect.cljs$core$IFn$_invoke$arity$1 = connect__1; + connect.cljs$core$IFn$_invoke$arity$2 = connect__2; + connect.cljs$core$IFn$_invoke$arity$3 = connect__3; + connect.cljs$core$IFn$_invoke$arity$4 = connect__4; + return connect; +}(); +clojure.browser.net.transmit = function() { + var transmit = null; + var transmit__2 = function(this$, opt) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$transmit$arity$2; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$transmit$arity$2(this$, opt); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.transmit[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.transmit["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.transmit", this$); + } + } + }().call(null, this$, opt); + } + }; + var transmit__3 = function(this$, opt, opt2) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$transmit$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$transmit$arity$3(this$, opt, opt2); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.transmit[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.transmit["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.transmit", this$); + } + } + }().call(null, this$, opt, opt2); + } + }; + var transmit__4 = function(this$, opt, opt2, opt3) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$transmit$arity$4; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$transmit$arity$4(this$, opt, opt2, opt3); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.transmit[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.transmit["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.transmit", this$); + } + } + }().call(null, this$, opt, opt2, opt3); + } + }; + var transmit__5 = function(this$, opt, opt2, opt3, opt4) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$transmit$arity$5; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$transmit$arity$5(this$, opt, opt2, opt3, opt4); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.transmit[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.transmit["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.transmit", this$); + } + } + }().call(null, this$, opt, opt2, opt3, opt4); + } + }; + var transmit__6 = function(this$, opt, opt2, opt3, opt4, opt5) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$transmit$arity$6; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$transmit$arity$6(this$, opt, opt2, opt3, opt4, opt5); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.transmit[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.transmit["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.transmit", this$); + } + } + }().call(null, this$, opt, opt2, opt3, opt4, opt5); + } + }; + transmit = function(this$, opt, opt2, opt3, opt4, opt5) { + switch(arguments.length) { + case 2: + return transmit__2.call(this, this$, opt); + case 3: + return transmit__3.call(this, this$, opt, opt2); + case 4: + return transmit__4.call(this, this$, opt, opt2, opt3); + case 5: + return transmit__5.call(this, this$, opt, opt2, opt3, opt4); + case 6: + return transmit__6.call(this, this$, opt, opt2, opt3, opt4, opt5); + } + throw new Error("Invalid arity: " + arguments.length); + }; + transmit.cljs$core$IFn$_invoke$arity$2 = transmit__2; + transmit.cljs$core$IFn$_invoke$arity$3 = transmit__3; + transmit.cljs$core$IFn$_invoke$arity$4 = transmit__4; + transmit.cljs$core$IFn$_invoke$arity$5 = transmit__5; + transmit.cljs$core$IFn$_invoke$arity$6 = transmit__6; + return transmit; +}(); +clojure.browser.net.close = function close(this$) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$IConnection$close$arity$1; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$IConnection$close$arity$1(this$); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.close[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.close["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "IConnection.close", this$); + } + } + }().call(null, this$); + } +}; +goog.net.XhrIo.prototype.clojure$browser$event$EventType$ = true; +goog.net.XhrIo.prototype.clojure$browser$event$EventType$event_types$arity$1 = function(this$) { + var this$__$1 = this; + return cljs.core.into.call(null, cljs.core.PersistentArrayMap.EMPTY, cljs.core.map.call(null, function(p__5235) { + var vec__5236 = p__5235; + var k = cljs.core.nth.call(null, vec__5236, 0, null); + var v = cljs.core.nth.call(null, vec__5236, 1, null); + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k.toLowerCase()), v], null); + }, cljs.core.merge.call(null, cljs.core.js__GT_clj.call(null, goog.net.EventType)))); +}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$ = true; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$2 = function(this$, uri) { + var this$__$1 = this; + return clojure.browser.net.transmit.call(null, this$__$1, uri, "GET", null, null, clojure.browser.net._STAR_timeout_STAR_); +}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$3 = function(this$, uri, method) { + var this$__$1 = this; + return clojure.browser.net.transmit.call(null, this$__$1, uri, method, null, null, clojure.browser.net._STAR_timeout_STAR_); +}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$4 = function(this$, uri, method, content) { + var this$__$1 = this; + return clojure.browser.net.transmit.call(null, this$__$1, uri, method, content, null, clojure.browser.net._STAR_timeout_STAR_); +}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$5 = function(this$, uri, method, content, headers) { + var this$__$1 = this; + return clojure.browser.net.transmit.call(null, this$__$1, uri, method, content, headers, clojure.browser.net._STAR_timeout_STAR_); +}; +goog.net.XhrIo.prototype.clojure$browser$net$IConnection$transmit$arity$6 = function(this$, uri, method, content, headers, timeout) { + var this$__$1 = this; + this$__$1.setTimeoutInterval(timeout); + return this$__$1.send(uri, method, content, headers); +}; +clojure.browser.net.xpc_config_fields = cljs.core.into.call(null, cljs.core.PersistentArrayMap.EMPTY, cljs.core.map.call(null, function(p__5237) { + var vec__5238 = p__5237; + var k = cljs.core.nth.call(null, vec__5238, 0, null); + var v = cljs.core.nth.call(null, vec__5238, 1, null); + return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.call(null, k.toLowerCase()), v], null); +}, cljs.core.js__GT_clj.call(null, goog.net.xpc.CfgFields))); +clojure.browser.net.xhr_connection = function xhr_connection() { + return new goog.net.XhrIo; +}; +clojure.browser.net.ICrossPageChannel = function() { + var obj5240 = {}; + return obj5240; +}(); +clojure.browser.net.register_service = function() { + var register_service = null; + var register_service__3 = function(this$, service_name, fn) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$3; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$3(this$, service_name, fn); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.register_service[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.register_service["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ICrossPageChannel.register-service", this$); + } + } + }().call(null, this$, service_name, fn); + } + }; + var register_service__4 = function(this$, service_name, fn, encode_json_QMARK_) { + if (function() { + var and__3431__auto__ = this$; + if (and__3431__auto__) { + return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$4; + } else { + return and__3431__auto__; + } + }()) { + return this$.clojure$browser$net$ICrossPageChannel$register_service$arity$4(this$, service_name, fn, encode_json_QMARK_); + } else { + var x__4070__auto__ = this$ == null ? null : this$; + return function() { + var or__3443__auto__ = clojure.browser.net.register_service[goog.typeOf(x__4070__auto__)]; + if (or__3443__auto__) { + return or__3443__auto__; + } else { + var or__3443__auto____$1 = clojure.browser.net.register_service["_"]; + if (or__3443__auto____$1) { + return or__3443__auto____$1; + } else { + throw cljs.core.missing_protocol.call(null, "ICrossPageChannel.register-service", this$); + } + } + }().call(null, this$, service_name, fn, encode_json_QMARK_); + } + }; + register_service = function(this$, service_name, fn, encode_json_QMARK_) { + switch(arguments.length) { + case 3: + return register_service__3.call(this, this$, service_name, fn); + case 4: + return register_service__4.call(this, this$, service_name, fn, encode_json_QMARK_); + } + throw new Error("Invalid arity: " + arguments.length); + }; + register_service.cljs$core$IFn$_invoke$arity$3 = register_service__3; + register_service.cljs$core$IFn$_invoke$arity$4 = register_service__4; + return register_service; +}(); +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$ = true; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$1 = function(this$) { + var this$__$1 = this; + return clojure.browser.net.connect.call(null, this$__$1, null); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$2 = function(this$, on_connect_fn) { + var this$__$1 = this; + return this$__$1.connect(on_connect_fn); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$3 = function(this$, on_connect_fn, config_iframe_fn) { + var this$__$1 = this; + return clojure.browser.net.connect.call(null, this$__$1, on_connect_fn, config_iframe_fn, document.body); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$connect$arity$4 = function(this$, on_connect_fn, config_iframe_fn, iframe_parent) { + var this$__$1 = this; + this$__$1.createPeerIframe(iframe_parent, config_iframe_fn); + return this$__$1.connect(on_connect_fn); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$transmit$arity$3 = function(this$, service_name, payload) { + var this$__$1 = this; + return this$__$1.send(cljs.core.name.call(null, service_name), payload); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$IConnection$close$arity$1 = function(this$) { + var this$__$1 = this; + return this$__$1.close(cljs.core.List.EMPTY); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$ = true; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$3 = function(this$, service_name, fn) { + var this$__$1 = this; + return clojure.browser.net.register_service.call(null, this$__$1, service_name, fn, false); +}; +goog.net.xpc.CrossPageChannel.prototype.clojure$browser$net$ICrossPageChannel$register_service$arity$4 = function(this$, service_name, fn, encode_json_QMARK_) { + var this$__$1 = this; + return this$__$1.registerService(cljs.core.name.call(null, service_name), fn, encode_json_QMARK_); +}; +clojure.browser.net.xpc_connection = function() { + var xpc_connection = null; + var xpc_connection__0 = function() { + var temp__4092__auto__ = (new goog.Uri(window.location.href)).getParameterValue("xpc"); + if (cljs.core.truth_(temp__4092__auto__)) { + var config = temp__4092__auto__; + return new goog.net.xpc.CrossPageChannel(goog.json.parse(config)); + } else { + return null; + } + }; + var xpc_connection__1 = function(config) { + return new goog.net.xpc.CrossPageChannel(cljs.core.reduce.call(null, function(sum, p__5246) { + var vec__5247 = p__5246; + var k = cljs.core.nth.call(null, vec__5247, 0, null); + var v = cljs.core.nth.call(null, vec__5247, 1, null); + var temp__4090__auto__ = cljs.core.get.call(null, clojure.browser.net.xpc_config_fields, k); + if (cljs.core.truth_(temp__4090__auto__)) { + var field = temp__4090__auto__; + var G__5248 = sum; + G__5248[field] = v; + return G__5248; + } else { + return sum; + } + }, function() { + var obj5250 = {}; + return obj5250; + }(), config)); + }; + xpc_connection = function(config) { + switch(arguments.length) { + case 0: + return xpc_connection__0.call(this); + case 1: + return xpc_connection__1.call(this, config); + } + throw new Error("Invalid arity: " + arguments.length); + }; + xpc_connection.cljs$core$IFn$_invoke$arity$0 = xpc_connection__0; + xpc_connection.cljs$core$IFn$_invoke$arity$1 = xpc_connection__1; + return xpc_connection; +}(); +goog.provide("clojure.browser.repl"); +goog.require("cljs.core"); +goog.require("clojure.browser.event"); +goog.require("clojure.browser.event"); +goog.require("clojure.browser.net"); +goog.require("clojure.browser.net"); +clojure.browser.repl.xpc_connection = cljs.core.atom.call(null, null); +clojure.browser.repl.repl_print = function repl_print(data) { + var temp__4090__auto__ = cljs.core.deref.call(null, clojure.browser.repl.xpc_connection); + if (cljs.core.truth_(temp__4090__auto__)) { + var conn = temp__4090__auto__; + return clojure.browser.net.transmit.call(null, conn, new cljs.core.Keyword(null, "print", "print", 1120839199), cljs.core.pr_str.call(null, data)); + } else { + return null; + } +}; +clojure.browser.repl.evaluate_javascript = function evaluate_javascript(conn, block) { + var result = function() { + try { + return new cljs.core.PersistentArrayMap(null, 2, [new cljs.core.Keyword(null, "status", "status", 4416389988), new cljs.core.Keyword(null, "success", "success", 3441701749), new cljs.core.Keyword(null, "value", "value", 1125876963), [cljs.core.str(eval(block))].join("")], null); + } catch (e5230) { + var e = e5230; + return new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "status", "status", 4416389988), new cljs.core.Keyword(null, "exception", "exception", 2495529921), new cljs.core.Keyword(null, "value", "value", 1125876963), cljs.core.pr_str.call(null, e), new cljs.core.Keyword(null, "stacktrace", "stacktrace", 3069736751), cljs.core.truth_(e.hasOwnProperty("stack")) ? e.stack : "No stacktrace available."], null); + } + }(); + return cljs.core.pr_str.call(null, result); +}; +clojure.browser.repl.send_result = function send_result(connection, url, data) { + return clojure.browser.net.transmit.call(null, connection, url, "POST", data, null, 0); +}; +clojure.browser.repl.send_print = function() { + var send_print = null; + var send_print__2 = function(url, data) { + return send_print.call(null, url, data, 0); + }; + var send_print__3 = function(url, data, n) { + var conn = clojure.browser.net.xhr_connection.call(null); + clojure.browser.event.listen.call(null, conn, new cljs.core.Keyword(null, "error", "error", 1110689146), function(_) { + if (n < 10) { + return send_print.call(null, url, data, n + 1); + } else { + return console.log([cljs.core.str("Could not send "), cljs.core.str(data), cljs.core.str(" after "), cljs.core.str(n), cljs.core.str(" attempts.")].join("")); + } + }); + return clojure.browser.net.transmit.call(null, conn, url, "POST", data, null, 0); + }; + send_print = function(url, data, n) { + switch(arguments.length) { + case 2: + return send_print__2.call(this, url, data); + case 3: + return send_print__3.call(this, url, data, n); + } + throw new Error("Invalid arity: " + arguments.length); + }; + send_print.cljs$core$IFn$_invoke$arity$2 = send_print__2; + send_print.cljs$core$IFn$_invoke$arity$3 = send_print__3; + return send_print; +}(); +clojure.browser.repl.order = cljs.core.atom.call(null, 0); +clojure.browser.repl.wrap_message = function wrap_message(t, data) { + return cljs.core.pr_str.call(null, new cljs.core.PersistentArrayMap(null, 3, [new cljs.core.Keyword(null, "type", "type", 1017479852), t, new cljs.core.Keyword(null, "content", "content", 1965434859), data, new cljs.core.Keyword(null, "order", "order", 1119910592), cljs.core.swap_BANG_.call(null, clojure.browser.repl.order, cljs.core.inc)], null)); +}; +clojure.browser.repl.start_evaluator = function start_evaluator(url) { + var temp__4090__auto__ = clojure.browser.net.xpc_connection.call(null); + if (cljs.core.truth_(temp__4090__auto__)) { + var repl_connection = temp__4090__auto__; + var connection = clojure.browser.net.xhr_connection.call(null); + clojure.browser.event.listen.call(null, connection, new cljs.core.Keyword(null, "success", "success", 3441701749), function(e) { + return clojure.browser.net.transmit.call(null, repl_connection, new cljs.core.Keyword(null, "evaluate-javascript", "evaluate-javascript", 2953437843), e.currentTarget.getResponseText(cljs.core.List.EMPTY)); + }); + clojure.browser.net.register_service.call(null, repl_connection, new cljs.core.Keyword(null, "send-result", "send-result", 3729280372), function(data) { + return clojure.browser.repl.send_result.call(null, connection, url, clojure.browser.repl.wrap_message.call(null, new cljs.core.Keyword(null, "result", "result", 4374444943), data)); + }); + clojure.browser.net.register_service.call(null, repl_connection, new cljs.core.Keyword(null, "print", "print", 1120839199), function(data) { + return clojure.browser.repl.send_print.call(null, url, clojure.browser.repl.wrap_message.call(null, new cljs.core.Keyword(null, "print", "print", 1120839199), data)); + }); + clojure.browser.net.connect.call(null, repl_connection, cljs.core.constantly.call(null, null)); + return setTimeout(function() { + return clojure.browser.repl.send_result.call(null, connection, url, clojure.browser.repl.wrap_message.call(null, new cljs.core.Keyword(null, "ready", "ready", 1122290965), "ready")); + }, 50); + } else { + return alert("No 'xpc' param provided to child iframe."); + } +}; +clojure.browser.repl.connect = function connect(repl_server_url) { + var repl_connection = clojure.browser.net.xpc_connection.call(null, new cljs.core.PersistentArrayMap(null, 1, [new cljs.core.Keyword(null, "peer_uri", "peer_uri", 1083496577), repl_server_url], null)); + cljs.core.swap_BANG_.call(null, clojure.browser.repl.xpc_connection, cljs.core.constantly.call(null, repl_connection)); + clojure.browser.net.register_service.call(null, repl_connection, new cljs.core.Keyword(null, "evaluate-javascript", "evaluate-javascript", 2953437843), function(js) { + return clojure.browser.net.transmit.call(null, repl_connection, new cljs.core.Keyword(null, "send-result", "send-result", 3729280372), clojure.browser.repl.evaluate_javascript.call(null, repl_connection, js)); + }); + return clojure.browser.net.connect.call(null, repl_connection, cljs.core.constantly.call(null, null), function(iframe) { + return iframe.style.display = "none"; + }); +}; +goog.provide("sudorace.connect"); +goog.require("cljs.core"); +goog.require("clojure.browser.repl"); +goog.require("clojure.browser.repl"); +clojure.browser.repl.connect.call(null, "http://localhost:9000/repl"); diff --git a/resources/public/sudorace.html b/resources/public/sudorace.html new file mode 100644 index 0000000..b628109 --- /dev/null +++ b/resources/public/sudorace.html @@ -0,0 +1,16 @@ + + + + + sudorace with clojurescript + + + + +

Hello

+
abc
+ + + + \ No newline at end of file diff --git a/src/clj/sudorace/core.clj b/src/clj/sudorace/core.clj new file mode 100644 index 0000000..34d331b --- /dev/null +++ b/src/clj/sudorace/core.clj @@ -0,0 +1,17 @@ +(ns sudorace.core + (:use compojure.core) + (:require [compojure.handler :as handler] + [compojure.route :as route])) + +(defroutes app-routes + + (GET "/" [] "

hello sudorace

") + + (route/resources "/") + + (route/not-found "Page not found")) + + + (def handler + (handler/site app-routes)) + diff --git a/src/cljs/sudorace/connect.cljs b/src/cljs/sudorace/connect.cljs new file mode 100644 index 0000000..09e19d3 --- /dev/null +++ b/src/cljs/sudorace/connect.cljs @@ -0,0 +1,4 @@ +(ns sudorace.connect + (:require [clojure.browser.repl :as repl])) + +(repl/connect "http://localhost:9000/repl") \ No newline at end of file diff --git a/src/cljs/sudorace/sudorace.cljs b/src/cljs/sudorace/sudorace.cljs new file mode 100644 index 0000000..f107b0a --- /dev/null +++ b/src/cljs/sudorace/sudorace.cljs @@ -0,0 +1,61 @@ +(ns sudorace.sudorace + (:require-macros [hiccups.core :as h]) + (:use [domina :only [append! by-id ]] + [domina.css :only [sel]] + [domina.events :only [listen!]]) + (:require [hiccups.runtime :as hiccupsrt])) + +(def sudoku "2461853793176498525897321646234175981785962434953287168542619377629534819318746..") + +(def selected_index (atom 0)) + +(defn move-right [] + (swap! selected_index inc)) + +(defn index [row col] + (+ (* 9 row) col)) + +(defn value-at [row col] + (get sudoku (index row col))) + +(defn cell-id [row col] + (str "cell"row"-"col)) + +(defn build-cell [row col] + (let [class-cell (if (= @selected_index (index row col)) + "cell fixed target_cell" + "cell fixed non_target_cell")] + [:div {:id (cell-id row col) + :class class-cell} (value-at row col)])) + +(defn build-grid [] + (h/html + [:table + (for [row (range 9)] + [:tr + (for [col (range 9)] + [:td (build-cell row col)])])])) + +(defn click-handler [row col] + (let [msg (str "cell "row"/"col" clicked")] + (fn [evt] (js/alert msg)))) + +(def arrows {37 :left 38 :up 39 :right 40 :down}) + +(def key-handler + (fn [evt] + (let [code (:keyCode evt)] + (when (< 36 code 41) + (js/alert (str "arrow "(get arrows (:keyCode evt)))))))) + +(defn register-listeners [] + (doseq [row (range 9) col (range 9)] + (listen! (by-id (cell-id row col)) :click (click-handler row col))) + (listen! :keydown key-handler)) + +(defn init[] + (append! (by-id "grid") (build-grid)) + (register-listeners)) + +;; initialize the HTML page in unobtrusive way +(set! (.-onload js/window) init) diff --git a/test/sudorace_cljs/core_test.clj b/test/sudorace_cljs/core_test.clj new file mode 100644 index 0000000..41de5cf --- /dev/null +++ b/test/sudorace_cljs/core_test.clj @@ -0,0 +1,7 @@ +(ns sudorace-cljs.core-test + (:require [clojure.test :refer :all] + [sudorace-cljs.core :refer :all])) + +(deftest a-test + (testing "FIXME, I fail." + (is (= 0 1))))