(nsclojure.core.protocols)(set!*warn-on-reflection*true)(defprotocolCollReduce"Protocol for collection types that can implement reduce faster than
first/next recursion. Called by clojure.core/reduce. Baseline
implementation defined in terms of Iterable."(coll-reduce[collf][collfval]))(defprotocolInternalReduce"Protocol for concrete seq types that can reduce themselves
faster than first/next recursion. Called by clojure.core/reduce."(internal-reduce[seqfstart]))(defn-seq-reduce([collf](if-let[s(seqcoll)](internal-reduce(nexts)f(firsts))(f)))([collfval](let[s(seqcoll)](internal-reducesfval))))(defn-iter-reduce([^java.lang.Iterablecollf](let[iter(.iteratorcoll)](if(.hasNextiter)(loop[ret(.nextiter)](if(.hasNextiter)(let[ret(fret(.nextiter))](if(reduced?ret)@ret(recurret)))ret))(f))))([^java.lang.Iterablecollfval](let[iter(.iteratorcoll)](loop[retval](if(.hasNextiter)(let[ret(fret(.nextiter))](if(reduced?ret)@ret(recurret)))ret)))))(defn-naive-seq-reduce"Reduces a seq, ignoring any opportunities to switch to a more
specialized implementation."[sfval](loop[s(seqs)valval](ifs(let[ret(fval(firsts))](if(reduced?ret)@ret(recur(nexts)ret)))val)))(defn-interface-or-naive-reduce"Reduces via IReduceInit if possible, else naively."[collfval](if(instance?clojure.lang.IReduceInitcoll)(.reduce^clojure.lang.IReduceInitcollfval)(naive-seq-reducecollfval)))(extend-protocolCollReducenil(coll-reduce([collf](f))([collfval]val))Object(coll-reduce([collf](seq-reducecollf))([collfval](seq-reducecollfval)))clojure.lang.IReduceInit(coll-reduce([collf](.reduce^clojure.lang.IReducecollf))([collfval](.reducecollfval)));;aseqs are iterable, masking internal-reducersclojure.lang.ASeq(coll-reduce([collf](seq-reducecollf))([collfval](seq-reducecollfval)));;for rangeclojure.lang.LazySeq(coll-reduce([collf](seq-reducecollf))([collfval](seq-reducecollfval)));;vector's chunked seq is faster than its iterclojure.lang.PersistentVector(coll-reduce([collf](seq-reducecollf))([collfval](seq-reducecollfval)))Iterable(coll-reduce([collf](iter-reducecollf))([collfval](iter-reducecollfval)))clojure.lang.APersistentMap$KeySeq(coll-reduce([collf](iter-reducecollf))([collfval](iter-reducecollfval)))clojure.lang.APersistentMap$ValSeq(coll-reduce([collf](iter-reducecollf))([collfval](iter-reducecollfval))))(extend-protocolInternalReducenil(internal-reduce[sfval]val);; handles vectors and rangesclojure.lang.IChunkedSeq(internal-reduce[sfval](if-let[s(seqs)](if(chunked-seq?s)(let[ret(.reduce(chunk-firsts)fval)](if(reduced?ret)@ret(recur(chunk-nexts)fret)))(interface-or-naive-reducesfval))val))clojure.lang.StringSeq(internal-reduce[str-seqfval](let[s(.sstr-seq)](loop[i(.istr-seq)valval](if(<i(.lengths))(let[ret(fval(.charAtsi))](if(reduced?ret)@ret(recur(inci)ret)))val))))java.lang.Object(internal-reduce[sfval](loop[cls(classs)ssffvalval](if-let[s(seqs)](if(identical?(classs)cls)(let[ret(fval(firsts))](if(reduced?ret)@ret(recurcls(nexts)fret)))(interface-or-naive-reducesfval))val))))(defprotocolIKVReduce"Protocol for concrete associative types that can reduce themselves
via a function of key and val faster than first/next recursion over map
entries. Called by clojure.core/reduce-kv, and has same
semantics (just different arg order)."(kv-reduce[amapfinit]))