clojure_core_sorted.clj

                                                                              (if as-static 0 1)) 
                                                                           Object)))))
                                                                          (replicate (count ptypes) obj-type))))))
                                                               " not defined?)"))))
                                                               (. m (getDescriptor)))))))
                                                               (. m (getName))
                                                               (. super-type (getInternalName))
                                                               impl-pkg-name "/" prefix (.getName m)
                                                           (unchecked-inc ~gi)))
                                                          d (if w (- w (if add-sign 1 0))))
                                                         (:extend-via-metadata opts))])
                                                         (recur
                                                         gfirst `(first ~gseq)
                                                         gseq `(next ~gseq))
                                                         ~(do-cmod etc)
                                                        (= mkn "strs") (assoc transforms mk str)
                                                        (= mkn "syms") (assoc transforms mk #(list `quote (symbol (or mkns (namespace %)) (name %))))
                                                        (into-array (cons obj-type 
                                                        :else transforms))
                                                      (count (filter #(= % \newline) s)))))))
                                                      (to-types (replicate (+ (count ptypes)
                                                      mkn (name mk)]
                                                     (next inline))))
                                                    (format fmt (str col)))))
                                                    (not (pretty-writer? real-stream)))
                                                    (recur (rest ~gxs)))
                                                    (str/starts-with? cl-name "clojure.core$ex_info")))
                                                    (str/starts-with? cl-name "clojure.test$")
                                                    (vec (map internal-name->class-symbol exceptions))
                                                    class-symbol
                                                    flags)
                                                    parameter-types
                                                    ~(do-mod etc)
                                                   " of protocol: " (:var (.protocol cache)) 
                                                   ((key entry) bes)))
                                                   (conj ret
                                                   (dissoc bes (key entry))
                                                   (is-runtime-annotation? c))
                                                   (list `nth gvec n nil)))
                                                   (nnext bs)
                                                   gfirst
                                                   n
                                                   ret)
                                                   true)
                                                  (. ~hinted-target ~(symbol (str "-" fld)))
                                                  (arg-types (count ptypes)))))
                                                  (cond (= mkn "keys") (assoc transforms mk #(keyword (or mkns (namespace %)) (name %)))
                                                  (cons arg (seq more-args))))))
                                                  (for [[col fmt] (map vector (map #(get row %) ks) fmts)]
                                                  (~giter (rest ~gxs)))))]
                                                  ~'thunk)))])
                                                 (.getClassLoader (.getClass ^Object loading#))}))
                                                 (:padchar params)))
                                                 (count scaled-exp-str)) 
                                                 (if has-rest
                                                 (not-empty (dissoc ~'__extmap k#))))))])
                                                 (recur (unchecked-inc ~gi)))))]
                                                 firstb
                                                 ~(do-cmod mod-pairs))
                                                 ~@(when needrec [recform]))
                                                 ~subform
                                                (. m (getDescriptor)))))))
                                                (. m (getName))
                                                (. super-type (getInternalName))
                                                (arg-types (inc (count ptypes))))))
                                                (if (identical? (class ~'gtarget) ~'gclass)
                                                (let [mkns (namespace mk)
                                                (or (str/starts-with? cl-name "java.lang.")
                                                (seq (protected-final-methods super))))]
                                                transforms))
                                                ~@(when needrec [recform]))]
                                                ~subform
                                               (do
                                               (let [~bind (.nth c# ~gi)]
                                               (vec (map internal-name->class-symbol exceptions))
                                               ancestors-visited)]
                                               class-symbol
                                               flags))))))
                                               parameter-types
                                               return-type
                                               true))
                                               ~recform)]))
                                              (- e 
                                              (.toString ^CharSequence replacement))
                                              (Modifier/isAbstract (. meth (getModifiers))))
                                              (Throwable->map ret)
                                              (clojure.lang.MapEntry/create k# v#))))
                                              (if (keyword? mk)
                                              (if (neg? k) (- k) 0)) \0))))
                                              (into-array Type (map asm-type pclasses))
                                              (into-array [iseq-type]))))
                                              (make-array Type 0)))
                                              \0))) 
                                              ret)
                                              ~'__extmap)))
                                             " found for class: " (if (nil? x) "nil" (.getName (class x)))))))
                                             "\" should be a vector"))))))
                                             "clojure/version.properties")]
                                             #(let [cl-name (.getClassName ^StackTraceElement %)]
                                             (- w-mantissa (if add-sign 1 0))))
                                             (.getStackTrace (Thread/currentThread)))) m)
                                             (clojure.lang.RT/baseLoader)
                                             (get-pretty-writer real-stream)
                                             (if (< ~gi size#)
                                             (inc n)
                                             (mapcat (comp (partial map str) vals val) exposes))))
                                             (mapcat (fn [[m s]] (map #(overload-name m (map the-class %)) s)) overloads)
                                             (next bs)
                                             (repeat 
                                             fs# (seq (iterys# ~next-expr))]
                                             real-stream)]
                                             seen-rest?))))
                                             {:tag 'clojure.lang.IChunk})
                                            "~<(~;~@{~w~^ ~:_~}~;)~:>"))
                                            "~<[~;~@{~w~^ ~:_~}~;]~:>"
                                            (= k 0) (dec d)
                                            (dissoc (with-meta (into {} this#) ~'__meta) k#)
                                            (err "Invalid 'for' keyword " k)
                                            (first body))]
                                            (fn [transforms mk]
                                            (if pclasses
                                            (keys b))]
                                            (neg? k) (dec d))
                                            (new ~tagname ~@(remove '#{__extmap __hash __hasheq} fields)
                                            (pos? k) d
                                            (when-not (identical? this# v#)
                                            `(do (chunk-append ~gb ~body-expr)
                                            `(do ~@body)
                                            emit-unsupported)
                                            {}
                                           " should be a list")))))
                                           " should be a vector")
                                           (- d (dec base-mantissa-width)
                                           (.getValue atts (int i)))
                                           (:offset this) remainder)]
                                           (chunk ~gb)
                                           (clojure.lang.Keyword/intern (symbol (.getQName atts i)))
                                           (concat fs# (~giter (rest ~gxs)))
                                           (cond
                                           (conj ret (:as b) gmap)
                                           (first body))
                                           (get [~'thunk ~'gtarget]
                                           (if w-mantissa 
                                           (recur (rest ~gxs))))
                                           (~giter (chunk-rest ~gxs)))
                                           :arglists arglists
                                           :doc doc}))))
                                           ret))))
                                           scaled-mantissa 0
                                           size# (int (count c#))
                                           ~gb (chunk-buffer size#)]
                                          (= k :let) `(let ~v ~(do-cmod etc))
                                          (= k :when) `(if ~v
                                          (= k :while) `(when ~v ~(do-cmod etc))
                                          (= superName "java/lang/Object"))
                                          (int (count c#)) (int 0)))
                                          (is-runtime-annotation? c)))]
                                          (keyword? k)
                                          (reduce1
                                          (reduce1 #(assoc %1 %2 ((val entry) %2))
                                          (repeat 
                                          :else
                                          {:name (vary-meta mname assoc :doc doc :arglists arglists)
                                         (chunk-cons
                                         (chunk-cons (chunk ~gb) nil)))
                                         (if (:as b)
                                         (if fs#
                                         (not stream) (java.io.StringWriter.)
                                         (true? stream) *out*
                                         :else stream)
                                         [(keyword (:name s)) (keyword (or (:on s) (:name s)))])
                                        (.toLowerCase ^String (subs s (inc offset)))))
                                        (.toString *out*)])]
                                        (Character/toUpperCase ^Character (nth s offset))
                                        (cond
                                        (dissoc b :as :or)
                                        (fn [bes entry]
                                        (list specs) 
                                        (set! ~'__hash h#)
                                        :flags flags})))
                                        ;                 (replicate (count ptypes) obj-type))))))
                                        ; class annotations
                                        ; is next, this was a regular clause
                                        ; so we'll force it
                                        ;(into-array (cons obj-type 
                                        ;add IProxy methods
                                        ;add ctors matching/calling super's
                                        ;add field for fn mappings
                                        ;add methods matching interfaces', if no fn -> throw
                                        ;add methods matching interfaces', if no mapping -> throw
                                        ;add methods matching supers', if no fn -> call super
                                        ;add methods matching supers', if no mapping -> call super
                                        ;box args
                                        ;box args
                                        ;box init args
                                        ;calc set of supers' non-private instance methods
                                        ;call fn
                                        ;call fn
                                        ;call init fn
                                        ;call super
                                        ;call super
                                        ;call super ctor
                                        ;ctors
                                        ;disable serialization
                                        ;else call supplied alternative generator
                                        ;else call supplied alternative generator
                                        ;expecting [[super-ctor-args] state] returned
                                        ;expose specified overridden superclass methods
                                        ;extra methods
                                        ;factory
                                        ;field exposers
                                        ;finish class def
                                        ;finish class def
                                        ;if found
                                        ;if found
                                        ;instance field for state
                                        ;lookup fn in map
                                        ;main
                                        ;no init found
                                        ;no main found
                                        ;push args
                                        ;push args
                                        ;start class definition
                                        ;start class definition
                                        ;static fields for vars
                                        ;static init to set up var fields and load init
                                        ;this is known duck/reflective as no common base of ASM Visitors
                                        ;unbox return
                                        ;unbox return
                                        flags (parse-flags access :method)]
                                        h#)
                                        specs)]
                                        transforms))]
                                       (. gen (loadArgs))
                                       (. gen (loadThis))
                                       (. gen (visitMethodInsn (. Opcodes INVOKESPECIAL) 
                                       (= ~'__extmap (. ~gs ~'__extmap))))))))
                                       (and (future? o) (not (future-done? o))) :pending
                                       (and (instance? clojure.lang.IPending o) (not (.isRealized ^clojure.lang.IPending o))) :not-delivered
                                       (every? #(every? % args) ps))))))))
                                       (fn [s] 
                                       (if (loop [~gi (int 0)]
                                       (vals sigs))))
                                       :else @o)))))
                                       :exception true)))
                                       :form s})
                                       :ms ms
                                       :ns (str (.name *ns*))
                                       :val (if (instance? Throwable ret)
                                       ;box init args
                                       ;call init fn
                                       ;no init found
                                       [(execute-sub-format clause navigator base-navigator) 
                                       base-fields)
                                       ~(do-mod mod-pairs)))))))))))]
                                      #(vector %1 (str \% %2)) 
                                      ((fn [ret]
                                      (+ 1 (quot (- minout mincol 1) colinc)))))
                                      (-> ret (conj local bv))
                                      (/ (.numerator r) (.denominator r)))
                                      (Constructor. class-symbol
                                      (Method. (symbol name)
                                      (conj gmap) (conj `(if (seq? ~gmap) (clojure.lang.PersistentHashMap/create (seq ~gmapseq)) ~gmap))
                                      (conj ret gseq (list `seq gvec))
                                      (let [h# (clojure.lang.APersistentMap/mapHash this#)]
                                      (list `get gmap bk (defaults local))
                                      (list `get gmap bk))]
                                      (mapcat 
                                      (pb ret bb bv))
                                      (range 1 (inc (count args))))))]
                                      (realize-parameter-list p navigator))
                                      (recur (pb (if has-rest
                                      (set! ~'__hasheq h#)
                                      (str "Invalid signature " sig
                                      (str "Parameter declaration " params
                                      (throw (new Exception "Unsupported binding form, only :as can follow & parameter"))
                                      `(let [iterys# ~(emit-bind next-groups)
                                      args 
                                      body)
                                      first character of the string even if it's a letter."
                                      h#)
                                      hash#)))
                                      representation"
                                      ret))
                                     (= k :let) `(let ~v ~(do-mod etc))
                                     (= k :when) `(if ~v
                                     (= k :while) `(when ~v ~(do-mod etc))
                                     (Modifier/isFinal mods)
                                     (cat (chunk-rest xys) zs))
                                     (every? #(and (p1 %) (p2 %) (p3 %)) args))))))
                                     (every? #(and (p1 %) (p2 %)) args))))))
                                     (every? p args))))))
                                     (field-descriptor->class-symbol desc)
                                     (fn [^GeneratorAdapter gen ^Method m]
                                     (keyword? k) (err "Invalid 'for' keyword " k)
                                     (let [c# (chunk-first ~gxs)
                                     (let [~bind (first ~gxs)]
                                     (map 
                                     (not (Modifier/isStatic mods))))))]
                                     (parse-flags access :field)))
                                     :else `(cons ~body-expr
                                     :exception true)))
                                     class-symbol
                                     next-groups
                                    #'clojure.pprint/*current-length* 0})
                                    ((-cache-protocol-fn ~gthis ~target ~on-interface ~ginterf) ~@gargs))))))
                                    (. Modifier (isFinal mods))
                                    (. Modifier (isStatic mods))
                                    (= "finalize" (.getName meth)))
                                    (conj acc d)
                                    (dec i))))
                                    (emit-method-builder (:on-interface opts) (:name s) (:on s) (:arglists s)
                                    (f# ~@gargs)
                                    (if (seq? (first sigs))
                                    (if (zero? hash#)
                                    (if constructor?
                                    (if has-rest
                                    (inc (var-get #'clojure.pprint/*current-level*))
                                    (let [h# (int (bit-xor ~type-hash (clojure.lang.APersistentMap/mapHasheq this#)))]
                                    (next bes)))
                                    (not (and (nl-t? %) (or (= nl-lb lb) (ancestor? nl-lb lb)))))
                                    (not (or (Modifier/isPublic mods) (Modifier/isProtected mods)))
                                    (recur (conj acc (add-implicit-args d)) (next ds))))))
                                    (recur (conj as (first rs)) (next rs))
                                    (reduce1
                                    (render-clauses else navigator (:base-args params)))
                                    (seq (. c (getDeclaredMethods)))
                                    (seq (. c (getMethods))))]
                                    (with-meta argvec (assoc m :tag (clojure.lang.Symbol/intern (.getName c))))
                                    :overflowchar (:overflowchar params),
                                    :padchar (:padchar params), :at (:at params)} 
                                    ;(. Modifier (isPrivate mods)) 
                                    [(seq as) (first rs)]))]
                                    argvec))
                                    hq#)))
                                   " should be a vector")
                                   (. super-type (getInternalName))
                                   (. target-m (getDescriptor))))
                                   (. target-m (getName))
                                   (apply str 
                                   (cond
                                   (cons (apply vector 'this params) body))
                                   (count st))))))))))
                                   (first sigs)
                                   (if (chunked-seq? ~gxs)
                                   (map (fn [[m p]] {(str m) [p]}) methods)))
                                   (merge name-meta
                                   (recur (chunk-rest ~seq-) c#
                                   (str (subs s 0 offset) 
                                   :exception true})
                                   :ns (str (.name *ns*)) :form s
                                   [(keyword fld) (list* `new tagname (replace {fld gs} (remove '#{__hash __hasheq} fields)))])
                                   [`(intern *ns* (with-meta '~(:name s) (merge '~s {:protocol (var ~name)})))
                                   `(reify clojure.lang.ILookupThunk
                                   navigator offsets)]
                                   nil
                                   superName)
                                   ~@(when needrec [recform]))))))])))))]
                                   ~subform
                                  & [[_ next-expr] :as next-groups]]]
                                  (. ~(bindings 0) close))))
                                  (.endsWith file ".cljc")
                                  (.endsWith file ".cljc")
                                  (:at params) (str "+" group-str)
                                  (= file "NO_SOURCE_FILE")))]
                                  (= file "NO_SOURCE_FILE")))]
                                  (cl-format true " ~_~w" attr-map))
                                  (cl-format true " ~_~w" doc-str))
                                  (declared-constructors cls))})))
                                  (declared-methods cls)
                                  (if (map? d)
                                  (if (vector? (first rs))
                                  (if (zero? hq#)
                                  (if c
                                  (if f#
                                  (let [{:keys [parameter-types return-type]} (parse-method-descriptor desc)
                                  (map internal-name->class-symbol)
                                  (map symbol)
                                  (meta# ~@gargs)
                                  (not-empty))]
                                  (recur (cons f p) (next args))
                                  (remove nil?)
                                  (set)
                                  (vector? (first stuff)) (single-defn stuff (or doc-str attr-map))
                                  :else (multi-defn stuff (or doc-str attr-map)))))
                                  [(first stuff) (next stuff)]
                                  [(keyword fld)
                                  [(str "0" m) (inc e) 1 (inc len)]
                                  [m e round-pos len])]
                                  [nil stuff])]
                                  abstract-meths (filter abstract? mm)]
                                  f# (.fnFor cache# (clojure.lang.Util/classOf ~target))]
                                  f# (.fnFor cache# (clojure.lang.Util/classOf ~target))]
                                  mm-no-abstract (remove abstract? mm)
                                  neg (str "-" group-str)
                                  p))))
                                  st))]
                                  true group-str)
                                 " should be a list"))))
                                 #\"(\\w+)(\\s+)(\\w+)\" \"$3$2$1\")
                                 (. Modifier (isFinal mods))
                                 (. Modifier (isStatic mods))
                                 (.append text (char i))
                                 (.isPublic v)))
                                 (.replaceAll (re-matcher ^Pattern match s)
                                 (= "finalize" (.getName meth)))))]
                                 (= ns (.ns v))
                                 (= ns (.ns v))))
                                 (and  ~@(map (fn [fld] `(= ~fld (. ~gs ~(symbol (str "-" fld))))) base-fields)
                                 (aset t (inc i) e)
                                 (aset t i c)
                                 (fn [s]
                                 (if d 
                                 (interleave (rest s1) (rest s2))))))))
                                 (let [c# (chunk-first ~seq-)]
                                 (let [~k (first ~seq-)]
                                 (map escape-class-name pclasses)))
                                 (next buffer)))]
                                 (not= ns (.ns v))))
                                 (replace-by s match replacement))
                                 (str "Cannot open <" (pr-str x) "> as an OutputStream."))))})
                                 (vals sigs)))))
                                 (when-let [~gxs (seq ~gxs)]
                                 [(first stuff) (next stuff)]
                                 [nil stuff])]
                                 base-fields)
                                 bk (val (first bes))
                                 bv (if (contains? defaults local)
                                 emit-unsupported))
                                 i)))
                                 local (if (instance? clojure.lang.Named bb) (with-meta (symbol nil (name bb)) (meta bb)) bb)
                                 mantissa
                                 t))
                                 ~'%))
                                 ~(do-mod mod-pairs)))))
                                 ~@(map (fn* [c] `(assert ~c)) post)
                                " has bad type in directive \"" (:directive def) "\": "
                                "Parameter declaration missing")))
                                ((-cache-protocol-fn ~gthis ~target ~on-interface ~ginterf) ~@gargs)))))))
                                (- w full-len (if append-zero 1 0) )
                                (. gen (throwException ex-type (. m (getName))))))))
                                (:colinc params) )
                                (:padchar params)))
                                (agent-error o))
                                (cl-format true "~w ~1I~@_~w" defn-sym defn-name)
                                (class val))
                                (clojure.lang.Util/hash val)) 
                                (cond
                                (conj (pop groups) (conj (peek groups) [k v]))
                                (conj groups [k v])))
                                (conj ms [((symbol name) exposes-methods) m])
                                (f# ~@gargs)
                                (f# ~@gargs)
                                (finally
                                (fn [fld]
                                (if (map? f)
                                (if attr-map
                                (if doc-str
                                (if e (apply str 
                                (if-let [meta# (when-let [m# (meta ~target)] ((.sym cache#) m#))]
                                (let [c (clojure.lang.Compiler$HostExpr/maybeClass tag false)]
                                (let [d (first ds)]
                                (loop [as [] rs (rest s)]
                                (mapcat 
                                (recur (cons f p) (next args))
                                (seq (. c (getDeclaredMethods)))
                                (seq (. c (getMethods)))))]
                                (some (complement #(Character/isWhitespace (char %))) (str *sb*)))
                                (str "Cannot open <" (pr-str x) "> as an InputStream."))))
                                (str "Unsupported annotation value: " v " of class " (class ev))))))
                                (with-meta (cons `fn fdecl) {:rettag (:tag m)})))))
                                (with-open ~(subvec bindings 2) ~@body)
                                :conflict k
                                :mappings m})))
                                ;; Note: the multi-defn case will work OK for malformed defns too
                                ;;(cons `fn fdecl)
                                Opcodes/ACC_ABSTRACT
                                Opcodes/ACC_INTERFACE)
                                [(first stuff) (next stuff)]
                                [arglists doc]
                                [nil stuff])
                                acc
                                argvec)
                                base-fields))
                                hours minutes seconds nanoseconds
                                mk (method-sig meth)]
                                mname (with-meta (first s) nil)
                                mods (. meth (getModifiers))
                                ms (quot (- (System/nanoTime) start) 1000000)]
                                ms)) [] (concat (seq mm)
                                offset-sign offset-hours offset-minutes)))
                                ret (eval form)
                                scaled-exp-str)
                                ~count- 0, ~i- 0]
                               "\" should be a list")
                               "\" should be a vector")))))
                               %
                               %
                               %)
                               '~'cached-compile))
                               '~'execute-format))
                               '~'init-navigator))
                               (.newPath this (.edit root) (- level (int 5)) tailnode))))]
                               (.pushTail this (- level (int 5)) child tailnode)
                               (:arglists sig))))
                               (:on (deref (resolve %)))
                               (:params element) context)
                               (apply hash-map 
                               (attrs {} (dec (.getLength atts)))))]
                               (compile-format raw-format)
                               (cons (vec (cons '&form (cons '&env args))) (next fd))))
                               (if (chunked-seq? ~seq-)
                               (into {} 
                               (let [i (* 2 (int (shift-mask shift mask (hash c))))]
                               (let [~gs ~(with-meta gs {:tag tagname})]
                               (loop [~gxs ~gxs]
                               (mapcat 
                               (recur (next fd))
                               (reduce1 conj (get targets k #{}) (cons target (targets target)))))
                               (repeat 
                               (when-first [~bind ~gxs]
                               :exception true})
                               :let [msig (method-sig meth)] :when (not (considered msig))]
                               :ns (str (.name *ns*))
                               :padchar (:padchar params) :at true} 
                               @*local-javadocs*)))]
                               fd)))
                               meths)]
                               raw-format)]
                               {(first args) "%"}
                               {:url url
                               ~@(when needrec [recform-chunk]))
                               ~subform-chunk
                              (. Method (getMethod "clojure.lang.IPersistentCollection cons(Object)"))))
                              (= firstb '&) (recur (pb ret (second bs) gseq)
                              (= firstb :as) (pb ret (second bs) gvec)
                              (assoc m :val (ex->data ex :read-eval-result)
                              (concat (map (fn* [c] `(assert ~c)) pre)
                              (conj ret g v b g)))
                              (conj ret g v)
                              (fn [probs] (map #(dissoc % :in) probs)))
                              (fn [probs] (map #(dissoc % :in) probs)))
                              (if (clojure.lang.Util/equals nil (clojure.lang.Compiler$HostExpr/maybeSpecialTag tag))
                              (if (contains? exposes-methods (symbol name))
                              (if (identical? f# ~ginterf)
                              (if (keyword? k)
                              (if (nil? ds)
                              (if (string? f)
                              (if f#
                              (into1 v (map #(str p "." %) cs)))))
                              (out-fn {:tag :ret
                              (recur (assoc mm mk meth) (conj considered mk) (next meths))))
                              (recur mm (conj considered mk) (next meths))
                              (set! *1 ret)
                              (set! *2 *1)
                              (set! *3 *2)
                              (str "Parameter declaration "
                              (str "Parameter declaration missing"))))))
                              (throw (IllegalArgumentException. (str "Definition of function " mname " in protocol " name " must take at least one arg."))))
                              (throw (IllegalArgumentException. (str "Function " mname " in protocol " name " was redefined. Specify all arities in single definition."))))
                              (try
                              :else (if seen-rest?
                              :form k})))
                              [mm-no-abstract (concat ifaces-meths abstract-meths)])
                              ^clojure.lang.Symbol tag (:tag m)]
                              `((let [~'% ~(if (< 1 (count body))
                              argvec)
                              bes (let [transforms
                              body)
                              body))
                              body)]
                              bs b
                              commas (repeat (count groups) (:commachar params))]
                              do-cmod (fn do-cmod [[[k v :as pair] & etc]]
                              gb (gensym "b__")
                              hours minutes seconds 0
                              n 0
                              offset-sign offset-hours offset-minutes)))
                              seen-rest? false]
                              signed-str)
                              true)))
                             (. clojure.lang.Keyword (intern (symbol q-name)))
                             (.clear a)
                             (.getStackTrace ^Throwable (or root o))))}
                             (Field. (symbol name)
                             (LinkedBlockingQueue. (int n-or-q)))
                             (all-ns))
                             (assoc m (key e) ((val e))))
                             (cond
                             (get-format-arg navigator)
                             (get-format-arg navigator)
                             (get-format-arg navigator)
                             (get-format-arg navigator)
                             (if (map? (first fd))
                             (if child
                             (lazy-seq
                             (let [args (first fd)]
                             (let [~k (.nth ~chunk- ~i-)]
                             (loop [~gxs ~gxs]
                             (make-output-stream (File. x) opts))))))
                             (map #(File. (str %) (str file-path ".html"))
                             (map #(cons `fn %) fnspecs)))
                             (next (next vvs)))
                             (or (not (or (Modifier/isPublic mods) (Modifier/isProtected mods)))
                             (re-find (re-matcher re (str (:name m))))))]
                             (recur (assoc ret
                             (recur (if (ident? bb)
                             (recur (next fd))
                             (rf result input)
                             (select-keys (meta a) [:file :line])))
                             (set-field this :cur (- (count s) nl 1))
                             (set-field this :line (+ (get-field this :line)
                             (some #(some % args) ps)))))))
                             (str "      at: " file ":" line)]))]
                             (str "  actual: " actual-str)
                             (unreduced (rf result v))))]
                             (when (identical? (class this#) (class ~gs))
                             (when (pos? (.getLength atts))
                             (when-let [~seq- (seq ~seq-)]
                             (write-tokens this section false)
                             ;;clear first!
                             [(first stuff) (next stuff)]
                             [nil stuff])]
                             [param-clause navigator]) 
                             [param-clause navigator]) 
                             [param-clause navigator]) 
                             [param-clause navigator])]
                             `(recur ~seq- ~chunk- ~count- (unchecked-inc ~i-))
                             b (chunk-buffer size)]
                             considered considered 
                             end-label (. gen newLabel)]
                             merge
                             meths (concat 
                             n-or-q
                             remainder)
                             result)]
                             ret
                             size (int (count c))
                             table cs)]
                             {:url url
                             ~(emit pred expr more))
                             ~b
                            "\n"
                            #(.atLineStart ^LineNumberingPushbackReader *in*)
                            #(identity true))
                            ()))) ; empty seq, not nil, so we know to put eos next time
                            (.clear a)
                            (.openStream x)) opts))
                            (= (.charAt fixed-repr 0) \0)
                            (= (.charAt fixed-repr 1) \.)
                            (> (count fixed-repr) (- w (if add-sign 1 0))))
                            (>= d 1)
                            (FileInputStream. (as-file x))
                            (apply str (interpose divider
                            (assoc m (keyword mname)
                            (assoc m :val (ex->data ex :print-eval-result)
                            (assoc m :val (valf val))
                            (catch Throwable ex
                            (chunk-append b x))))
                            (clojure.lang.Compiler/writeClassFile cname bytecode)))
                            (conj v (name spec))
                            (fn [^GeneratorAdapter gen ^Method m]
                            (if (:error-handler opts) :continue :fail)))
                            (if (clojure.lang.Util/equiv (.indexOf (.getName tag) ".") -1)
                            (if (or (considered mk)
                            (if (seq sigs)
                            (if (symbol? b)
                            (into-array (map totype cs))
                            (into-array (map totype cs))
                            (into-array (replicate n obj-type))
                            (keys impls))
                            (let [cache# (.__methodImplCache ~gthis)
                            (let [cache# (.__methodImplCache ~gthis)
                            (let [f (first args)]
                            (let [p (first spec) cs (rest spec)]
                            (list meths)
                            (make-array Type 0)))
                            (make-array Type 0)))
                            (make-array Type 0)))
                            (make-input-stream (File. x) opts))))
                            (make-output-stream (as-file x) opts)
                            (next buffer)))]
                            (recur (next p) (cons (first p) d))
                            (recur result (inc node-idx))))
                            (recur xs)
                            (str "Invalid signature " sig
                            (str sym " does not exist")))))
                            (str sym " is not public")
                            (take-nth 2 (next bindings)))
                            (throw (IllegalArgumentException. (str "Can not write to non-file URL <" x ">")))))))
                            (throw (ex-info nil {:clojure.error/phase :read-source} e))))]
                            (unreduced (rf result v))))]
                            (when (m (keyword mname))
                            (when (some #{0} (map count arglists))
                            (when-not (= :repl/quit ret)
                            (zipmap names (map refl names)))]
                            :right-params right-params})
                            ; month/year
                            ; rules
                            ;;clear first!
                            [(first stuff) (next stuff)]
                            [(first stuff) (next stuff)]
                            [(str "expected: " expected-str)
                            [] (partition 2 seq-exprs)))
                            [nil stuff])
                            [nil stuff])
                            argvec)))]
                            d))]
                            expr `(condp = ~expr-sym ~@testexprs ~default)]
                            mappings (data-reader-urls)))))
                            meths)
                            nil (java.io.StringWriter.)
                            optval)]
                            result
                            s)
                            trailer))]
                            true *out*
                           (+ 2 (- (count (.getStackTrace cause))
                           (. gen (throwException ex-type (str (. m (getName)) " ("
                           (:at params)
                           (:colon params)
                           (Character/toUpperCase ^Character (nth s offset)))
                           (and (:at params) (:colon params))
                           (apply str (repeat offset \space)) "^" \newline)]
                           (assoc m test expr)))
                           (assoc-test m test expr)))
                           (binding [*out* w] (println report-str)))
                           (catch MalformedURLException err
                           (chunk-append b (f (+ idx i) (.nth c i))))
                           (clojure.lang.RT/subvec arglist 2 (clojure.lang.RT/count arglist))
                           (distinct (concat (keys sigs-by-name)
                           (do
                           (do ; If that didn't produce any output, it has no nls
                           (dosync (ref-set capped true)))
                           (filter #(.exists ^File %)
                           (filter matches? (keys (ns-publics ns))))))
                           (if (< ~i- ~count-)
                           (if (keyword? t) t (class x)))))
                           (if (neg? i)
                           (if (neg? offset-sign) "-" "+")
                           (if (string? (first fd))
                           (init-navigator (first arg-list))
                           (init-navigator (next arg-list)))]
                           (into [] (concat rem2 remainder))))
                           (lazy-seq
                           (let [bb (key (first bes))
                           (let [child (aget ^objects (.arr parent) subidx)]
                           (let [firstb (first bs)]
                           (let [mods (. meth (getModifiers))]
                           (let [v (vec (.toArray a))]
                           (list fdecl)
                           (make-output-stream (URL. x) opts)
                           (not (and (Modifier/isProtected mods)
                           (pprint-indent :block (-> (count prefix) (- 2) -))
                           (pprint-newline :linear)
                           (reduce1 #(assoc-test %1 %2 expr) m test)
                           (second %1))) )
                           (set-field this :cur (+ (get-field this :cur) (count s)))
                           (some #(or (p1 %) (p2 %) (p3 %)) args)))))
                           (some #(or (p1 %) (p2 %)) args)))))
                           (some p args)))))
                           (str "Cannot open <" (pr-str x) "> as a Reader."))))
                           (str "Cannot open <" (pr-str x) "> as a Writer."))))))
                           (swap! result update :members (fnil conj #{})
                           (thisfn (rest pseq))))))]
                           (throw (IllegalArgumentException.
                           (throw (IllegalArgumentException. (str "Duplicate case test constant: " test)))
                           (when main [main-name])
                           (when post-init [post-init-name])
                           (write-out (cond 
                           (~c p#)
                           :else
                           ;(when exposes-methods (map str (vals exposes-methods)))
                           Ops$IntAndObjectPredicate Ops$IntAndObjectToObject))
                           Ops$Op Ops$BinaryOp Ops$Reducer Ops$Predicate Ops$BinaryPredicate 
                           ParallelArrayWithMapping 
                           ^Character (nth s (dec (count s))))))))
                           arglist)
                           capitalize-word-writer
                           chunk- (with-meta (gensym "chunk_")
                           clause 
                           count- (gensym "count_")
                           defaults (:or b)]
                           downcase-writer)]
                           fdecl)
                           gfirst (gensym "first__")
                           gmapseq (with-meta gmap {:tag 'clojure.lang.ISeq})
                           gseq (gensym "seq__")
                           has-rest (some #{'&} b)]
                           i- (gensym "i_")
                           init-cap-writer
                           lis)
                           match (re-find m)
                           needrec (steppair 0)
                           needrec (steppair 0)
                           nil))))])
                           node-idx (bit-and 0x1f aidx)]
                           offset (and match (.start m))]
                           offset-hours offset-minutes)))))
                           recform `(recur (next ~seq-) nil 0 0)
                           recform-chunk
                           result
                           ret))))
                           ret))))]
                           steppair (step recform (nnext exprs))
                           steppair-chunk (step recform-chunk (nnext exprs))
                           subform (steppair 1)
                           subform (steppair 1)]
                           subform-chunk (steppair-chunk 1)]
                           tailnode
                           upcase-writer
                           {(if saw-else :else :clauses) [clause] 
                           {msig meth}))
                           {} (seq pmap)))
                           ~(:prefix options) ~(:per-line-prefix options) ~(:suffix options))
                           ~(emit pred expr more)))))]
                           ~@(let [hinted-target (with-meta 'gtarget {:tag tagname})] 
                          ((formatter-out (if (vector? lis)
                          (. gen (loadThis))
                          (. ~(with-meta target {:tag on-interface}) (~(or on-method method) ~@(rest gargs))))))
                          (Character/isWhitespace 
                          (apply str (next (interleave commas groups))))
                          (assoc m :val (valf (:val m)))
                          (catch LispReader$ReaderException e
                          (catch MalformedURLException e
                          (catch Throwable ex
                          (fn [_] (datafy t))})))
                          (if (.offer q (if (nil? x) NIL x))
                          (if (= "file" (.getProtocol x))
                          (if (= "file" (.getProtocol x))
                          (if (get (ns-interns ns) sym)
                          (if (instance? clojure.lang.Symbol tag)
                          (if (reduced? result)
                          (if (symbol? spec)
                          (if p
                          (invalid-method? meth))
                          (let [[cname bytecode] (generate-proxy super interfaces)]
                          (let [^java.lang.reflect.Method meth (first meths)
                          (let [name-meta (meta (first s))
                          (let [start (System/nanoTime)
                          (let [v (vec (.toArray a))]
                          (make-input-stream (URL. x) opts)
                          (map #(get (:ancestors h) %) superclasses))))
                          (map #(vector m (vec (repeat (dec (count %))'Object)) 'Object) 
                          (out-fn {:tag :ret :val (ex->data ex (or (-> ex ex-data :clojure.error/phase) :execution))
                          (remove #(#{"clojure.lang.RestFn" "clojure.lang.AFn"} (.getClassName %))
                          (set! *e ex)
                          (str "Invalid signature \""
                          (str "Method '" (name sym) "' redefined")))))
                          (str "Parameter declaration \""
                          (str (root-directory (ns-name *ns*)) \/ path))]
                          (throw (java.util.NoSuchElementException.)))))
                          (try
                          (try
                          (when-not (.offer q q) ; q itself is eos sentinel
                          (when-not (nil? x)
                          (with-read-known (read request-prompt request-exit))
                          (write-out lis)))
                          1)
                          :clojure.error/path (file-path source))
                          [] (map vector bs vs gs))]
                          [mm considered]))]
                          `(fn ~giter [~gxs]
                          b (chunk-buffer size)]
                          do-mod (fn do-mod [[[k v :as pair] & etc]]
                          gxs (gensym "s__")
                          m))
                          path
                          result
                          size (count c)
                          target (first gargs)]
                          target (first gargs)]
                          true)))
                          {:url url})))
                         " FAILED"
                         ""))]
                         "cond requires an even number of forms")))
                         ((requiring-resolve 'clojure.pprint/pprint) report)))
                         (+ mincol (* colinc
                         (. gen dup)
                         (. gen getStatic ctype (var-name v) var-type)
                         (. gen goTo end-label)
                         (. gen ifZCmp (. GeneratorAdapter EQ) false-label)
                         (. gen invokeVirtual var-type (. Method (getMethod "Object get()")))
                         (. gen invokeVirtual var-type (. Method (getMethod "boolean isBound()")))
                         (. gen mark end-label)))
                         (. gen mark false-label)
                         (. gen pop)
                         (. gen visitInsn (. Opcodes ACONST_NULL))
                         (.getAbsolutePath f))
                         (.write writer s))) 
                         (/ 1 0)))
                         (:directive def) "\"")
                         (= k :let) [needrec `(let ~v ~subform)]
                         (= k :when) [false `(if ~v
                         (= k :while) [false `(when ~v
                         (and (not (empty? head-str)) (not (empty? tail-str))) 
                         (cat (first zs) (next zs)))))))]
                         (chunk-cons (chunk b) (mapi (+ idx size) (chunk-rest s))))
                         (chunk-cons (chunk-first xys)
                         (cons (first xys) (cat (rest xys) zs)))
                         (cons f (step (rest s) (conj seen f))))))
                         (do (.write writer 
                         (dotimes [i size]
                         (emit-nl this newl)
                         (for [^Class iface interfaces meth (. iface (getMethods))
                         (get ~'__extmap k# else#)))
                         (if (= rem2 section)
                         (if (contains? m test)
                         (if (seq bes)
                         (if (seq bs)
                         (if (seq? test)
                         (into1 #{} (map #(shift-mask shift mask %) skip-check)))]
                         (let [constructor? (= name "<init>")]
                         (let [mods (. meth (getModifiers))]
                         (let [t (get (meta x) :type)]
                         (make-input-stream
                         (map #(.getRawRoot ^clojure.lang.Var %) (keys binding-map)))]
                         (next b))
                         (not (empty? head-str)) (str head-str "th")
                         (or (identical? this# ~gs)
                         (or (re-find (re-matcher re (:doc m)))
                         (recur (rest s) seen)
                         (str (apply str (repeat (- (:mincol params) (.length signed-str)) 
                         (str head-str ", " tail-str)
                         (throw (IllegalArgumentException.
                         (try
                         (with-open [w (BufferedWriter. (FileWriter. f))]
                         :else tail-str))))
                         :expected '~form, :actual e#})
                         :expected '~form, :actual e#})))
                         :pnodes (if path (conj (:pnodes path) node) [node]) 
                         :ppath path 
                         :r cnext}] (meta loc))))))
                         LineNumberingPushbackReader RT LispReader$ReaderException))
                         fm nil nil cv)]
                         m nil nil cv)
                         mincol
                         signed-str)]
                         skip-check
                         ~(and (:on opts)
                        #_"inner-most loop"
                        #_"not the inner-most loop"
                        (#'clojure.core/lift-ns amap))
                        ((formatter-out "~w ~w ") ns kw)
                        (. gen (loadArgs))
                        (. gen (visitMethodInsn (. Opcodes INVOKESPECIAL) 
                        (. obj-type getDescriptor)
                        (. var-type getDescriptor)
                        (.nth this (.decrementAndGet i))
                        (.toString ^CharSequence replacement))
                        (.visitAnnotation visitor (descriptor c)
                        (.visitParameterAnnotation visitor i (descriptor c)
                        (>= *current-length* *print-length*))]
                        (and (= (count strs) 1) (not (:at params))))]
                        (and (== low-digit 1) not-teens) "st"
                        (and (== low-digit 2) not-teens) "nd"
                        (and (== low-digit 3) not-teens) "rd"
                        (and ppath (assoc ppath :changed? true))]
                        (apply str 
                        (assoc m h expr)))
                        (assoc ret k
                        (boolean 
                        (catch IndexOutOfBoundsException _
                        (catch Throwable ex
                        (clojure.lang.RecordIterator. ~gs [~@(map keyword base-fields)] (RT/iter ~'__extmap)))
                        (cond 
                        (cons (apply vector (vary-meta target assoc :tag c) args)
                        (cons (if (identical? x NIL) nil x) (drain)))))))]
                        (cons x (keepi (inc idx) (rest s)))))))))]
                        (get-max-column *out*))
                        (if (#{:ret :tap} tag)
                        (if (instance? clojure.lang.Symbol iname) false true))
                        (if (seq meths)
                        (if (seq? (first fdecl))
                        (if (sequential? lis)
                        (if add-sign (if (neg? arg) \- \+)) 
                        (if append-zero "0")
                        (if prepend-zero "0")
                        (if s
                        (instance? (second (second %2)) val)))
                        (keepi (inc idx) (rest s))
                        (let [gi (gensym "i__")
                        (let [groups (map #(apply str %) (group-by* (:commainterval params) raw-str))
                        (let [m (meta argvec)
                        (let [m (munge (:name sig))]
                        (let [result (f result (.aget am node node-idx))]
                        (let [x (f (+ idx i) (.nth c i))]
                        (log-error q e))))))
                        (not= (mappings k) v-var))
                        (release-pending-sends)
                        (reverse (map #(:name (meta %)) vars)))))
                        (send-off agt fill)
                        (throw (IllegalArgumentException.
                        (try
                        (var-name v) 
                        (when-not (identical? form EOF)
                        *current-length*
                        *print-length*
                        :clojure.error/path (file-path source))
                        :else "th")))))))
                        [] specs)))))
                        `([~@gargs]
                        `([~@gargs]
                        `(fn ~giter [~gxs]
                        `(loop [~seq- (seq ~v), ~chunk- nil,
                        argsig (pop msig)]
                        full-mantissa
                        m))))))))
                        max-columns))
                        nil nil)))
                        nil nil)))
                        offset)
                        offset)
                        or \"none\", overrides System property clojure.main.report
                        raw-str)
                        result))]
                        scaled-exp-str))))
                        state-name 
                        {:eof nil :read-cond :allow}
                        {:eof nil})
                        {} sigs))
                        ~(apply hash-map 
                       'loop* form
                       'recur (concat `(recur (inc ~var-sym)) (rest form))
                       (.reduce (chunk-first s) f val)
                       (.write w "#=(identity ")
                       (.write w ")"))
                       (.write w "\n   :message ")
                       (.write w ^String (primitives-classnames c))
                       (.write writer (int (Character/toUpperCase c))))
                       (:colinc params))))
                       (:overflowchar params))
                       (:stream options)
                       (System/identityHashCode o)
                       (apply max (count (str k)) (map #(count (str (get % k))) rows)))
                       (assoc e :content (conj (or (:content e) []) c)))
                       (binding [*print-namespace-maps* false]
                       (catch Exception e ""))]
                       (catch Throwable _)))] ;; ignore, fallback to stderr
                       (chunk-next s))
                       (cond
                       (conj acc (nth (nth table pos) (dec digit))))
                       (cons (f idx (first s)) (mapi (inc idx) (rest s)))))))]
                       (cons name (maybe-destructured params body)))
                       (cons path *pending-paths*))
                       (disj 'Object 'java.lang.Object)
                       (do
                       (dosync (ref-set capped true))
                       (float? val) (bigdec val)
                       (fn [m [test expr]]
                       (if (and (instance? clojure.lang.Agent o)
                       (if (chunked-seq? xys)
                       (if (contains? seen f)
                       (if (vector? a) a (vec a))
                       (if (vector? b) b (vec b))
                       (if offset
                       (impl t))
                       (inc signed-len) 
                       (let [c (chunk-first s)
                       (let [f (.toFile (Files/createTempFile "clojure-" ".edn" (into-array FileAttribute [])))]
                       (let [false-label (. gen newLabel)
                       (let [rem2 (write-token-string this section)]
                       (list form x))]
                       (loop [ret (-> bvec (conj gmap) (conj v)
                       (loop [ret (let [ret (conj bvec gvec val)]
                       (map-ref-type (.getSimpleName (class o)))
                       (new ~tagname ~@(remove '#{__extmap __hash __hasheq} fields) (assoc ~'__extmap k# ~gs))))
                       (out-fn
                       (print-method (:message %) w)
                       (print-method (:type %) w)
                       (range (max (count a) (count b)))))))
                       (ratio? val) (let [^clojure.lang.Ratio r val] 
                       (recur))))
                       (repeat '(.. clojure.lang.Var create setDynamic)))]
                       (seq newParents)))]
                       (set! *current* (push-content *current* (str *sb*)))))]
                       (split-at (if (= :>> (second args)) 3 2) args)
                       (str leader
                       (throw (ex-info nil {:clojure.error/phase :print-eval-result} e)))))))
                       (throw e)
                       (walk inner identity form)))
                       (when zs
                       (when-not (= name "<clinit>")
                       (with-meta `(~(first form) ~x ~@(next form)) (meta form))
                       :else val)] 
                       :incremental (Integer/valueOf ^String incremental)
                       :method-builders 
                       :method-map 
                       :minor       (Integer/valueOf ^String minor)
                       :qualifier   (if (= qualifier "SNAPSHOT") nil qualifier)}]
                       :sigs '~sigs 
                       :var (var ~name)
                       ;; ignore java.lang.Object on interfaces to match reflection
                       [(make-node loc pnode (concat l (cons node r))) 
                       [pnode ppath])
                       [true
                       _ (when (not (vector? params))
                       `((. java.math.RoundingMode ~(second exprs)))]
                       `(clear [this#] (throw (UnsupportedOperationException.)))
                       `(containsValue [this# v#] (boolean (some #{v#} (vals this#))))
                       `(entrySet [this#] (set this#)))])
                       `(get [this# k#] (.valAt this# k#))
                       `(isEmpty [this#] (= 0 (.count this#)))
                       `(keySet [this#] (set (keys this#)))
                       `(put [this# k# v#] (throw (UnsupportedOperationException.)))
                       `(putAll [this# m#] (throw (UnsupportedOperationException.)))
                       `(remove [this# k#] (throw (UnsupportedOperationException.)))
                       `(size [this#] (.count this#))
                       `(values [this#] (vals this#))
                       acc 
                       b)
                       bases (->> (cons superName interfaces)
                       body (if conds (next body) body)
                       body (if post
                       body (if pre
                       conds (or conds (meta params))
                       conds (when (and (next body) (map? (first body)))
                       e))
                       match (re-find m)
                       n (count clause)]
                       newpos (+ oldpos (count s0))]
                       nil)
                       offset (and match (inc (.start m)))]
                       post (:post conds)
                       pre (:pre conds)
                       result)
                       set
                       signed-len)]
                       superName (if (and (flags :interface)
                       true) 
                       v (second exprs)]
                       vec)
                       {} pairs)
                       ~@(mapcat (fn [fld]
                      (. gen (loadArg i))
                      (.bindRoot ^clojure.lang.Var a-var a-val)))
                      (.toString ^CharSequence replacement))
                      (and (nil? va) (nil? vb))))]
                      (and ppath (assoc ppath :changed? true))]
                      (apply (formatter-out "~w ~:i~@{~w~^ ~:_~}") arg)))
                      (assoc m :doc docstring)
                      (butlast fdecl)
                      (catch Exception e
                      (chunk-cons (chunk b) (keepi (+ idx size) (chunk-rest s))))
                      (conj (meta mm-name) m)
                      (cons (map first ss) (step (map rest ss)))))))]
                      (do
                      (do @agt nil)  ;touch agent just to propagate errors
                      (dotimes [i size]
                      (first %)
                      (first options)
                      (first options)
                      (fn [^GeneratorAdapter gen ^Method m]
                      (if (< node-idx (.alength am node))
                      (if (nil? x)
                      (if (or pad-only (next strs) (:at params)) pad-str)
                      (if (pos? extra-pad) (:padchar params))))
                      (if extend-via-meta
                      (if next-groups
                      (let [[ns kw lis] arg]
                      (let [testexprs (apply concat bucket)
                      (list `nth 'overage i)))
                      (list fdecl)
                      (loop [[x & xs :as s] (seq s)]
                      (loop [mm mm 
                      (make-pretty-writer base-writer# *print-right-margin* *print-miser-width*)
                      (map #(symbol ns-name (str %))
                      (next fdecl)
                      (next fdecl)
                      (next ks) (next vs))
                      (next options)
                      (next options)
                      (not (:colon params)))
                      (out-fn {:tag :ret :val (ex->data ex :read-source)
                      (read [] (let [i (proxy-super read)]
                      (recur  (conj (conj ret `(var ~(first vvs))) (second vvs))
                      (recur (dec n) (rest s))
                      (recur pred (rest s))
                      (recur r2 (= c2 \Q))))
                      (recur r2 (not= c2 \E))
                      (seq ret))))]
                      (set! *e ex)
                      (subs s (inc offset))]
                      (swap! result update :members (fnil conj #{})
                      (throw (IllegalArgumentException.
                      (throw (java.util.NoSuchElementException.)))))
                      (throw (java.util.NoSuchElementException.)))))
                      (try
                      (update m (clojure.lang.Util/hash (first ks)) (fnil conj []) [(first ks) (first vs)])
                      (update spec :clojure.spec.alpha/problems
                      (update spec :clojure.spec.alpha/problems
                      (vals sigs))]
                      :expected '~form, :actual t#}))))
                      :expected nil, :actual e})))
                      :imports (-> n ns-imports sortmap)
                      :interns (-> n ns-interns sortmap)}
                      :publics (-> n ns-publics sortmap)
                      [(next (next exprs))
                      [exprs nil])]
                      \space))] 
                      ^String (capitalize-string (.toLowerCase s) @last-was-whitespace?))
                      `([~@gargs]
                      `(~(first f) ~gx ~@(next f))
                      `(~f ~gx))
                      base-writer#)]
                      expanded (> (count round-up-result) (count result))]
                      fdecl)
                      fdecl)
                      fdecl)
                      fdecl)
                      fmap (. imap-type (getDescriptor)) nil nil))          
                      ifn (first inline)
                      iname (second inline)]
                      m (cons source (sources source))))]
                      m)
                      m)
                      mk (method-sig meth)]
                      mods (. meth (getModifiers))
                      nil)
                      nil)
                      options)
                      options)
                      s)))]
                      s)))]
                      spec)))
                      spec))))
                      specs)))]
                      true))
                      {})
                     "" ;; omit, not useful
                     '^:unsynchronized-mutable __hash
                     '^:unsynchronized-mutable __hasheq)
                     (.add a input))
                     (.append sb ^String str-cbuf ^int off ^int len)
                     (.append sb ^chars str-cbuf ^int off ^int len)))))
                     (.getMessage e)
                     (.load version-stream)))
                     (.setLineNumber (if (and line (or eval-file (not= pre-line line))) line line-number)))]
                     (.write w "\\E\\\"\\Q")
                     (.write w "\\\""))
                     (.write writer (.toLowerCase s))))
                     (.write writer (int (Character/toLowerCase c)))))))))))
                     (< current colnum) (- colnum current)
                     (= colinc 0) 0
                     (= val pval))
                     (>= e 0) (max (inc e) (dec w))
                     (apply concat (vals impls)))]
                     (assoc ~opts 
                     (case k#
                     (catch Throwable e
                     (condp = (first form)
                     (condp identical? k#
                     (cons (clojure.lang.MapEntry/create (first pseq) (v (first pseq)))
                     (cons (map first ss) (step (map rest ss)))))))]
                     (cons `defn decl)
                     (dec pos)
                     (disj result item) 
                     (disj result item)))
                     (do
                     (filter #(< 1 (count (second %))))
                     (fn [k]
                     (if (.offer q q)
                     (if (:at params) [:level nil :length nil] [])
                     (if (:colon params) [:pretty true] []))]
                     (if (chunked-seq? s)
                     (if xys
                     (impl Object)))))))
                     (interpose \, unsupported))))
                     (into1 #{}))]
                     (let [gmap (gensym "map__")
                     (let [gvec (gensym "vec__")
                     (let [m (re-matcher #"\S" s)
                     (let [seq- (gensym "seq_")
                     (let [steppair (step recform (nnext exprs))
                     (list '. (list 'var name) '(setMacro))
                     (list 'var name)))))
                     (map #(select-keys % [:members]) (vals reflections)))))))
                     (map first)
                     (map namespace-doc (all-ns))
                     (map special-doc (keys special-doc-map)))]
                     (meta loc))))))
                     (meta loc))))))
                     (next digits))))))
                     (not (.isRealized ^clojure.lang.IPending o)))
                     (print value)
                     (reduce #(conj %1 (merge %2 x)) ret found)
                     (str " (" simple-class ")"))]
                     (str "function " (.sym v)))))))))
                     (str "method " (.sym v) " of protocol " (.sym p))
                     (subs fixed-repr 1)  ; chop off leading 0
                     (subs round-up-result 0 (dec (count round-up-result)))
                     (try
                     (when (and (= *state* :chars)
                     (when-let [info (ex-data e)] (str " " (pr-str info)))))
                     (when-let [s (seq xs)]
                     (when-let [t (reduce1 pref (filter impl (disj (supers c) Object)))]
                     (when-not (identical? m EOF)
                     :base (column-writer writer max-columns)
                     :buffer []
                     :buffer-block lb
                     :buffer-level 1
                     :else (+ w e))
                     :else (- colinc (rem (- current colnum) colinc)))]
                     :expected '~form, :actual e#})
                     :logical-blocks lb 
                     :miser-width miser-width
                     :mode :writing
                     :pos 0})]
                     :sections nil
                     :trailing-white-space nil
                     :type :summary)]
                     ;; If d was given, that forces the rounding
                     ;; If e>=0, then abs value of number is >= 1.0,
                     ;; Otherwise w was specified, so pick round-pos
                     ;; and e+1 is number of decimal digits before the
                     ;; based upon that.
                     ;; decimal point when the number is written
                     ;; e < 0, so number abs value < 1.0
                     ;; have been specified.
                     ;; number before the decimal point.
                     ;; position, regardless of any width that may
                     ;; without scientific notation.  Never round the
                     [(str (subs s 0 offset) 
                     [s nil]))))
                     and can be a constructor, method, or field.
                     d (+ e d 1)
                     fixed-repr)
                     ks)
                     m nil nil cv)
                     nl (.lastIndexOf s (int \newline))]
                     of the type.
                     result))
                     ret)))
                     round-up-result)
                     {:at (StackTraceElement->vec (aget st 0))}))))
                    %))
                    ((formatter-out "~:_"))))))
                    ((formatter-out "~_"))))
                    (* (+ (quot (- (:mincol params) min-width 1) 
                    (. clojure.lang.Compiler$HostExpr (emitBoxReturn nil gen (nth pclasses i))))
                    (. gen (pop)))
                    (.meta ^clojure.lang.IMeta &form))))
                    (.nth this (dec (.incrementAndGet i)))
                    (.nth this (dec (.incrementAndGet i)))
                    (.openStream url) "UTF-8"))]
                    (.write w sep)
                    (apply str (interpose ", " non-syms)))))))))
                    (assoc m :inline (cons ifn (cons (clojure.lang.Symbol/intern (.concat (.getName ^clojure.lang.Symbol name) "__inliner"))
                    (assoc m argsig (assoc (m argsig {}) rtype meth))))
                    (assoc m k (apply f (get m k) args)))))]
                    (assoc m k (up (get m k) ks f args))
                    (assoc mm (method-sig meth) meth))))
                    (assoc v i (val e))
                    (catch IndexOutOfBoundsException _
                    (catch IndexOutOfBoundsException _
                    (catch Throwable ex
                    (char (inc (int (.charAt s i))))
                    (class class-or-object))]
                    (cons ta
                    (doseq [[a-var a-val] m]
                    (emit-forwarding-method (.getName meth) (.getParameterTypes meth) (.getReturnType meth) false
                    (fn [] ~@body)))
                    (if (= spec/*explain-out* spec/explain-printer)
                    (if (= spec/*explain-out* spec/explain-printer)
                    (if (and (= (count arg) 3) (keyword? (second arg)))
                    (if (and (pos? n) s)
                    (if (and s (pred (first s)))
                    (if (identical? x q) ;q itself is eos sentinel
                    (if (seq? f)
                    (if *print-radix* (or (get special-radix-markers *print-base*) (str "#" *print-base* "r")))
                    (if add-sign (if (neg? arg) \- \+)) 
                    (if append-zero "0")
                    (if prepend-zero "0")
                    (if vvs
                    (init-navigator [arg]) nil))
                    (let [[form s] (read+string in-reader false EOF)]
                    (let [c (chunk-first s)
                    (let [gargs (map #(gensym (str "gf__" % "__")) args)
                    (let [gargs (map #(gensym (str "gf__" % "__")) args)
                    (let [giter (gensym "iter__")
                    (let [ns-name (str ns)]
                    (let [x (f idx (first s))]
                    (log-error q s)
                    (map (fn [i] (. rsmeta (getColumnLabel i))) idxs))
                    (mapcat walk (children node))))))]
                    (meta f)))
                    (min (nth (:colon flags) 1) (nth (:at flags) 1))))))
                    (nth (:at flags) 1)))
                    (nth (:colon flags) 1)))
                    (opt-base-str *print-base* n)))
                    (recur
                    (recur (assoc mm mk meth) (conj considered mk) (next meths))))
                    (recur (inc i))
                    (recur mm (conj considered mk) (next meths))
                    (recur xs (dec print-length))))))
                    (reduce load-data-reader-file
                    (reduce1 (fn [groups [k v]]
                    (ref false) (ref false)
                    (repeat (- len-1 i) "0"))))))
                    (rf result input)))))))))
                    (str (:name options-map)) bytecode options)))
                    (str url url-path ".html")))
                    (throw (Exception. "ResultSet must have unique column labels")))
                    (try
                    (vreset! dv nil)
                    (when (every? identity ss)
                    *ns* "." name " had: "
                    :members.
                    ;; inserts the same fn name to the inline fn if it does not have one
                    AsmReflector is also an option."
                    [ 'T' time-part ] ] ]
                    [(symbol core (name s)) f]
                    [110 2 33 2]]
                    [time-secfrac] [time-offset] ] ]
                    ancestors, and add all ancestor members to
                    class-and-interfaces)
                    class-or-object 
                    client-id (str client-counter)]
                    comp))))))))
                    full-mantissa
                    in (LineNumberingPushbackReader. (InputStreamReader. (.getInputStream conn)))
                    include an :ancestors key with the entire set of
                    low-digit (rem low-two-digits 10)]
                    m))
                    m))
                    meths (if (vector? (first meths))
                    meths (map (fn [[params & body]]
                    nn (vswap! nv dec)
                    not-teens (or (< 11 low-two-digits) (> 19 low-two-digits))
                    out (BufferedWriter. (OutputStreamWriter. (.getOutputStream conn)))
                    prefix per-line-prefix suffix)]
                    result (if (pos? n)
                    scaled-exp-str)))
                    v))
                   "with-open only allows Symbols in bindings"))))
                   #(.contains (str %) (str str-or-pattern)))]
                   #(if (seq? %)
                   #(re-find str-or-pattern (str %))
                   #(when-let [v (get t (key %))] [(find-var v) (val %)]) 
                   (+ (dec (count strs)) (if (:colon params) 1 0) (if (:at params) 1 0)))
                   (- level (int 5))))))
                   (-> lets (conj (first params)) (conj gparam)))))
                   (. Method getMethod "void <clinit> ()")
                   (.append w \\)
                   (.append w c)
                   (.append w c2)
                   (.getAnnotation c java.lang.annotation.Retention)]
                   (.write w "#=(java.lang.Class/forName \"")
                   (.write w "\")"))
                   (.write w (.getName c))
                   (:var proto)))))
                   (add-annotation avec "value" vval))
                   (add-to-buffer this (make-buffer-blob s white-space oldpos newpos))))))
                   (and *print-meta* *print-readably*)))
                   (assoc m (ffirst bucket) (second (first bucket)))
                   (assoc-multi m h bucket)))
                   (case k# ~@(mapcat (fn [fld] [(keyword fld) fld]) 
                   (clojure.core.protocols/coll-reduce coll (xf f1) (f1)))
                   (clojure.core.protocols/coll-reduce coll (xf f1) init))
                   (clojure.core.protocols/coll-reduce coll (xf f1) init)))))
                   (clojure.core.protocols/coll-reduce this f1 (f1)))
                   (cons (apply struct row-struct (row-values)) (lazy-seq (thisfn)))))]
                   (cons (deref x) (step xs (rest s)))
                   (count results) results))
                   (doto (new java.util.Properties)
                   (every? #(and (integer? %) (<= Integer/MIN_VALUE % Integer/MAX_VALUE)) tests)
                   (every? keyword? tests)
                   (flush-fn (.toString sb)))
                   (fn [bvec b v]
                   (fn [bvec b val]
                   (format "GMT%s%02d:%02d"
                   (if (and (not @capped) (Character/isLetter c))
                   (if (contains? s2 item)
                   (if (contains? s2 item) 
                   (if (instance? String str-cbuf)
                   (if (keyword? k)
                   (if (not @capped) 
                   (if found
                   (if offset
                   (if p
                   (if qmode
                   (if qmode
                   (into-array (map iname ifc)))))
                   (java.io.InputStreamReader.
                   (let [form (macroexpand form)] 
                   (let [xys (seq xys)]
                   (let [{:keys [tag val] :as m} (readf rd EOF)]
                   (let [~'gclass (class this#)]              
                   (map deref vs))))]
                   (maybe-destructured params body)))
                   (or (not (:colon (:right-params params))) (> count 0)))
                   (or (not (:colon (:right-params params))) (> count 0)))
                   (or (not (:colon (:right-params params))) (> count 0)))
                   (or (not (:colon (:right-params params))) (> count 0)))
                   (or reload (not require) (not loaded))
                   (partition 2 clauses))]
                   (partition 2 clauses))]
                   (recur r qmode))
                   (recur r qmode)))))
                   (reduce #(conj %1 (merge %2 x)) ret found)
                   (reduce1 (fn [m e]
                   (remove loc)
                   (replace loc '/)
                   (set! *1 value)
                   (set! *2 *1)
                   (set! *3 *2)
                   (setf :pos newpos)
                   (setf :trailing-white-space white-space))
                   (str
                   (str "java.lang." strx)) 
                   (str n (if *print-radix* "."))
                   (swap! result merge {:bases bases 
                   (throw (IllegalArgumentException.
                   (throw (IllegalArgumentException.
                   (throw (IllegalArgumentException.
                   (throw (IllegalArgumentException.
                   (throw (IllegalArgumentException.
                   (try
                   (when (every? identity ss)
                   (when (pos? (alength st))
                   (when-let [pseq (seq plseq)]
                   (when-let [s (seq coll)]
                   (when-not (reduced? ret)
                   (write-to-base s)
                   (write-white-space this)
                   :as m}]
                   :clojure.main/message message
                   :clojure.main/trace trace)
                   :clojure.main/triage triage
                   :doc "Synchronization primitive that should be avoided
                   :else :hashes)]
                   :expected '~form, :actual nil})
                   :identity
                   :ints
                   :keys [forms arglists special-form doc url macro spec]
                   :or {target "file"} :as opts}]
                   ;; Assume single arity syntax
                   [xrel yrel (map-invert km)]
                   [xrel yrel]
                   [yrel xrel km])
                   [yrel xrel])
                   `(assoc [this# k# ~gs]
                   `(cons [this# e#] ((var imap-cons) this# e#))
                   `(containsKey [this# k#] (not (identical? this# (.valAt this# k# this#))))
                   `(count [this#] (+ ~(count base-fields) (count ~'__extmap)))
                   `(empty [this#] (throw (UnsupportedOperationException. (str "Can't create empty: " ~(str classname)))))
                   `(entryAt [this# k#] (let [v# (.valAt this# k# this#)]
                   `(equiv [this# ~gs] 
                   `(iterator [~gs]
                   `(seq [this#] (seq (concat [~@(map #(list `clojure.lang.MapEntry/create (keyword %) %) base-fields)]
                   `(withMeta [this# ~gs] (new ~tagname ~@(replace {'__meta gs} fields))))])
                   `(without [this# k#] (if (contains? #{~@(map keyword base-fields)} k#)
                   add-args (fn [acc ds]
                   add-implicit-args (fn [fd]
                   considered considered
                   decl (loop [p prefix d fdecl]
                   e (struct element
                   e1 expanded])
                   false remainder]]
                   fdecl (if (vector? (first fdecl))
                   fdecl (loop [fd args]
                   fdecl (seq (add-args [] fdecl))
                   fdecl)
                   form))]
                   forms)]
                   forms)]
                   import-symbols-or-lists)]
                   load-all
                   load-one)
                   loc)))))
                   loc)))))
                   m)))
                   method (. pd (getReadMethod))]
                   meths (seq (concat
                   nil nil cv)]
                   nm :name
                   offset-sign offset-hours offset-minutes]
                   pmap
                   print-length *print-length*]
                   ret)))
                   ret)))))))))
                   sigs
                   strx
                   true remainder]]))
                   xs seen)))]
                   {:data ed})
                   {:message msg})
                  "assoc expects even number of arguments after map/vector, found odd number")))
                  "namespace '%s' not found" lib))
                  #(.atLineStart *in*)
                  #(identity true))
                  ((fn [[f :as xs] seen]
                  (+ offset (condp = relative-to
                  (. clojure.lang.Compiler$HostExpr (emitBoxReturn nil gen (nth pclasses i))))
                  (. gen (dup))
                  (. gen (dup))
                  (. gen (getField ctype fmap imap-type))
                  (. gen (goTo end-label))
                  (. gen (ifNonNull found-label))
                  (. gen (ifNull else-label))
                  (. gen (invokeInterface ifn-type (new Method "invoke" obj-type 
                  (. gen (invokeStatic rt-type (. Method (getMethod "Object get(Object, Object)"))))
                  (. gen (loadArg i))
                  (. gen (loadArg i)))
                  (. gen (loadThis))
                  (. gen (loadThis))
                  (. gen (loadThis)))
                  (. gen (mark else-label))
                  (. gen (mark end-label))))
                  (. gen (mark found-label)))
                  (. gen (pop))
                  (. gen (pop)))
                  (. gen (pop)))
                  (. gen (push (. meth (getName))))
                  (. gen (unbox rtype))
                  (.checkCast gen ifn-type)
                  (.close wr))))
                  (.toString b)))))
                  (.visitEnum av name (descriptor (class ev)) (str ev))
                  (= "+" offset-sign)  1
                  (= 0 (rem (.numerator r) (.denominator r))))
                  (= 0 n) `(throw (IllegalArgumentException. (str "No matching clause: " ~expr)))
                  (= 1 n) a
                  (= 2 n) `(if (~pred ~a ~expr)
                  (= op :bound) (. pa withBounds (args 0) (args 1))
                  (= op :filter) (. pa withFilter (predicate args))
                  (= op :filter-index) (. pa withIndexedFilter (int-and-object-predicate args))
                  (= op :filter-with) (. pa withFilter (binary-predicate (args 0)) (par (args 1)))
                  (= op :map) (. pa withMapping (parallel/op args))
                  (= op :map-index) (. pa withIndexedMapping (int-and-object-to-object args))
                  (= op :map-with) (. pa withMapping (binary-op (args 0)) (par (args 1)))
                  (Type/getMethodDescriptor (asm-type rclass) 
                  (accept-connection conn name client-id in out (if bind-err out *err*) accept args)))
                  (all-ns)))))
                  (apply str (repeat (- w full-len) (:padchar params)))
                  (chunk-append b v))))
                  (class? ev) (.visit av name (clojure.asm.Type/getType ev))
                  (conj m (first fdecl))
                  (conj m (last fdecl))
                  (do
                  (do
                  (dotimes [i (count ptypes)]
                  (else-gen gen m)
                  (emit-get-var gen (overload-name mname pclasses))
                  (ensure-reduced result)
                  (fn [args]
                  (fn [args]
                  (fn [mappings]
                  (getBeanInfo c)
                  (getPropertyDescriptors))))
                  (if (= 0 comp)
                  (if (and ks vs)
                  (if (chunked-seq? s)
                  (if (if (clojure.lang.Util/equiv 'fn ifn)
                  (if (instance? Exception s) ; we failed to .offer an error earlier
                  (if (not (or (namespace s) (special-symbol? s)))
                  (if (or (considered mk)
                  (if add-sign sign) 
                  (if append-zero "0")))))
                  (if ks
                  (if prepend-zero "0")
                  (if-let [e (find smap (nth v i))]
                  (instance? java.lang.Enum ev)
                  (keys nspublics)
                  (last clauses)
                  (let [rtype (peek msig)
                  (let [s (seq coll)]
                  (let [s (seq coll)]
                  (let [ss (map seq cs)]
                  (let [x (.take q)]
                  (let [x (f1 ret k v)] (if (reduced? x) (reduced x) x))))]
                  (let [x (f1 ret v)] (if (reduced? x) (reduced x) x)))
                  (loop [ret [] vvs (seq var-vals)]
                  (or (:refer fs) (:only fs) (keys nspublics)))]
                  (or (not (nil? ab))
                  (pprint-logical-block :prefix start :suffix end
                  (print-dup (str o) w))
                  (print-one x w)
                  (re-matches timestamp cs)]
                  (recur (.append b \0))
                  (recur (inc i) ret)))
                  (recur cls (next s) f ret)))
                  (recur mm considered (. c (getSuperclass))))
                  (reduce1 into1 superclasses
                  (rf result input)
                  (rf result input))))))))
                  (spec/explain-out
                  (spec/explain-out
                  (str "Clojure Connection " name " " client-id) client-daemon
                  (str (first ~'&form) " requires " ~(second pairs) " in " ~'*ns* ":" (:line (meta ~'&form))))))
                  (str mname)
                  (vary-meta (apply-template argv expr a)
                  (when (.startsWith classname prefix)
                  (when (= (. rtype (getSort)) (. Type VOID))
                  (when (branch? node)
                  (when (next args)
                  (when (next args)
                  (when xs
                  (with-meta
                  (write-out arg)
                  :block @(:start-col lb)
                  :current (get-column (getf :base))))))
                  :doc "Synchronization primitive that should be avoided
                  :else                0)
                  :else (throw (Exception. (str "Unsupported par op: " op)))))
                  :else (throw (IllegalArgumentException.
                  :else `(if-let [p# (~pred ~a ~expr)]
                  :expected '~form, :actual (class object#)})
                  :expected '~form, :actual (class object#)}))
                  :expected '~form, :actual (cons ~pred values#)})
                  :expected '~form, :actual (list '~'not (cons '~pred values#))}))
                  ;; same as: (if (and (= 'fn ifn) (not (symbol? iname))) ...)
                  @ret
                  @ret
                  [(if expanded
                  [(str (apply str (repeat (dec (- e)) \0)) m) -1]
                  [m e])
                  ^String result (subs m1 0 round-pos)]
                  ^String s (.replaceFirst s0 "\\s+$" "")
                  `(throw (IllegalArgumentException. (str "No matching clause: " ~ge))))]
                  append-zero (and append-zero (< full-len w))]
                  arglists))
                  arglists))]
                  byte and char streams.   
                  c (resolve nested)
                  decl-type (. Type (getType (. meth (getDeclaringClass))))]
                  dm (new Method (. dest (getName)) (totype (. dest (getReturnType))) (to-types (. dest (getParameterTypes))))
                  dtype (totype (.getDeclaringClass dest))
                  else-label (. gen (newLabel))
                  end-label (. gen (newLabel))
                  f
                  fixed-repr
                  full-len (if prepend-zero (inc signed-len) signed-len)
                  gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)
                  gen (new GeneratorAdapter (bit-or (. Opcodes ACC_PUBLIC) (. Opcodes ACC_BRIDGE)) m nil nil cv)]
                  input (try
                  m (new Method (. meth (getName)) rtype ptypes)
                  m (new Method (. meth (getName)) rtype ptypes)
                  m)
                  m)
                  mm
                  mode (getf :mode)]
                  nav (.visitAnnotation av name (descriptor c))]
                  nil nil)]
                  offset-sign offset-hours offset-minutes)))
                  prepend-zero (and prepend-zero (not (= signed-len w)))
                  ptypes (to-types pclasses)
                  ptypes (to-types pclasses)
                  result
                  result
                  result)))))))
                  result)))))))
                  ret)))
                  rtype ^Type (totype (. meth (getReturnType)))
                  rtype ^Type (totype (. meth (getReturnType)))
                  shift (range 0 31)]
                  signed-len (if add-sign (inc len) len)
                  v (f i input)]
                  white-space (.substring s0 (count s))
                  {:doc (first fdecl)}
                  {})
                  ~@(for [i (range 0 (count over))]
                  ~@field-args
                 "." "/")))))
                 '^int ^:unsynchronized-mutable __hash
                 '^int ^:unsynchronized-mutable __hasheq)
                 (+ min-width 
                 (.add a input)
                 (.clear a)
                 (.col_write this x))
                 (.flush ^Writer this)
                 (.flush wr)
                 (.getResourceAsStream this (resource-name typeref))))
                 (.reduce ^clojure.lang.IReduceInit coll f init)
                 (.setLength sb 0))
                 (.visitEnd avec))
                 (.write ^Writer (get-field this :base) s))
                 (.write wr buf 0 n)
                 (add-to-buffer this (make-buffer-blob (str (char c)) nil))))))))))
                 (assoc m (keyword name) (fn [] (clojure.lang.Reflector/prepRet (.getPropertyType pd) (. method (invoke x nil)))))
                 (catch Throwable ex)))
                 (clojure.core.protocols/coll-reduce coll f init))]
                 (coll-fold coll n combinef (xf reducef))))))
                 (compare-and-set! v d x))
                 (cond
                 (cond
                 (cond
                 (conj m
                 (cons node
                 (do
                 (doseq [vval v]
                 (dosync (if (neg? nl)
                 (f))))
                 (finally
                 (first (:else params))
                 (first clauses))]
                 (if ((mk-bound-fn sc end-test end-key) e) s (next s))))))
                 (if ((mk-bound-fn sc start-test start-key) e) s (next s))))))
                 (if (== 1 (count bucket))
                 (if (seq? (first sigs))
                 (if (seq? form)
                 (if found
                 (if-let [s (seq fs)]
                 (inc i))))))
                 (into-array (map iname (cons IProxy interfaces)))))
                 (lazy-seq
                 (lazy-seq
                 (lazy-seq
                 (lazy-seq
                 (lazy-seq
                 (let [[params & body] sig
                 (let [c ^Character (char x)]
                 (let [flags (parse-flags access :class)
                 (let [found (idx (select-keys x ks))]
                 (let [k (first exprs)
                 (let [m (re-matcher #"\W\w" s)
                 (let [oldpos (getf :pos)
                 (let [ret (rf result v)]
                 (let [s (.toLowerCase ^String x)]
                 (let [ss (map seq cs)]
                 (let [st (.getStackTrace t)]
                 (let [tl (.array am 1)] (.aset am  tl 0 val) tl) (meta this))))))
                 (let [value (binding [*read-eval* read-eval] (eval input))]
                 (list sigs)
                 (map (fn [[[target & args] & body]]
                 (nth clauses arg))]
                 (prn (if (#{:ret :tap} (:tag m))
                 (recur new-buffer)))))))
                 (recur))))
                 (ref-set last-was-whitespace? 
                 (reset! *open-url-script* (open-url-script-val))
                 (second clauses)
                 (set! (. Classname-symbol staticFieldName-symbol) expr)]
                 (set! (. instance-expr instanceFieldName-symbol) expr)
                 (tap x)
                 (when (. rs (next))
                 (when (not (seq? sig))
                 (when (pos? (.length sb))
                 (when (pos? len)
                 (when close-fn (close-fn))
                 (when-let [ed (ex-data t)]
                 (when-let [ifc (seq interfaces)]
                 (when-let [msg (.getLocalizedMessage t)]
                 (with-meta arglist (conj (if (meta arglist) (meta arglist) {}) (first body)))
                 (write-initial-lines this "\n")
                 (write-white-space this)
                 :preserve to keep all branches
                 ;; Ensure correct type before destructuring sig
                 ;elide implicit macro args
                 Integer
                 String 
                 [name doc-string? attr-map? ([params*] body)+ attr-map?])
                 [nil nil]
                 [true `(do ~@body)]
                 [true e])))]
                 arglist (if (clojure.lang.Util/equals '&form (first arglist))
                 arglist)
                 body (next fdecl)]
                 cname nil (iname super)
                 cname nil (iname super) 
                 false remainder]]))))
                 m)))
                 min-width
                 mode (getf :mode)]
                 newpos (+ oldpos (count l))]
                 nil)
                 result)
                 s (.replaceFirst s0 "\\s+$" "")
                 script)]
                 taps @tapset]
                 val (f input)]
                 white-space (.substring s0 (count s))
                 x (if (identical? ::tap-nil t) nil t)
                 ~@body)))))))
                "/"
                "Given a class name, return that typeref's class bytes as an InputStream."))
                (. gen (dup))
                (. gen (goTo end-label))
                (. gen (ifNull else-label))
                (. gen (invokeInterface dtype dm))
                (. gen (invokeInterface ifn-type (new Method "invoke" obj-type 
                (. gen (invokeStatic rt-type nth-method))
                (. gen (invokeVirtual dtype dm)))
                (. gen (mark else-label))
                (. gen (mark end-label))))
                (. gen (pop))
                (. gen (putField ctype state-name obj-type)))
                (. gen (unbox rtype))
                (. gen getField ctype (str f) ftype)))
                (. gen loadArgs)
                (. gen loadArgs)
                (. gen loadThis)
                (. gen loadThis)
                (. gen push (int 1))
                (. gen putField ctype (str f) ftype)))
                (. gen putStatic ctype (str f) ftype))
                (.add (JButton. "Back"))
                (.add (JButton. "Bar"))
                (.add (JButton. "Bean"))
                (.add (JButton. "Line"))
                (.add (JButton. "List"))
                (.add (JButton. "Next")))
                (.add (JButton. "Prev"))
                (.add (JButton. "Table"))
                (.addSeparator)
                (.addSeparator)
                (.checkCast gen ifn-type)
                (.clear a)
                (.col_write this s)
                (.replace (.getFile u) \/ File/separatorChar)))
                (.toString buffer)))))
                (.write w "...")
                (.write w sep)
                (.write writer (int mod-c))
                (.write writer cbuf off len))
                (:colon params) "(")
                (:colon params) ")")
                (> clause-count 1) (:string (:params (first (first clauses))))
                (> clause-count 2) (:string (:params (first (nth clauses 2))))
                ([ret k v]
                ([ret v]
                (apply require repl-requires)))
                (apply str "Unsupported option(s) supplied: "
                (assoc m k (f (get m k) v))
                (assoc m k v))))
                (chunk-append b x))))
                (clojure.lang.LineNumberingPushbackReader.))]
                (condp = (:relative-to token)
                (condp = (class x)
                (do
                (do
                (do
                (do-report {:type :fail, :message ~msg,
                (do-report {:type :pass, :message ~msg,
                (dosync 
                (dosync (ref-set last-was-whitespace? (Character/isWhitespace (char x))))))))))))
                (dotimes [i (count ptypes)]
                (else-gen gen m)
                (else-gen gen m)
                (emit-get-var gen mname)
                (format "%s%n" cause)))
                (gen-method meth 
                (if (< (.length b) width)
                (if (and drop? (pred input))
                (if (contains? mm (method-sig meth))
                (if (instance? clojure.lang.MapEquivalence m#) m# (into {} m#)))))
                (if (not (pos? nn))
                (if (pos? n)
                (if (reduced? ret)
                (if (reduced? ret)
                (if (zero? (rem i n))
                (if *print-radix* (or (get special-radix-markers *print-base*) (str "#" *print-base* "r")))
                (if symbol (str symbol " ") "")
                (if-not (contains? fmap (name sym))          
                (initialize args inits)
                (into1 (set (bases tag)) tp)
                (lazy-seq
                (lazy-seq
                (lazy-seq
                (lazy-seq
                (let [[k & ks] ks]
                (let [[mm considered]
                (let [[start end] (brackets arg)]
                (let [^java.lang.reflect.Method meth (first meths)
                (let [comp (clojure.lang.Util/compare (.nth this i) (.nth v i))]
                (let [round-up-result (inc-s result)
                (let [superclasses (set (supers tag))]
                (map? b) (pmap bvec b v)
                (new clojure.lang.MultiFn ~(name mm-name) ~dispatch-fn ~default ~hierarchy)))))))
                (next more)
                (ns-map ns))))
                (ns-map ns))))
                (ns-map ns))))
                (opt-base-str *print-base* (.denominator ^clojure.lang.Ratio n)))
                (opt-base-str *print-base* (.numerator ^clojure.lang.Ratio n))
                (or (apply distinct? keys)
                (partition c values)))))
                (print (apply str (repeat w (:overflowchar params))))
                (print (cond 
                (print (str
                (prn actual))))
                (recur (.find m)))
                (recur (assoc fmap (name sym) (cons `fn meths)) (next fs))
                (recur (conj via t) (.getCause t))
                (recur (isa? h (child i) (parent i)) (inc i))))))))
                (recur f
                (recur f (f val (first s)) (next s)))
                (recur xs)))))
                (reduce1 (fn [v spec]
                (reductions f (f init (first s)) (rest s))))))))
                (rf result input))))))))
                (rf result input))))))))
                (rf result v))
                (rf result v))))))))
                (rf sepr input)))
                (second clauses)
                (setf :buffer []))
                (setf :trailing-white-space white-space))
                (string? name) (clojure.lang.Keyword/find ^String name)))
                (string? name) (clojure.lang.Keyword/intern ^String name)))
                (symbol? b) (-> bvec (conj b) (conj v))
                (symbol? name) (clojure.lang.Keyword/find ^clojure.lang.Symbol name)
                (symbol? name) (clojure.lang.Keyword/intern ^clojure.lang.Symbol name)
                (thread
                (throw (IllegalArgumentException.
                (vector? b) (pvec bvec b v)
                (vswap! nv dec)
                (when (= (. rtype (getSort)) (. Type VOID))
                (when (pred v)
                (when is-overload
                (when is-overload
                (when s
                (when-let [s (seq coll)]
                (when-not as-static
                (with-out-str
                (with-out-str
                (with-out-str (stack/print-cause-trace actual t/*stack-trace-depth*))
                (write-tokens this (getf :buffer) true)
                (write-white-space this)
                *err* (PrintWriter-on #(out-fn {:tag :err :val %1}) nil)]
                *out* (PrintWriter-on #(out-fn {:tag :out :val %1}) nil)
                ---  ------------  -------
                0
                2 (+ 1 1)
                4 (* 2 2))
                :else (throw (new Exception (str "Unsupported binding form: " b))))))
                :expected '~form, :actual value#})
                :expected '~form, :actual value#}))
                ;;must figure out how to convey primitive hints to self calls first
                ;;todo - restore propagation of fn name
                @(:done-nl (:logical-block token))))
                [(conj i 'java.util.Map 'java.io.Serializable)
                [(rem % base) (quot % base)] 
                [mm considered]))
                [mm considered]))]
                [name doc-string? attr-map? ([params*] prepost-map? body)+ attr-map?])
                [nil nil]) 
                [params offsets] (unzip-map params)
                [result e1 false]))
                `(. clojure.lang.Numbers (~op ~x ~y))))
                `(extend-type ~t ~p ~@fs))
                `(getLookupThunk [this# k#]
                `(valAt [this# k# else#] 
                ancestors-to-visit (set/difference (set (mapcat :bases (vals reflections)))
                cause)))))
                cause-type
                coll (range (count coll)))
                else-label (. gen (newLabel))
                end-label (. gen (newLabel))]
                exposes-methods prefix load-impl-ns impl-ns post-init]} 
                forms)
                found-label (. gen (newLabel))
                full-str (add-english-scales parts-strs 0)]
                gen (new GeneratorAdapter (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_STATIC)) 
                gen (new GeneratorAdapter (+ (. Opcodes ACC_PUBLIC) (if as-static (. Opcodes ACC_STATIC) 0)) 
                gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
                gen (new GeneratorAdapter acc m nil nil cv)]
                gen (new GeneratorAdapter acc m nil nil cv)]
                head-str (add-english-scales parts-strs 1)
                is-overload (seq (overloads mname))
                loc
                loc
                m (new Method "<init>" (. Type VOID_TYPE) ptypes)
                m (new Method mname rtype ptypes)
                min  max           default
                name & args]
                o o]
                params (assoc params :base-args args)]
                pbr (proxy [PushbackReader] [rdr]
                pclasses (map the-class pclasses)
                pmetas (map meta pclasses)
                ptypes (to-types pclasses)
                rclass (the-class rclass)
                read-opts (if (.endsWith ^String filepath "cljc") {:read-cond :allow} {})]
                result
                result
                ret
                rtype ^Type (totype rclass)
                sep)
                sepr
                stderr (.getErrorStream proc)]
                symbol
                ta)))))
                tail-str (format-simple-ordinal (last parts))]
                tp)))))
                via))
               "Common Lisp HyperSpec"]]}
               "Common Lisp the Language"]
               "core$promise" "Promise"})
               #{} s))
               (-> e ex-data :clojure.error/phase))
               (.append sb ch (int start) (int length))
               (.equals (.nth this i) (nth o i)) (recur (inc i))
               (.flush w)))
               (.instanceMember Classname args*)
               (.visitEnd av))))))))
               (.write w "\n   :at ")
               (.write w "\n   :data ")
               (.write writer cbuf off len)))
               (:actual m))))
               (:expected m)
               (= (.nth this i) (nth o i)) (recur (inc i))
               (= i cnt) true
               (= i cnt) true
               (Classname/staticMethod args*)
               (VecNode. (.edit root) arr))))
               (VecNode. (.edit root) arr)))))
               (add-to-buffer this (make-buffer-blob s white-space))))
               (agent-error o)))
               (apply hash-map options))
               (as-env-strings (:env opts))
               (as-file (:dir opts)))
               (aset arr subidx new-child)
               (aset arr subidx nil)
               (assoc parentMap tag childsParents)
               (c-write-char this x)
               (c-write-char this x))))))))
               (catch Throwable e
               (cond
               (dissoc parentMap tag))
               (do
               (do 
               (dosync
               (dosync
               (empty? (:rest (:base-args params)))
               (empty? (:rest navigator)))
               (f1 ret k v)
               (f1 ret k v)
               (fn [m [h bucket]]
               (get (:impls protocol) atype))))
               (if (:at params) :mandatory :fill)
               (if (:at params) :miser :linear))]
               (if (= c (int \newline))
               (if (= mode :writing)
               (if (and method (zero? (alength (. method (getParameterTypes)))))
               (if (empty? s)
               (if (next body)
               (if s
               (if-not exprs
               (init-navigator [arg])
               (is (= 4 (* 2 2))))
               (lazy-seq
               (let [[[a b c :as clause] more]
               (let [^String s x
               (let [found (idx (rename-keys (select-keys x (keys k)) k))]
               (let [specs (if (vector? (first specs)) 
               (let [v (vec (.toArray a))]
               (let ~(vec (interleave bs gs))
               (list 'do
               (locking lock
               (map #(cons `fn (hint (drop 1 %))) fs))]))
               (merge {:type (symbol (.getName (class t)))}
               (next ks)
               (next vs))
               (or *print-dup*
               (pop-thread-bindings)))))
               (print-doc m))))
               (print-method (:at %) w))
               (print-method data w))
               (process-annotation av v)
               (push-chars)
               (recur (conj ret (first s)) (next s))
               (recur ret)))
               (reduce f1 ret (f k v))))))))
               (reduce1 (fn [m s]
               (reduced ret)))))))
               (seq ret)))))
               (set! *current* e)
               (set! *sb* (new StringBuilder)))
               (set! *stack* (conj *stack* *current*))
               (set! *state* :chars))
               (set! *state* :element))
               (str " " (nth english-scale-numbers (+ pos offset)))))
               (str "defrecord and deftype fields must be symbols, "
               (throw (ex-info "Conflicting data-reader mapping"
               (try
               (vary-meta name assoc :doc docstring)
               (vary-meta name merge metadata)
               (vector name (vec (map tag args)) (tag name) (map meta args)))
               (when-not (= n -1)
               (write-white-space this)))
               10
               :else false)))
               :else false)))
               @ret
               Classname/staticField]
               Integer
               Long
               String 
               ^"[Ljava.lang.String;" (into-array cmd)
               `(equals [this# ~gs] (clojure.lang.APersistentMap/mapEquals this# ~gs)))])
               `(hashCode [this#] (let [hash# ~'__hash]
               `(hasheq [this#] (let [hq# ~'__hasheq]
               amap))))
               arglist)))
               digits digits]
               exposer-m (new Method (str local-mname) rtype ptypes)
               gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) exposer-m nil nil cv)]
               kw (k w)]
               kw (k w)]
               name)
               name)
               pos (dec (count digits))
               remainder]]
               ret))))))
               rtype (totype (.getReturnType m))
               s1 s1)
               target-m (new Method (.getName m) rtype ptypes)
               unit-digit (rem tens 10)]
               unit-digit (rem tens 10)]
               { :mincol 0, :padchar 0, :commachar 0 :commainterval 0})
               { :mincol 0, :padchar \space, :commachar \, :commainterval 3, :colon true}
               {} buckets)
               ~@(map 
               ~@(map 
              #(if (< % 10) (char (+ (int \0) %)) (char (+ (int \a) (- % 10)))) 
              (#'clojure.pprint/end-block *out*)
              (#'clojure.pprint/start-block *out*
              (-> htmlpane .getDocument (.processHTMLFrameHyperlinkEvent e))
              (. clojure.lang.Compiler$HostExpr (emitBoxReturn nil gen (nth pclasses i))))
              (. clojure.lang.Compiler$HostExpr (emitUnboxArg nil gen (nth super-pclasses i))))
              (. gen (endMethod))))
              (. gen (endMethod))))]
              (. gen (invokeConstructor super-type super-m)))
              (. gen (invokeStatic rt-type nth-method))
              (. gen (loadArg i))
              (. gen (loadArgs))
              (. gen (loadThis))
              (. gen (loadThis))
              (. gen (returnValue))
              (. gen (returnValue))
              (. gen (visitCode))
              (. gen (visitCode))
              (. gen getStatic ctype (str f) ftype)
              (. gen loadLocal local)
              (. gen pop))
              (. gen push (int i))
              (.. s (subSequence lindex rindex) toString))))))))
              (.deref clojure.lang.Compiler/COLUMN)
              (.deref clojure.lang.Compiler/COLUMN)
              (.deref clojure.lang.Compiler/LINE)
              (.deref clojure.lang.Compiler/LINE)
              (.setAutoResizeMode JTable/AUTO_RESIZE_LAST_COLUMN)))
              (.setPage htmlpane (.getURL e)))))))
              (.visitEnd nav))
              (.write ^java.io.Writer *out* " ")
              (.write writer 
              (.write writer cbuf off len))
              (.write writer cbuf off len))
              (::halt result)
              (AssertionError.
              (add-annotations gen (nth pmetas i) i))
              (and max-count (>= count max-count)))
              (and max-count (>= count max-count)))
              (and max-count (>= count max-count)))
              (and max-count (>= count max-count)))
              (apply distinct? (map #(shift-mask s m %) hashes)))
              (apply merge-with into result {:ancestors ancestors-visited}
              (aset 0 root)
              (aset 1 (.newPath this (.edit root) shift tail-node)))
              (assoc node :content (and children (apply vector children))))
              (catch SocketException _disconnect))
              (chunk-append b (f (.nth c i))))
              (cond
              (cond
              (condp = (class x)
              (condp = (class x)
              (disj (parentMap tag) parent) #{})
              (do
              (do
              (do
              (do
              (do
              (dosync
              (dotimes [i (count ptypes)]
              (else-gen gen m)
              (f1 ret k v)
              (f1 ret k v))))))))
              (finally 
              (fn [o w]
              (if (-> dest .getDeclaringClass .isInterface)
              (if (= i cnt)
              (if (= prior input)
              (if (> (count pclasses) 18)
              (if (>= (int round-char) (int \5))
              (if (and (or (> full-len w) (and e (> (- exp-width 2) e)))
              (if (and (pos? ten-digit) (pos? unit-digit)) "-")
              (if (chunked-seq? s)
              (if (class? tag)
              (if (class? tag)
              (if (contains? m k)
              (if (instance? Throwable actual)
              (if (nil? v)
              (if (or (not ret) (= i (count parent)))
              (if (pos? ten-digit) (nth english-cardinal-tens ten-digit))
              (if (pos? unit-digit) (nth english-ordinal-units unit-digit))))))
              (if (re-find ~re m#)
              (if (reduced? sepr)
              (if (sequential? arg)
              (if (zero? print-length)
              (if add-sign sign) 
              (if append-zero "0"))))
              (if c
              (if meths
              (if prepend-zero "0")
              (if spec
              (if symbol (str symbol " ") "")
              (if symbol (str symbol " ") "")
              (if symbol (str symbol " ") "")
              (if symbol (str symbol " ") "")
              (if t
              (let [[sym & meths] (first fs)
              (let [conn (.accept socket)
              (let [drop? @dv]
              (let [i (vswap! iv inc)]
              (let [low-two-digits (rem arg 100)
              (let [mod-c (if @last-was-whitespace? (Character/toUpperCase (char x)) c)]
              (let [n @nv
              (let [n @nv]
              (let [v (.nth c i)]
              (let [v (vec (.toArray a))]
              (list form x))]
              (load-one lib need-ns require)
              (map f (rest s1) (rest s2) (rest s3)))))))
              (map f (rest s1) (rest s2)))))))
              (map test-f tests)
              (neg? tilde) [(compile-raw-string s offset) ["" (+ offset (.length s))]]
              (not (zero? (bit-and flags (:flag fd)))))
              (pprint-newline :miser)
              (pr object)))
              (pr-str expected)
              (print-one x w)
              (prn value))
              (process-annotation nav nv)
              (read read-opts (PushbackReader. pbr)))
              (recur (if (= 0 digit) 
              (recur (inc lindex))
              (recur (merge reflections (make-ancestor-map ancestors-to-visit)))
              (recur (next me) (next you)))))
              (recur (rightmost child))
              (recur new-ns entries (assoc lm (strip-ns k) v)))))
              (recur ns entries (assoc lm (strip-ns k) v)))
              (recur)))
              (recur)))))))
              (recur)))))))
              (recur)))))))
              (reduce1 (fn [ret k]
              (reduced result))))))
              (reduced ret)
              (reduced {::halt (if retf (retf (rf result) input) input)})
              (remainders base val))))))
              (remove-ns lib))
              (rf result input)
              (rf result input)))))))
              (rf result input))))))))
              (rf result v)))))))
              (rf result)))
              (rf result)))
              (set-field this :cur 0)
              (set-field this :line (inc (get-field this :line))))
              (some needs-pretty (first (:clauses (:params (first format)))))
              (some needs-pretty (first (:else (:params (first format))))))
              (str "Flag \"" (first s) "\" appears more than once in a directive")
              (str "java.lang." strx))))))
              (str atype " already directly implements " (:on-interface proto) " for protocol:"  
              (str proto " is not a protocol"))))
              (throw (IllegalStateException. "Unable to read source while *read-eval* is :unknown."))
              (throw (new java.lang.IllegalAccessError
              (transient [])
              (vreset! pv input)
              (vreset! started true)
              (when (pos? (.length s))
              (when xs
              (when-let [s (seq coll)]
              (when-not (nil? x)
              (with-meta `(~(first form) ~@(next form)  ~x) (meta form))
              (write-out (second alis))))
              (write-out object))
              (zero? tilde)  (compile-directive (subs s 1) (inc offset))
              *current* (struct element)
              *err* err
              *file*
              *file*
              *out* out
              *sb* nil]
              *session* {:server name :client client-id}]
              *state* :between
              :flags (parse-flags (.getModifiers cls) :class)
              :members (set/union (declared-fields cls)
              :when (and (:doc m)
              @*loaded-libs*))))
              BorderLayout/NORTH)
              BufferedInputStream BufferedOutputStream
              BufferedReader File OutputStream
              CharArrayReader Closeable)
              FileInputStream FileOutputStream ByteArrayOutputStream
              OutputStreamWriter BufferedWriter Writer
              StringReader ByteArrayInputStream
              When not supplied, only the default-data-readers will be used.
              ["http://www.lispworks.com/documentation/HyperSpec/Body/22_c.htm"
              [(compile-raw-string (subs s 0 tilde) offset) [(subs s tilde) (+ tilde offset)]]))))
              [attr-map stuff] (if (map? (first stuff))
              [doc-str stuff] (if (string? (first stuff))
              [params offsets] (unzip-map params)
              [shift mask]))))
              ] 
              ^java.lang.reflect.Method meth bridges]
              `(. clojure.lang.Numbers (~op ~x))))
              b (chunk-buffer size)]
              b (chunk-buffer size)]
              b (chunk-buffer size)]
              base-writer (condp = optval
              bfs (reduce1 (fn [ret [b v g]]
              bs (take-nth 2 bindings)
              caught      repl-caught}}
              cause)
              cause)
              cause)
              cause-type
              cause-type
              cause-type
              client-daemon true}} opts
              coll)
              e (char-escape-string c)]
              err-line (or (:line caller) line)]
              eval        eval
              exception)))))
              fdecl (if (map? (first fdecl))
              fdecl (if (map? (last fdecl))
              fdecl (if (string? (first fdecl))
              fdecl (if (vector? (first fdecl))
              file (first (remove #(or (nil? %) (#{"NO_SOURCE_FILE" "NO_SOURCE_PATH"} %)) [(:file caller) file]))
              fixed-repr
              flush       flush
              fmap)))
              fv (f fst)
              gs (map (fn [b] (if (symbol? b) b (gensym))) bs)
              impls))))
              iter-result (execute-sub-format clause (init-navigator sublist) navigator)]
              loc
              loc
              loc
              loc
              loc))
              long-section (not (tokens-fit? this result))
              m (conj (if (meta name) (meta name) {}) m)]
              m (conj {:arglists (list 'quote (sigs fdecl))} m)
              m (if (map? (first fdecl))
              m (if (map? (last fdecl))
              m (let [inline (:inline m)
              message
              mm (mapcat #(.getMethods ^Class %) interfaces))
              need-prompt (if (instance? LineNumberingPushbackReader *in*)
              offset)
              out (-> output FileOutputStream. .getChannel)]
              params (assoc params :base-args base-args)]
              pos (+ pos bytes-xferred)]
              print       prn
              prompt      repl-prompt
              read        repl-read
              result
              result (if do-nl 
              result (if long-section
              result))))))
              ret)))))))
              rfld (first (filter #(= f (.getName ^java.lang.reflect.Field %)) dflds))]
              run (cons fst (take-while #(= fv (f %)) (next s)))]
              server-daemon true
              size (count c)
              size (count c)
              size (int (count c))
              strx
              subidx (bit-and (bit-shift-right i level) (int 0x1f))]
              table (reduce1 (fn [^objects t [c e]]
              thens))))
              true 
              w))
              ~@body
             #{} s))))
             (+ (:offset token)
             (. x (withMeta m))))
             (.flush ^Writer this)))))
             (.flush wrapped-stream))))
             (.ppflush ^PrettyFlush this)
             (.write w "}"))]
             (:actual m))))
             (:expected m)
             (:func this) (:def this) 
             (:offset this))
             (System/exit 1)))))
             ([x]
             (add-to-buffer this (make-buffer-blob l nil oldpos newpos))
             (assoc m k v-var)))
             (assoc! counts x (inc (get counts x 0))))
             (binding [*out* out, *flush-on-newline* true, *print-readably* true]
             (caught e)
             (cond
             (condp = (class x)
             (conj m 
             (conj m `(meta [this#] ~'__meta)
             (conj ret entry)
             (cons p (partition n step (nthrest s step))))))))
             (cons p (partition n step pad (nthrest s step)))
             (do-report {:type :error, :message "Uncaught exception, not in assertion."
             (doseq [tap taps]
             (drop-while seq? (next s)))
             (each-fixture-fn (fn [] (test-var v))))))))))
             (emit-forwarding-method (.getName meth) (.getParameterTypes meth) (.getReturnType meth) false
             (f1 ret (f k v)))))))
             (fn
             (fn [a b] `(. clojure.lang.Numbers (~op ~a ~b)))
             (fn [s]
             (fn ~gthis
             (format-error 
             (format-error (str "Parameter " (name (first %2))
             (if (= (getf :mode) :buffering)
             (if (= (getf :mode) :writing)
             (if (= mode :writing)
             (if (and (not (empty? this)) (not (empty? acc))) ", ")
             (if (and (not (empty? this)) (pos? (+ pos offset)))
             (if (map? (first body))
             (if (next s)
             (if (or (identical? pval ::none)
             (if (pred k v)
             (if (pred k v)
             (if (reduced? ret)
             (inc count) iter-result (:pos navigator))))))))
             (java.sql Connection Statement)))"
             (lazy-seq
             (let [^StringBuilder sb *sb*]
             (let [^Writer w (getf :base)]
             (let [^Writer writer (get-field this :base)] 
             (let [arr (aclone ^objects (.arr node))]
             (let [attrs (fn [ret i]
             (let [av (if i
             (let [n (.read in-reader buf)]
             (let [name (. pd (getName))
             (let [prefix (loop [p (list name) args args]
             (let [pvec
             (let [s (seq coll)]
             (list (take n (concat p pad)))))))))
             (loop* ~(vec (interleave gs gs))
             (map 
             (map #(cons `fn (drop 1 %)) fs))])
             (merge (:params this) (tuple-map subex (:offset this)))
             (new ~classname
             (not (:macro (meta v))))))
             (not-empty (get (:descendants h) tag)))))
             (not= (.source ^clojure.lang.Compiler$CompilerException cause) "NO_SOURCE_FILE"))
             (not= (.source ^clojure.lang.Compiler$CompilerException cause) "NO_SOURCE_FILE"))
             (nth english-ordinal-tens ten-digit)
             (or (#{request-prompt request-exit} input)
             (par coll) 
             (partition 2 ops))))
             (push-chars)
             (push-thread-bindings {#'clojure.pprint/*current-level*
             (recur ret)))
             (recur sentinel m (next ks))))
             (recur v kv (next more))))
             (recur v kv (next more))))
             (recur w kw (next more))
             (recur w kw (next more))
             (recur))
             (report-error t :target (get flags "report" (System/getProperty "clojure.main.report" "file")))
             (rf result input)
             (rf result)))
             (seq (.. java.beans.Introspector
             (set! *current* (push-content (peek *stack*) *current*))
             (set! *e e))))]
             (set! *stack* (pop *stack*))
             (set! *state* :between)
             (setf :pos newpos)
             (str
             (throw (clojure.lang.ArityException. (+ ~arg-count (count ~'overage)) (name '~fn-name))))
             (throw (ex-info (str "Invalid form in data-reader file")
             (throw (java.lang.UnsupportedOperationException. "Can't get descendants of classes"))
             (try  
             (vreset! pv val)
             (when (and (contains? mappings k)
             (when-let [at (:at %)]
             (when-let [data (:data %)]
             (when-not (= *state* :chars)
             (write-buffered-output this))
             (write-to-base l)))
             (write-to-base prefix)))
             (write-white-space this)
             *1 nil
             *2 nil
             *3 nil
             *assert* *assert*
             *command-line-args* *command-line-args*
             *compile-path* (System/getProperty "clojure.compile.path" "classes")
             *data-readers* *data-readers*
             *default-data-reader-fn* *default-data-reader-fn*
             *depth* 1]
             *e nil]
             *math-context* *math-context*
             *print-length* *print-length*
             *print-level* *print-level*
             *print-meta* *print-meta*
             *print-namespace-maps* true
             *unchecked-math* *unchecked-math*
             *var-context* (list)
             *warn-on-reflection* *warn-on-reflection*
             :at - top stack element
             :data - ex-data
             :message - exception message
             :type - exception class symbol
             @ret
             Defaults to false.
             Defaults to false.
             [:up-arrow navigator]
             [subargs navigator] (next-arg navigator)
             [true [(subs s 1) (inc offset) (assoc flags flag [true offset])]])
             ^String l (first lines)] 
             ^clojure.lang.AFunction f#
             `(. clojure.lang.Numbers (~op ~x ~y)) more))))))
             be called with the tag and the value."
             before reading again
             cause (.getCause e)]
             clojure.spec.alpha/*explain-out* clojure.spec.alpha/*explain-out*
             fmt-row (fn [leader divider trailer row]
             fmts (map #(str "%" % "s") widths)
             namespace in which the record was defined to be loaded.
             namespace in which the type was defined to be loaded.
             navigator))))
             newpos (+ oldpos (if prefix (count prefix) 0))]
             newpos (+ oldpos (if suffix (count suffix) 0))]
             nil
             nil)
             nil)
             nil)
             not-found
             remainder (next remainder)]
             result
             result (loop [result result
             result)))))
             ret)
             s)))))
             spacers (map #(apply str (repeat % "-")) widths)
             sub-navigator (init-navigator subargs)]
             t2 (fjtask (fc v2))]
             this
             val))))
             {:bases (not-empty (set (map typesym (bases cls))))
             {}
             ~@(map #(list 'quote %) args)))
             ~@(mapcat (partial emit-hinted-impl c) impls))))
            "Found lib name '%s' containing period with prefix '%s'.  lib names inside prefix lists must not contain periods"
            "getDesktop" (to-array nil))
            "namespace '%s' not found after loading '%s'"
            (#{"NO_SOURCE_FILE" "NO_SOURCE_PATH"} source) (dissoc :clojure.error/source :clojure.error/path)
            ((formatter-out " "))
            (+ (:pass m) (:fail m) (:error m)) "assertions.")
            (. *ns* (refer (or (rename sym) sym) v)))))))
            (. ^Class parent isAssignableFrom child))
            (. ^DynamicClassLoader (deref clojure.lang.Compiler/LOADER) (defineClass pname bytecode [super interfaces]))))))
            (. clojure.lang.Compiler$HostExpr (emitBoxReturn nil gen (nth pclasses i))))
            (. gen (dup))
            (. gen (endMethod))))
            (. gen (endMethod))))
            (. gen (endMethod)))))
            (. gen (endMethod))))))
            (. gen (endMethod))))))
            (. gen (invokeConstructor ctype m))            
            (. gen (invokeConstructor super-type m))
            (. gen (invokeConstructor super-type super-m))
            (. gen (invokeInterface ifn-type (new Method "invoke" obj-type 
            (. gen (invokeStatic rt-type nth-method))
            (. gen (loadArg i))
            (. gen (loadArgs))
            (. gen (loadArgs))
            (. gen (loadThis))
            (. gen (loadThis))
            (. gen (returnValue))
            (. gen (returnValue))
            (. gen (returnValue))
            (. gen (returnValue))
            (. gen (returnValue))
            (. gen (throwException ex-type (str impl-pkg-name "/" prefix init-name " not defined")))
            (. gen (visitCode))
            (. gen (visitCode))
            (. gen (visitCode))
            (. gen (visitCode))
            (. gen (visitCode))
            (. gen dup)
            (. gen dup)
            (. gen dup)
            (. gen dupX1)
            (. gen goTo end-label)
            (. gen ifNull no-init-label)
            (. gen mark end-label))
            (. gen mark no-init-label)
            (. gen newInstance ctype)
            (. gen push (int 0))
            (. gen storeLocal local)
            (.add a input)
            (.arr node)
            (.checkCast gen ifn-type)
            (.close rd))))))
            (.toString ^java.io.StringWriter base-writer)))))))
            (.write ^java.io.Writer *out* " ")
            (.write ^java.io.Writer *out* " ")
            (.write ^java.io.Writer *out* " ")
            (.write ^java.io.Writer *out* " ")
            (.write ^java.io.Writer *out* ", ")
            (.write out buffer 0 size)
            (.write w "#=")
            (.write w (.getName c)))))
            (< base-char 32) (str "Control-" (char (+ base-char 64)))
            (= (count parent) (count child))
            (= base-char 127) "Control-?"
            ([ret k v]
            (aclone [_ ~garr] (aclone ~tgarr))
            (add-annotations gen (meta name))
            (aget [_ ~garr i#] (aget ~tgarr i#))
            (alength [_ ~garr] (alength ~tgarr))
            (alter-var-root #'servers dissoc name)))))
            (and source method) (assoc :clojure.error/symbol (java-loc->source source method))
            (apply load-lib prefix (prependss arg opts))))))))
            (apply str (repeat (- w full-len) (:padchar params)))
            (array [_ size#] (~(symbol (str t "-array")) size#))
            (aset [_ ~garr i# val#] (aset ~tgarr i# (~t val#))))))
            (assoc ret :name (-> c .getName symbol) :members (->> members (group-by :name) sortmap)))))
            (binding [*loaded-libs* (ref (sorted-set))]
            (binding [*out* base-writer]
            (chunk-cons (chunk-first s) (concat (chunk-rest s) y))
            (cl-format true \"~4D~7,vT\" col column-width))
            (clojure.core.protocols/coll-reduce (flatten v) f1 ret)
            (comp seq :content)
            (cond (= "-" offset-sign) -1
            (cons 'clojure.core/cond (next (next clauses))))))
            (cons (first s) (concat (rest s) y)))
            (cons f (filter pred r))
            (cons x (keep f (rest s))))))))))
            (consume
            (do
            (do
            (do (.appendReplacement m buffer (Matcher/quoteReplacement (f (re-groups m))))
            (do (.appendTail m buffer)
            (do (vswap! seen conj input)
            (do-report {:type :pass, :message ~msg,
            (dotimes [i (count pclasses)]
            (dotimes [i (count pmetas)]
            (dotimes [i (count super-pclasses)]
            (doto (JTable. (list-model (list-provider x)))
            (doto ^objects (.arr new-root)
            (drop-while #(= class-name (.getClassName ^StackTraceElement %1)) tr)))))))
            (emit-get-var gen init-name)
            (f1 ret v)))))))
            (filter pred r))))))))
            (find-protocol-method (.protocol cache) (.methodk cache) x))]
            (fn [node children]
            (fn [node children] (with-meta (vec children) (meta node)))
            (fn [node children] (with-meta children (meta node)))
            (for [mask (map #(dec (bit-shift-left 1 %)) (range 1 (inc max-mask-bits)))
            (if (= :unknown *read-eval*)
            (if (= n (.size a))
            (if (> (count pclasses) 18)
            (if (Character/isWhitespace (.charAt s lindex))
            (if (and (:colon params) add-sign) (if (neg? arg) \- \+))
            (if (and (map? result) (contains? result ::halt))
            (if (and (not (:colon params)) add-sign) (if (neg? arg) \- \+))
            (if (and (pos? ten-digit) (pos? unit-digit)) "-")
            (if (instance? javax.swing.text.html.HTMLFrameHyperlinkEvent e)
            (if (neg? @cnt)
            (if (neg? @cnt)
            (if (next clauses)
            (if (nil? v)
            (if (pos? ten-digit) (nth english-cardinal-tens ten-digit))
            (if (pos? unit-digit) (nth english-cardinal-units unit-digit)))))))))
            (if (pred input)
            (if (pred input)
            (if (seq ancestors-to-visit)
            (if (some #{\. \[} strx)
            (if fs
            (if s
            (if state
            (if static?
            (if static?
            (if-let [child (and (branch? loc) (down loc))]
            (if-not days     1 (parse-int days))
            (if-not fraction 0 (parse-int (zero-fill-right fraction 9)))
            (if-not hours    0 (parse-int hours))
            (if-not minutes  0 (parse-int minutes))
            (if-not months   1 (parse-int months))
            (if-not offset-hours   0 (parse-int offset-hours))
            (if-not offset-minutes 0 (parse-int offset-minutes)))
            (if-not seconds  0 (parse-int seconds))
            (keep f (rest s))
            (keyword? (second x))))))
            (let [^String s0 (write-initial-lines this x)
            (let [arg (first args)]
            (let [c (char x)]
            (let [digit (first digits)]
            (let [i (vswap! iv inc)
            (let [k (key e) v (val e)]
            (let [len (+ (count full-mantissa) exp-width)
            (let [m# (.getMessage e#)]
            (let [pclasses (. meth (getParameterTypes))
            (let [pclasses (. meth (getParameterTypes))
            (let [prior @pv]
            (let [read-eval *read-eval*
            (let [result (if (.isEmpty a)
            (let [round-char (nth m1 round-pos)
            (let [s ^String x]
            (let [sepr (rf result sep)]
            (let [ta (get (:ancestors h) tag)]
            (let [tp (get (:parents h) tag)]
            (let [x (f (.nth c i))]
            (list* `gen-class :name (.replace (str name) \- \_) :impl-ns name :main true (next gen-class-clause)))
            (loop [[x & xs] xs
            (loop [[x & xs] xs]
            (loop [i (int 0)]
            (loop [i (int 0)]
            (loop [i (int 0)]
            (loop [mm mm
            (loop [mm {} considered #{} c super]
            (loop [ret true i 0]
            (map vector
            (meta n)))
            (meta name))]
            (name lib) prefix)
            (new Vec am (inc cnt) (+ shift (int 5)) new-root (let [tl (.array am 1)] (.aset am  tl 0 val) tl) (meta this)))
            (nil? (second x))
            (or fn (and source method)) (assoc :clojure.error/symbol (or fn (java-loc->source source method)))
            (p-write-char this x)
            (p-write-char this x)))
            (parse-int years)
            (pos? (count args))
            (pprint-newline :linear)
            (pprint-newline :linear)
            (pprint-newline :linear)
            (pprint-newline :linear)
            (pprint-newline :miser)
            (pprint-newline :miser)
            (print (apply str acc))
            (print (str
            (print (str (if (neg? arg) "minus ") 
            (print (str (if (neg? arg) "minus ") full-str)))
            (printf " %s '%s" (key opt) (print-str (val opt))))
            (prn (:actual data)))))))))
            (process-clause bracket-info offset remainder)]
            (recur 
            (recur (. sb  (append (str (first more)))) (next more))
            (recur (aget ^objects (.arr node) (bit-and (bit-shift-right i level) (int 0x1f))) 
            (recur (conj ret (. m (group c))) (inc c))
            (recur (inc client-counter))))
            (recur (inc count) (next arg-list))))))))
            (recur (inc count) iter-result (:pos args))))))))
            (recur (inc count) navigator)))))))
            (recur (next (rest alis)))))))
            (recur (next args))))))
            (recur (next aseq))))))))
            (recur (next params) (conj new-params gparam)
            (recur (with-read-known (read reader false eof))))))))
            (recur pos)))))))
            (recur references)))))
            (recur ret (inc i))))
            (recur))
            (reduce1
            (resolve sym)))
            (second iter-result)
            (set! *current-length* 0) ; always print both parts of the [k v] pair
            (stack/print-cause-trace (:actual data) t/*stack-trace-depth*)
            (str "Bad argument: " arg ". It must be one of " choices)))))
            (str (Character/toUpperCase f) (subs s 1))
            (str sb)))
            (str text)))))))
            (swap! cnt dec)
            (swap! cnt dec)
            (throw (IllegalArgumentException. (str "No implementation of method: " (.methodk cache) 
            (throw (new Exception ":init not specified, but ctor and super ctor args differ"))))
            (throw e)))
            (try
            (try (identical? (read-eval-print) request-exit)
            (try (loop []
            (when (= ns (namespace k))
            (when (next alis)
            (when (try
            (when undefined-on-entry
            (when-let [new-ns (namespace k)]
            (when-not (nil? value)
            (when-not v
            (with-pretty-writer base-writer
            (write-out (ffirst aseq))
            (write-out (first alis))
            (write-out (fnext (first aseq))))
            (write-out (second alis))))
            (write-out (second binding))))
            (zero? (mod (count args) (count argv)))))
            :else (char base-char)))
            :trace (vec (map StackTraceElement->vec
            ; compact case ints, with shift-mask
            ; sparse case ints, no shift-mask
            ;; TODO clean up choices string
            @*remote-javadocs*)
            Integer
            Integer
            Long
            Prevents console apps from becoming GUI unnecessarily."}
            String 
            String 
            [(conj i 'clojure.lang.IObj)
            [(conj i 'clojure.lang.IPersistentMap)
            [0 0 (case-map hashcode identity tests thens) :sparse]
            [c & cnext :as cs] (children loc)]
            [clojure.edn :as edn]
            [clojure.main :as m])
            [clojure.stacktrace :as stack]
            [clojure.stacktrace :as stack]))
            [clojure.string :as str])
            [clojure.string :as str]))
            [clojure.test :as t]))
            [cname bytecode] (generate-class options-map)]
            [iter-result result-str] (binding [*out* (java.io.StringWriter.)]
            [m e false]))
            [nil (apply (:func element) [params args offsets])])))
            [opts sigs]))
            [rounded-mantissa _ incr-exp] (round-str 
            [shift mask (case-map #(shift-mask shift mask (hashcode %)) identity tests thens) :compact])))
            [shift mask case-map switch-type] (prep-hashes expr-sym default tests thens)
            [true [(merge-with concat clause-map { :clauses [clause] })
            [true [(merge-with concat clause-map { :else [clause] :else-params else-params})
            ^Integer scaled-exp (- exp (dec k))
            ^String signed-str (cond
            _ (add-annotations gen constructor-annotations)
            `((clojure.core/refer '~'clojure.core)))
            `(let [~ge ~e] (case* ~ge ~shift ~mask ~default ~imap ~switch-type :hash-equiv ~skip-check)))
            `(let [~ge ~e] (case* ~ge ~shift ~mask ~default ~imap ~switch-type :hash-identity ~skip-check))))))))
            `(let [~ge ~e] (case* ~ge ~shift ~mask ~default ~imap ~switch-type :int)))
            acc (+ Opcodes/ACC_PUBLIC (if static? Opcodes/ACC_STATIC 0))]
            add-sign (or (:at params) (neg? arg))
            append-zero (and (= k (count rounded-mantissa)) (nil? d))]
            append-zero (and append-zero (not (>= signed-len w)))
            assoc-test (fn assoc-test [m test expr]
            base-mantissa-width (count mantissa)
            bracket (:bracket-info (:def this))]
            cd-path (str (.getAbsolutePath (java.io.File. "")) "/")]
            d (:d params)
            e (:e params)
            e#))))
            e#))))
            end-label (. gen newLabel)
            end-label (. gen newLabel)]
            end-post-init-label (. gen newLabel)
            err (future (stream-to-string stderr))
            err-line (assoc :clojure.error/line err-line)
            exit-code (.waitFor proc)]
            exp-width (count scaled-exp-str)
            expchar (or (:exponentchar params) \E)
            file (assoc :clojure.error/source file)
            file (assoc :clojure.error/source file)
            ftype (totype (.getType fld))
            full-len (if (or prepend-zero append-zero)
            full-mantissa (insert-scaled-decimal rounded-mantissa k)
            full-repr))
            gen (new GeneratorAdapter (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_STATIC)) 
            gen (new GeneratorAdapter (. Opcodes ACC_PRIVATE) m nil nil cv)]
            gen (new GeneratorAdapter (. Opcodes ACC_PRIVATE) m nil nil cv)]
            gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)
            group-str (if (:colon params)
            identity
            interf
            k (:k params)
            keyword? (recur (assoc opts (first sigs) (second sigs)) (nnext sigs))
            ks (seq ks)]
            lib (root-resource lib))
            line (assoc :clojure.error/line line)
            local (. gen newLocal obj-type)]
            m (new Method "<init>" (. Type VOID_TYPE) ptypes)
            m m
            message (assoc :clojure.error/cause message)
            message (assoc :clojure.error/cause message)))
            message (assoc :clojure.error/cause message)))
            mode (cond
            more (next coll)
            navigator
            navigator
            navigator
            navigator (init-navigator args)]
            navigator (init-navigator args)]
            new-mappings (read read-opts rdr)]
            new-offset (+ offset (.end m))]
            new-root ^clojure.core.VecNode (.popTail this shift root)]
            newl (first b)]
            newpos (inc oldpos)]
            no-init-label (. gen newLabel)
            no-main-label (. gen newLabel)
            no-post-init-label (. gen newLabel)
            nth-method (. Method (getMethod "Object nth(Object,int)"))
            p# (new ~(symbol pname) ~@args)] ;(construct-proxy pc# ~@args)]   
            padded-str (if (< (.length signed-str) (:mincol params))
            pairs (reduce1
            parts (remainders 1000 abs-arg)]
            parts (remainders 1000 abs-arg)]
            pclasses (map the-class pclasses)
            pos-arg (if neg (- arg) arg)
            prepend-zero (<= k 0)
            prepend-zero (and prepend-zero (not (>= signed-len w)))
            problems (assoc :clojure.error/spec data))))
            ptypes (to-types pclasses)
            r (ClassReader. is)
            raw-str (opt-base-str base pos-arg)
            remainder (next remainder)
            remainder (subs s (.end m))
            rep (Matcher/quoteReplacement (f (re-groups m)))]
            result
            result (atom {:bases #{} :flags #{} :members #{}})]
            ret
            ret)))))
            root))
            root))
            root))
            s)]
            scaled-exp-str (str (Math/abs scaled-exp))
            scaled-exp-str (str expchar (if (neg? scaled-exp) \- \+) 
            scaled-mantissa (str (apply str (repeat (- k) \0))
            sep (str separator)]
            seq
            signed-len (if add-sign (inc len) len)
            skip-check (if (zero? mask)
            source (assoc :clojure.error/source (file-name source)
            special special
            static? (Modifier/isStatic (.getModifiers fld))
            string? (recur (assoc opts :doc (first sigs)) (next sigs))
            super-m (new Method "<init>" (. Type VOID_TYPE) super-ptypes)
            super-pclasses (map the-class super-pclasses)
            super-ptypes (to-types super-pclasses)
            tests (keys pairs)
            thens (vals pairs)
            threaded (if (seq? form)
            threaded (if (seq? form)
            timeout-val))))
            type (assoc :clojure.error/class type)
            val val]
            vcnt (.count v)]
            w-mantissa (if w (- w exp-width))
            xset xset))
            you (seq o)]
            ~@body))))))
            ~then)
            ~then))))))
           "The else clause (\"~:;\") is only allowed in the first position for this directive." 
           ((main-dispatch opt) args inits)
           (. gen (endMethod)))))
           (. gen (loadArgs))
           (. gen (loadThis))
           (. gen (returnValue))
           (. gen (visitMethodInsn (. Opcodes INVOKESPECIAL) 
           (.aset am new-tail (bit-and i (int 0x1f)) val)
           (.deref ^clojure.lang.IDeref ref)
           (.flush writer))
           (.nth this i)
           (.toLowerCase (subs s 1))))))
           (.write ^Writer this (subs (str x) off (+ off len)))))
           (.write ^java.io.Writer *out* " ")
           (.write ^java.io.Writer *out* "#")
           (IllegalArgumentException.
           (System/arraycopy tail 0 new-tail 0 (.alength am tail))
           ([] (rf))
           ([] (rf))
           ([] (rf))
           ([] (rf))
           ([result input]
           ([result input]
           ([result input]
           ([result input]
           ([result] (rf result))
           ([result] (rf result))
           ([result] (rf result))
           ([result] (rf result))
           ([x]
           ([x]
           (and (not (= (:type token) :fill))
           (aset ~ret ~idx ~expr)
           (catch Throwable e
           (catch Throwable e
           (catch Throwable t
           (characters [^chars ch start length]
           (clojure.lang Compiler Compiler$CompilerException
           (clojure.lang RT Reflector)))
           (clojure.lang.RT/classForName 
           (clojure.lang.RT/conj coll x)))))
           (conj acc (str this " " (nth english-scale-numbers (+ pos offset)))))
           (contains? core-namespaces (second (re-find #"^([^$]+)\$" class-name))))))
           (core/remove #{k} %))
           (dec extra-pad)
           (dec slots)
           (def ~mm-name
           (demunge (.getClassName el))
           (demunge (.getClassName el))
           (deref-future ref)))
           (divisible? year 400))))
           (do
           (do 
           (do (is (= 2 (+ 1 1)))
           (endDocument [])
           (endElement [uri local-name q-name]
           (endPrefixMapping [prefix])
           (fail (str "Unrecognized date/time syntax: " cs))))
           (finally
           (first
           (flush))
           (fn [m]
           (if (<= kw kv)
           (if (= n (count p))
           (if (>= kw kv)
           (if (and (nil? new-child) (zero? subidx))
           (if (and (pos? ten-digit) (not (pos? unit-digit)))
           (if (apply write arg bindings)
           (if (contains? flags flag)
           (if (identical? sentinel m)
           (if (not (or (nil? val) (contains? special-params val) 
           (if (pred input)
           (if (reduced? ret)
           (if entry
           (if pad-only strs (next strs))
           (if prefix
           (if-not (identical? real-stream wrapped-stream)
           (ignorableWhitespace [ch start length])
           (init-navigator [arg])
           (init-navigator [arg])
           (java.nio.charset Charset)))
           (java.nio.file Files)
           (java.nio.file.attribute FileAttribute)
           (javax.xml.parsers SAXParser SAXParserFactory)))
           (let [arglist (first fdecl)
           (let [c ^Character x]
           (let [cls (typeref->class typeref classloader)]
           (let [oldpos (getf :pos)
           (let [pval @pv
           (let [result (if (.isEmpty a)
           (let [ret (f ret (.next iter))]
           (let [s0 (write-initial-lines this x)
           (let [tilde (.indexOf s (int \~))]
           (let [v-var (data-reader-var v)]
           (loop [ret [] s s]
           (map #(clojure.lang.RT/iter %) (cons coll colls))))
           (neg? x)))
           (new Vec am (dec cnt) (- shift 5) (aget ^objects (.arr new-root) 0) new-tail (meta this))
           (new Vec am (dec cnt) shift EMPTY-NODE new-tail (meta this))
           (new Vec am (dec cnt) shift new-root new-tail (meta this))))))
           (new Vec am cnt shift root new-tail (meta this)))
           (new-instant
           (next keys)))
           (not (neg? x))))
           (or
           (or (right (up p)) (recur (up p)))
           (pop-thread-bindings))))))
           (pos? x)))
           (pprint-newline :linear)
           (println "Caused by:")
           (println (fmt-row "| " " | " " |" row))))))
           (println (str \tab (stack-element-str el))))
           (processingInstruction [target data])
           (prompt)
           (pst cause (min depth
           (recur (:parent lb)))))))
           (recur (chunk-next s)
           (recur (clojure.lang.RT/conj coll x) (first xs) (next xs))
           (recur (conj ret (resolve-tag (asig (first fdecls)))) (next fdecls))
           (recur (conj s x) etc))
           (recur (next (rest alis)))))))))
           (recur (unchecked-inc ~i)))))))
           (recur (unchecked-inc ~i)))))))
           (recur (unchecked-inc ~idx)))
           (recur result (bit-and 0xffe0 (+ aidx 32)))))
           (reduce1 merge-entry (or m1 {}) (seq m2)))]
           (ref-set (:indent lb) col)))
           (ref-set (:intra-block-nl lb) true)
           (ref-set (:start-col lb) col)
           (remove-tap tapfn)))))))
           (replace \- \_)
           (replace \. \/))))
           (rest st)
           (rf result (apply f input inputs))))))
           (rf result (f input)))
           (send agent count-down))
           (seq ret)))
           (setDocumentLocator [locator])
           (skippedEntity [name])
           (startDocument [])
           (startElement [uri local-name q-name ^Attributes atts]
           (startPrefixMapping [prefix uri])
           (str
           (str (.getClassName el) "." (.getMethodName el)))
           (str (.getClassName el) "." (.getMethodName el)))
           (take (dec n) (rest st)))]
           (transient {}) coll)))
           (when (:test (meta v))
           (when (= n (count p))
           (when (is-annotation? c)
           (when (not (symbol? k))
           (write-out object)))
           (write-to-base ^String (pp-newline))
           (write-to-base l)
           (write-to-base prefix))
           (write-to-base suffix))
           ))))
           - depending on need-prompt, this may cause the repl to prompt
           10
           10
           :doc "Evaluates the exprs in order, then, in parallel, rebinds
           :doc "The expr is evaluated and thrown, therefore it should
           :doc "Yields the unevaluated form."}
           :done-nl :intra-block-nl
           :logical-block-callback)
           :parent :section :start-col :indent
           :prefix :per-line-prefix :suffix
           ;=> (+ 2 2)"
           ;=> (do (+ 4 2) (+ 5 3))"
           @result
           @ret
           If :bytes is given, the sub-process's stdout will be stored
           If the :in option provides a byte array, then the bytes are passed
           Integer
           String 
           String is given, it will be used as a character encoding
           String[] if you are a masochist).
           [(node p) :end])))))
           [:up-arrow navigator]
           [[k v :as entry] & entries] (seq m)
           []
           [arg navigator] (next-arg navigator)]
           [exit navigator] navigator))))) 
           [java.sql Timestamp]))
           [nil [s offset flags]]))))
           [nil s]
           [r s] (if (<= (count xrel) (count yrel))
           [x [(symbol (name (first x))) (second x)]]))))
           ^java.io.Writer wrapped-stream (if (and (needs-pretty format) 
           `((.resetMeta (clojure.lang.Namespace/find '~name) ~name-metadata)))
           acc
           arg-list arg-list]
           arg2 (:arg2 params)
           arg3 (:arg3 params)
           args args
           clojure.java.io/copy, e.g. InputStream, Reader, File, byte[],
           clojure.lang.LazilyPersistentVector))
           convert the input string specified by the :in option to the
           count-down (fn [agent] (. latch (countDown)) agent)]
           dim-leap [nil 31 29 31 30 31 30 31 31 30 31 30 31]]
           encoding name (for example \"UTF-8\" or \"ISO-8859-1\") to
           exit (if (:colon params) :colon-up-arrow :up-arrow)]
           extra-pad extra-pad
           false
           false))))
           idx (index r ks)]
           if not specified, will throw
           in a byte array and returned.  Defaults to UTF-8.
           ks (seq keys)
           last-pos (num -1)]
           last-pos (num -1)]
           lets []]
           lm {}]
           name (for example \"UTF-8\" or \"ISO-8859-1\") to convert
           navigator navigator
           navigator navigator]
           navigator)))))
           new-params (with-meta [] (meta params))
           not-found)))
           offset (+ offset trim-count)]
           offset (inc offset)
           offset)
           opts (apply hash-map options)]
           or String, to be fed to the sub-process's stdin.
           pad-only (or (:colon params)
           pos (dec cnt)
           remainder (next parts)]
           remainder (subs remainder trim-count)
           result# (apply ~pred values#)]
           ret (if (instance? clojure.lang.IReduceInit coll)
           ret))
           s (.trim (.getString stream))]
           s (.trim (.getString stream))]
           s (next this)]
           s1 s1)))
           strs (if (:at params) ["y" "ies"] ["" "s"])
           strs strs
           sub-process's stdin.  Defaults to UTF-8.
           sw (java.io.StringWriter.)]
           the sub-process's stdout to a String which is returned.
           this (first parts)
           trim-count (if trim? (prefix-count remainder [\space \tab]) 0)
           trim? (and (= \newline (:directive def))
           unencoded, and this option is ignored.
           vs (seq vals)]
           xform
           { :mincol 0, :padchar 0, :commachar 0 :commainterval 0}))
           { :mincol 0, :padchar 0, :commachar 0 :commainterval 0}))))
           { :mincol 0, :padchar \space, :commachar \, :commainterval 3, :colon true}
           { :mincol 0, :padchar \space, :commachar \, :commainterval 3, :colon true}
           ~@(interleave (repeat g) (butlast steps))]
           ~@(interleave (repeat g) (butlast steps))]
           ~@(interleave (repeat g) (butlast steps))]
           ~@(interleave (repeat g) (butlast steps))]
           ~@body
           ~@body
           ~@body))
           ~@body))))
           ~@body)))))
           ~@body)))))
           ~gexpr ~expr]
          "clojure.core/tap-loop")
          #(let [t (.take tapq)
          %)
          (#{"NO_SOURCE_FILE" "NO_SOURCE_PATH"} source) (dissoc :clojure.error/source :clojure.error/path)
          ((formatter-out " ~_~w") attr-map))
          ((formatter-out " ~_~w") doc-str))
          ((formatter-out " ~_~{~w~^ ~_~}") (next (rest alis))))
          ((formatter-out "~@:_")))
          ((formatter-out "~w ~1I~@_") base-sym)
          ((formatter-out "~w~:[~;~:@_~]") attr-map (seq references)))
          ((if (vector? %) vec identity)
          (*print-pprint-dispatch* object))))
          (+ i (.count s))
          (. ^clojure.lang.IMeta x (meta)))))
          (. clojure.lang.Var (popThreadBindings)))))))
          (. gen (invokeInterface ifn-type (new Method "invoke" obj-type 
          (. gen (loadThis))
          (. gen (throwException ex-type (str impl-pkg-name "/" prefix post-init-name " not defined")))
          (. gen dup)
          (. gen goTo end-post-init-label)
          (. gen ifNull no-post-init-label)
          (. gen mark end-post-init-label))
          (. gen mark no-post-init-label)
          (. gen pop)
          (.. s (subSequence 0 index) toString))))))
          (.. s (subSequence index len) toString))))))
          (.append buffer ch))
          (.append buffer replacement)
          (.aset am arr (bit-and i (int 0x1f)) val)
          (.checkCast gen ifn-type)
          (.flush out))))))
          (.indexOf (.toString s) ^String value (unchecked-int from-index)))]
          (.indexOf (.toString s) ^String value))]
          (.indexOf (.toString s) ^int (.charValue ^Character value) (unchecked-int from-index))
          (.indexOf (.toString s) ^int (.charValue ^Character value))
          (.lastIndexOf (.toString s) ^String value (unchecked-int from-index)))]
          (.lastIndexOf (.toString s) ^String value))]
          (.lastIndexOf (.toString s) ^int (.charValue ^Character value) (unchecked-int from-index))
          (.lastIndexOf (.toString s) ^int (.charValue ^Character value))
          (.nth this i)
          (.nth this i)
          (.write ^java.io.Writer *out* " ")
          (.write w "\n  ")
          (.write w "\n  ")
          (.write writer (.toLowerCase s)))
          (.write writer (.toUpperCase s)))
          (.write writer (int (Character/toLowerCase (char c))))))))))
          (.write writer (int (Character/toUpperCase (char c))))))))))
          (.write writer cbuf off len))
          (:else clause-map)
          (< cnt vcnt) -1
          (= (.value r) java.lang.annotation.RetentionPolicy/RUNTIME)))))
          (= (:right bracket-info) (:directive (:def this)))
          (> cnt vcnt) 1
          (JScrollPane. 
          (Throwable->map x))
          (VecNode. (.edit node) arr))
          (VecNode. (.edit node) arr)))))
          ([^chars cbuf ^Integer off ^Integer len] 
          ([ret k v]
          ([ret k v]
          ([ret k v]
          ([x]
          (add-annotations mv (nth pmetas i) i))
          (add-tap tapfn)
          (and (= :first (:else bracket-info)) (seq (:clauses clause-map)))
          (and (instance? clojure.lang.Agent o)
          (and c (or (first (remove nil? (map impl (butlast (super-chain c)))))
          (aset arr i (.nth this i)))
          (aset arr subidx (.doAssoc this (- level (int 5)) (aget arr subidx) i val))
          (aset ret i (to-array (first xs)))
          (bigdec x)
          (bigdec x)
          (catch Exception e
          (catch java.util.concurrent.TimeoutException e
          (catch ~klass e#
          (catch ~klass e#
          (chunk-cons (chunk b) (filter pred (chunk-rest s))))
          (chunk-cons (chunk b) (keep f (chunk-rest s))))
          (chunk-cons (chunk b) (map f (chunk-rest s))))
          (cl-format true "\"~a\"~:[~;~:@_~]" doc-str (or attr-map (seq references))))
          (clojure.lang.APersistentVector$RSeq. this (dec (.count this)))
          (clojure.lang.MethodImplCache. (.sym cache) (.protocol cache) (.methodk cache) shift mask table))
          (clojure.lang.RT/load (.substring path 1)))))))
          (close []
          (concat (map first ss) (apply interleave (map rest ss))))))))
          (cond-> (merge (-> via second :data) top-data)
          (cond-> top-data
          (cond-> {:clojure.error/class type}
          (condp #(%1 %2) (first sigs) 
          (condp = (class x)
          (condp = (class x)
          (conj acc (merge {:name k3} (edn/read-string v)))
          (conj m `(valAt [this# k#] (.valAt this# k# nil))
          (cons 'fn* new-sigs))
          (cons (first s) (take (dec n) (rest s))))))))
          (cons (first s) (take-while pred (rest s))))))))
          (cons (first s1) (cons (first s2)
          (cons run (partition-by f (lazy-seq (drop (count run) s)))))))))
          (cons seg (partition-all n step (nthrest s step))))))))
          (construct-calendar years months days
          (copy in os :encoding in-enc)))
          (do
          (do
          (do (.write output buffer 0 size)
          (do (.write output buffer 0 size)
          (do (.write output buffer 0 size)
          (do (dosync (commute @#'*loaded-libs* conj '~name)) nil)))))
          (do (format-integer ;; for numbers > 10^63, we fall back on ~D
          (do-report {:type :error, :message ~msg,
          (do-report {:type :fail, :message ~msg,
          (do-report {:type :fail, :message ~msg, :expected '~form, :actual nil})
          (doseq [arg args]
          (doseq [col row]
          (doseq [opt filter-opts]
          (dotimes [_ (dec (:line (meta v)))] (.readLine rdr))
          (dotimes [i (count pclasses)]
          (dotimes [i size]
          (dotimes [i size]
          (dotimes [i size]
          (else-separator? this)
          (emit-get-var gen post-init-name)
          (execute-format format args)
          (finally
          (finally
          (first s))))
          (first valid-keys)
          (flush []
          (fn [] (test-var (var ~name))))))
          (fn [] (test-var (var ~name))))))
          (format-error
          (format-error "A plain clause (with \"~;\") follows an else clause (\"~:;\") inside bracket construction." offset)
          (format-error "A separator (\"~;\") is in a bracket type that doesn't support it." 
          (format-error "An else clause (\"~:;\") is in a bracket type that doesn't support it." 
          (format-error "Two else clauses (\"~:;\") inside bracket construction." offset)
          (format-integer ;; for numbers > 10^63, we fall back on ~D
          (gen-bridge meth dest))
          (gen-method meth 
          (if (<= c gc)
          (if (= :colon-up-arrow (first iter-result))
          (if (= :colon-up-arrow (first iter-result))
          (if (= :first (:else bracket-info))
          (if (= :up-arrow (first iter-result))
          (if (= :up-arrow (first iter-result))
          (if (= pclasses super-pclasses)
          (if (> len round-pos)
          (if (and (not *print-dup*) *print-length*)
          (if (chunked-seq? s)
          (if (contains? @seen input)
          (if (empty? digits)
          (if (instance? Throwable (:actual data))
          (if (nil? optval) 
          (if (nil? x)
          (if (pred f)
          (if (reduced? ret)
          (if (sequential? v)
          (if (zero? level)
          (if (zero? mask)
          (if *current-length* (set! *current-length* (inc *current-length*)))
          (if *print-pretty*
          (if @started
          (if e (.write w e) (.append w c))))
          (if found
          (if more
          (if n (.write w n) (.append w c))))
          (if ns
          (if prefix 
          (if w
          (instance? Byte x)))
          (instance? Integer x)
          (instance? Short x)
          (into-array StackTraceElement
          (last steps)))))
          (last steps)))))
          (last steps)))))
          (last steps)))))
          (let [[cname bytecode] (generate-proxy super interfaces)]
          (let [[params args] (realize-parameter-list 
          (let [[shift mask imap switch-type skip-check] (prep-hashes ge default tests thens)]
          (let [[shift mask imap switch-type skip-check] (prep-hashes ge default tests thens)]
          (let [[shift mask imap switch-type] (prep-ints tests thens)]
          (let [ancestors-visited (set (keys reflections))
          (let [fm (new Method factory-name ctype ptypes)
          (let [gparam (gensym "p__")]
          (let [m (new Method (str getter) ftype (to-types []))
          (let [m (new Method (str setter) Type/VOID_TYPE (into-array [ftype]))
          (let [mname (str name)
          (let [new-root (VecNode. (.edit root) (object-array 32))]
          (let [op (if *unchecked-math* unchecked-op op)]
          (let [parts-strs (map format-simple-cardinal (drop-last parts))
          (let [parts-strs (map format-simple-cardinal parts)
          (let [ptypes (to-types (. ctor (getParameterTypes)))
          (let [s (seq coll)]
          (let [text (StringBuilder.)
          (let [v (f input)]
          (let [v (nspublics sym)]
          (let [value (eval input)]
          (let [{:keys [members] :as ret} ((requiring-resolve 'clojure.reflect/reflect) c)]
          (let [~form temp#]
          (let [~form temp#]
          (let ~lets
          (list 'def (with-meta name m)
          (list* 'fn* name new-sigs)
          (list* `assert-args more)))))
          (load lib need-ns require)
          (loop []
          (loop [lindex 0]
          (loop [loc (with-meta [(peek l) (assoc path :l (pop l) :changed? true)] (meta loc))]
          (map #(let [[s f] %] 
          (map #(str ", " %) (rest valid-keys)))))))
          (map #(subs % (inc (.lastIndexOf ^String % "."))) inames)
          (merge default-options options-map)
          (new Vec am (inc cnt) shift (.pushTail this shift root tail-node) 
          (node loc)))))
          (not (:allows-separator bracket-info))
          (not (:else bracket-info))
          (or rfld (recur (.getSuperclass c))))))))
          (pop-thread-bindings)))"
          (pprint-binding-form (second alis))
          (pprint-logical-block
          (pprint-logical-block alis
          (pprint-logical-block writer :prefix "(" :suffix ")"
          (pprint-newline :linear)
          (pprint-ns-reference (first references))
          (pr-on (:tag m) w)
          (pr-on m w))
          (print (apply str (repeat w (:overflowchar params))))
          (print (str
          (print (str (if (not pad-only) (first strs))
          (print-method t w)))
          (print-via v)))
          (printf "(clojure.core/alias '%s '%s)\n" as lib))
          (printf "(clojure.core/refer '%s" lib)
          (printf ")\n"))
          (println " " (str (name role) ":") (spec/describe spec)))))))
          (println "Warning: protocol" protocol-var "is overwriting"
          (println (str "\n  Please see http://clojure.org/" url)))
          (println (str message (System/lineSeparator) "Full report at:" (System/lineSeparator) err-path))
          (println (str report-str (System/lineSeparator) message)))))))
          (prn))))
          (process-bracket this remainder)
          (process-bracket this remainder)
          (recur
          (recur 
          (recur (.assoc this (.getKey pair) (.getValue pair)) (rest o)))
          (recur (assoc ret (key (first es)) (val (first es))) (next es))
          (recur (dec index))
          (recur (dec rindex))
          (recur (inc i) (next s)))
          (recur (inc i) (next xs))))
          (recur (inc index))
          (recur (inc n))))
          (recur (next (rest binding))))))))
          (recur (next clauses) (conj acc result-str) iter-result))))))
          (recur (next params) (conj new-params (first params)) lets)
          (recur (next s) ret)))
          (recur (next s))
          (recur (rightmost child))
          (recur (unchecked-add-int (unchecked-multiply-int 31 hash) 
          (recur (unchecked-inc index))
          (recur [rounded-mantissa (inc exp)]))))
          (recur p)
          (recur ret (first kvs) (second kvs) (nnext kvs))
          (recur ret (next es)))
          (require (symbol nsname))
          (resolve valf))
          (rest (tree-seq sequential? seq x))))
          (rf result (f (vswap! i inc) input)))))))
          (right-bracket this)
          (separator? this)
          (subs path (count cd-path))
          (subs s n)
          (swap! mem assoc args ret)
          (symbol (name sym))))
          (throw
          (throw (Exception. (print-str "Cyclic derivation:" parent "has" tag "as ancestor"))))
          (throw (Exception. (print-str tag "already has" parent "as ancestor"))))
          (throw (IllegalArgumentException.
          (throw (IllegalArgumentException. "First argument to defn must be a symbol")))
          (throw (IndexOutOfBoundsException.))))
          (throw (ex-info (str "Not a valid data-reader map")
          (throw (new AssertionError (str "Assert failed: " (pr-str '~x)))))))
          (throw (new AssertionError (str "Assert failed: " ~message "\n" (pr-str '~x))))))))
          (throw-if (nil? prefix) "prefix cannot be nil")
          (try
          (try [false (deref o)]
          (visit [version access name signature superName interfaces]
          (visitAnnotation [desc visible])
          (visitEnd [])
          (visitField [access name desc signature value]
          (visitInnerClass [name outerName innerName access])
          (visitMethod [access name desc signature exceptions]
          (visitSource [name debug])
          (when (< pos sz)
          (when (= (.getEventType e) (. javax.swing.event.HyperlinkEvent$EventType ACTIVATED))
          (when (next (rest alis))
          (when (next alis)
          (when (next aseq)
          (when (next binding)
          (when (not (.isClosed socket))
          (when (seq args)
          (when gen-class-clause
          (when-let [cb (getf :logical-block-callback)] (cb :start))
          (when-let [references (next references)]
          (with-lock lock
          (with-meta (if changed?
          (with-meta [(deref r)] (meta r)))
          (with-meta [(make-node loc (peek pnodes) rs) 
          (with-meta [c {:l [] 
          (with-meta {:name (.getName n)
          (write [str-cbuf off len]
          (write-out (first alis))
          (write-out (first binding))
          ) 0)
          :block @(:start-col lb)
          :current (get-column (getf :base)))))))
          :doc "Used to set thread-local-bound vars, Java object instance
          :else
          :hashes
          :identity
          :implements ~(vec i)
          :ints
          :repl/quit request-exit
          :url "vars#set"
          ;;     (prlabel write x (getf :mode))
          ;; Every formatted floating point number should include at
          ;; Treat abstract methods as interface methods
          ;; least one decimal digit and a decimal point.
          ;; so no need to check for lindex reaching len.
          ;; there is at least one non-whitespace char in the string,
          @ret
          @v
          BorderLayout/CENTER)))
          [ [token-str offset] [(subs remainder 1) (inc new-offset) true]]))
          [ [token-str offset] [remainder new-offset false]]
          [ nil [:right-bracket (:params this) nil remainder]]
          ["0" 0 false]
          [(.getName super)]
          [(Integer/toHexString (hash inames))])))))
          [ClassVisitor]
          [Opcodes/ASM4]
          [acc (second iter-result)]
          [attr-map references] (if (map? (first stuff))
          [attr-map stuff] (if (map? (first stuff))
          [cname bytecode] (generate-interface options-map)]
          [doc-str stuff] (if (string? (first stuff))
          [doc-str stuff] (if (string? (first stuff))
          [keyw & args] reference]
          [m1 e1 round-pos len] (if (= round-pos 0) 
          [mm ifaces-meths] (let [abstract? (fn [[_ ^Method meth]]
          [nil (apply (:func element) [params args offsets])])))
          [nil [:else nil (:params this) remainder]]
          [nil [:separator nil nil remainder]] ;; TODO: check to make sure that there are no params on ~;
          [nil context]
          [ns-name fn-name & nested] (->> (str clazz) (.split #"\$") (map demunge) (map degen))]
          [result new-context] (apply func [this context])]
          [this remainder])))
          [this remainder]))))
          [true [(merge-with concat clause-map { :clauses [clause] })
          `(if (= (count ~'overage) ~over-count)
          `(let ~bfs
          `(new ~classname ~@field-args)))))
          `(~(symbol "clojure.core" (clojure.core/name kname))
          acc)))
          aidx (+ i offset)]
          boring? #(not= (.getMethodName ^StackTraceElement %) "doInvoke")
          bridge? (reduce1 into1 #{} (map second mb))
          chain (apply str (interpose "->" pending))]
          check-keys
          count-down (fn [agent] (. latch (countDown)) agent)]
          cs (assoc cs c (clojure.lang.MethodImplCache$Entry. c f))]
          d)
          d)))
          default   (get options :default :default)
          each-fixture-fn (join-fixtures (::each-fixtures (meta ns)))]
          err-path (when (= target "file")
          exception (Exception. message)
          exclude (set (:exclude fs))
          f f
          false)))
          fs (apply hash-map filters)
          g
          g
          g
          g
          gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
          gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
          gen (new GeneratorAdapter (. Opcodes ACC_PUBLIC) m nil nil cv)]
          hierarchy (get options :hierarchy #'global-hierarchy)]
          idxs (range 1 (inc (. rsmeta (getColumnCount))))
          ifaces-meths (into1 {} 
          ifaces-meths (remove bridge? (vals ifaces-meths))
          impl #(get (:impls protocol) %)]
          input))))
          keys (map (comp keyword #(.toLowerCase ^String %))
          loc))
          mb (map #(vector (%1 %2) (vals (dissoc %1 %2))) mgroups rtypes)
          merge2 (fn [m1 m2]
          message (assoc :clojure.error/cause message)
          message (ex-str triage)
          mgroups (group-by-sig (concat mm ifaces-meths))
          mm (remove bridge? (vals mm))]
          ms (concat (mapcat #(sort-by :name (map meta (vals (ns-interns %))))
          new-sigs (map psig sigs)]
          nil
          nil
          nil))
          node-to-insert (if (= level (int 5))
          not-found))
          nspublics (ns-publics ns)
          p (:protocol (meta v))]
          parent ^clojure.core.VecNode parent
          path))
          pname (proxy-name super interfaces)]
          problems (assoc :clojure.error/spec data))
          psig (fn* [sig]
          pv (volatile! ::none)]
          raw-trace (.getStackTrace exception)
          remainder (next lis)
          rename (or (:rename fs) {})
          report (array-map
          report-str (with-out-str
          result)))))
          ret (VecNode. (.edit parent) (aclone ^objects (.arr parent)))
          ret)))))
          round-pos (cond
          row-struct (apply create-struct keys)
          row-values (fn [] (map (fn [^Integer i] (. rs (getObject i))) idxs))
          rows (fn thisfn []
          rtypes (map #(most-specific (keys %)) mgroups)
          s (.getSuperclass c)]
          s s
          saw-else
          sigs (if (vector? (first sigs))
          sigs (if name (next sigs) sigs)
          source (assoc :clojure.error/source (file-name source)
          subidx (bit-and (bit-shift-right (- cnt (int 2)) level) (int 0x1f))]
          timeout-val))
          to-do (if (= :all (:refer fs))
          trace (into-array StackTraceElement (drop 2 (drop-while boring? raw-trace)))]
          triage (ex-triage trace)
          true
          true
          true         ; if the ~:; is in the last position, the else clause
          type (assoc :clojure.error/class type)
          unsupported (seq (remove supported flags))]
          val val]
          w (if w (max 2 w))
          xn xn]
          y))))
          {} coll)))
          ~(conj hinted-fields '__meta '__extmap
          ~@(mapcat identity opts)
          ~@m))))))
          ~else
          ~else)))))
         " (" (.getFileName el) ":" (.getLineNumber el) ")")))
         " (" (.getFileName el) ":" (.getLineNumber el) ")")))
         "-SNAPSHOT")))
         #_[:super 0x0020  :class]        
         '[clojure.set :as set]
         '[clojure.string :as str])
         '[java.lang.reflect Modifier]
         (#'clojure.pprint/execute-format cf# navigator#)))))
         ((if leap-year? dim-leap dim-norm) month))))
         (+ x y))
         (. clojure.lang.Var (popThreadBindings)))))))
         (.close server-socket)
         (.equals st (seq o))
         (.getTimeInMillis
         (.setErrorHandler a (:error-handler opts)))
         (.toString sw)))))
         (.unlock lockee#)))))
         (.withMeta ^clojure.lang.IObj (cons 'fn* decl)
         (.write ^java.io.Writer *out* "...")))))
         (< (int k) cnt)))
         (<= 0 (int k))
         (= 0 columnIndex) (get-label rowIndex)
         (= 1 columnIndex) (print-str (get-value rowIndex)))))))
         (= raw-val :parameter-from-args) 
         (= raw-val :remaining-arg-count) 
         (= type :else)
         (= type :right-bracket)
         (= type :separator)
         (>= @(:start-col lb) (- maxcol miser-width))
         (System/exit 1))))
         ([] (reduce1 #(conj %1 (%2)) [] fs))
         ([] (rf))
         ([] (rf))
         ([] (rf))
         ([] (rf))
         ([] (rf))
         ([] (rf))
         ([] (rf))
         ([] (rf))
         ([] nil)
         ([] true)
         ([k default] (if (contains? pmap k) (v k) default)))
         ([m#] (~(symbol (str classname "/create"))
         ([result input]
         ([result input]
         ([result input]
         ([result input]
         ([result input]
         ([result input]
         ([result input]
         ([result input]
         ([result]
         ([result]
         ([result] (rf result))
         ([result] (rf result))
         ([result] (rf result))
         ([result] (rf result))
         ([result] (rf result))
         ([result] (rf result))
         ([ret k v]
         ([ret k v]
         ([x y z & args] (boolean (and (epn x y z)
         ([x y z & args] (or (spn x y z)
         ([x y z & args] (reduce1 #(conj %1 (apply %2 x y z args)) [] fs))))))
         ([x y z] (every? #(and (% x) (% y) (% z)) ps))
         ([x y z] (reduce1 #(conj %1 (%2 x y z)) [] fs))
         ([x y z] (some #(or (% x) (% y) (% z)) ps))
         ([x y] (every? #(and (% x) (% y)) ps))
         ([x y] (reduce1 #(conj %1 (%2 x y)) [] fs))
         ([x y] (some #(or (% x) (% y)) ps))
         ([x] (every? #(% x) ps))
         ([x] (reduce1 #(conj %1 (%2 x)) [] fs))
         ([x] (some #(% x) ps))
         (absolute-reposition navigator n)))
         (add-to-buffer this (make-buffer-blob (str (char c)) nil oldpos newpos)))))))
         (add-to-buffer this (make-end-block-t lb oldpos newpos))))
         (add-to-buffer this (make-indent-t lb relative-to offset pos pos)))))))
         (add-to-buffer this (make-start-block-t lb oldpos newpos)))))))
         (alter-var-root #'servers dissoc name)
         (and (> shift 5) (nil? (aget ^objects (.arr new-root) 1)))
         (and (clojure.lang.Util/equiv (first me) (first you))
         (and arg1 arg2 arg3)
         (and arg1 arg2)
         (apply f x y z args)))))
         (assoc m ik (conj (get m ik #{}) x))))
         (assoc m new (get map old))
         (binding-map (if (or (not (= *print-base* 10)) *print-radix*) {#'pr pr-with-base} {}) 
         (clojure.lang.TransformerIterator/create xform (clojure.lang.RT/iter coll)))
         (clojure.lang.TransformerIterator/createMulti
         (clojure.lang.Var/resetThreadBindingFrame frame)
         (clojure.lang.Var/resetThreadBindingFrame frame)
         (clojure.lang.Var/resetThreadBindingFrame frame)
         (clojure.lang.Var/resetThreadBindingFrame frame)
         (clojure.lang.Var/resetThreadBindingFrame frame)
         (coll-fold left n combinef reducef)
         (combinef (f1) (fjjoin t2)))))))
         (cond
         (cond
         (cond
         (condp = (class x)
         (conj m
         (cons (re-groups m) (lazy-seq (step))))))))
         (contains? #{ :at :colon } param) ;pass flags through unchanged - this really isn't necessary
         (contains? #{"--report"} opt)
         (dec pos)
         (deref [] fields)
         (do
         (do ~@mod-body)
         (do-report {:type :fail, :message ~msg,
         (do-report {:type :fail, :message ~msg,
         (do-report {:type :pass, :message ~msg,
         (do-report {:type :pass, :message ~msg,
         (doseq [^String l (next (butlast lines))]
         (doseq [el (take depth
         (doseq [row rows]
         (doseq [v vars]
         (emit-forwarding-method mname pclasses rclass (:static (meta msig))
         (execute-sub-format subformat navigator  (:base-args params))))
         (execute-sub-format subformat sub-navigator (:base-args params))
         (f (str "-- caught signal " signal)))))))
         (f x y z))
         (f x y))
         (f x))
         (f))
         (finally
         (finally
         (first remainder)
         (fjfork t2)
         (fjjoin rt)))))))
         (flush []
         (fn
         (fn
         (fn
         (fn
         (fn [fdecl]
         (fn [m [k v]]
         (for [x amap] 
         (if (.hasNext iter)
         (if (<= arg1 arg2 arg3) [exit navigator] navigator)
         (if (= :buffering (getf :mode))
         (if (= arg1 0) [exit navigator] navigator)
         (if (= arg1 arg2) [exit navigator] navigator)
         (if (and (>= i z) (< i (.count this)))
         (if (contains? s x)
         (if (empty? s)
         (if (empty? this)
         (if (if (:colon params) 
         (if (include e) s (next s)))
         (if (include e) s (next s)))
         (if (not stream) (.toString real-stream)))))
         (if (reduced? result)
         (if (reduced? ret)
         (if (up p)
         (if (write-out arg)
         (if fdecls
         (if flag
         (if or# or# (or ~@next)))))
         (if suffix
         (if xs
         (if-let [[_ years months days hours minutes seconds fraction
         (if-not (identical? buffer new-buffer)
         (init-dispatch opt)
         (interface-or-naive-reduce s f val))
         (into-array (map #(.getInternalName (asm-type %)) extends))))
         (jio/copy r sw)
         (last lines))))))
         (let [[arg navigator] (next-arg navigator)]
         (let [col (get-column (getf :base))]
         (let [m (get m (first ks) sentinel)]
         (let [new-child (.popTail this (- level 5) (aget ^objects (.arr node) subidx))]
         (let [new-tail (.array am (.alength am tail))]
         (let [p (doall (take n s))]
         (let [p (doall (take n s))]
         (let [ptypes (to-types (.getParameterTypes m))
         (let [ret (f ret (.next iter))]
         (let [ret (f val (.charAt s i))]
         (let [ret (f val (first s))]
         (let [ten-digit (quot tens 10)
         (let [ten-digit (quot tens 10)
         (let [w (first more)
         (let [w (first more)
         (let [~form temp#]
         (let [~form temp#]
         (linear-nl? this lb section))))
         (my-e-f# stream# cf# navigator#)))))
         (neg? n) ""
         (new Vec am cnt shift (.doAssoc this shift root i val) tail (meta this)))
         (next remainder))))))
         (next-arg navigator)
         (nil? (seq o)))
         (nil? new-root) 
         (nil? you)
         (not (= (nth s n) c)) (subs s 0 (inc n))
         (nth english-cardinal-units tens)
         (nth english-ordinal-units tens)
         (or (seq coll) ())))
         (pprint-logical-block alis
         (print "[empty stack trace]"))
         (print-trace-element e)
         (println "Note: The following stack trace applies to the reader or compiler, your code was not executed."))
         (println (fmt-row "| " " | " " |" (zipmap ks ks)))
         (println (fmt-row "|-" "-+-" "-|" (zipmap ks spacers)))
         (println)
         (prn)))
         (prn)))))
         (proxy
         (proxy [ContentHandler] []
         (pst (root-cause e) e-or-depth))))
         (recur (-> sb (.append sep) (.append (str (first more))))
         (recur (unchecked-inc-int ~idx) ~expr)
         (recur more (conj inits [opt arg]) flags)
         (recur more inits (merge flags {(subs opt 2) arg}))
         (recur ret (first ks) (next ks))
         (recur ret)
         (recur))))))
         (reduce rrf result input)))))
         (reduce1 f (first s) (next s))
         (ref-set (:indent lb) 
         (relative-reposition navigator (if (:colon params) (- n) n))))))
         (report-error t :target "file")
         (reverse (for [[name [default]] (:params def)] [name [default offset]])))
         (seq [this] (seq f)))))
         (set! (.__methodImplCache f#) cache#)
         (setf :buffering :writing)
         (setf :pos newpos)
         (setf :pos newpos)
         (setf :pos newpos)
         (str "." i))
         (str sb)))))
         (throw (IllegalArgumentException.
         (toString [this] f))))
         (try
         (try
         (vector? (first stuff)) (single-defn stuff (or doc-str attr-map))
         (when (< ~i n#)
         (when (< ~i n#)
         (when (need-prompt)
         (when (next (rest alis))
         (when (pos? (count q)) (str "-" q)))
         (when cause
         (when-let [c (resolve k)]
         (when-let [cb (getf :logical-block-callback)] (cb :end)))
         (when-not (and (.hasRoot v#) (instance? clojure.lang.MultiFn (deref v#)))
         (write
         (write-to-base (int \newline))
         (write-white-space this)
         (write-white-space this)
         (write-white-space this)
         - else returns the next object read from the input stream
         - returns its first argument to request a fresh prompt
         - returns its second argument to request an exit from the repl
         :ancestors (tf (:ancestors h) tag td parent ta)
         :descendants (tf (:descendants h) parent ta tag td)})
         :doc "Creates and interns a global var with the name
         :doc "The args, if any, are evaluated from left to right, and
         :doc "The symbol must resolve to a var, and the Var object
         :doc "catch-clause => (catch classname name expr*)
         :else
         :else (multi-defn stuff (or doc-str attr-map)))))
         :main-opt
         :name name-symbol
         :or {bind-err true
         :or {init        #()
         :special-form true))
         :url "java_interop#new"
         ;; :super is ancient history and is unfindable (?) by
         ;; flag
         ;; init opt
         ;; reflection. skip it
         NIL (Object.) ;nil sentinel since LBQ doesn't support nils
         [& vals#] (apply struct ~type-name ~(keyword name-str) vals#))
         [(conj i 'clojure.lang.ILookup 'clojure.lang.IKeywordLookup)
         [(count (:rest navigator)) navigator]
         [:abstract 0x0400  :class :method]
         [:annotation 0x2000  :class]
         [:bridge 0x0040  :method]
         [:enum 0x4000  :class :field :inner]])))
         [:final 0x0010  :class :field :method]
         [:interface 0x0200  :class]
         [:native 0x0100  :method]
         [:private 0x002 :class :field :method]
         [:protected 0x0004  :class :field :method]
         [:static 0x0008  :field :method]
         [:strict 0x0800  :method]
         [:synchronized 0x0020  :method]
         [:synthetic 0x1000  :class :field :method]
         [:transient 0x0080  :field]
         [:varargs 0x0080  :method]
         [:volatile 0x0040  :field]
         [nil [(merge-with concat clause-map 
         [pre-read s] (read+string opts reader)
         [raw-val navigator]
         [raw-val navigator])]
         [super interfaces] (get-super-and-interfaces bases)
         [v kv] (if (< kx ky) [x kx] [y ky])]
         [v kv] (if (> kx ky) [x kx] [y ky])]
         ^"[I" dimarray (make-array (. Integer TYPE)  (count dims))]
         ^String base-output (or (format-simple-number arg) (print-func arg))
         ^String suffix (:suffix lb)]
         acc []
         acc []]
         acc []]
         acc []]
         acc []]
         actual: (not (= 5 4))
         address (InetAddress/getByName address)  ;; nil returns loopback
         agt (agent (lazy-seq s)) ; never start with nil; that signifies we've already put eos
         arg1
         arr (.array am 1)]
         arr (.array am 2)]
         arr (.array am 3)]
         arr (.array am 4)]
         base-width (.length base-output)
         buffer (StringBuilder. (.length s))]
         bval (as-set-value b)]
         c c]
         cf# (if (string? format-in#) (#'clojure.pprint/cached-compile format-in#) format-in#)]
         cf# (if (string? format-in#) (my-c-c# format-in#) format-in#)]
         chars (apply str (repeat (- width base-width) (:padchar params)))]
         compile-effect (when *compile-files*
         considered #{}
         detail (apply str (interpose
         drain (fn drain []
         f#))))
         fc (fn [child] #(foldvec child n combinef reducef))]
         fill (fn [s]
         identity 
         idx (index r (vals k))]
         java.io.InputStream)
         len (.length s)]
         lis lis
         log-error (fn [q e]
         m)) 
         m))))
         m])
         mappings
         min-width (+ base-width (:minpad params))
         my-c-c# (var-get (get (ns-interns (the-ns 'clojure.pprint))
         my-e-f# (var-get (get (ns-interns (the-ns 'clojure.pprint))
         my-i-n# (var-get (get (ns-interns (the-ns 'clojure.pprint))
         navigator navigator]
         navigator))))
         new-mappings)))))
         new-writer# (not (pretty-writer? base-writer#))]
         nil
         nil)))
         nil)))
         object# ~(nth form 2)]
         opts (apply hash-map options)]
         pc-effect (apply get-proxy-class bases)
         persistent!))
         pname (proxy-name super interfaces)]
         qmode false]
         r
         re-reader (doto (LineNumberingPushbackReader. (StringReader. s))
         resolve-tag (fn [argvec]
         ret# ~expr]
         ret)))
         ret)))))
         ret)))))
         rets (map #(future (f %)) coll)
         socket (ServerSocket. port 0 address)]
         step (fn step [[x & xs :as vs] fs]
         ta (:ancestors h)
         td (:descendants h)
         tf (fn [m source sources target targets]
         true 
         true     ; TODO: handle looking up the arglist stack for info
         true (recur (dec n))))
         true))
         true)))))
         v)))))
         v)))))
         v1 (subvec v 0 split)
         v2 (subvec v split (count v))
         val val]
         val))))
         val))))
         width (if (>= min-width (:mincol params)) 
         {:a 12 :b 11 :c 12 :e 3}
         {:a 2 :b 12 :c 2 :d 6}
         {:a 3 :b 3 :c 3 :d 8 :f 42}})
         {:a 3 :b 3 :c 3 :e 7 }})
         {:keys [clojure.core/eval-file line]} (meta pre-read)
         ~(loop [fmap {} fs fs]
         ~(str "Factory function for class " classname ", taking a map of keywords to field values.")
         ~@(interleave (repeat name) (butlast forms))]
         ~@(map (fn [f]
         ~@body
         ~@body
         ~@body)))
         ~gx)))
         ~ret (aclone a#)]
         ~ret))))
         ~ret))))
        ""
        ""
        '(clojure.asm ClassWriter ClassVisitor Opcodes Type)
        '(clojure.asm.commons Method GeneratorAdapter)
        '(clojure.lang IPersistentMap))
        '. pprint-hold-first, '.. pprint-hold-first, '-> pprint-hold-first,
        'cond pprint-cond, 'condp pprint-condp,
        'fn* pprint-anon-func,
        'if pprint-if, 'if-not pprint-if, 'when pprint-if, 'when-not pprint-if,
        'let pprint-let, 'loop pprint-let, 'binding pprint-let,
        'locking pprint-hold-first, 'struct pprint-hold-first,
        'struct-map pprint-hold-first, 'ns pprint-ns 
        'with-local-vars pprint-let, 'with-open pprint-let, 'when-let pprint-let,
        ((formatter-out " ~@_")))
        ((formatter-out " ~_"))
        ((formatter-out "~<#(~;~@{~w~^ ~_~}~;)~:>") nlis))
        ((formatter-out "~w ~1I~@_~w") defn-sym defn-name)
        ((formatter-out "~w ~1I~@_~w") ns-sym ns-name)
        ((formatter-out "~w~:i") keyw)
        (-> x class .getComponentType (= Byte/TYPE))))
        (. Array (~method array# idx# (~coerce val#)))
        (. ParallelArray defaultExecutor))))
        (. clojure.lang.Var (pushThreadBindings {clojure.lang.Compiler/LOADER
        (. gen (endMethod))
        (. gen (endMethod)))
        (. gen (endMethod))))
        (. gen (endMethod))))
        (. gen (invokeInterface ifn-type (new Method "applyTo" obj-type 
        (. gen (invokeStatic rt-type (. Method (getMethod "clojure.lang.ISeq seq(Object)"))))
        (. gen (invokeStatic util-type (. Method (getMethod "Object loadWithClass(String,Class)"))))
        (. gen (invokeStatic var-type (. Method (getMethod "clojure.lang.Var internPrivate(String,String)"))))
        (. gen (loadArgs))
        (. gen (loadArgs))
        (. gen (loadThis))
        (. gen (loadThis))
        (. gen (returnValue))
        (. gen (returnValue))
        (. gen (throwException (totype NotSerializableException) pname))
        (. gen (throwException (totype NotSerializableException) pname))
        (. gen (throwException ex-type (str impl-pkg-name "/" prefix main-name " not defined")))
        (. gen (visitCode))
        (. gen (visitCode))
        (. gen (visitCode))
        (. gen (visitCode))
        (. gen dup)
        (. gen goTo end-label)
        (. gen ifNull no-main-label)
        (. gen loadArgs)
        (. gen mark end-label)
        (. gen mark no-main-label)
        (. gen pop)
        (. gen pop))
        (. gen push (str "/" impl-cname))
        (. gen push (str prefix v))
        (. gen push ctype)
        (. gen push impl-pkg-name)
        (. gen putStatic ctype (var-name v) var-type))
        (. java.util.regex.Pattern (compile s))))
        (. m (group))
        (. mv visitEnd)))
        (.. s (subSequence 0 index) toString)))))
        (.accept
        (.add
        (.add (doto (JToolBar.)
        (.appendReplacement m buffer rep)
        (.appendTail m buffer)
        (.aset am new-tail (.alength am tail) val)
        (.browse (URI. url)))
        (.checkCast gen ifn-type)
        (.countDown d)
        (.getDeclaredConstructors cls))))
        (.getDeclaredFields cls))))
        (.getDeclaredMethods cls))))
        (.setTimeZone (java.util.TimeZone/getTimeZone "GMT"))))))
        (.setTimeZone (java.util.TimeZone/getTimeZone "GMT"))))))
        (.write w begin)
        (.write w end)))))
        (:compile-syntax-check :compilation :macro-syntax-check :macroexpansion)
        (:read-eval-result :print-eval-result)
        (< i 0) -1
        (< width (count s)) (.substring s 0 width)
        (= c \") (do
        (= c \\) (let [[^Character c2 & r2] r]
        (= o (.nth this i)) i
        (= o (.nth this i)) i
        (== i cnt) -1
        (System/arraycopy a 0 target idx (count a))
        (System/arraycopy tail 0 new-tail 0 (.alength am new-tail))
        (System/arraycopy tail 0 new-tail 0 (.alength am tail))
        ([] (rf))
        ([] (rf))
        ([] (rf))
        ([] [])
        ([coll x & xs]
        ([coll x] (clojure.lang.RT/conj coll x))
        ([coll] coll)
        ([result input & inputs]
        ([result input]
        ([result input]
        ([result input]
        ([result]
        ([result] (rf result))
        ([result] (rf result))
        ([x off len]
        (add [_ e] (throw (UnsupportedOperationException.)))
        (add-annotations mv (meta mname))
        (alias as lib))
        (alter-var-root #'servers assoc-in [name :sessions client-id] {}))
        (alter-var-root #'servers update-in [name :sessions] dissoc client-id))
        (and (fn? value)
        (apply accept-fn args)))
        (apply hash-map options)
        (apply load-lib nil (prependss arg opts))
        (apply refer lib (mapcat seq filter-opts))))))
        (apply str "Only these options are valid: "
        (apply ~name (aget array# idx#) idx2# idxv#))))
        (aset ^objects (.arr ret) 0 (.newPath this edit (- level (int 5)) node))
        (assoc! ret k (conj (get ret k []) x))))
        (bar-me [this y] x))))
        (bar-me [this] x)
        (binding [*out* *err*]
        (binding [*pending-paths* (conj *pending-paths* path)]
        (case input
        (catch Throwable t#
        (caught e)
        (cl-format true \"There ~[are~;is~:;are~]~:* ~d result~:p: ~{~d~^, ~}~%\" 
        (class x)
        (clojure.lang.Compiler/writeClassFile cname bytecode))
        (clojure.lang.Compiler/writeClassFile cname bytecode))))
        (clojure.lang.MethodImplCache. (.sym cache) (.protocol cache) (.methodk cache) cs)))))
        (combinef
        (concat
        (cond
        (cond
        (cond
        (cond
        (cond 
        (cond 
        (cond 
        (cond-> top-data
        (condp = mode
        (cons (f (first s)) (map f (rest s)))))))
        (cons (f (first s1) (first s2) (first s3))
        (cons (f (first s1) (first s2))
        (cons (first s) (take-nth n (drop n s)))))))
        (do
        (do
        (do
        (do
        (do (-> sym namespace symbol serialized-require)
        (do (f) :ok)
        (doseq [row aseq]
        (doseq [t (rest trace)]
        (doseq [v (rest via)]
        (dosync
        (dotimes [i (count pmetas)]
        (dotimes [i cnt]
        (emit-element c))
        (emit-get-var gen main-name)
        (execute-format stream compiled-format navigator)))))
        (execute-format stream compiled-format navigator)))))
        (execute-sub-format clause arg-navigator (:base-args params))
        (finally
        (finally
        (finally
        (flush))
        (fn [[kname & args]]
        (fn []
        (fn [^java.lang.reflect.Method meth ^java.lang.reflect.Method dest]
        (fn [^java.lang.reflect.Method meth else-gen]
        (fn [name pclasses rclass as-static else-gen]
        (foo [this] 17)
        (format "Execution error - invalid arguments to %s at (%s).%n%s"
        (format "Execution error%s at %s(%s).%n%s%n"
        (format-error "Badly formed parameters in format directive" offset)
        (hasNext [_] (< (.get i) cnt))
        (hasNext [_] (< (.get i) cnt))
        (hasPrevious [_] (pos? i))
        (hyperlinkUpdate [^javax.swing.event.HyperlinkEvent e]
        (if (.await d timeout-ms java.util.concurrent.TimeUnit/MILLISECONDS)
        (if (.equals '~name 'clojure.core)
        (if (.startsWith path cd-path)
        (if (:right bracket)
        (if (<= (count parts) (count english-scale-numbers))
        (if (<= (count parts) (count english-scale-numbers))
        (if (= :up-arrow (first iter-result))
        (if (> (.count this) 0)
        (if (> (bit-shift-right cnt (int 5)) (bit-shift-left (int 1) shift)) ;overflow root?
        (if (Character/isWhitespace (.charAt s (dec rindex)))
        (if (Character/isWhitespace (.charAt s index))
        (if (Character/isWhitespace (.charAt s index))
        (if (abort? context)
        (if (and (= k1 "clojure") (= k2 "server"))
        (if (and (> full-len w) (:overflowchar params))
        (if (and (>= i 0) (< i cnt))
        (if (and (>= i 0) (< i cnt))
        (if (instance? Character value)
        (if (instance? Character value)
        (if (instance? Character value)
        (if (instance? Character value)
        (if (instance? clojure.lang.Counted s)
        (if (instance? clojure.lang.IMeta x)
        (if (instance? clojure.lang.Symbol name)
        (if (neg? round-pos)
        (if (next kvs)
        (if (next s)
        (if (nil? temp#)
        (if (not (= \, (nth remainder 0)))
        (if (not incr-exp)
        (if (not= x 0)
        (if (or (= ch \newline) (= ch \return))
        (if (or (= n len) (not (= (nth s n) c)))
        (if (or (== d Double/POSITIVE_INFINITY) (== d Double/NEGATIVE_INFINITY))
        (if (pos? (count l))
        (if (pos? size)
        (if (pos? size)
        (if (pred (keyfn (first es)))
        (if (reduced? ret)
        (if (symbol? (first params))
        (if attr-map
        (if doc-str
        (if err-path
        (if init
        (if name
        (if p
        (if s
        (if temp#
        (if-let [child (and (branch? loc) (down loc))]
        (if-let [replacement (cmap ch)]
        (init-proxy p#
        (iter# ~(second seq-exprs)))))
        (last forms))))
        (let [[defn-sym defn-name & stuff] alis
        (let [[params args] (realize-parameter-list (:params element) context)
        (let [[prefix & args] arg]
        (let [[shift mask] (or (maybe-min-hash hashes) [0 0])]
        (let [[source method file line] (-> trace first)]
        (let [[source method file line] (->> trace (drop-while #(core-class? (name (first %)))) first)
        (let [[sublist navigator] (next-arg-or-nil navigator)
        (let [^java.util.Map$Entry pair (first o)]
        (let [arr (.aclone am (.arr node))]
        (let [arr (aclone ^objects (.arr node))
        (let [bytes-xferred (.transferTo in pos (- sz pos) out)
        (let [c (.charAt s n)
        (let [c (chunk-first s)
        (let [c (chunk-first s)
        (let [c (chunk-first s)
        (let [c ^Character x]
        (let [c ^Character x]
        (let [dflds (.getDeclaredFields c)
        (let [do-nl (emit-nl? newl this section (get-sub-section b))
        (let [entry (. clojure.lang.RT (find map (first keys)))]
        (let [f (first s) r (rest s)]
        (let [fst (first s)
        (let [iter-result (execute-sub-format 
        (let [iter-result (execute-sub-format clause args (:base-args params))] 
        (let [iter-result (execute-sub-format clause navigator (:base-args params))] 
        (let [m (if (string? (first fdecl))
        (let [n (char-name-string c)]
        (let [optval (if (contains? options :stream) 
        (let [pnode (peek pnodes)]
        (let [ret (apply f args)]
        (let [ret (f ret (.aget am arr i))]
        (let [s ^String x]
        (let [s ^String x]
        (let [seg (doall (take n s))]
        (let [table (make-array Object (* 2 (inc mask)))
        (let [val (.nth this i)]
        (let [vs (take-nth 2 (drop 1 bindings))
        (let [x (f (first s))]
        (let [{:clojure.error/keys [line column]} data]
        (list (f)))))
        (loop [acc []
        (loop [args args]
        (loop [client-counter 1]
        (loop [found true]
        (loop [node root level shift]
        (loop [opts {:on (list 'quote iname) :on-interface iname} sigs opts+sigs]
        (loop [references references]
        (loop [reflections (make-ancestor-map (:bases result))]
        (loop [ret [] c 0]
        (m/skip-if-eol *in*)
        (m/skip-whitespace *in*))
        (macroexpand ex))))
        (map-passing-context realize-parameter navigator parameter-map)]
        (mapcat 
        (merge {:reflector default-reflector}
        (meta &form))))
        (miser-nl? this lb section))))
        (new Vec am (dec cnt) shift root new-tail (meta this)))
        (new Vec am (inc cnt) shift root new-tail (meta this)))
        (next [_] (try
        (next [_] (try
        (nextIndex [_] (.get i))
        (not (tokens-fit? this subsection))
        (open-url-in-browser url)
        (open-url-in-swing url))))
        (partition 2 deriv-seq))
        (pprint-logical-block binding
        (pprint-simple-code-list alis)))))
        (pprint-simple-code-list writer alis)))))
        (previous [_] (try
        (previousIndex [_] (dec (.get i)))
        (print "...")
        (print (apply str (repeat ee \space)))
        (print padded-str))
        (print-method ft w)
        (print-via fv)
        (printf "(clojure.core/in-ns '%s)\n" (ns-name *ns*)))
        (printf "(clojure.core/load \"%s\")\n" path)
        (println (str "\n  Please see http://clojure.org/special_forms#" nm))))
        (re-groups m))))
        (recur 
        (recur (assoc map (first ks) (first vs))
        (recur (conj ret (first items)) (next items))
        (recur (dec n) (next xs))
        (recur (dec n) (rest xs))
        (recur (inc i) (+ idx (count a)))))
        (recur (inc i) (next s))
        (recur (inc index) buffer)))))
        (recur (into1 ret bs) (into1 (disj cs c) bs)))
        (recur (next format))))))
        (recur (unchecked-dec index))
        (recur cause)
        (recur cause)
        (recur mm considered (. c (getSuperclass))))
        (recur threaded (next forms)))
        (recur threaded (next forms)))
        (reduce
        (reductions f (first s) (rest s))
        (remove [_] (throw (UnsupportedOperationException.)))
        (remove [_] (throw (UnsupportedOperationException.))))))
        (root-bind old-vals)))))
        (send agent count-down))
        (set [_ e] (throw (UnsupportedOperationException.))))))
        (set! *e e)))
        (set-field this :cur (inc (get-field this :cur)))))
        (skip-if-eol *in*)
        (str (apply str (interpose ", " acc))
        (str buffer))
        (test-all-vars ns-obj))
        (throw (Exception. (str "can't resolve: " valf))))
        (throw (IllegalArgumentException. (str "Argument must be an integer: " n)))))
        (throw (RuntimeException. "%@{ construct not consuming any arguments: Infinite loop!")))
        (throw (RuntimeException. "%{ construct not consuming any arguments: Infinite loop!")))
        (throw (new Exception ":only/:refer value must be a sequential collection of symbols")))
        (throw (new Exception "Insert at top"))
        (throw (new Exception "Insert at top"))
        (throw (new Exception "Remove at top"))
        (throw (new Exception (str "field, " f ", not defined in class, " start-class ", or its ancestors")))
        (throw-if (and need-ns (not (find-ns lib)))
        (to-array coll) 
        (try
        (try
        (try
        (type-map match))
        (val e)
        (vary-meta v assoc ::obj x ::class (-> x class .getName symbol))
        (when (and s1 s2)
        (when (contains? (ta parent) tag)
        (when (contains? (ta tag) parent)
        (when (every? identity ss)
        (when (next (rest binding))
        (when (not (map? new-mappings))
        (when (or (keyword? k) (symbol? k))
        (when (or doc-str attr-map (seq references))
        (when (pos? size)
        (when (pos? size)
        (when (pred (first s))
        (when *feeling-lucky* (str *feeling-lucky-url* url-path ".html"))))))
        (when *loading-verbosely*
        (when *loading-verbosely*
        (when alis
        (when aseq
        (when attr-map
        (when cs
        (when doc-str
        (when factory
        (when getter
        (when more
        (when post-init
        (when setter
        (when tr
        (when url
        (when xs
        (when-let [^java.lang.annotation.Retention r
        (when-let [nsname (namespace valf)]
        (when-let [s (seq coll)]
        (when-let [spec (get fnspec role)]
        (when-let [xs (seq sequence)]
        (when-not (. Modifier (isPrivate (. ctor (getModifiers))))
        (when-not (= input eof)
        (when-not (exclude sym)
        (when-not pending
        (with-meta [(first l) (assoc path :l [] :r (concat (rest l) [node] r))] (meta loc))
        (with-meta [(last r) (assoc path :l (apply conj l node (butlast r)) :r nil)] (meta loc))
        (with-meta [(peek l) (assoc path :l (pop l) :r (cons node r))] (meta loc)))))
        (with-meta [node (assoc path :l (conj l item) :changed? true)] (meta loc)))))
        (with-meta [node (assoc path :r (cons item r) :changed? true)] (meta loc)))))
        (with-meta [r (assoc path :l (conj l node) :r rnext)] (meta loc)))))
        (with-meta ret (meta map)))))
        (with-open [os (.getOutputStream proc)]
        (with-open [rdr (LineNumberReader. (InputStreamReader. strm))]
        (with-out-str
        (zero? (bit-and (clojure.lang.RT/uncheckedLongCast n) 1))
        - returns the object."
        - skips the next input character if it's end of line, then
        ...
        :doc "Evaluates test. If not the singular values nil or false,
        :doc "Evaluates the expressions in order and returns the value of
        :else    (do
        :else (loop [b (StringBuilder. s)]
        :else (recur (dec i)))))
        :else (recur (inc i)))))
        :execution
        :no-test)))
        :read-source
        :when (not (. Modifier (isPrivate (. ctor (getModifiers)))))]
        ; compact case ints, no shift-mask
        ; compact case ints, with shift-mask
        ; sparse case ints, no shift-mask
        ;; Note: Cannot delegate this check to def because of the call to (with-meta name ..)
        ;; Note: the multi-defn case will work OK for malformed defns too
        ;; Otherwise, just test every var in the namespace.
        ;; RFC3339 says to use -00:00 when the timezone is unknown (+00:00 implies a known GMT)
        ;; TODO get the offset in here and call format exception
        ;; TODO get the offset in here and call format exception
        ;; if *feeling-lucky* try a web search
        ;ns-effect (clojure.core/in-ns name)
        ;on this branch, array will need val type
        @result))))
        Diff
        Diff
        EOF (Object.)]
        EqualityPartition
        Integer
        Integer
        String 
        String 
        [ nil [s offset]]))))
        [(conj i 'clojure.lang.IHashEq)
        [(conj i 'clojure.lang.IRecord)
        [(str (subs s 0 1) (subs s 2 exploc)) (subs s (inc exploc))]))))
        [(str (subs s 0 dotloc) (subs s (inc dotloc))) (str (dec dotloc))])
        [(subs s 0 exploc) (subs s (inc exploc))]
        [0 0 (case-map hashcode identity tests thens) :compact]
        [0 0 (case-map int int tests thens) :sparse]
        [[:public 0x0001 :class :field :method]
        [_ [rest offset flags]] (extract-flags rest offset)
        [_ timeout-ms timeout-val]
        [a* b* ab] (diff va vb)
        [acc context]
        [acc new-context]
        [arg navigator] (if arg [arg arg-navigator] (next-arg arg-navigator))
        [arg navigator] (next-arg navigator)
        [arg navigator] (next-arg navigator)]
        [arg-list navigator] (next-arg navigator)
        [arg-list navigator] (next-arg navigator)]
        [clause navigator] (if (empty? param-clause) 
        [clause navigator] (if (empty? param-clause) 
        [clause navigator] (if (empty? param-clause) 
        [clause navigator] (if (empty? param-clause) 
        [cmd opts] (split-with string? args)]
        [cname bytecode] (generate-class options-map)]
        [else-params new-navigator] (when-let [p (:else-params params)]
        [ex val]
        [field-args over] (split-at 20 fields)
        [field-args over] (split-at 20 fields)]
        [interfaces methods opts] (parse-opts+specs opts+specs)
        [interfaces methods opts] (parse-opts+specs opts+specs)
        [java.io Writer])
        [java.io Writer])
        [m e false]))
        [mantissa exp] (float-parts (Math/abs arg))
        [mantissa exp] (float-parts (if (neg? arg) (- arg) arg))
        [mantissa exp] (float-parts abs)
        [nil context] ; just keep passing it along
        [ns (apply conj (empty m) lm)]))))
        [opts sigs]
        [rounded-mantissa scaled-exp expanded] (round-str mantissa exp d nil)
        [rounded-mantissa scaled-exp expanded] (round-str mantissa scaled-exp 
        [s (str (dec (count s)))]
        [shift mask (case-map #(shift-mask shift mask (int %)) int tests thens) :compact]))))
        [shift mask case-map switch-type skip-check]))))
        [sign abs] (if (neg? arg) ["-" (- arg)] ["+" arg])
        [strs navigator] (render-clauses clauses navigator (:base-args params))
        ]
        ]
        ^String e (if (and (pos? (count e)) (= (nth e 0) \+)) (subs e 1) e)]
        ^String fixed-repr (get-fixed rounded-mantissa (if expanded (inc scaled-exp) scaled-exp) d)
        ^String fixed-repr (get-fixed rounded-mantissa (if expanded (inc scaled-exp) scaled-exp) d)
        ^String prefix (:per-line-prefix lb)] 
        ^Throwable root (peek via)]
        ^long port (if (string? port) (Integer/valueOf ^String port) port)
        `(#'assert-same-protocol (var ~name) '~(map :name (vals sigs))))
        `(loop* ~bindings ~@body)
        `(~new-params
        abs (convert-ratio abs)
        add-sign (or (:at params) (neg? arg))
        add-sign (or (:at params) (neg? arg))
        all-sigs (distinct (concat (map #(let[[m p] (key %)] {m [p]}) (mapcat non-private-methods supers))
        amap (or lift-map amap)
        append-zero (and (not d) (<= (dec (count mantissa)) scaled-exp))
        arg (convert-ratio arg)
        arg (convert-ratio arg)]
        arg-count (count field-args)
        arg-navigator)
        arg-types (fn [n] (if (pos? n)
        args (filter (complement keyword?) args)]
        args (init-navigator arg-list)]
        arr)
        as-int (int c)
        assoc-multi (fn [m h bucket]
        bad-args (seq (remove #(vector? %) argdecls))]
        base-char (bit-and as-int 127)
        base-fields fields
        body (if message (next body) body)]
        body (nth clauses (if (> clause-count 1) 1 0))
        body (nthnext form 2)]
        body (nthnext form 3)]
        cause))))
        cause))))
        cause-type (if (contains? #{"Exception" "RuntimeException"} simple-class)
        chars (reduce + (map count strs))
        class-name (name (or class ""))
        class-type  (totype Class)
        classname (symbol (str ns-part "." gname))
        classname (symbol (str ns-part "." gname))
        clause (if (or (neg? arg) (>= arg (count clauses)))
        clause (if arg
        clause (if arg (first clauses))]
        clause-count (count clauses)
        clauses (:clauses params)
        clauses (:clauses params)
        clauses (:clauses params)
        clauses (:clauses params)
        clojure-fn? (and file (or (.endsWith file ".clj")
        clojure-fn? (and file (or (.endsWith file ".clj")
        cname (. name (replace "." "/"))
        cname (.replace pname \. \/) ;(str "clojure/lang/" (gensym "Proxy__"))
        cname (with-meta (symbol (str (namespace-munge *ns*) "." name)) (meta name))]
        colinc (:colinc params)
        colinc (:colinc params)
        colinc (:colinc params)
        compiled-format (if (instance? String raw-format) 
        constructor->map
        ctor-sig-map (or constructors (zipmap (ctor-sigs super) (ctor-sigs super)))
        ctype (. Type (getObjectType cname))
        ctype (. Type (getObjectType cname))
        current (get-column (:base @@*out*))
        cv (clojure.lang.Compiler/classWriter)
        cv (clojure.lang.Compiler/classWriter)]
        d (:d params)
        d (:d params)
        d (:d params) ; digits after the decimal
        d (if d d (max (count mantissa) (min n 7)))
        dd (- d n)]
        def (get directive-table (Character/toUpperCase ^Character directive))
        default (if (odd? (count clauses))
        default-opts {:out-enc default-encoding :in-enc default-encoding :dir *sh-dir* :env *sh-env*}
        delta (- (count m1) (count m2))
        directive (first rest)
        directive-table (hash-map ~@(mapcat process-directive-table-element directives))))
        dispatch-fn (first options)
        docstring  (when (string? (first references)) (first references))
        docstring (str "Positional factory function for class " classname ".")]
        dotloc (.indexOf s (int \.))]
        e (:e params)
        ee (if e (+ e 2) 4)
        emit (fn emit [pred expr args]
        emit-bind (fn emit-bind [[[bind expr & mod-pairs]
        emit-forwarding-method
        emit-get-var (fn [^GeneratorAdapter gen v]
        emit-unsupported (fn [^GeneratorAdapter gen ^Method m]
        err (fn [& msg] (throw (IllegalArgumentException. ^String (apply str msg))))
        ex-type  (totype java.lang.UnsupportedOperationException)
        ex-type  (totype java.lang.UnsupportedOperationException)
        exploc (.indexOf s (int \e))
        extra-pad (- total-pad (* pad slots))
        f (if (.isInstance c x)
        factory-name (str factory)
        false
        field->map
        field-count (count fields)
        fields (conj fields '__meta '__extmap
        fields (ref {:pretty-writer true
        fields (vec (map #(with-meta % nil) fields))
        fields (vec (map #(with-meta % nil) fields))
        fields (vec (map #(with-meta % nil) fields))]
        filter-opts (select-keys opts '(:exclude :only :rename :refer))
        fixed-repr (if (and w d
        fmap "__clojureFnMap"
        form
        full-len (+ (count full-repr) (if add-sign 1 0))]
        full-path))))
        full-repr (str (apply str (repeat (- n (.indexOf fixed-repr (int \.))) \0)) fixed-repr)
        fut (.submit clojure.lang.Agent/soloExecutor ^Callable f)]
        gen-bridge 
        gen-class-call
        gen-class-clause (first (filter #(= :gen-class (first %)) references))
        gen-method
        gexpr (gensym "expr__")
        ginterf (gensym)]
        gthis (with-meta (gensym) {:tag 'clojure.lang.AFunction})
        hash
        hashes (into1 #{} (map hashcode tests))]
        hinted-fields fields
        hinted-fields fields
        hinted-fields fields
        hmap (reduce1
        i (.indexOf s (int match))]
        i (.indexOf s match)]
        i)))
        i))))
        ifn-type (totype clojure.lang.IFn)
        ifn-type (totype clojure.lang.IFn)
        imap-type ^Type (totype IPersistentMap)
        impl-cname (.. impl-pkg-name (replace "." "/") (replace \- \_))
        impl-pkg-name (str impl-ns)
        impls (parse-impls specs)
        in (InputStreamReader. input (encoding opts))]
        in-a (contains? a k)
        in-b (contains? b k)
        iname (fn [^Class c] (.. Type (getType c) (getInternalName)))
        iname (fn [^Class c] (.. Type (getType c) (getInternalName)))
        init-name (str init)
        input)))
        interface-set (set (map resolve interfaces))
        interfaces (-> (map #(if (var? (resolve %)) 
        interfaces (conj interfaces 'clojure.lang.IType)]
        interfaces (map the-class implements)
        interfaces (vec interfaces)
        iseq-type (totype clojure.lang.ISeq)
        java.io.BufferedWriter.
        java.io.PrintWriter.)))
        lb (:logical-block nl)
        lb (:logical-block nl)
        len (count m1)
        load (cond reload-all
        loaded (contains? @*loaded-libs* lib)
        loc)))
        loc)))
        lock (Object.)]
        m           (if (map? (first options))
        m           (if (meta mm-name)
        m           (if docstring
        m1 (rtrim m \0)
        m2 (ltrim m1 \0)
        main-name "main"
        map)))
        max-columns (or (first (:max-columns else-params))
        maxcol (get-max-column (getf :base))]
        meta (bit-and as-int 128)
        metadata   (when (map? (first references)) (first references))
        method->map
        methodname-set (set (map first methods))
        methods (map (fn [[name params & body]]
        meths (mapcat (fn [sig]
        min-remaining (or (first (:min-remaining else-params)) 0)
        mincol (:mincol params)
        minout (+ chars (* slots minpad))
        minpad (:minpad params)
        mm-name (with-meta mm-name m)]
        mod-body (pll-mod-body count-var body)]
        n (:n params) ; minimum digits before the decimal
        n (if (= arg 0.0) 0 (inc exp))
        n (second bindings)]
        n (second bindings)]
        name
        name (if docstring
        name (if metadata
        name (str name)
        name-meta (meta name)
        name-metadata (meta name)]
        navigator
        navigator
        navigator
        navigator
        navigator (init-navigator args)]
        navigator (or new-navigator navigator)
        navigator (or new-navigator navigator)
        navigator)
        need-ns (or as use)
        nlis (first (rest (rest alis)))]
        ns-part (namespace-munge *ns*)
        ns-part (namespace-munge *ns*)
        obj-type (totype Object)
        obj-type ^Type (totype Object)
        offset (if (pos? colinc) (rem start-col colinc) 0)
        offset-minutes (- (.length calstr) 2)]
        old-vals (zipmap (keys binding-map)
        options     (if (map? (first options))
        options     (if (string? (first options))
        options     (next options)
        opts (apply hash-map options)
        opts (interleave flags (repeat true))
        out (OutputStreamWriter. output (encoding opts))]
        out *out*
        over-count (count over)
        overloads (into1 {} (filter (fn [[m s]] (next s)) sigs-by-name))
        p#)))
        pad (max minpad (quot total-pad slots))
        pad-str (apply str (repeat pad (:padchar params)))]
        param (re-find m)]
        param-clause (first (:clauses params))
        param-clause (first (:clauses params))
        param-clause (first (:clauses params))
        param-clause (first (:clauses params))
        params (:params def)))
        params (if def (map-params def (map translate-param raw-params) flags offset))]
        pb (fn pb [bvec b v]
        pkg-name name
        pname (proxy-name super interfaces)
        post-init-name (str post-init)
        pred (first form)]
        prefix (cond
        prefix (if ns (str "#:" ns "{") "{")]
        prepend-zero (= (first fixed-repr) \.)]
        print-via #(do (.write w "{:type ")
        proc (.exec (Runtime/getRuntime) 
        process-entry (fn [bvec b] (pb bvec (first b) (second b)))]
        psig (fn [[name [& args]]]
        push-chars (fn []
        rd (-> socket .getInputStream InputStreamReader. BufferedReader. LineNumberingPushbackReader.)
        re (nth form 2)
        read-eval-print
        reader (LineNumberingPushbackReader. (java.io.StringReader. str))]
        readf (resolve-fn readf)
        references (if docstring (next references) references)
        references (if metadata (next references) references)
        references (remove #(= :gen-class (first %)) references)
        refl (partial do-reflect reflector)
        request-exit (Object.)
        request-prompt (Object.)
        result (refl typeref)]
        result-columns (if (<= minout mincol) 
        ret)))
        ret)))
        ret)))
        ret))))
        ret)))))
        rt-type  (totype clojure.lang.RT)
        rt-type  (totype clojure.lang.RT)
        s
        s (if (and first? f (Character/isLetter f))
        same (and in-a in-b
        scaled-exp (+ exp (:k params))
        script (if (= :uninitialized script)
        section (seq (take-while #(let [nl-lb (:logical-block %)]
        section (seq (take-while #(not (and (nl-t? %) (ancestor? (:logical-block %) lb)))
        sigs (when sigs
        sigs-by-name (apply merge-with concat {} all-sigs)
        simple-class (if class (or (first (re-find #"([^.])++$" class-name)) class-name))
        skip-check (->> buckets
        slots (max 1
        snapshot (fn []
        socket (Socket. host port)
        space-count (+ colrel (if (= 0 offset) 0 (- colinc offset)))]
        space-count (cond
        special (get special-chars base-char)]
        start-col (+ colrel (get-column (:base @@*out*)))
        state-name (str state)
        steps (map (fn [[test step]] `(if ~test (-> ~g ~step) ~g))
        steps (map (fn [[test step]] `(if ~test (->> ~g ~step) ~g))
        steps (map (fn [step] `(if (nil? ~g) nil (-> ~g ~step)))
        steps (map (fn [step] `(if (nil? ~g) nil (->> ~g ~step)))
        suffix (cond
        super (if extends (the-class extends) Object)
        super-type ^Type (totype super)
        super-type ^Type (totype super)
        supers (cons super interfaces)
        sym-type (totype clojure.lang.Symbol)
        tail
        tapfn #(out-fn {:tag :tap :val %1})]
        target-len (if d (+ e1 d 1) (inc e1))]
        tens (rem num 100)]
        tens (rem num 100)]
        tgarr (with-meta garr {:tag (symbol (str t "s"))})]
        this))))
        this)))))
        thisfn (fn thisfn [plseq]
        to-types (fn [cs] (if (pos? (count cs))
        to-types (fn [cs] (if (pos? (count cs))
        total-pad (- result-columns chars)
        totype (fn [^Class c] (. Type (getType c)))
        totype (fn [^Class c] (. Type (getType c)))
        true
        true
        type-hash (hash classname)]
        undefined-on-entry (not (find-ns lib))]
        url-path (.replace classname \. \/)]
        util-type (totype clojure.lang.Util)
        v (atom d)]
        v))))
        val#)
        var-fields (concat (when init [init-name]) 
        var-name (fn [s] (clojure.lang.Compiler/munge (str s "__var")))
        var-type ^Type (totype clojure.lang.Var)
        vb (get b k)
        via (loop [via [], ^Throwable t o]
        w (:w params)
        w (:w params) ; minimum field width
        wr (-> socket .getOutputStream OutputStreamWriter.)
        ww (if w (- w ee))
        x))))
        xs)))
        xs)))
        {:cause root-msg})
        {:clojure.error/keys [source] :as top-data} (:data (first via))]
        {:clojure.spec.alpha/keys [problems fn], :clojure.spec.test.alpha/keys [caller]} data
        {:data data})
        {:diff-similar (fn [a b] ((if (.. a getClass isArray) diff-sequential atom-diff) a b))}
        {:diff-similar atom-diff})
        {:equality-partition (fn [x] (if (.. x getClass isArray) :sequential :atom))})
        {:exit exit-code :out @out :err @err}))))
        {:file (.getFileName s) :line (.getLineNumber s)})
        {:keys [as reload reload-all require use verbose]} opts
        {:keys [in in-enc out-enc]} opts]
        {:keys [name extends implements constructors methods main factory state init exposes 
        {:keys [type message data]} (last via)
        {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent))
        {:phase phase}))))
        })))
        ~@(map process-reference references))
        ~@(when (and (not= name 'clojure.core) (not-any? #(= :refer-clojure (first %)) references))
        ~@(when gen-class-call (list gen-class-call))
        ~@body
       "."
       "com.google.common." "http://google.github.io/guava/releases/23.0/api/docs/"
       "java." *core-java-api*
       "javax." *core-java-api*
       "org.apache.commons.codec." "http://commons.apache.org/proper/commons-codec/apidocs/"
       "org.apache.commons.io." "http://commons.apache.org/proper/commons-io/javadocs/api-release/"
       "org.apache.commons.lang." "http://commons.apache.org/proper/commons-lang/javadocs/api-2.6/"
       "org.apache.commons.lang3." "http://commons.apache.org/proper/commons-lang/javadocs/api-release/")))
       "org.ietf.jgss." *core-java-api*
       "org.omg." *core-java-api*
       "org.w3c.dom." *core-java-api*
       "org.xml.sax." *core-java-api*
       #"(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9_]+))?(?:-(SNAPSHOT))?"
       #(if (sequential? %)
       ()))
       ())))
       (. ParallelArray createUsingHandoff  
       (. clojure.lang.Var (pushThreadBindings ~amap))
       (. java.util.Arrays (sort a comp))
       (. latch (await  timeout-ms (. java.util.concurrent.TimeUnit MILLISECONDS))))))
       (. ~t (~name ~@args)))))
       (.. (name lib)
       (.assoc this (.getKey pair) (.getValue pair)))
       (.assoc this (.nth vec 0) (.nth vec 1)))
       (.deref ^clojure.lang.IBlockingDeref ref timeout-ms timeout-val)
       (.getString stream)
       (.getString stream)
       (.isAssignableFrom java.lang.annotation.Annotation c)))
       (.ppflush ^PrettyFlush *out*))))
       (.reduce ^clojure.lang.IReduce coll f)
       (.reduce ^clojure.lang.IReduceInit coll f val)
       (.replace (if (some #{\. \[} strx)
       (.replaceFirst (re-matcher ^Pattern match s)
       (.setErrorMode a (or (:error-mode opts)
       (.toString bout))))
       (:at params)               #(format-new-roman %1 %2 %3)
       (:base-args params)))
       (:colon (:params this))))
       (:colon params)            #(format-ordinal-english %1 %2 %3)
       (:minor *clojure-version*)
       (< y (first more)))
       (<= y (first more)))
       (= \9 (.charAt s i)) (recur (dec i))
       (= y (first more)))
       (== y (first more)))
       (> level 5) 
       (> y (first more)))
       (>= y (first more)))
       ([] (ctor))
       ([] (f (g)))
       ([] (f))
       ([] (f1))
       ([] (rf))
       ([] [(f) (g) (h)])
       ([] [(f) (g)])
       ([] [(f)])
       ([] nil)
       ([] nil)
       ([] nil)
       ([] true)
       ([] true)
       ([] true)
       ([^chars cbuf ^Integer off ^Integer len] 
       ([array# idx# idx2# & idxv#]
       ([array# idx# val#]
       ([f coll]
       ([f val coll]
       ([left right] (cat left right))))
       ([result input]
       ([result] (rf result))
       ([ret v]
       ([x y & more]
       ([x y z & args] (boolean (and (ep1 x y z)
       ([x y z & args] (boolean (and (ep2 x y z)
       ([x y z & args] (boolean (and (ep3 x y z)
       ([x y z & args] (f (apply g x y z args)))))
       ([x y z & args] (or (sp1 x y z)
       ([x y z & args] (or (sp2 x y z)
       ([x y z & args] (or (sp3 x y z)
       ([x y z & args] [(apply f x y z args) (apply g x y z args) (apply h x y z args)])))
       ([x y z & args] [(apply f x y z args) (apply g x y z args)])))
       ([x y z & args] [(apply f x y z args)])))
       ([x y z] (boolean (and (p x) (p y) (p z))))
       ([x y z] (boolean (and (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z))))
       ([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] (f (g x y z)))
       ([x y z] (or (p x) (p y) (p z)))
       ([x y z] (or (p1 x) (p1 y) (p1 z) (p2 x) (p2 y) (p2 z)))
       ([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] [(f x y z) (g x y z) (h x y z)])
       ([x y z] [(f x y z) (g x y z)])
       ([x y z] [(f x y z)])
       ([x y] (boolean (and (p x) (p y))))
       ([x y] (boolean (and (p1 x) (p1 y) (p2 x) (p2 y))))
       ([x y] (boolean (and (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y))))
       ([x y] (f (g x y)))
       ([x y] (f x y)))))
       ([x y] (let [op (if *unchecked-math* unchecked-op op)]
       ([x y] (or (p x) (p y)))
       ([x y] (or (p1 x) (p1 y) (p2 x) (p2 y)))
       ([x y] (or (p1 x) (p2 x) (p3 x) (p1 y) (p2 y) (p3 y)))
       ([x y] [(f x y) (g x y) (h x y)])
       ([x y] [(f x y) (g x y)])
       ([x y] [(f x y)])
       ([x]
       ([x]
       ([x] (boolean (and (p1 x) (p2 x) (p3 x))))
       ([x] (boolean (and (p1 x) (p2 x))))
       ([x] (boolean (p x)))
       ([x] (cf x))
       ([x] (f (g x)))
       ([x] (let [op (if *unchecked-math* unchecked-op op)]
       ([x] (or (p1 x) (p2 x) (p3 x)))
       ([x] (or (p1 x) (p2 x)))
       ([x] (p x))
       ([x] [(f x) (g x) (h x)])
       ([x] [(f x) (g x)])
       ([x] [(f x)])
       (alter-meta! #'~type-name assoc :private true)
       (alter-meta! (var ~name) assoc :inline (fn ~name ~args ~expr))
       (and (:at params) (:colon params))   #(format-old-roman %1 %2 %3)
       (and (= cnt (count o))
       (and (= cnt (count o))
       (and (branch? loc) (down loc))
       (and (class? child) (some #(contains? ((:ancestors h) %) parent) (supers child)))
       (and (class? parent) (class? child)
       (and (empty? argv) (empty? args))
       (and (pos? (count argv))
       (and (vector? parent) (vector? child)
       (aset-int dimarray i (nth dims i)))
       (binding [*out* wrapped-stream]
       (binding [*print-pretty* true]
       (cat (concat x y) zs))))
       (catch IllegalStateException e
       (catch Throwable t
       (caught e)
       (clojure.core.protocols/coll-reduce coll f init))))
       (clojure.core.protocols/coll-reduce coll f val))))
       (clojure.core.protocols/coll-reduce coll f)))
       (clojure.core.protocols/kv-reduce coll f init)
       (clojure.core/in-ns '~name)
       (clojure.lang.LazilyPersistentVector/create coll))
       (clojure.lang.Util/equiv (seq this) (seq o))
       (clojure.lang.Util/equiv y (first more)))
       (cond
       (cond
       (conj result (:name fd))
       (cons init
       (contains? ((:ancestors h) child) parent)
       (copy in bout :encoding enc)
       (decimal? x) (.toBigInteger ^BigDecimal x)
       (decimal? x) (bigint (.toBigInteger ^BigDecimal x))
       (decimal? x) x
       (declare ~(symbol (str  '-> gname)))
       (declare ~(symbol (str 'map-> gname)))
       (def ~name ~expr))))
       (defn my-function [x y]
       (defn ~(symbol (str 'map-> gname))
       (defn ~name ~@pre-args ~args ~(apply (eval (list `fn args expr)) args))
       (defn- ~(symbol (str "make-" name-str)) 
       (defn- ~(symbol (str name-str "?")) [x#] (= (:type-tag x#) ~(keyword name-str))))))
       (defstruct ~type-name :type-tag ~@fields)
       (deref
       (deref [_] (.await d) @v)
       (deref-future ref timeout-ms timeout-val))))
       (do
       (do
       (do
       (do (ref-set (:done-nl lb) true)
       (do ~@body))))
       (do-report summary)
       (do-report {:type :fail, :message ~msg,
       (do-report {:type :pass, :message ~msg,
       (doseq [[local-mname ^java.lang.reflect.Method m] (reduce1 (fn [ms [[name _ _] m]]
       (doseq [[mname pclasses rclass :as msig] methods]
       (doseq [agent agents]
       (doseq [e (if (nil? n)
       (dotimes [i (dec cnt)]
       (every? #(contains? set1 %) set2)))
       (every? #(contains? set2 %) set1)))
       (f ret))))
       (f)))
       (f))))
       (finally
       (first (:base params))     #(format-integer (:base %1) %1 %2 %3)
       (float? x)  (bigint (. BigDecimal valueOf (double x)))
       (float? x) (. BigDecimal valueOf (double x))
       (float? x) (.toBigInteger (. BigDecimal valueOf (double x)))
       (fn
       (fn
       (fn
       (fn
       (fn
       (fn
       (fn
       (fn
       (fn
       (fn [[^String s offset]]
       (fn []
       (fn [month leap-year?]
       (fn [params navigator offsets]
       (fn epn
       (fn spn
       (format-error "No closing bracket found." offset)
       (gen-interface :name ~cname :methods ~(vec (map psig sigs)))
       (get-child-count parent))
       (handle [signal]
       (if (.hasNext iter)
       (if (< i len)
       (if (< tens 20) 
       (if (< tens 20) 
       (if (< ~idx  l#)
       (if (< ~idx l#)
       (if (>= i (.tailoff this))
       (if (contains? map old)
       (if (fn? ret)
       (if (identical? (class s) cls)
       (if (nil? me)
       (if (nil? temp#)
       (if (not (= 0 (get-column *out*)))
       (if (or (not *print-length*) (< ~count-var *print-length*))
       (if (pos? cnt) (fresh-line))
       (if (pos? hundreds) "th")))))
       (if ks
       (if ks
       (if more
       (if more
       (if more
       (if result#
       (if result#
       (if xs
       (if-let [e (first st)]
       (if-let [st (seq this)]
       (import ~classname)
       (import ~classname)
       (import ~cname))))
       (init-navigator arg)
       (instance? BigInteger x) (BigDecimal. ^BigInteger x)
       (instance? BigInteger x) (clojure.lang.BigInt/fromBigInteger x)
       (instance? BigInteger x) x
       (instance? clojure.lang.BigInt x) (.toBigDecimal ^clojure.lang.BigInt x)
       (instance? clojure.lang.BigInt x) (.toBigInteger ^clojure.lang.BigInt x)
       (instance? clojure.lang.BigInt x) x
       (interface-or-naive-reduce s f val))
       (internal-reduce (next s) f (first s))
       (internal-reduce s f val))))
       (is (= -1 (+ 3 -4)))))
       (is (= -4 (+ -2 -2)))
       (is (= 4 (+ 2 2)))
       (is (= 7 (+ 3 4))))
       (keepi 0 coll))))
       (lazy-seq (step n coll)))))
       (lazy-seq (step pred coll)))))
       (let [[arg navigator] (next-arg navigator)]
       (let [[subformat navigator] (get-format-arg navigator)
       (let [[subformat navigator] (get-format-arg navigator)]
       (let [^String prefix (:per-line-prefix (first (getf :logical-blocks)))
       (let [dv (volatile! true)]
       (let [flag (get flag-defs (first s))]
       (let [ik (select-keys x ks)]
       (let [iv (volatile! -1)]
       (let [n (or (:n params) 0)] ; ~@* has a default n = 0
       (let [n (or (:n params) 1)] ; whereas ~* and ~:* have a default n = 1
       (let [navigator# (#'clojure.pprint/init-navigator args#)]
       (let [navigator# (my-i-n# args#)]
       (let [new-buffer (write-token-string this buffer)]
       (let [node (.arrayFor vec aidx)
       (let [nv (volatile! n)]
       (let [nv (volatile! n)]
       (let [oldpos (getf :pos)
       (let [oldpos (getf :pos)
       (let [pos (getf :pos)]
       (let [ret (.reduce (chunk-first s) f val)]
       (let [st (.getStackTrace e)
       (let [this (first remainder)
       (let [widths (map
       (let [z (int 0)]
       (let [~ginterf
       (let [~x (first xs#)]
       (list (resolve-tag (asig fdecl)))))))
       (list @init)
       (loop [p loc]
       (loop [ret (.next iter)]
       (loop [ret [] fdecls fdecl]
       (loop [~i 0]
       (loop [~i 0]
       (map #(if-let [e (find smap %)] (val e) %) coll))))
       (monitor-exit lockee#)))))
       (neg? i) (apply str "1" (repeat (inc len-1) "0"))
       (new VecSeq am vec (.arrayFor vec nexti) nexti 0))))
       (newline)
       (newline)
       (number? x) (BigDecimal/valueOf (long x))
       (number? x) (BigInteger/valueOf (long x))
       (number? x) (clojure.lang.BigInt/valueOf (long x))
       (or (.startsWith class-name "clojure.lang.")
       (or (indivisible? year 100)
       (print " at ") 
       (print "Caused by: " )
       (print (apply str (repeat n \~)))
       (print (if (= arg 1) (first strs) (second strs)))
       (print \formfeed))
       (print-throwable tr)
       (println "<?xml version=\"1.0\" encoding=\"UTF-8\"?>")
       (println "<testsuites>"))
       (println (str (-> e class .getSimpleName) " "
       (prn actual)))))
       (prn))
       (prn))
       (proxy [Writer IDeref] []
       (pst e-or-depth 12)
       (push-thread-bindings (hash-map ~@(var-ize bindings)))
       (ratio? x) (.bigIntegerValue ^clojure.lang.Ratio x)
       (ratio? x) (/ (BigDecimal. (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))
       (ratio? x) (bigint (.bigIntegerValue ^clojure.lang.Ratio x))
       (recur (conj v (first xn)) (next xn))
       (recur (inc pos))))))
       (recur cause n))))
       (recur ret (first ks) (next ks))
       (recur ret (first ks) (next ks))
       (recur ret (first ks) (next ks))
       (recur ret (first kvs) (second kvs) (nnext kvs))
       (recur s2 s1)
       (recur y (first more) (next more))
       (recur y (first more) (next more))
       (recur y (first more) (next more))
       (recur y (first more) (next more))
       (recur y (first more) (next more))
       (recur y (first more) (next more))
       (recur y (first more) (next more))
       (recur))))
       (reduce (fn [result item]
       (reduce (fn [result item] 
       (reduce (fn [ret x]
       (reduce conj s1 s2)))
       (reduce conj s2 s1)
       (reduce conj to from)))
       (reduce disj s1 s2)))
       (reduce intersection (first bubbled-sets) (rest bubbled-sets)))))
       (reduce into (first bubbled-sets) (rest bubbled-sets)))))
       (reduce1 (fn [v i]
       (reduced ret)
       (ref-set (:indent lb) col)))))
       (ref-set (:start-col lb) col)
       (reify Object 
       (reify clojure.lang.Seqable 
       (repl-opt nil nil)
       (replace-first-by s match replacement))
       (rfn [f1 k]
       (rfn [f1 k]
       (rfn [f1 k]
       (right loc)
       (set! *e e)
       (setup-reference a options)
       (skip-whitespace *in*))
       (stack/print-cause-trace actual *stack-trace-depth*)
       (start-case (test-name *var-context*) (name (ns-name (:ns (meta var)))))))))
       (str "  actual:"
       (str s#))))
       (str/replace "[]" "<>")
       (symbol))
       (t/with-test-out (println "</testsuites>"))
       (take-while include (. sc seq false)))))
       (take-while include (. sc seq true)))))
       (throw (IllegalArgumentException. (str "Unrecognized type " ~t))))))
       (throw (new Exception "Can't await in agent action")))
       (throw (new IllegalStateException ~(or message "I/O in transaction")))
       (throw ex))))
       (throw ex)))))
       (transduce xform conj to from))))
       (try
       (try
       (up m ks f args))))
       (var ~name))))
       (when (#{:read-source :macro-syntax-check :macroexpansion :compile-syntax-check :compilation}
       (when (. m (find))
       (when (:error-handler opts)
       (when (:interim *clojure-version*)
       (when (meta name) (.setMeta v (meta name)))
       (when (meta name) (.setMeta v (meta name)))
       (when (seq extends)
       (when (symbol? k)
       (when alis
       (when server-socket
       (when temp#
       (when-let [[e :as s] (. sc seqFrom key false)]
       (when-let [[e :as s] (. sc seqFrom key true)]
       (when-let [e *e]
       (when-let [i (:incremental *clojure-version*)]
       (when-let [q (:qualifier *clojure-version*)]
       (when-let [s (seq coll)]
       (when-let [s (seq coll)]
       (when-not 
       (with-loading-context
       (with-meta (persistent! (reduce conj! (transient to) from)) (meta to))
       (with-meta (persistent! (transduce xform conj! (transient to) from)) (meta to))
       (with-meta (seq a) (meta coll)))
       (with-meta coll nil)
       (with-open [^java.io.Reader r (apply jio/reader f opts)]
       (write-to-base prefix))
       (zero? (.getCount d)))
       (zero? (:error summary 0))))
       (zero? subidx) nil
       (~args ~@body))))
       (~cargs (fn [x#] (~name ~@cargs x#)))
       1      1       1    
       2      4       8    
       3      9      27    
       4     16      64    
       5     25     125    
       6     36     216    
       7     49     343    
       8     64     512    
       9     81     729    
       :added "1.0"}
       :added "1.0"} 
       :added "1.2"}
       :author "Rich Hickey"}
       :author "Rich Hickey"}
       :author "Rich Hickey"}
       :author "Rich Hickey"}
       :author "Rich Hickey"}
       :author "Rich Hickey"}
       :author "Stephen C. Gilardi and Rich Hickey"}
       :author "Stuart Sierra"}
       :author "Stuart Sierra"}
       :author "Stuart Sierra"}
       :doc "Returns escape string for char or nil if none"
       :doc "Returns name string for char or nil if none"
       :doc "The instance member form works for both fields and methods.
       :else (BigDecimal. x)))
       :else (BigInteger. x)))
       :else (apply str (subs s 0 i)
       :else (bigint (BigInteger. x))))
       :else (let [arr (aclone ^objects (.arr node))]
       :filter-with [< [110 2 33 2]]))
       :forms [(.instanceMember instance args*)
       :implements ~interfaces 
       ;; (are [] true) is meaningless but ok
       ;; Catch wrong number of args
       FAIL in  (:1)
       [format-str 0])))))
       [nil [s offset flags]]
       [o s])
       [o s])
       [remainder offset])]))
       [~@field-args ~@(if (seq over) '[& overage] [])]
       `(deftype* ~(symbol (name (ns-name *ns*)) (name tagname)) ~classname
       `(when-not ~x
       `(when-not ~x
       a)))
       am#
       arg-navigator)))
       argument
       bindings for set!-able vars in place.
       body 
       clojure.set)
       coll
       default: #()
       default: (if (instance? LineNumberingPushbackReader *in*)
       default: eval
       default: flush
       default: prn
       default: repl-caught"
       default: repl-prompt
       default: repl-read
       expected: (= 5 (+ 2 2))
       false
       fkv)
       foo/baz my.project/baz}
       iname nil "java/lang/Object"
       navigator)))
       nil))
       offset-sign offset-hours offset-minutes]
       pos
       read, eval, or print throws an exception or error
       read-eval-print except the first, the user will be prompted if it
       result#)))
       result#)))
       result#)))
       result))
       result)))
       ret)))
       ret))))
       ret))))
       ret))))
       ret))))
       returns true.
       summary)))
       true                       #(format-cardinal-english %1 %2 %3))))
       user> (is (= 5 (+ 2 2)))
       v))
       v)))
       v))))
       val))))
       version-string)
       {'def pprint-hold-first, 'defonce pprint-hold-first, 
       {:arglists '([~'array ~'idx ~'val] [~'array ~'idx ~'idx2 & ~'idxv])}
       ~(build-positional-factory gname classname fields)
       ~(build-positional-factory gname classname fields)
       ~(emit gpred gexpr clauses))))
       ~(emit-defrecord name gname (vec hinted-fields) (vec interfaces) methods opts)
       ~(emit-deftype* name gname (vec hinted-fields) (vec interfaces) methods opts)
       ~(if (empty? steps)
       ~(if (empty? steps)
       ~(if (empty? steps)
       ~(if (empty? steps)
       ~(if (seq over)
       ~@(map (fn [[t fs]]
       ~@(mapcat identity opts)
       ~@(when name-metadata
       ~@body
       ~@body
       ~@body
       ~@body
       ~@body)))
       ~@methods)))
       ~classname)))
       ~classname)))
       ~docstring
      ""
      ""
      "A library for reduction and parallel folding. Alpha and subject
      "An implementation of a Common Lisp compatible format function"
      "Too many parameters for directive \"~C\": ~D~:* ~[were~;was~:;were~] specified but only ~D~:* ~[are~;is~:;are~] allowed"
      "fifteen" "sixteen" "seventeen" "eighteen" "nineteen"])
      "fifteenth" "sixteenth" "seventeenth" "eighteenth" "nineteenth"])
      "isDesktopSupported" (to-array nil))
      "octodecillion" "novemdecillion" "vigintillion"])
      "quindecillion" "sexdecillion" "septendecillion" 
      "sextillion" "septillion" "octillion" "nonillion" "decillion" 
      "sixtieth" "seventieth" "eightieth" "ninetieth"])
      "ten" "eleven" "twelve" "thirteen" "fourteen"
      "tenth" "eleventh" "twelfth" "thirteenth" "fourteenth"
      "undecillion" "duodecillion" "tredecillion" "quattuordecillion" 
      #(let [f1 (fc v1)
      #foo/bar [1 2 3]
      'boolean Boolean/TYPE
      'booleans (Class/forName "[Z")
      'byte Byte/TYPE
      'bytes (Class/forName "[B")
      'char Character/TYPE
      'chars (Class/forName "[C")})
      'double Double/TYPE
      'doubles (Class/forName "[D")
      'float Float/TYPE
      'floats (Class/forName "[F")
      'ints (Class/forName "[I")
      'long Long/TYPE
      'longs (Class/forName "[J")
      'short Short/TYPE
      'shorts (Class/forName "[S")
      'var "#'", 'clojure.core/unquote "~"})
      'void Void/TYPE
      ((:content *current*) 0)))) 
      ((:zip/children (meta loc)) (node loc))
      ((formatter-out "~{~w~^ ~_~}") alis))))
      (+ m div))))
      (- (:end-pos (last l)) (:start-pos (first l)))
      (-> (clojure.lang.Reflector/invokeStaticMethod "java.awt.Desktop" 
      (-> file .toURI str)
      (. cv (visitField (+ (. Opcodes ACC_PRIVATE) (. Opcodes ACC_FINAL) (. Opcodes ACC_STATIC))
      (. cv (visitField (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_FINAL))
      (. gen (checkCast imap-type))
      (. gen (dup))
      (. gen (endMethod)))
      (. gen (endMethod)))
      (. gen (endMethod)))
      (. gen (endMethod)))
      (. gen (getField ctype fmap imap-type))
      (. gen (getField ctype fmap imap-type))
      (. gen (invokeInterface (totype clojure.lang.IPersistentCollection)
      (. gen (loadArgs))
      (. gen (loadArgs))
      (. gen (loadThis))
      (. gen (loadThis))
      (. gen (loadThis))
      (. gen (putField ctype fmap imap-type))
      (. gen (putField ctype fmap imap-type))
      (. gen (returnValue))
      (. gen (returnValue))
      (. gen (returnValue))
      (. gen (returnValue))
      (. gen (visitCode))
      (. gen (visitCode))
      (. gen (visitCode))
      (. gen (visitCode))
      (. latch (await)))))
      (.aget am a (bit-and i (int 0x1f)))))
      (.append w \"))
      (.assocN this k v)
      (.bindRoot v (build cache)))))
      (.checkCast gen (totype clojure.lang.IPersistentCollection))
      (.chunkedNext this)))
      (.close (.getOutputStream proc)))
      (.close conn))))
      (.defineClass ^DynamicClassLoader (deref clojure.lang.Compiler/LOADER)
      (.getName (java.io.File. full-path))
      (.getPath f))))
      (.nth this (dec cnt))))
      (.resetMeta r (:meta opts)))
      (.setBounds 32 32 700 900)
      (.setContentPane (javax.swing.JScrollPane. htmlpane))
      (.setMaxHistory r (:max-history opts)))
      (.setMinHistory r (:min-history opts)))
      (.setStackTrace
      (.setStackTrace exception trace)
      (.setValidator r (:validator opts)))
      (.setVisible true))))
      (.toString buffer)
      (.toUpperCase s)
      (.write ^java.io.Writer *out* " ")
      (.write ^java.io.Writer *out* " ")
      (.write ^java.io.Writer *out* " ")
      (.write ^java.io.Writer *out* " ")
      (.write ^java.io.Writer *out* macro-char)
      (.write w " "))))
      (.write w "#")
      (.write w "\n :data ")
      (.write w "\n :trace\n [")
      (.write w "\n :via\n [")
      (.write w "]"))
      (.write w "]")))
      (.write w "^")
      (.write w (.getName c))))
      (:directive def) (count params) (count (:params def)))
      (Cat. (+ (count left) (count right)) left right))))
      (IllegalArgumentException.
      (IllegalArgumentException. "Interface methods must not contain '-'")))
      (Type/getObjectType 
      (URLDecoder/decode "UTF-8")))
      (VecSeq. am this (.arrayFor this 0) 0 0)))
      ([]
      ([] (rf))
      ([result input]
      ([result] (rf result))
      ([this x]
      ([x y z & args]
      ([x y z]
      ([x y]
      ([x]
      (absolute-reposition navigator newpos)
      (add-annotation av (name k) v))
      (add-core-ns
      (addTableModelListener [tableModelListener])
      (alter-var-root #'servers assoc name {:name name, :socket socket, :sessions {}}))
      (and (vector? x)
      (apply (formatter-out "~w ~@_~w ~@_~w ~_") alis)
      (apply pr more)))
      (apply prn more)))
      (apply str 
      (apply with-bindings* bindings f args))))
      (as-file (escaped-utf8-urlstring->str
      (aset ^objects (.arr ret) subidx node-to-insert)
      (assoc [k v] (assoc (snapshot) k v))
      (assoc attrs :package package)
      (atom-diff a b))))
      (bar [x y] ...)
      (bar [x y] ...)
      (bar [x y] ...)
      (bar [x y] ...)
      (bar [x y] ...))
      (base-str base val))))
      (baz ([x] ...) ([x y & zs] ...)))
      (binding [*in* (or stdin in-reader)
      (binding [*out* (get-pretty-writer *out*)]
      (binding [*out* *err*]
      (binding [*symbol-map* (if (= 1 (count args)) 
      (binding-map (if (or (not (= *print-base* 10)) *print-radix*) {#'pr pr-with-base} {}) 
      (browse-url url)
      (call)
      (cancel [_ interrupt?] (.cancel fut interrupt?)))))
      (case phase
      (catch Throwable e
      (catch Throwable e
      (catch Throwable t
      (catch Throwable t))))
      (check-cyclic-dependency path)
      (check-valid-options options :default :hierarchy)
      (clojure.core/format format-str val)
      (clojure.lang.Compiler/maybeResolveIn (the-ns ns) sym))))
      (clojure.lang.MapEntry/create k (.nth this (int k)))
      (clojure.lang.MethodImplCache. (.sym cache) (.protocol cache) (.methodk cache) cs))
      (clojure.lang.RT/assoc clojure-version :interim true)
      (close []
      (close [] (.close writer))
      (close [] (.close writer))
      (cnt [c] ...)
      (coll-fold [_ n combinef reducef]
      (coll-reduce [_ f1 init]
      (coll-reduce [_ f1 init]
      (coll-reduce [_ f1]
      (coll-reduce [this f1]
      (cond
      (cond
      (cond
      (cond
      (cond
      (cond (pred x y) -1 (pred y x) 1 :else 0)))
      (cons [m] (conj (snapshot) m))
      (consume 
      (containsKey [k] (contains? pmap k))
      (count [] (count pmap))
      (deref [] fields)
      (deref-future fut timeout-ms timeout-val))
      (diff-similar a b)
      (do
      (do
      (do (print-one (key e) w) (.append w \space) (print-one (val e) w)))
      (do-report {:type :begin-test-ns, :ns ns-obj})
      (do-report {:type :begin-test-var, :var v})
      (do-report {:type :end-test-ns, :ns ns-obj}))
      (do-report {:type :end-test-var, :var v}))))
      (doseq [[^java.lang.reflect.Method dest bridges] mb
      (doseq [^java.lang.reflect.Method meth (vals mm)]
      (doseq [^java.lang.reflect.Method meth ifaces-meths]
      (doseq [^java.lang.reflect.Method meth mm]
      (doseq [agent agents]
      (doseq [c (:content e)]
      (doseq [m ms
      (doseq [role [:args :ret :fn]]
      (doseq [sym to-do]
      (doseq [v var-fields]
      (dosync 
      (dotimes [n (count s)]
      (doto (JPanel. (BorderLayout.))
      (doto (java.text.SimpleDateFormat. "yyyy-MM-dd'T'HH:mm:ss")
      (doto (java.text.SimpleDateFormat. "yyyy-MM-dd'T'HH:mm:ss.SSS-00:00")
      (entryAt [k] (when (contains? pmap k) (clojure.lang.MapEntry/create k (v k))))
      (enumeration-seq (.getResources cl "data_readers.clj"))
      (enumeration-seq (.getResources cl "data_readers.cljc")))))
      (eqhash [[i m]] 
      (even? (count bindings)) "an even number of forms in binding vector")
      (execute-sub-format 
      (execute-sub-format clause navigator (:base-args params))
      (execute-sub-format clause navigator (:base-args params))
      (execute-sub-format clause navigator (:base-args params)))))
      (exponential-float params navigator offsets))))
      (finally
      (finally
      (finally (. clojure.lang.Var (popThreadBindings))))))
      (finally (update-proxy this m)))))
      (find-ns name) `(#'print-doc (#'namespace-doc (find-ns '~name)))
      (flush []
      (flush [] (.flush writer))
      (flush [] (.flush writer))
      (flush)))
      (fn
      (fn
      (fn
      (fn [element context]
      (foo [x] ...)
      (foo [x] ...)
      (foo [x] ...)
      (foo [x] ...)
      (format "Error printing return value%s at %s (%s).%n%s%n" cause-type symbol loc cause)
      (format "Error reading eval result%s at %s (%s).%n%s%n" cause-type symbol loc cause)
      (format "Syntax error macroexpanding %sat (%s).%n%s"
      (format "Syntax error reading source at (%s).%n%s%n" loc cause)
      (format "Syntax error%s compiling %sat (%s).%n%s%n"
      (format "Unexpected error%s compiling %sat (%s).%n%s%n"
      (format "Unexpected error%s macroexpanding %sat (%s).%n%s%n"
      (format-ascii print-str {:mincol (:mincol params) :colinc 1 :minpad 0 
      (format-error "Format string ended in the middle of a directive" offset))
      (format-error (str "Cannot combine \"@\" and \":\" flags for format directive \"" 
      (format-error (str "Directive \"" directive "\" is undefined") offset))
      (format-error (str "\":\" is an illegal flag for format directive \"" (:directive def) "\"")
      (format-error (str "\"@\" is an illegal flag for format directive \"" (:directive def) "\"")
      (format-integer ;; for anything <= 0 or > 3999, we fall back on ~D
      (func)
      (future
      (future (stop-server name)))))
      (get [_ timeout unit] (.get fut timeout unit))
      (get [_] (.get fut))
      (get-child parent index))
      (getColumnClass [columnIndex] Object)
      (getColumnCount [] 2)
      (getColumnCount [] colcnt)
      (getColumnName [columnIndex]
      (getRowCount [] cnt)
      (getRowCount [] nrows)
      (getValueAt [rowIndex columnIndex]
      (getValueAt [rowIndex columnIndex]
      (if (:content e)
      (if (< i end)
      (if (= (.length s) index)
      (if (= c Object)
      (if (= db bindings)
      (if (= i cnt)
      (if (= len index)
      (if (== d 0.0)
      (if (>= i (.tailoff this))
      (if (Character/isWhitespace (.charAt s (unchecked-dec index)))
      (if (abort? context)
      (if (and (= (count m) 1) (:tag m))
      (if (and (next alis) (vector? (second alis)))
      (if (and (not max-count) (= (:pos args) last-pos) (> count 1))
      (if (and (not max-count) (= (:pos navigator) last-pos) (> count 1))
      (if (and ks vs)
      (if (and match (= "invoke" method))
      (if (and path (seq l))
      (if (and path r)
      (if (and s (< i n))
      (if (and xs (pos? n))
      (if (chunked-seq? s)
      (if (chunked-seq? s)
      (if (chunked-seq? s)
      (if (contains? (parentMap tag) parent)
      (if (contains? m :url)
      (if (fits-table? hashes)
      (if (identical? ex form)
      (if (instance? clojure.lang.IObj v)
      (if (libspec? arg)
      (if (neg? dotloc)
      (if (neg? dotloc)
      (if (next alis) 
      (if (nil? path)
      (if (nil? path)
      (if (nil? path)
      (if (nil? remainder)
      (if (not continue)
      (if (not result)
      (if (or (:pretty (:flags (:def (first format))))
      (if (or (and (empty? (:rest args))
      (if (or (and (empty? (:rest navigator))
      (if (or (and (empty? (:rest navigator))
      (if (or (and (empty? arg-list)
      (if (seq o)
      (if (seq strs)
      (if (zero? columnIndex)
      (if (zero? gc)
      (if (zero? level)
      (if (zero? mask)
      (if (zero? rindex)
      (if and# (and ~@next) and#))))
      (if clause
      (if entry
      (if es
      (if f
      (if has-doc-str?
      (if items
      (if keys
      (if kvs
      (if length-reached
      (if load
      (if params
      (if round-pos
      (if s
      (if s (cons s i) i))))
      (if saw-comma 
      (if spec
      (if-let [[shift mask] (maybe-min-hash (map hash (keys cs)))]
      (if-let [^String tws (getf :trailing-white-space)]
      (if-let [cause (.getCause cause)]
      (if-let [cause (.getCause cause)]
      (if-let [e (find @mem args)]
      (if-let [s (seq coll)]
      (if-let [v (find-var (symbol (str (ns-name ns-obj)) "test-ns-hook"))]
      (if-let [xs (and (pos? n) (seq xs))]
      (ijavamap [[i m]]
      (ilookup [[i m]] 
      (imap [[i m]] 
      (in-ns 'user)
      (inc-report-counter :test)
      (init)
      (instance? BigInteger n)
      (instance? Byte n)))
      (instance? Float n)))
      (instance? Long n)
      (instance? Short n)
      (instance? String name) (clojure.lang.Symbol/intern name)
      (instance? clojure.lang.BigInt n)
      (instance? clojure.lang.Keyword name) (.sym ^clojure.lang.Keyword name)
      (instance? clojure.lang.Var name) (.toSymbol ^clojure.lang.Var name)
      (interleave (repeat "$")
      (into-array Object this)))
      (iobj [[i m]] 
      (is-leaf node))
      (isCancelled [_] (.isCancelled fut))
      (isCellEditable [rowIndex columnIndex] false)
      (isDone [_] (.isDone fut))
      (isRealized [this]
      (iterator [] (clojure.lang.SeqIterator. ^java.util.Iterator (thisfn (keys pmap))))
      (keyword? name) `(#'print-doc {:spec '~name :doc '~(spec/describe name)})
      (let [[clause [type right-params else-params remainder]] 
      (let [[k1 k2 k3] (str/split k #"\.")]
      (let [[mm considered]
      (let [[node path] loc
      (let [[section remainder] (get-section b)
      (let [[tests thens skip-check] (merge-hash-collisions expr-sym default tests thens)
      (let [^StackTraceElement s (nth stacktrace depth)]
      (let [^clojure.lang.IPersistentVector v (cast clojure.lang.IPersistentVector o)
      (let [abs-arg (if (neg? arg) (- arg) arg) ; some numbers are too big for Math/abs
      (let [abs-arg (if (neg? arg) (- arg) arg) ; some numbers are too big for Math/abs
      (let [accept-fn (resolve accept)]
      (let [buffer (StringBuffer. (.length s))
      (let [buffer (StringBuffer. (.length s))]
      (let [c (first cs) bs (bases c)]
      (let [ch (.charAt s (dec index))]
      (let [ch (.charAt s index)]
      (let [class-symbol (typesym typeref)
      (let [clause (first clauses)
      (let [compiled-format (if (string? format-in) (compile-format format-in) format-in)
      (let [compiled-format (if (string? format-in) (compile-format format-in) format-in)
      (let [constructor-annotations (meta pclasses)
      (let [digits (remainders 10 arg)]
      (let [fld (find-field super (str f))
      (let [form (first forms)
      (let [form (first forms)
      (let [i (int k)]
      (let [i (int k)]
      (let [input (read {:read-cond :allow} *in*)]
      (let [input (renumbering-read {:read-cond :allow} *in* 1)]
      (let [k (f x)]
      (let [len (count fixed-repr)
      (let [m (. Method (getMethod "void readObject(java.io.ObjectInputStream)"))
      (let [m (. Method (getMethod "void writeObject(java.io.ObjectOutputStream)"))
      (let [m (. Method getMethod "void main (String[])")
      (let [make-ancestor-map (fn [names]
      (let [mv (. cv visitMethod (+ Opcodes/ACC_PUBLIC Opcodes/ACC_ABSTRACT)
      (let [navigator (fixed-float {:w ww, :d dd, :k 0, 
      (let [neg (neg? arg)
      (let [new-tail (.array am (dec (.alength am tail)))]
      (let [new-tail (.array am (inc (.alength am tail)))]
      (let [new-tail (.arrayFor this (- cnt 2))
      (let [oldpos (getf :pos)
      (let [options-map (into1 {} (map vec (partition 2 options)))
      (let [out (future (stream-to-enc stdout out-enc))
      (let [p (up loc)]
      (let [pairs (partition 2 clauses)
      (let [path (.getPath (java.io.File. full-path))
      (let [read-opts (if (.endsWith (.getPath url) "cljc")
      (let [ret (VecNode. edit (object-array 32))]
      (let [ret (f val (first s))]
      (let [rt (fjfork (fjtask #(coll-fold right n combinef reducef)))]
      (let [s (seq x)]
      (let [s1 (seq c1) s2 (seq c2)]
      (let [size (.read in buffer 0 (alength buffer))]
      (let [size (.read input buffer)]
      (let [size (.read input buffer)]
      (let [size (.read input buffer)]
      (let [ss (map seq (conj colls c2 c1))]
      (let [tail-node (VecNode. (.edit root) tail)] 
      (let [this (first remainder)
      (let [token-str (first (re-groups m))
      (let [w (:w params)
      (list 'if (first clauses)
      (load-reader *in*)
      (load-script path))))
      (loop [i 0 xs (seq coll)]
      (loop [input (with-read-known (read reader false eof))]
      (loop [loc lloc]
      (loop [n (dec len)]
      (loop [n 0]
      (loop [pos 0]
      (monitor-enter lockee#)
      (name (nth (keys row1) columnIndex))
      (new ArrayChunk am arr (inc off) end)))
      (new StringBuilder (str x)) ys)))
      (new Vec am 0 5 EMPTY-NODE (.array am 0) (meta this))
      (new VecSeq am vec anode i (inc offset))
      (nil? form) :always-fail
      (node loc)
      (not (tokens-fit? this section))))
      (not-empty (set/difference bval aval))
      (not-empty (set/intersection aval bval))]))
      (not-empty ret))))
      (once-fixture-fn
      (or 
      (or (RT/loadClassForName pname)
      (or (impl c)
      (or (pred (first s)) (recur pred (next s)))))
      (or (some (fn [[prefix url]]
      (or ex
      (or s (clojure.lang.PersistentList/EMPTY))))
      (or s (clojure.lang.PersistentList/EMPTY)))))
      (persistent! (.reduce ^clojure.lang.IReduceInit coll conj! (transient #{})))
      (persistent! (reduce1 conj! (transient #{}) coll)))))
      (pop-thread-bindings))))
      (ppflush []
      (pprint-indent :block 1)
      (pprint-logical-block :prefix "(" :suffix ")"
      (pprint-logical-block :prefix "(" :suffix ")"
      (pprint-logical-block :prefix start :suffix end
      (pprint-newline :linear)
      (pprint-newline :linear)
      (pprint-newline :linear)
      (pprint-newline :linear)
      (pprint-simple-code-list alis))))
      (pprint-simple-code-list alis))))
      (pr object)
      (pr sym))))
      (print "  ")
      (print "zero")
      (print "zeroth")
      (print (name sym))
      (print (str
      (print (str " " (name (key attr)) "='" (val attr)"'"))))
      (print (str " " (name key) "=\"" (escape-xml value) "\""))))
      (print (str "<" (name (:tag e))))
      (print (str base-output chars)))
      (print (str chars base-output))
      (print eol-str))
      (print-length-loop [alis (seq (drop 3 alis))]
      (print-length-loop [aseq (seq amap)]
      (print-map m pr-on w))
      (print-map m pr-on w))))
      (print-meta c w)
      (print-meta m w)
      (print-meta s w)
      (print-meta v w)
      (print-method (.getName c) w)
      (print-method data w))
      (print-prefix-map (str "#:" ns) lift-map pr-on w)
      (print-sequential "#{" pr-on " " "}" (seq s) w))
      (print-sequential "(" pr-on " " ")" c w))
      (print-sequential "(" pr-on " " ")" c w))
      (print-sequential "[" pr-on " " "]" v w))
      (print-tap-diagnostic
      (println " " doc)
      (println ">")
      (println "Could not find Javadoc for" c))))
      (println "Spec")
      (println "Special Form")
      (println "WARNING: (slurp f enc) is deprecated, use (slurp f :encoding enc).")
      (println (str "</" (name (:tag e)) ">")))
      (prn f)))
      (prn))
      (proxy [javax.swing.event.HyperlinkListener] []
      (push-thread-bindings bindings)
      (re-matches
      (recur (assoc opts k v) rs)
      (recur (assoc ret (first s) (take-while seq? (next s)))
      (recur (drop 2 body) (concat acc (take 2 body)))
      (recur (next alis)))))))
      (recur (next alis)))))))
      (recur (next aseq)))))))
      (recur (next s) (next lead))
      (recur new-context (conj acc result))))))
      (recur new-context (conj acc result))))))
      (recur new-context remainder (conj acc result))))))
      (reduce1 (fn [mm ^java.lang.reflect.Method meth]
      (reduce1 bit-and (bit-and x y) more)))
      (reduce1 merge2 maps))))
      (reduce1 process-entry [] bents))))
      (reify P 
      (reify java.util.Iterator
      (reify java.util.ListIterator
      (removeTableModelListener [tableModelListener]))))
      (replace "[]" "<>")))
      (require (symbol (namespace accept)))
      (resolve name) `(#'print-doc (meta (var ~name))))))
      (root-bind binding-map)
      (rows)))
      (run-tests 'my.cool.library))
      (runInTransaction (fn [] ~@body))))
      (seq [] (thisfn (keys pmap))))))
      (seq? form) (first form)
      (setf :buffer []))))
      (setf :trailing-white-space nil))))
      (special-doc-map name) `(#'print-doc (#'special-doc '~name))
      (special-form alis)
      (startparse s content-handler)
      (str ".class")))
      (str "Clojure Server " name) server-daemon
      (str (.toUpperCase (subs s 0 1))
      (str (subs m 0 loc) "." (subs m loc)))))
      (str (subs s 0 i) replace (subs s (+ i (.length match)))))))
      (str (subs s 0 i) replace (subs s (inc i))))))
      (str columnIndex)))
      (str m1 (apply str (repeat (- target-len len) \0))) 
      (str/replace "." "/")
      (str/trim-newline which-out))))
      (struct arg-navigator (:seq navigator) (drop position (:rest navigator)) newpos))))
      (symbol ns-name (String/join "$" ^"[Ljava.lang.String;" (into-array String (cons fn-name nested)))))
      (symbol? name) name
      (throw (AssertionError. (str "The names in " specials " cannot be used as field names for types or records.")))))
      (throw (Exception. "The syntax for defmulti has changed. Example: (defmulti name dispatch-fn :default dispatch-value)")))
      (throw (Exception. "called children on a leaf node"))))
      (throw (IllegalArgumentException.
      (throw (IllegalArgumentException. 
      (throw (IllegalArgumentException. ":volatile-mutable or :unsynchronized-mutable not supported for record fields")))
      (throw (IllegalArgumentException. "Key must be integer"))))
      (throw (IllegalArgumentException. "Key must be integer"))))
      (throw (IllegalArgumentException. (apply print-str "Unsupported option(s) -" bad-opts))))
      (throw (IllegalArgumentException. (str "Not a file: " u)))))
      (throw (IllegalArgumentException. (str "Parameter declaration \"" (first bad-args)
      (throw (IllegalArgumentException. (str f " is not a relative path")))
      (throw (IllegalStateException. "Can't pop empty vector"))
      (throw (IllegalStateException. "dropFirst of empty chunk"))
      (throw (IndexOutOfBoundsException.))))
      (throw (clojure.lang.Compiler$CompilerException.
      (throw (clojure.lang.Compiler$CompilerException.
      (throw (java.io.IOException. (str "Couldn't delete " f)))))
      (throw (new Exception "Can't await in agent action")))
      (throw-if true "Cyclic load dependency: %s" chain))))
      (throw-if unsupported
      (try
      (try
      (try (loop []
      (try (t)
      (up loc)))
      (valAt ([k] (when (contains? pmap k) (v k)))
      (vector? bindings) "a vector for its binding"
      (when (. m (matches))
      (when (:attrs e)
      (when (and  s1 s2 s3)
      (when (and (pos? (.getCount d))
      (when (and need-ns *loading-verbosely*)
      (when (and path (seq l))
      (when (and path rs)
      (when (and s1 s2)
      (when (and to-do (not (instance? clojure.lang.Sequential to-do)))
      (when (and v (bound? v) (not= protocol-var p))
      (when (or use (:refer filter-opts))
      (when (pos? n)
      (when (seq binding)
      (when *compile-files*
      (when *loading-verbosely*
      (when alis
      (when alis
      (when as
      (when aseq
      (when load-impl-ns
      (when pnodes
      (when-let [a (nth xs i nil)]
      (when-let [data (ex-data root)]
      (when-let [ft (first trace)]
      (when-let [fv (first via)]
      (when-let [phase (-> o ex-data :clojure.error/phase)]
      (when-let [root-msg (.getLocalizedMessage root)]
      (when-let [s (seq coll)]
      (when-let [s (seq coll)]
      (when-let [s (seq coll)]
      (when-let [s (seq coll)]
      (when-let [strm (.getResourceAsStream (RT/baseLoader) filepath)]
      (when-let [value (get-possibly-unbound-var v)]
      (when-not (= path (first *pending-paths*))
      (when-not (contains? (tp tag) parent)
      (with-lock lock
      (with-lock lock
      (with-meta
      (with-meta [node (assoc path :changed? true)] (meta loc))))
      (without [k] (dissoc (snapshot) k))
      (write 
      (write 
      (write ([^chars cbuf ^Integer off ^Integer len] 
      (write-initial-lines this "\n")
      (write-out (second alis))
      (write-to-base c))
      (write-to-base istr))
      (write-to-base prefix))
      (write-to-base tws)
      (write-to-base tws)))
      (write-tokens this buf true)
      (write-white-space this)
      (zero? (count left)) right
      (zero? (count right)) left
      - reads an object from the input stream, then
      - returns request-exit on end of stream, or
      - returns request-prompt on start of line, or
      -1)
      0
      0)))
      10    100    1000"
      :added "1.3"
      :author "Alex Miller"}
      :author "Rich Hickey"}
      :author "Rich Hickey"}
      :author "Stuart Sierra, Stuart Halloway, David Liebke"}
      :bar (fn [a b] ...)
      :bar (fn [x y] ...)})"
      :base             'clojure.pprint/*print-base*,
      :baz (fn ([a]...) ([a b] ...)...)}
      :boolean (mk-am boolean)})
      :byte (mk-am byte)
      :char (mk-am char)
      :circle           'clojure.pprint/*print-circle*,
      :clojure.error/phase phase)))
      :compilation
      :compile-syntax-check
      :dispatch         'clojure.pprint/*print-pprint-dispatch*,
      :doc "A Pretty Printer for Clojure
      :doc "Helper namespace for clojure.java.browse.
      :doc "Reflection on Host Types
      :double (mk-am double)
      :else
      :else
      :else (throw (IllegalArgumentException. "no conversion to symbol"))))
      :else :default)))
      :execution
      :execution :read-eval-result :print-eval-result
      :failed
      :filter-with [(fn [x y] (> y x)) 
      :float (mk-am float)
      :length           'clojure.core/*print-length*,
      :level            'clojure.core/*print-level*,
      :lines            'clojure.pprint/*print-lines*,
      :long (mk-am long)
      :macro-syntax-check
      :macroexpansion
      :map #(* % 2)))
      :miser-width      'clojure.pprint/*print-miser-width*,
      :pending
      :pretty           'clojure.pprint/*print-pretty*,
      :print-eval-result
      :private true
      :private true}
      :radix            'clojure.pprint/*print-radix*,
      :read-eval-result
      :read-source
      :read-source :compile-syntax-check :compilation :macro-syntax-check :macroexpansion
      :readably         'clojure.core/*print-readably*,
      :ready)
      :right-margin     'clojure.pprint/*print-right-margin*,
      :short (mk-am short)
      :suppress-namespaces 'clojure.pprint/*print-suppress-namespaces*})
      ; resolve hash collisions and try again
      ;; If no local file, try remote URLs:
      ;; If the namespace has a test-ns-hook function, call that:
      ;;:case             *print-case*,
      ;;:escape           *print-escape*,
      ;;:gensym           *print-gensym*,
      CollFold
      Perform setup, establish bindings, whatever.
      Tear-down / clean-up code here.
      [ "C" "CC" "CCC" "CCCC" "D" "DC" "DCC" "DCCC" "DCCCC"]
      [ "C" "CC" "CCC" "CD" "D" "DC" "DCC" "DCCC" "CM"]
      [ "M" "MM" "MMM"]])
      [ "M" "MM" "MMM"]])
      [ "X" "XX" "XXX" "XL" "L" "LX" "LXX" "LXXX" "XC"]
      [ "X" "XX" "XXX" "XXXX" "L" "LX" "LXX" "LXXX" "LXXXX"]
      ["0" 0]
      [(.substring name 0 i) (.substring name (+ i 1))])))
      [(apply hash-map acc) body])))
      [(first rst) (struct arg-navigator (:seq navigator ) (next rst) (inc (:pos navigator)))]
      [(first rst) (struct arg-navigator (:seq navigator ) (next rst) (inc (:pos navigator)))]
      [:encoding (first opts)])
      [_ major minor incremental qualifier snapshot]
      [_ timeout-ms timeout-val]
      [acc context]
      [acc navigator]
      [m2 (- (Integer/valueOf e) delta)])))
      [nil name]
      [nil navigator])))
      [opts s])))
      [stream format-in & args]
      [stream format-in & args]
      [this x]
      \o (cl-format true "\\o~3,'0o" (int c))
      \u (cl-format true "\\u~4,'0x" (int c))
      ]
      `(binding [*math-context* (java.math.MathContext. ~precision ~@rm)]
      `(let [or# ~x]
      `(let [v# (def ~mm-name)]
      `(let [~ge ~e] ~default)
      `(let [~gx ~x]
      args
      args that appear after any main option
      attrs)))
      bindings
      cause
      cause
      childsParents (if (parentMap tag)
      clojure-version {:major       (Integer/valueOf ^String major)
      clojure-version)))
      clojure.core.protocols/CollReduce
      clojure.core.protocols/CollReduce
      deriv-seq (flatten (map #(cons (key %) (interpose (key %) (val %)))
      false
      format)
      h))))
      loc
      m
      m1)))
      mm)))
      name))
      navigator)))
      navigator)))
      navigator)))
      newParents (if (not-empty childsParents)
      nil
      nil
      nil
      nil
      nil
      nil
      nil 
      nil (pr c))
      nil))
      nil)))        
      node
      not-found))
      pending
      persistent!))
      result)))
      result)))
      result)))
      result))))
      result))))
      ret))
      ret))
      ret)))
      s
      s
      s
      s)))
      s)))
      s)))
      s)))
      s)))
      silently
      to change."
      true)))
      url)
      v
      val)))
      version-string (.getProperty properties "version")
      x)))
      x)))
      {'inst #'clojure.instant/read-instant-date})))
      {...} 
      {:file (.getFileName s) :line (.getLineNumber s)})
      {:file nil :line nil})))
      {foo/bar my.project.foo/bar
      }
      ~@body
      ~@body
     " (" file ":" line ")")))
     "--help" help-opt
     "--main" main-opt
     "--repl" repl-opt
     "-?"     help-opt} opt)
     "-h"     help-opt
     "-m"     main-opt
     "Parse a string containing an RFC3339-like like timestamp.
     "True while a verbose load is pending"}
     #(absolute-tabulation %1 %2 %3)))
     #(modify-case mod-case-writer %1 %2 %3)))
     #(relative-tabulation %1 %2 %3)
     #{}))
     '~name)))
     ((fn [^StringBuilder sb more]
     ())))
     (-> (reduce (fn [v o] (conj! v (f o))) (transient []) coll)
     (-reset-methods ~name)
     (. Array (newInstance type dimarray)))))
     (. clojure.lang.LazilyPersistentVector (create (cons a (cons b (cons c (cons d (cons e (cons f args))))))))))
     (. clojure.lang.Var (pushThreadBindings (hash-map ~@name-vals-vec)))
     (. f (applyTo (cons a (cons b (cons c (cons d (spread args)))))))))
     (. f (applyTo (list* x args))))
     (. f (applyTo (list* x y args))))
     (. f (applyTo (list* x y z args))))
     (. f (applyTo (seq args))))
     (. set (disjoin key))))
     (.aset am arr 0 x1)
     (.aset am arr 0 x1)
     (.aset am arr 0 x1)
     (.aset am arr 0 x1)
     (.aset am arr 1 x2)
     (.aset am arr 1 x2)
     (.aset am arr 1 x2)
     (.aset am arr 2 x3)
     (.aset am arr 2 x3)
     (.aset am arr 3 x4)
     (.captureString stream)
     (.captureString stream)
     (.conj coll x)))
     (.get fut))
     (.lock lockee#)
     (.setDaemon true)
     (.start))))
     (.substring path (if (.startsWith path "@/") 2 1)))
     (.write w# ~@args)))
     (:at params)
     (:at params)
     (:at params) readable-character
     (:colon params)
     (:colon params)
     (:colon params) pretty-character
     (< (+ (get-column (getf :base)) (buffer-length tokens)) maxcol))))
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
     (= 2 (count bindings)) "exactly 2 forms in binding vector")
     (= c (int \;)) (do (.readLine s) :line-start)
     (= c (int \newline)) :line-start
     (= c (int \newline)) :line-start
     (= c -1) :stream-end
     (= c -1) :stream-end
     (= i cnt) (.cons this val)
     (Class/forName ^String ~class-name)
     (File. ^File (as-file parent) ^String (as-relative-path child)))
     (JavaReflector. (.getContextClassLoader (Thread/currentThread))))
     (LazilyPersistentVector/createOwning (.split re s limit))))
     (LazilyPersistentVector/createOwning (.split re s)))
     (System/getProperty "line.separator"))
     (Vec. am 0 5 EMPTY-NODE (.array am 0) nil)))
     (Vec. am 1 5 EMPTY-NODE arr nil)))
     (Vec. am 2 5 EMPTY-NODE arr nil)))
     (Vec. am 3 5 EMPTY-NODE arr nil)))
     (Vec. am 4 5 EMPTY-NODE arr nil)))
     ([] (f arg1 arg2 arg3))
     ([] (f arg1 arg2))
     ([] (f arg1))
     ([] (~f1))
     ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c) ds)))))
     ([a b c & ds] (apply f (if (nil? a) x a) (if (nil? b) y b) c ds))))
     ([a b c & ds] (apply f (if (nil? a) x a) b c ds))))
     ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) (if (nil? c) z c)))
     ([a b c] (f (if (nil? a) x a) (if (nil? b) y b) c))
     ([a b c] (f (if (nil? a) x a) b c))
     ([a b] (f (if (nil? a) x a) (if (nil? b) y b)))
     ([a b] (f (if (nil? a) x a) (if (nil? b) y b)))
     ([a b] (f (if (nil? a) x a) b))
     ([a] (f (if (nil? a) x a)))
     ([x y z & args] (apply f arg1 arg2 arg3 x y z args))))
     ([x y z & args] (apply f arg1 arg2 x y z args))))
     ([x y z & args] (apply f arg1 x y z args))))
     ([x y z] (f arg1 arg2 arg3 x y z))
     ([x y z] (f arg1 arg2 x y z))
     ([x y z] (f arg1 x y z))
     ([x y] (f arg1 arg2 arg3 x y))
     ([x y] (f arg1 arg2 x y))
     ([x y] (f arg1 x y))
     ([x] (f arg1 arg2 arg3 x))
     ([x] (f arg1 arg2 x))
     ([x] (f arg1 x))
     (add-to-buffer this (make-nl-t type (getf :logical-blocks) pos pos)))))
     (addition)
     (alter-meta! (var ~name) assoc :doc ~(:doc opts))
     (alter-var-root (var ~name) merge 
     (and (:at params) (:colon params))
     (and (<= (int 0) i) (< i cnt))
     (apply concat (apply map f colls))))
     (apply dissoc map (keys kmap)) kmap))
     (apply pr more))))
     (apply pr xs)))
     (apply print xs)))
     (apply println xs)))
     (apply str coll))
     (arithmetic))
     (as-file arg))
     (bar [x y] ...))
     (bar [x y] ...))
     (bar [x y] ...))
     (bar [x y] ...)))"
     (binding [*in* s#]
     (binding [*out* (if new-writer#
     (binding [*out* *err*]
     (binding [*out* s#]
     (binding [*var-context* (conj *var-context* var)]
     (catch ClassNotFoundException _#)))
     (catch Throwable ex
     (catch Throwable ex
     (cl-format 
     (clojure.core.protocols/kv-reduce coll f init)))
     (clojure.lang.EdnReader/read stream opts)))
     (clojure.lang.LazilyPersistentVector/create coll))))
     (clojure.lang.LongRange/create end)
     (clojure.lang.LongRange/create start end step)
     (clojure.lang.LongRange/create start end)
     (clojure.lang.PersistentArrayMap/createAsIfByAssoc (to-array keyvals))))
     (clojure.lang.RT/seqToTypedArray (seq aseq)))
     (clojure.lang.RT/seqToTypedArray type (seq aseq))))
     (clojure.lang.Range/create end)))
     (clojure.lang.Range/create start end step))))
     (clojure.lang.Range/create start end)))
     (clojure.lang.TransformerIterator/create xform (clojure.lang.RT/iter coll)))
     (coll-fold coll n combinef reducef)))
     (commute *loaded-libs* conj lib))))
     (comp seq :content)
     (complement string?)
     (cond
     (cond
     (cond
     (cond                          ; ~R is overloaded with bizareness
     (cons a (cons b (cons c (cons d (spread more)))))))
     (defonce ~name {})
     (deref
     (deref [_] (deref-future fut))
     (doall (map merge diff1 diff2)))
     (doseq [[k v] m]
     (dotimes [i (:count params)]
     (dotimes [i (:count params)]
     (dotimes [i (alength dimarray)]
     (drain))))
     (even? (count bindings)) "an even number of forms in binding vector")
     (even? (count bindings)) "an even number of forms in binding vector")
     (even? (count name-vals-vec)) "an even number of forms in binding vector")
     (even? (count seq-exprs)) "an even number of forms in binding vector")
     (even? (count seq-exprs)) "an even number of forms in binding vector")
     (f)  Then call the function we were passed.
     (filter (complement pred) coll)))
     (filter (fn [_] (< (rand) prob)) coll)))
     (filter (fn [_] (< (rand) prob))))
     (first 
     (fjinvoke
     (flush)
     (flush))))
     (fn
     (fn
     (fn
     (fn
     (fn
     (fn
     (fn
     (fn
     (fn
     (fn [& args#]
     (fn [^java.io.File d] (seq (. d (listFiles))))
     (fn [^java.io.File f] (. f (isDirectory)))
     (fn [m [old new]]
     (fn [m x]
     (fn [params navigator offsets]
     (fn [params navigator offsets]
     (fn [params navigator offsets]
     (fn [params navigator offsets]     ; args from main arg list
     (fn [params navigator offsets]     ; args from sub-list
     (fn [result [k v]] (assoc result k v))
     (fn [rf]
     (fn [rf]
     (fn [rf]
     (fn [rf]
     (fn [rf]
     (fn [rf]
     (fn [stream# & args#]
     (fn ep1
     (fn ep2
     (fn ep3
     (fn sp1
     (fn sp2
     (fn sp3
     (foo [x] ...) 
     (foo [x] ...) 
     (foo [x] ...) 
     (foo [x] ...) 
     (gen-interface :name ~iname :methods ~meths)
     (hash-ordered-coll [k v]).
     (identical? parent child) true
     (identical? this o) true
     (identical? this o) true
     (if (#{< <=} test)
     (if (#{> >=} test)
     (if (.hasNext iter)
     (if (.isAssignableFrom a b) b a)))
     (if (:at params)
     (if (< (- cnt (.tailoff this)) (int 32))
     (if (< (count s1) (count s2))
     (if (< (count s1) (count s2))
     (if (< (count s2) (count s1))
     (if (< aidx (count vec))
     (if (= (getf :mode) :writing)
     (if (= (getf :mode) :writing)
     (if (= (getf :mode) :writing)
     (if (and (get (:contexts fd) context)
     (if (and (pos? hundreds) (pos? tens)) " ")
     (if (and (pos? hundreds) (pos? tens)) " ")
     (if (chunked-seq? s)
     (if (empty? remainder)
     (if (empty? s)
     (if (instance? CharSequence replacement)
     (if (instance? ParallelArrayWithMapping coll)
     (if (instance? Throwable actual)
     (if (instance? Throwable e-or-depth)
     (if (instance? clojure.lang.IBlockingDeref ref)
     (if (instance? clojure.lang.IEditableCollection to)
     (if (instance? clojure.lang.IEditableCollection to)
     (if (instance? clojure.lang.IObj coll)
     (if (instance? clojure.lang.IReduce coll)
     (if (instance? clojure.lang.IReduceInit coll)
     (if (instance? java.util.Map coll)
     (if (next more)
     (if (next more)
     (if (next more)
     (if (next more)
     (if (next more)
     (if (next more)
     (if (next more)
     (if (not (tokens-fit? this buffer))
     (if (or (= pos (count aseq)) (not (test (nth aseq pos))))
     (if (pos? hundreds) (str (nth english-cardinal-units hundreds) " hundred"))
     (if (pos? hundreds) (str (nth english-cardinal-units hundreds) " hundred"))
     (if (pos? tens) 
     (if (pos? tens) 
     (if (reduced? init)
     (if (reduced? ret)
     (if (seq? (first fdecl))
     (if (seq? coll) coll
     (if (vector? coll)
     (if am#
     (if ks
     (if ks
     (if ks
     (if kvs
     (if lb
     (if message (str message "\n" detail) detail)))
     (if value#
     (if xn
     (if-let [s (seq coll)]
     (if-let [s (seq s)]
     (instance? CharSequence match)
     (instance? CharSequence match) (.replace s ^CharSequence match ^CharSequence replacement)
     (instance? Character match)
     (instance? Character match) (.replace s ^Character match ^Character replacement)
     (instance? Pattern match)
     (instance? Pattern match) (if (instance? CharSequence replacement)
     (intern *ns* (symbol pname) pc-effect)
     (into [] (apply map f c1 c2 c3 colls))))
     (into [] (map f c1 c2 c3)))
     (into [] (map f c1 c2)))
     (invoke
     (is (= 1 (- 4 3)))
     (is (= 3 (- 7 4))))
     (is (= 4 (+ 2 2)))
     (is (= 4 (my-function 2 2)))
     (is (= 7 (+ 3 4))))
     (is (= 7 (my-function 3 4))))
     (isRealized [_] (.isDone fut))
     (java.awt BorderLayout)
     (java.awt.event ActionEvent ActionListener)
     (java.io Reader InputStream InputStreamReader PushbackReader
     (java.net URI URL MalformedURLException Socket URLDecoder URLEncoder)))
     (javax.swing JPanel JTree JTable JScrollPane JFrame JToolBar JButton SwingUtilities)))
     (javax.swing.table TableModel AbstractTableModel)
     (javax.swing.tree TreeModel)
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (lazy-seq
     (let [[i m] (-> [interfaces methods] irecord eqhash iobj ilookup imap ijavamap)]
     (let [^clojure.lang.IPersistentVector vec o]
     (let [^java.io.Writer real-stream (cond 
     (let [^java.util.Map$Entry pair o]
     (let [a (java.util.ArrayList. n)]
     (let [a (new clojure.lang.Agent state)
     (let [a (to-array coll)]
     (let [arg1 (:arg1 params)
     (let [bindings (concat
     (let [bubbled-sets (bubble-max-key #(- (count %)) (conj sets s2 s1))]
     (let [bubbled-sets (bubble-max-key count (conj sets s2 s1))]
     (let [cat (fn cat [xys zs]
     (let [cnt (:count params)]
     (let [cnt (atom n)]
     (let [cnt (atom n)]
     (let [col (get-column (getf :base))]
     (let [dim-norm [nil 31 28 31 30 31 30 31 31 30 31 30 31]
     (let [f (xform f)
     (let [f1 (fn
     (let [fields (ref {:max max-columns, :cur 0, :line 0 :base writer})]
     (let [fs (list* f g h fs)]
     (let [i (volatile! -1)]
     (let [iv (volatile! -1)]
     (let [ks (intersection (set (keys (first xrel))) (set (keys (first yrel))))
     (let [latch (new java.util.concurrent.CountDownLatch (count agents))
     (let [n (:n params)]
     (let [navigator (if (:colon params) (relative-reposition navigator -1) navigator)
     (let [o (read opts stream)
     (let [o (read stream eof-error? eof-value recursive?)
     (let [opts (normalize-slurp-opts opts)
     (let [ps (list* p1 p2 p3 ps)]
     (let [ps (list* p1 p2 p3 ps)]
     (let [pv (volatile! ::none)]
     (let [remainder (subs rest 1) 
     (let [result# (do ~@body)]
     (let [result# (instance? klass# object#)]
     (let [ret (disj set key)]
     (let [ret (f)]
     (let [s (seq coll)]
     (let [seen (volatile! #{})]
     (let [server-socket ^ServerSocket (get-in servers [name :socket])]
     (let [st (.getStackTrace tr)]
     (let [started (volatile! false)]
     (let [step (fn [n coll]
     (let [step (fn [pred coll]
     (let [summary (assoc (apply merge-with + (map test-ns namespaces))
     (let [up (fn up [m ks f args]
     (let [v (clojure.lang.Var/intern (the-ns ns) name val)]
     (let [v (clojure.lang.Var/intern (the-ns ns) name)]
     (letfn [(keepi [idx coll]
     (loop  [~idx 0 ~ret ~init]
     (loop  [~idx 0]
     (loop [[opt arg & more :as args] args, inits [], flags nil]
     (loop []
     (loop [i (.i str-seq)
     (loop [me this
     (loop [ret val]
     (loop [s #{x y} [x & etc :as xs] more]
     (loop [sb (StringBuilder. (str (first coll)))
     (loop [sentinel (Object.)
     (loop [v v kv kv more more]
     (loop [v v kv kv more more]
     (map #(apply f %) (step (conj colls c3 c2 c1))))))
     (map #(if-let [e (find smap %)] (val e) %)))
     (map-passing-context 
     (mapi 0 coll))))
     (newline)))))
     (nil? child) false
     (nil? maxcol) 
     (nil? oldform) "1 or 2 forms after binding vector"
     (nil? oldform) "1 or 2 forms after binding vector"
     (or
     (or (Character/isWhitespace (char c)) (= c (int \,))) (recur (.read s))
     (or (clojure.lang.RT/chunkIteratorSeq
     (or (clojure.lang.RT/chunkIteratorSeq
     (or (instance? clojure.lang.IPersistentVector o) (instance? java.util.RandomAccess o))
     (or (instance? clojure.lang.IPersistentVector o) (instance? java.util.RandomAccess o))
     (or (instance? clojure.lang.Sequential o) (instance? java.util.List o))
     (or (instance? clojure.lang.Sequential o) (instance? java.util.List o))
     (or (instance? clojure.lang.Sequential o) (instance? java.util.List o))
     (outer (reduce (fn [r x] (conj r (inner x))) form form))
     (partition n n coll))
     (partition-all n n coll))
     (pmap #(apply f %) (step (cons coll colls))))))
     (pr-on x *out*))
     (print "    ")
     (print-length-loop [alis (next alis)]
     (print-stack-trace tr n)
     (print-trace-element e)
     (println v#)))
     (prn (str "Elapsed time: " (/ (double (- (. System (nanoTime)) start#)) 1000000.0) " msecs"))
     (prompt)
     (proxy [sun.misc.SignalHandler] []
     (re-find m))))
     (re-groups m)))
     (read opts re-reader))))
     (recur (dec n) (next coll)))))
     (recur (first more) nmore)
     (recur (next s))))
     (reduce (fn [pa [op args]] 
     (reduce (fn [ret x]
     (reduce difference s1 (conj sets s2))))
     (reduce file (file parent child) more)))
     (reduce1 * (* x y) more)))
     (reduce1 + (+ x y) more)))
     (reduce1 - (- x y) more)))
     (reduce1 comp (list* f g fs))))
     (reduce1 get m ks))
     (reify
     (reify
     (replace-first-char s match replacement)
     (replace-first-str s (.toString ^CharSequence match)
     (reverse (map #(:name (meta %)) *testing-vars*))
     (rfn [f1 k]
     (rfn [f1 k]
     (rfn [f1 k]
     (run-tests 'my.cool.library))"
     (second (first params))))
     (send-off agt fill)
     (setf :buffer (into [] buffer))
     (setf :logical-blocks (:parent lb)))))
     (setf :logical-blocks lb)
     (setf :trailing-white-space nil))))
     (step coll #{}))))
     (step rets (drop n rets))))
     (subtraction))
     (sun.misc.Signal. "INT")
     (t/with-test-out
     (take-while (mk-bound-fn sc end-test end-key)
     (take-while (mk-bound-fn sc start-test start-key)
     (testing \"with negative integers\"
     (testing \"with positive integers\"
     (throw (new Exception  "Not enough arguments for format definition")))))
     (trampoline #(apply f args))))
     (transduce xform (completing f) init coll))
     (try
     (try
     (try
     (try
     (try
     (try (.get fut timeout-ms java.util.concurrent.TimeUnit/MILLISECONDS)
     (two-forms
     (vec (repeat (apply max (keys m))  nil))
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? bindings) "a vector for its binding"
     (vector? name-vals-vec) "a vector for its binding"
     (vector? seq-exprs) "a vector for its binding"
     (vector? seq-exprs) "a vector for its binding"
     (walk root)))
     (when (< nexti (count vec))
     (when (and in-b (or (not (nil? b*)) (not same))) {k b*})
     (when (seq rows)
     (when *agent*
     (when *assert*
     (when *assert*
     (when same {k ab})
     (when ~test
     (when-let [^String prefix (:prefix lb)] 
     (when-let [cause (.getCause tr)]
     (when-not (.hasRoot v#)
     (with-open [bout (StringWriter.)]
     (with-pretty-writer writer
     (write-line this))))
     (zipmap "'<>\"&" (map #(str \& % \;) '[apos lt gt quot amp])))
     - :caught, function of one argument, a throwable, called when
     - :eval, function of one argument, returns the evaluation of its
     - :flush, function of no arguments, flushes output
     - :init, function of no arguments, initialization hook called with
     - :need-prompt, function of no arguments, called before each
     - :print, function of one argument, prints its argument to the output
     - :prompt, function of no arguments, prompts for more input.
     - :read, function of two arguments, reads from *in*:
     :actual     A form representing what actually occurred
     :added "1.1"}
     :ancestors     in addition to the keys described above, also
     :append    true to open stream in append mode
     :arglists '([input output opts])}
     :bound [start end] 
     :doc "A ref to a sorted set of symbols representing loaded libs"}
     :doc "A repl helper to quickly open javadocs."}
     :doc "A stack of paths currently being loaded by this thread"}
     :doc "A unit testing framework.
     :doc "This file defines a generic tree walker for Clojure data
     :doc "This file defines polymorphic I/O utility functions for Clojure."}
     :dynamic true
     :else (do (.unread s c) :body))))
     :else (do (.unread s c) :body))))
     :else (recur (:parent child)))))
     :else (throw (IllegalArgumentException. (str "Invalid match arg: " match))))))
     :else (throw (IllegalArgumentException. (str "Invalid match arg: " match))))))
     :else (throw (IndexOutOfBoundsException.))))
     :else false))
     :else false))
     :else false))
     :else plain-character))
     :encoding  string name of encoding to use, e.g. \"UTF-8\".
     :expected   The form that was expected to be true
     :filter pred 
     :filter-index pred2 
     :filter-with [pred2 coll2] 
     :get-label (fn [i] ((v i) 0))}))
     :get-label (fn [i] i)}))
     :get-value (fn [i] ((v i) 1)) 
     :get-value (fn [i] (v i)) 
     :map f 
     :map-index f2 
     :map-with [f2 coll2]
     :message    The string message given as an argument to 'is'
     :private true
     :reflector     implementation to use. Defaults to JavaReflector,
     :val val}))
     ;; NB (completing f) isolates completion of inner rf from outer rf
     ;; Uncomment to include namespace in failure report:
     ;;(ns-name (:ns (meta (first *testing-vars*)))) "/ "
     ;remember the class to prevent it from disappearing before use
     Maps are reduced with reduce-kv"
     When init is not provided, (f) is used.
     ["" "" "twentieth" "thirtieth" "fortieth" "fiftieth"
     ["" "" "twenty" "thirty" "forty" "fifty" "sixty" "seventy" "eighty" "ninety"])
     ["" "thousand" "million" "billion" "trillion" "quadrillion" "quintillion" 
     ["zero" "one" "two" "three" "four" "five" "six" "seven" "eight" "nine"
     ["zeroth" "first" "second" "third" "fourth" "fifth" "sixth" "seventh" "eighth" "ninth"
     [(irecord [[i m]]
     [(not-empty (set/difference aval bval))
     [[ "I" "II" "III" "IIII" "V" "VI" "VII" "VIII" "VIIII"]
     [[ "I" "II" "III" "IV" "V" "VI" "VII" "VIII" "IX"]
     \" "\\\""
     \\  "\\\\"
     \backspace "\\b"})
     \formfeed "\\f"
     \return "\\r"
     \tab  "\\t"
     ]))
     `(let [;pc# (get-proxy-class ~@class-and-interfaces)
     `(let [temp# ~tst]
     `(let [temp# ~tst]
     arg-navigator))
     arg-navigator))
     arg-navigator))
     arg-navigator))
     boolean-conditional
     check-arg-conditional
     choice-conditional))
     clojure.lang.IBlockingDeref
     clojure.lang.IBlockingDeref
     clojure.lang.IDeref
     clojure.lang.IDeref
     clojure.lang.IFn
     clojure.lang.IPending
     clojure.lang.IPending
     dir))
     english-cardinal-tens
     english-cardinal-units 
     english-ordinal-tens
     english-ordinal-units 
     english-scale-numbers 
     escape-xml-map
     false)))
     false)))
     false)))
     false)))
     false)))
     false)))
     false)))
     false)))
     flag-defs { \: :colon, \@ :at })
     global-hierarchy (make-hierarchy))
     iterate-list-of-sublists
     iterate-main-list
     iterate-main-sublists
     iterate-sublist))
     java-base-formats {8 "%o", 10 "%d", 16 "%x"})
     java.util.concurrent.Future
     m)))
     new-roman-table
     nil      null-opt
     nil))
     old-roman-table
     param-pattern #"^([vV]|#|('.)|([+-]?\d+)|(?=,))")
     remainder]))
     ret#))
     root))
     special-chars { 8 "Backspace", 9 "Tab",  10 "Newline", 13 "Return", 32 "Space"})
     special-params #{ :parameter-from-args :remaining-arg-count })
     special-radix-markers {2 "#b" 8 "#o", 16 "#x"})
     true
     true
     type-map {"core$future_call" "Future",
     val))
     value#))
     {'int Integer/TYPE
     {'quote "'", 'clojure.core/deref "@", 
     {:baz (fn ([x] ...) ([x y & zs] ...))
     {:cnt (fn [c] ...)}
     {:foo an-existing-fn
     {:int (mk-am int)
     {:test 0, :pass 0, :fail 0, :error 0})
     {;:array            *print-array*
     {} xrel))
     ~(clojure.walk/postwalk
     ~(if (empty? forms)
     ~(let [more (nnext pairs)]
     ~(when sigs
     ~@body
     ~@body))
     ~@body))
     ~@body))
     ~@body))
     ~@body))
     ~@body))
     ~@forms))
     ~@forms))
     ~fkv))
    ", "
    "--eval" eval-opt} opt))
    "--init" init-opt
    "-e"     eval-opt
    "/usr/bin/open"
    "0"
    "1.8" "http://docs.oracle.com/javase/8/docs/api/"
    "10" "http://docs.oracle.com/javase/10/docs/api/"
    "11" "https://docs.oracle.com/en/java/javase/11/docs/api/java.base/"
    "9" "http://docs.oracle.com/javase/9/docs/api/"
    "clojure.edn" "clojure.instant" "clojure.java.io" "clojure.main" "clojure.pprint" "clojure.reflect"
    "clojure.repl" "clojure.set" "clojure.spec.alpha" "clojure.spec.gen.alpha" "clojure.spec.test.alpha"
    "clojure.string" "clojure.template" "clojure.uuid" "clojure.walk" "clojure.xml" "clojure.zip"})
    "http://docs.oracle.com/javase/8/docs/api/"))
    "}"
    'added'. (conj nil item) returns (item).  The 'addition' may
    'defn pprint-defn, 'defn- pprint-defn, 'defmacro pprint-defn, 'fn pprint-defn,
    'if-let pprint-let, 'doseq pprint-let, 'dotimes pprint-let,
    'when-first pprint-let,
    ((:zip/branch? (meta loc)) (node loc)))
    ((:zip/make-node (meta loc)) node children))
    ((fn step []
    ((formatter-out " ~_~{~w~^ ~_~}") alis)))
    ((init-dispatch opt) arg)))
    ((var-get v))
    (- cnt (.alength am tail)))
    (-> (proxy [Writer] []
    (-reset-methods (alter-var-root (:var proto) assoc-in [:impls atype] mmap))))
    (. *out* (append system-newline))
    (. *out* (flush))
    (. Reflector (invokeConstructor c (to-array ctor-args))))
    (. clojure.lang.Compiler (macroexpand1 form)))
    (. clojure.lang.Numbers (quotient num div)))
    (. clojure.lang.Numbers (remainder num div)))
    (. clojure.lang.PersistentStructMap (construct s vals)))
    (. clojure.lang.PersistentStructMap (create s inits)))
    (. clojure.lang.PersistentStructMap (createSlotMap keys)))
    (. clojure.lang.PersistentStructMap (getAccessor s key)))
    (. coll all)
    (. cv (visit (. Opcodes V1_5) (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_SUPER))
    (. cv (visit (. Opcodes V1_8) (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_SUPER))
    (. cv (visitEnd))
    (. cv (visitEnd))
    (. cv (visitField (+ (. Opcodes ACC_PRIVATE) (. Opcodes ACC_VOLATILE))
    (. cv visit Opcodes/V1_8 (+ Opcodes/ACC_PUBLIC 
    (. cv visitEnd)
    (. e (getKey)))
    (. e (getValue)))
    (. proxy (__getClojureFnMappings)))
    (. proxy (__initClojureFnMappings mappings))
    (. proxy (__updateClojureFnMappings mappings))
    (. re (matcher s)))
    (. ref (alter fun args)))
    (. ref (commute fun args)))
    (. ref (deref)))
    (. ref (set val)))
    (. ref (touch))
    (. rev (rseq)))
    (. x (getNamespace)))
    (.. (clojure.lang.RT/getRootClassLoader) (defineClass cname bytecode options))))
    (.add
    (.add (JScrollPane. (JTable. (old-table-model data))))
    (.add (JScrollPane. (JTree. (tree-model data))))
    (.addHyperlinkListener htmlpane
    (.append w c))
    (.empty ^clojure.lang.IPersistentCollection coll)))
    (.getCause ^Throwable ex)))
    (.getData ^IExceptionInfo ex)))
    (.getHistoryCount ref))
    (.getMaxHistory ref))
    (.getMessage ^Throwable ex)))
    (.getMinHistory ref))
    (.invoke ^java.util.concurrent.ForkJoinPool @pool ^java.util.concurrent.ForkJoinTask (fjtask f))))
    (.isArray (class obj)) (pprint-array obj)
    (.isArray c) (do
    (.isNaN ^Double o) (.write w "##NaN")
    (.isNaN ^Float o) (.write w "##NaN")
    (.isPrimitive c) (do
    (.mkdirs parent)))
    (.readLine ^clojure.lang.LineNumberingPushbackReader *in*)
    (.readLine ^java.io.BufferedReader *in*)))
    (.reduce ^clojure.lang.IReduceInit coll f val)
    (.restart a new-state (if (:clear-actions opts) true false))))
    (.set Calendar/MILLISECOND (quot nanoseconds 1000000))
    (.setContextClassLoader (Thread/currentThread) (clojure.lang.DynamicClassLoader. cl)))
    (.setDaemon ~daemon)
    (.setEditable htmlpane false)
    (.setMaxHistory ref n)))
    (.setMinHistory ref n)))
    (.setNanos nanoseconds)))
    (.setSize 400 400)
    (.setSize 400 600)
    (.setSize 400 600)
    (.setTimeZone (TimeZone/getTimeZone
    (.setVisible true)))
    (.setVisible true)))
    (.setVisible true)))
    (.start)))
    (.startsWith "mac os x")))
    (.toByteArray bout)))
    (.write w "#inst \"")
    (.write w "#inst \"")
    (.write w "#inst \"")
    (.write w ":")
    (.write w "\"")))
    (.write w "\"")))
    (.write w "\"")))
    (.write w (.format utc-format d))
    (.write w (.format utc-format ts))
    (.write w (format ".%09d-00:00" (.getNanos ts)))
    (.write w (str content))))
    (.write w calstr 0 offset-minutes)
    (.write w calstr offset-minutes 2)
    (.write w s))
    (:import
    (:import 
    (:import (java.util Date Timer Random)
    (:pnodes (loc 1)))
    (:r (loc 1)))
    (:refer-clojure :exclude (deftype))
    (:refer-clojure :exclude [ancestors printf])
    (:require (clojure.contrib sql combinatorics))
    (:require clojure.string)
    (:type m)
    (:use (my.lib this that))
    (:use [clojure.walk :only [walk]]))
    (= (.length p) 0) nil
    (= (count bindings) 0) `(do ~@body)
    (= 1 cnt) 
    (= :end (loc 1)))
    (= Double/NEGATIVE_INFINITY o) (.write w "##-Inf")
    (= Double/POSITIVE_INFINITY o) (.write w "##Inf")
    (= Float/NEGATIVE_INFINITY o) (.write w "##-Inf")
    (= Float/POSITIVE_INFINITY o) (.write w "##Inf")
    (> (- cnt (.tailoff this)) 1)
    (Compiler/loadFile path)))
    (Murmur3/hashOrdered this))
    (RT/loadResourceScript
    (Type/getType (the-class c))
    ([] (ctor))
    ([] (not (f)))
    ([a b c d e f] [a b c d e f])
    ([a b c d e] [a b c d e])
    ([a b] (op a b))))
    ([coll f val] (.reduce coll f val)))
    ([coll f val] (iter-reduce coll f val)))
    ([coll f val] (iter-reduce coll f val))))
    ([coll f] (.reduce ^clojure.lang.IReduce coll f))
    ([coll f] (iter-reduce coll f))
    ([coll f] (iter-reduce coll f))
    ([x y & zs] (not (apply f x y zs)))))
    ([x y] (not (f x y)))
    ([x] (not (f x)))
    (^Bar method2 [^Baz b ^Quux q]))"
    (^int method1 [x])
    (add-annotation av "value" v)))
    (add-annotations cv (meta name))
    (add-annotations cv name-meta)
    (addTreeModelListener [treeModelListener])
    (alter-meta! #'*print-pprint-dispatch* (constantly old-meta)))
    (alter-var-root #'*print-pprint-dispatch* (constantly function))
    (and (= (.length p) 1) (= \# (nth p 0))) :remaining-arg-count
    (and (= (.length p) 1) (contains? #{\v \V} (nth p 0))) :parameter-from-args
    (and (= (.length p) 2) (= \' (nth p 0))) (nth p 1)
    (and (clojure.lang.Util/isInteger k)
    (and *print-suppress-namespaces* (symbol? obj)) (print (name obj))
    (and miser-width maxcol
    (apply (ns-resolve (doto (symbol main-ns) require) '-main) args)))
    (apply f args)
    (apply pr more)
    (apply printf "%s/%s" (rest match))
    (apply println args)))
    (apply require args)))
    (apply str 
    (apply str (.replace (str *ns*) \- \_) ".proxy"
    (apply str mname (interleave (repeat \-) 
    (apply vector (. ctor (getParameterTypes)))))
    (assert-any msg form)))
    (assert-args
    (assert-predicate msg form)
    (assoc
    (assoc m k (assoc-in (get m k) ks v))
    (assoc m k v)))
    (await a))
    (bar [this a b] \"bar docs\")
    (bar-me [this y] (+ c y)))
    (bar-me [this] [this y]))
    (bar-me [this] b)
    (baz [this a] [this a b] [this a b c] \"baz docs\"))
    (binding [*file* (.getFile url)]
    (binding [*in* in
    (binding [*loading-verbosely* (or *loading-verbosely* verbose)]
    (binding [*out* (make-writer *out*)] 
    (binding [*print-readably* nil]
    (binding [*print-readably* nil]
    (binding [*stack* nil
    (binding [*testing-vars* (conj *testing-vars* v)]
    (binding-map (table-ize write-option-table options) 
    (case phase
    (catch ClassNotFoundException e
    (catch SocketException _disconnect)
    (clojure.core.protocols/coll-reduce left f1 init)))
    (clojure.lang.ChunkedCons. chunk rest)))
    (clojure.lang.Cons. o this))
    (clojure.lang.RT/classForName (typename typeref) false classloader)))
    (clojure.lang.RT/vector (.toArray al))))
    (close [] (.close writer))
    (close [] (.close writer))
    (concat
    (concat x coll)))
    (cond
    (cond
    (cond
    (cond
    (cond
    (cond
    (cond 
    (cond 
    (cond 
    (cond 
    (cond 
    (condp = (:char-format params)
    (cons c (super-chain (.getSuperclass c)))))
    (cons line (lazy-seq (line-seq rdr)))))
    (cons max (remove #(identical? max %) coll))))
    (cons params body)
    (cons x coll)
    (consume #(if (pos? %) 
    (consume (fn [x] [(seq (reverse (take unit x))) (seq (drop unit x))]) (reverse lis)))))
    (contains? (. clojure.lang.Compiler specials) s))
    (copy in bout)
    (count coll)
    (defn print-table [aseq column-width]
    (diff-associative a b (set/union (keys a) (keys b)))))
    (diff-sequential a b))
    (do
    (do
    (do
    (do
    (do
    (do
    (do
    (do
    (do
    (do
    (do
    (do
    (do 
    (do (.append w \")
    (do (.append w \\)
    (do-copy in output opts)))
    (do-copy in output opts)))
    (do-copy input out opts)))
    (do-copy input out opts)))
    (doseq [[f {getter :get setter :set}] exposes]
    (doseq [[k v] v]
    (doseq [[key value] attrs]
    (doseq [[mname pclasses rclass pmetas] methods]
    (doseq [[pclasses super-pclasses] ctor-sig-map]
    (doseq [^Constructor ctor (. super (getDeclaredConstructors))]
    (doseq [arg args]
    (doseq [attr (:attrs e)]
    (doseq [f forms]
    (doseq [name (keys servers)]
    (doseq [v var-fields]
    (dosync
    (dosync
    (dosync
    (dosync (commute *report-counters* update-in [name] (fnil inc 0)))))
    (doto (javax.swing.JFrame.)
    (doto ex
    (elide-top-frames (ExceptionInfo. msg map cause) "clojure.core$ex_info")))
    (elide-top-frames (ExceptionInfo. msg map) "clojure.core$ex_info"))
    (emit-nl this token)
    (even? (count bindings)) "an even number of forms in binding vector")
    (execute-format writer compiled-format navigator)))
    (f)
    (filter (fn [[s m]]
    (filter-key val (fn [^clojure.lang.Var v] (and (instance? clojure.lang.Var v)
    (filter-key val (fn [^clojure.lang.Var v] (and (instance? clojure.lang.Var v)
    (filter-key val (fn [^clojure.lang.Var v] (and (instance? clojure.lang.Var v)
    (filter-methods c not-exposable?)))
    (filter-methods c not-overridable?)))
    (finally
    (finally
    (flush [] (.flush writer))
    (flush [] (.flush writer))
    (flush)))
    (fn
    (fn
    (fn [& args]
    (fn [& args]
    (fn [[clause-map saw-else remainder]]
    (fn []
    (fn [acc [^String k ^String v]]
    (fn [e ^Writer w]
    (fn [element context]
    (fn [remainder]
    (fn [ret x]
    (fn [rf]
    (fn [rf]
    (fn [x y]
    (fn? x)))
    (foo [this] a)
    (foo [this]) 
    (format-error 
    (format-logical-block params navigator offsets)
    (getChild [parent index]
    (getChildCount [parent]
    (getColumnCount [] 2)
    (getIndexOfChild [parent child]
    (getRoot [] data)
    (getRowCount [] 1)
    (getValueAt [rowIndex columnIndex]
    (if (.contains version-string "SNAPSHOT")
    (if (.containsKey this k)
    (if (.find m)
    (if (.find m)
    (if (.isAbsolute f)
    (if (.isArray c)
    (if (:at params)
    (if (< (count s) 2)
    (if (< (inc offset) (.alength am anode))
    (if (< depth (count stacktrace))
    (if (< i 0)
    (if (< len target-len) 
    (if (<= 0 dd d)
    (if (= "file" (.getProtocol u))
    (if (= (.length s) index)
    (if (= (count lines) 1)
    (if (= (equality-partition a) (equality-partition b))
    (if (= -1 i)
    (if (= -1 i)
    (if (= 0 arg)
    (if (= 0 arg)
    (if (= :end (loc 1))
    (if (= :end (loc 1))
    (if (= c \newline)
    (if (= off end)
    (if (= path "-")
    (if (= result -1)
    (if (= result -1)
    (if (= result -1)
    (if (= result -1)
    (if (= which-out "")
    (if (== (count tests) (count hashes))
    (if (> 2 (count clauses))
    (if (> meta 0) (print "Meta-"))
    (if (>= (count arr) cnt)
    (if (and  (<= (int 0) i) (< i cnt))
    (if (and (instance? clojure.lang.Compiler$CompilerException cause)
    (if (and (instance? clojure.lang.Compiler$CompilerException cause)
    (if (and (not (:at allowed)) (:at flags))
    (if (and (not (:both allowed)) (:at flags) (:colon flags))
    (if (and (not (:colon allowed)) (:colon flags))
    (if (and (number? arg) (> arg 0) (< arg 4000))
    (if (and (pos? len) (= (nth s (dec (count s))) c))
    (if (and (pos? len) (= (nth s 0) c))
    (if (and *print-level* (neg? *print-level*))
    (if (and eol-str (> (+ (get-column (:base @@*out*)) min-remaining result-columns) 
    (if (and format-str (integer? val) (not (instance? clojure.lang.BigInt val)))
    (if (branch? loc)
    (if (clojure.lang.Util/isInteger k)
    (if (clojure.lang.Util/isInteger k)
    (if (clojure.lang.Util/isInteger k)
    (if (empty? clauses)
    (if (empty? format)
    (if (empty? lis)
    (if (empty? m2)
    (if (every? symbol? (map first bents))
    (if (identical? this o)
    (if (identical? v x)
    (if (instance? clojure.lang.IReduceInit coll)
    (if (integral? arg)
    (if (keyword? k)
    (if (map? row1)
    (if (neg? exploc)
    (if (neg? position)
    (if (not (= 0 (get-column (:base @@*out*))))
    (if (not def)
    (if (not directive)
    (if (opts (first body))
    (if (or (zero? m) (= (pos? num) (pos? div)))
    (if (seq cs)
    (if (seq s)
    (if (vector? args)
    (if (zero? cnt) 
    (if (zero? index)
    (if (zero? index)
    (if (zero? level)
    (if *print-suppress-namespaces* 
    (if a (write-tokens this a false))
    (if ancestors
    (if arg
    (if b
    (if c
    (if clause
    (if clause
    (if forms
    (if forms
    (if in
    (if l 
    (if lead
    (if ns
    (if package
    (if param
    (if prefix 
    (if rst
    (if rst
    (if s
    (if w
    (if-let [^String tws (getf :trailing-white-space)]
    (if-let [file ^File (first
    (if-let [lloc (left loc)]
    (if-let [special-form (*code-table* (first alis))]
    (if-let [url (javadoc-url (.getName c))]
    (if-not (= (:type-tag token) :nl-t)
    (if-not *print-pretty*
    (inc-report-counter :fail)
    (initialValue []
    (initialValue []
    (initialize args inits)
    (initialize args inits)
    (initialize args inits)))
    (instance? java.util.Map$Entry x))
    (integer? n) (if (= *print-base* 10)
    (into {}
    (into-array items))
    (io! "await-for in transaction"
    (isLeaf [node]
    (java.util.Collections/shuffle al)
    (justify-clauses params navigator offsets)))
    (keyword nil (name named))))
    (lazy-seq
    (let [[_ path] loc]
    (let [[body rm] (if (= (first exprs) :rounding)
    (let [[defn-sym defn-name & stuff] alis
    (let [[mm considered]
    (let [[node {l :l  [r & rnext :as rs] :r :as path}] loc]
    (let [[node {l :l :as path}] loc]
    (let [[node {l :l r :r :as path}] loc]
    (let [[node {l :l r :r :as path}] loc]
    (let [[node {l :l r :r :as path}] loc]
    (let [[node {l :l, ppath :ppath, pnodes :pnodes r :r, changed? :changed?, :as path}] loc]
    (let [[node {l :l, ppath :ppath, pnodes :pnodes, rs :r, :as path}] loc]
    (let [[node {r :r :as path}] loc]
    (let [[ns-sym ns-name & stuff] alis
    (let [[result continue new-context] (apply func [context])]
    (let [[result new-context] (apply func [context])]
    (let [[shift mask] (or (maybe-min-hash (map int tests)) [0 0])]
    (let [[start end] (brackets reference)
    (let [[super interfaces] (get-super-and-interfaces bases)
    (let [^StackTraceElement s (first stacktrace)]
    (let [^String istr (apply str (repeat (- @(:indent lb) (count prefix))
    (let [^String message (apply format fmt args)
    (let [^String path (if (.startsWith path "/")
    (let [a (.arrayFor this i)]
    (let [a (java.util.ArrayList.)
    (let [buf (char-array 1024)]
    (let [c (class x)
    (let [cache (clojure.lang.MethodImplCache. (symbol v) protocol (keyword (.sym v)))]
    (let [cs (assoc (.map cache) c (clojure.lang.MethodImplCache$Entry. c f))]
    (let [cs (into1 {} (remove (fn [[c e]] (nil? e)) (map vec (partition 2 (.table cache)))))
    (let [d (double x)]
    (let [db (destructure bindings)]
    (let [degen #(.replaceAll ^String % "--.*$" "")
    (let [ex (macroexpand-1 form)]
    (let [f (:test (meta v))]
    (let [gc  (. m (groupCount))]
    (let [gen (new GeneratorAdapter (+ (. Opcodes ACC_PUBLIC) (. Opcodes ACC_STATIC)) 
    (let [gs (gensym)]
    (let [gx (gensym)]
    (let [i (java.util.concurrent.atomic.AtomicInteger. 0)]
    (let [i (java.util.concurrent.atomic.AtomicInteger. i)]
    (let [i (seq (.getInterfaces c))
    (let [latch (new java.util.concurrent.CountDownLatch (count agents))
    (let [len (count m)
    (let [loc (inc e)]
    (let [m (. Method (getMethod "clojure.lang.IPersistentMap __getClojureFnMappings()"))
    (let [m (. Method (getMethod "void __initClojureFnMappings(clojure.lang.IPersistentMap)"))
    (let [m (. Method (getMethod "void __updateClojureFnMappings(clojure.lang.IPersistentMap)"))
    (let [m (re-matcher re s)]
    (let [match (re-matches #"^([A-Za-z0-9_.-]+)\$(\w+)__\d+$" (str class))]
    (let [merge-entry (fn [m e]
    (let [mm (non-private-methods super)]
    (let [name (if (symbol? (first sigs)) (first sigs) nil)
    (let [node ^clojure.core.VecNode node
    (let [node ^clojure.core.VecNode node]       
    (let [ns (or (find-ns ns-sym) (throw (new Exception (str "No namespace: " ns-sym))))
    (let [ns-obj (the-ns ns)]
    (let [once-fixture-fn (join-fixtures (::once-fixtures (meta ns)))
    (let [options   (apply hash-map options)
    (let [options-map (apply hash-map options)
    (let [parentMap (:parents h)
    (let [pending (map #(if (= % path) (str "[ " % " ]") %)
    (let [re (re-pattern re-string-or-pattern)
    (let [ret (clojure.lang.RT/assoc map key val)]
    (let [ret (make-array (. Class (forName "[Ljava.lang.Object;")) (. coll (size)))]
    (let [ret to items (seq from)]
    (let [rsmeta (. rs (getMetaData))
    (let [s (.chunkedNext this)]
    (let [s (.next this)]
    (let [s1 (seq c1) s2 (seq c2) s3 (seq c3)]
    (let [s1 (seq c1) s2 (seq c2)]
    (let [strx (str c)]
    (let [subidx (bit-and (bit-shift-right (dec cnt) level) (int 0x1f))
    (let [supported #{:as :reload :reload-all :require :use :verbose :refer}
    (let [sz (.size in)]
    (let [this (first lis)
    (let [trace (Throwable->map t)
    (let [v (resolve m)
    (let [x 42]
    (let [xlated-val (cond
    (letfn 
    (linear-nl? this lb section)))
    (list 'if test nil (cons 'do body)))
    (list 'new 'clojure.lang.Delay (list* `^{:once true} fn* [] body)))
    (list e)))
    (list* `defn (with-meta name (assoc (meta name) :private true)) decls))
    (load-one lib true true))
    (load-reader rdr)))
    (loop [[mantissa exp] (float-parts (if (neg? arg) (- arg) arg))]
    (loop []
    (loop []
    (loop []
    (loop []
    (loop [acc []
    (loop [c c]
    (loop [count 0
    (loop [count 0
    (loop [count 0
    (loop [count 0
    (loop [hash (int 1) i (int 0)]
    (loop [i (dec cnt)]
    (loop [i (int 0)]
    (loop [i (int len-1)]
    (loop [i 0 idx 0]
    (loop [i 0 s (seq coll)]
    (loop [i 1
    (loop [index (int 0)]
    (loop [index 0]
    (loop [map {}
    (loop [n n xs (seq coll)]
    (loop [n n xs coll]
    (loop [ns nil
    (loop [params params
    (loop [pos 0]
    (loop [ret init i off]
    (loop [ret {} es (seq amap)]
    (loop [ret {} keys (seq keyseq)]
    (loop [rindex len]
    (loop [slots slots
    (m/with-bindings
    (merge {:via (vec (map base via))
    (miser-nl? this lb section)))
    (naive-seq-reduce coll f val)))
    (new clojure.lang.XMLHandler
    (new-instance years months days hours minutes seconds nanoseconds
    (newline)
    (newline)
    (ns-resolve ns nil sym))
    (nth (step nil (seq seq-exprs)) 1)))
    (nth (vals (nth data rowIndex)) columnIndex))
    (null-opt args (map vector (repeat "-i") inits))))
    (op [i x] (boolean (f x i)))))
    (op [i x] (f x i))))
    (op [x y] (boolean (f x y)))))
    (op [x y] (f x y))))
    (op [x y] (f x y))))
    (op [x] (boolean (f x)))))
    (op [x] (f x))))
    (or 
    (or (= :up-arrow token) (= :colon-up-arrow token))))
    (or (find-ns x) (throw (Exception. (str "No namespace: " x " found"))))))
    (or (resolve sym)
    (or (resolve valf)
    (or (when script (sh/sh script (str url)) true)
    (or @(:intra-block-nl lb)
    (orig-pr x)))
    (par coll)))
    (partial diff-associative-key a b)
    (persistent! (reduce1 conj! (transient to) from))
    (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))
    (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))
    (pprint-indent :block 1)
    (pprint-indent :block 1)
    (pprint-indent relative-to (:n params))
    (pprint-logical-block  :prefix prefix :suffix ">"
    (pprint-logical-block :prefix "(" :suffix ")"
    (pprint-logical-block :prefix "(" :suffix ")"
    (pprint-logical-block :prefix prefix :suffix "}"
    (pprint-logical-block :prefix prefix :suffix suffix
    (pprint-newline kind)
    (pprint-simple-code-list alis)))
    (pprint-simple-code-list alis)))
    (pprint-simple-list alis)))
    (pr info)))
    (prepl *in*
    (pretty-writer writer *print-right-margin* *print-miser-width*)))
    (print (apply str (repeat space-count \space))))
    (print (apply str (repeat space-count \space))))
    (print (cond
    (print (err->msg e))
    (print (str
    (print arg-num)
    (print char)
    (print s)
    (print-dup x w)
    (print-length-loop [alis (seq alis)]
    (print-length-loop [alis (seq alis)]
    (print-length-loop [aseq (seq avec)]
    (print-length-loop [binding binding-vec]
    (print-map r print-dup w)
    (print-meta o w))
    (print-method (vary-meta o #(dissoc % :type)) w)
    (print-method cause w)
    (print-method x w))
    (print-object c w)))
    (print-object c w)))
    (print-object m w)))
    (print-object s w)))
    (print-object v w)))
    (print-sequential "[" pr-on ", " "]" (vals r) w)))
    (print-simple o w)))
    (print-tap-diagnostic (:message data)))
    (print-tap-diagnostic (str "  actual:" (pr-str (:actual data))))
    (print-tap-diagnostic (t/testing-contexts-str)))
    (printf "%s.%s" class method))))
    (println "  actual:" (pr-str (:actual m)))))
    (println "#" line)))
    (println "/>")))))
    (println "Clojure" (clojure-version)))
    (println "Macro")
    (println "Spec"))
    (println "\nFAIL in" (testing-vars-str m))
    (println "expected:" (pr-str (:expected m)))
    (println e)
    (prn arglists))
    (prn)))
    (process-nesting
    (proxy [AbstractTableModel] []
    (proxy [TableModel] []
    (proxy [Writer IDeref PrettyFlush] []
    (proxy [clojure.lang.APersistentMap]
    (proxy [java.io.Writer] []
    (proxy [java.io.Writer] []
    (ratio? n) (str
    (recur (next (if (= '* (node loc)) 
    (recur (next (if (= '* (node loc)) 
    (recur cause)
    (reduce
    (reduce
    (reduce 
    (reduce (fn [s k] (if (pred k) s (disj s k)))
    (reduce1 #(apply derive %1 %2) (make-hierarchy)
    (reduce1 #(conj (or %1 {}) %2) maps)))
    (reduce1 bit-and-not (bit-and-not x y) more)))
    (reduce1 bit-or (bit-or x y) more)))
    (reduce1 bit-xor (bit-xor x y) more)))
    (reduce1 conj () coll))
    (reduce1 conj to from)))
    (ref-set (:indent lb) 
    (reify
    (reify
    (relative-reposition navigator (- position (:pos navigator)))
    (removeTreeModelListener [treeModelListener])))
    (repl-opt (concat ["-r"] args) (map vector (repeat "-i") inits))))
    (replace loc (apply f (node loc) args)))
    (replace loc (make-node loc (node loc) (concat (children loc) [item]))))
    (replace loc (make-node loc (node loc) (cons item (children loc)))))
    (root loc)
    (root loc)
    (seq (:l (loc 1))))
    (seq m) w))
    (set! (.__methodImplCache pf) (expand-method-impl-cache cache (class x) f))
    (setf :trailing-white-space (:trailing-white-space token)))
    (sort (mapcat (fn [ns]
    (start-element 'testsuite true (suite-attrs package classname))))
    (start-server server)))
    (str
    (str
    (str
    (str "." m)
    (str "." m)
    (str (if clojure-fn?
    (str (if clojure-fn?
    (str (subs m 0 k) "." (subs m k))))
    (str mname "-void")))
    (str prefix "{")
    (stream-to-bytes stream)
    (stream-to-string stream enc)))
    (struct arg-navigator (:seq navigator) (drop position (:seq navigator)) position)))
    (struct arg-navigator s s 0)))
    (subs d 0 (.lastIndexOf d "/"))))
    (symbol (name clazz) (name method))))
    (symbol nil (name named))
    (symbol? (bindings 0)) `(let ~(subvec bindings 0 2)
    (test (.. sc comparator (compare (. sc entryKey e) key)) 0)))
    (thread
    (thread "clojure.core.server/remote-prepl" true
    (throw
    (throw
    (throw (AssertionError. "No fields vector given.")))
    (throw (Exception. "Incompatible return types"))))
    (throw (IllegalArgumentException. "The number of args doesn't match are's argv."))))
    (throw (IllegalArgumentException. (str "Not a qualified symbol: " sym)))))
    (throw (RuntimeException. full-message))))
    (throw (ex-info (str "Invalid socket server port: " port) opts))))
    (throw (ex-info (str "Missing required socket server property " prop) opts))))
    (throw-if (not (seq args)) "Nothing specified to load")
    (transient {}) coll)))
    (tree-seq
    (tree-seq
    (try
    (try
    (try
    (try
    (update-nl-state lb)))
    (update-proxy this (assoc m meth nil))
    (use 'clojure.test)
    (use 'clojure.test)
    (use 'clojure.test.junit)
    (use 'clojure.test.tap)
    (valueForPathChanged [path newValue])
    (vector? bindings) "a vector for its binding"
    (verify (<= -1 offset-sign 1))
    (verify (<= 0 hours 23))
    (verify (<= 0 minutes 59))
    (verify (<= 0 nanoseconds 999999999))
    (verify (<= 0 offset-hours 23))
    (verify (<= 0 offset-minutes 59))
    (verify (<= 0 seconds (if (= minutes 59) 60 59)))
    (verify (<= 1 days (days-in-month months (leap-year? years))))
    (verify (<= 1 months 12))
    (walk inner identity body)))
    (when (:max-history opts)
    (when (:meta opts)
    (when (:min-history opts)
    (when (:validator opts)
    (when (= (count options) 1)
    (when (> cnt (int 0)) 
    (when (and (pos? (count m))
    (when (and force-trailing-whitespace tws)
    (when (and macro-char (= 2 (count alis)))
    (when (branch? loc)
    (when (clojure.lang.Reflector/invokeStaticMethod "java.awt.Desktop" 
    (when (implements? proto atype)
    (when (next alis)
    (when (next alis)
    (when (next alis)
    (when (next aseq)
    (when (not= "NO_SOURCE_FILE" *source-path*) (. cv visitSource *source-path* nil))
    (when (seq *testing-contexts*) (println (testing-contexts-str)))
    (when (seq non-syms)
    (when (some #(isa? % Serializable) (cons super interfaces))
    (when (some #{:volatile-mutable :unsynchronized-mutable} (mapcat (comp keys meta) hinted-fields))
    (when (some specials fields)
    (when *agent*
    (when *compile-files*
    (when *flush-on-newline*
    (when bad-args
    (when clauses
    (when data
    (when main
    (when mname (throw (IllegalArgumentException. (str "Not a valid method name: " mname))))))
    (when reference (write-out reference))))
    (when s
    (when state
    (when trace
    (when via
    (when-class "java.sql.Timestamp"
    (when-let [bad-opts (seq (remove #{:no-print :load-ns} (keys opts)))]
    (when-let [filepath (:file (meta v))]
    (when-let [fnspec (spec/get-spec (symbol (str (ns-name n)) (name nm)))]
    (when-let [message (:message m)] (println message))
    (when-let [s (seq coll)]
    (when-let [s (seq coll)]
    (when-let [s (seq coll)]
    (when-let [s (seq coll)]
    (when-let [v (resolve x)]
    (when-not (contains? env sym)
    (when-not (protocol? proto)
    (when-not f
    (with-bindings
    (with-junit-output
    (with-lock lock
    (with-meta `(reify* ~interfaces ~@methods) (meta &form))))
    (with-meta coll nil)
    (with-open [is (resolve-class class-resolver typeref)]
    (with-open [stdout (.getInputStream proc)
    (with-out-str
    (with-out-str
    (with-out-str
    (with-tap-output
    (write ([^chars cbuf ^Integer off ^Integer len] 
    (write ([^chars cbuf ^Integer off ^Integer len] 
    (write-out (first alis))
    (write-out (first alis))
    (write-out (first alis))
    (write-out (first aseq))
    (write-out alis)))
    (write-to-base suffix)))
    (write-to-base tws)
    (write-to-base tws)))
    (write-token this token)
    (xdg-open-loc)))
    (zero? cnt) 
    (zipmap (map case-f tests)
    (zipper (complement string?) 
    (zipper seq?
    (zipper vector?
    )
    -                   Run a script from standard input
    - Binds *command-line-args* to a seq of strings containing command line
    - Calls a -main function or runs a repl or script if requested
    - Enters the user namespace
    - Establishes thread-local bindings for commonly set!-able vars
    - Runs all init options in order
    - skips whitespace, then
    --report target     Report uncaught exception to \"file\" (default), \"stderr\",
    -e, --eval string   Evaluate expressions in string; print non-nil values
    -h, -?, --help      Print this help message and exit
    -i, --init path     Load a file or resource
    -m, --main ns-name  Call the -main function from a namespace with args
    -r, --repl          Run a repl
    ...
    ...)
    :accept Namespaced symbol of the accept function to invoke, required
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.0"}
    :added "1.1"}
    :address Host or address, string, defaults to loopback address
    :args Vector of args to pass to accept function
    :as triage-data}]
    :bind-err Bind *err* to socket out stream?, defaults to true
    :bracket-info bracket-info,
    :buffer-size  buffer size to use, default is 1024.
    :cause - root cause message
    :client-daemon Are client threads daemons?, defaults to true
    :clojure.error/cause - cause exception message
    :clojure.error/class - cause exception class symbol
    :clojure.error/column - integer column number
    :clojure.error/line - integer line number
    :clojure.error/path - source path
    :clojure.error/phase - keyword phase indicator, one of:
    :clojure.error/source - file name (no path)
    :clojure.error/spec - explain-data for spec error"
    :clojure.error/symbol - symbol being expanded/compiled/invoked
    :commainterval [ 3 Integer]]
    :commainterval [ 3 Integer]]
    :commainterval [ 3 Integer]]
    :commainterval [ 3 Integer]]
    :commainterval [ 3 Integer]]
    :doc "Conveniently launch a sub-process providing its stdin and
    :doc "Non-core data functions."}
    :doc "Returns a new seq where x is the first element and seq is
    :doc "Start a web browser from Clojure"}
    :doc "Utilities meant to be used interactively at the REPL"}
    :else
    :else (.write w (str o))))
    :else (.write w (str o))))
    :else (do
    :else (pr obj)))
    :else (throw (IllegalArgumentException.
    :else nil))
    :encoding     encoding to use if converting between
    :eof - on eof, return value unless :eofthrow, then throw.
    :err  => sub-process's stderr (String via platform default encoding)"
    :error (merge (stacktrace-file-and-line (.getStackTrace ^Throwable (:actual m))) m)
    :exit => sub-process's exit code
    :exponentchar [nil Character] ]
    :exponentchar [nil Character] ]
    :fail (merge (stacktrace-file-and-line (drop-while
    :features - persistent set of feature keywords for reader conditionals
    :flags flags,
    :generator-fn (concat '(fn [ params offset]) generator-fn) }])
    :init repl-init
    :inline-arities >1?
    :make-input-stream (fn [^File x opts] (make-input-stream (FileInputStream. x) opts))
    :make-input-stream (fn [^Socket x opts] (make-input-stream (.getInputStream x) opts))
    :make-input-stream (fn [^String x opts]
    :make-input-stream (fn [^URI x opts] (make-input-stream (.toURL x) opts))
    :make-input-stream (fn [^URL x opts]
    :make-input-stream (fn [x opts] (BufferedInputStream. x))
    :make-input-stream (fn [x opts] (make-input-stream (ByteArrayInputStream. x) opts))))
    :make-input-stream (fn [x opts] x)
    :make-output-stream (fn [^File x opts] (make-output-stream (FileOutputStream. x (append? opts)) opts))))
    :make-output-stream (fn [^Socket x opts] (make-output-stream (.getOutputStream x) opts))))
    :make-output-stream (fn [^String x opts]
    :make-output-stream (fn [^URI x opts] (make-output-stream (.toURL x) opts))))
    :make-output-stream (fn [^URL x opts]
    :make-output-stream (fn [x opts] (BufferedOutputStream. x))
    :make-output-stream (fn [x opts] x)
    :make-reader (fn [x opts]
    :make-reader (fn [x opts] (BufferedReader. x))))
    :make-reader (fn [x opts] (make-reader (CharArrayReader. x) opts))))
    :make-reader (fn [x opts] x)))
    :make-reader inputstream->reader))
    :make-reader inputstream->reader))
    :make-writer (fn [x opts]
    :make-writer (fn [x opts] (BufferedWriter. x))))
    :make-writer (fn [x opts] x)))
    :make-writer outputstream->writer))
    :make-writer outputstream->writer))
    :name Name, required
    :out  => sub-process's stdout (as byte[] or String)
    :overflowchar [nil Character] :padchar [\space Character] 
    :overflowchar [nil Character] :padchar [\space Character] 
    :padchar [\space Character] ]
    :params `(array-map ~@params),
    :phase - error phase
    :port Port, integer, required
    :pre and :post that contain collections of pre or post conditions."
    :read repl-read))
    :read-cond - :allow to process reader conditionals, or
    :server-daemon Is server thread a daemon?, defaults to true
    :target - \"file\" (default), \"stderr\", \"none\"
    :trace - root cause stack elements"
    :via - cause chain, with cause keys:
    ; (prlabel wws (str "*" tws "*"))
    ; check a load target was specified
    ; check for unsupported options
    ; compact case ints, no shift-mask
    ;; RFC3339 says to use -00:00 when the timezone is unknown (+00:00 implies a known GMT)
    ;; Usually convert to a double, only resorting to the slower
    ;; add on nanos and offset
    ;; bigdec conversion if the result does not fit within the range
    ;; calstr is almost right, but is missing the colon in the offset
    ;; could make simpler loop of two args: names an
    ;; nanos must be set separately, pass 0 above for the base calendar
    ;; of a double.
    ;; only apply to maps
    ;; only apply to maps
    ;optional doc string
    @*report-counters*))
    AClass
    AProtocol
    AType
    BProtocol 
    BType
    Countable
    Foo
    Strings, native Java arrays (of reference types) and any objects
    ["(" ")"]))
    ["[" "]"]
    [(.getFileName s) (.getLineNumber s)]))
    [(first bases) (next bases)]))
    [(into {} pairs) new-navigator]))
    [(keys hmap) (vals hmap) skip-check]))
    [(struct compiled-directive 
    [(struct compiled-directive ((:generator-fn def) params offset) def params offset)
    [(take n coll) (drop n coll)])
    [(take-while pred coll) (drop-while pred coll)])
    [(when (and in-a (or (not (nil? a*)) (not same))) {k a*})
    [0 0 (case-map int int tests thens) :compact]
    [Object bases]
    [[param [real-param offset]] new-navigator]))
    [] props))
    [clojure.java.javadoc :refer (javadoc)]
    [clojure.pprint :refer (pp pprint)]])
    [cmd (merge default-opts (apply hash-map opts))]))
    [cname (. cv (toByteArray))]))
    [cname (. cv toByteArray)]))
    [compiled-format navigator]))
    [data]
    [iname (. cv toByteArray)]))
    [interfaces methods opts]))
    [m e false]))
    [new-instant ^CharSequence cs]
    [nil nil a]
    [p (zipmap (map #(-> % first name keyword) fs)
    [pre (seq (drop (count pre) tokens))]))
    [root nil])
    [section (seq (drop (inc (count section)) buffer))])) 
    [{ :clauses [] } false remainder])))
    \"A doc string for AProtocol abstraction\"
    \backspace "backspace"
    \formfeed "formfeed"
    \return "return"})
    \space "space"
    \tab "tab"
    ^{:author "Christophe Grand",
    ^{:author "Tom Faulhaber",
    ^{:doc "Type object for a Java primitive byte array."
    ^{:doc "Type object for a Java primitive char array."
    ^{:zip/branch? branch? :zip/children children :zip/make-node make-node}
    `(#'print-doc (#'special-doc '~special-name))
    `(.reset ~v (~f (.deref ~v) ~@args))))
    `(alter-meta! (var ~name) assoc :test (fn [] ~@body))))
    `(def ~(vary-meta name assoc :test `(fn [] ~@body) :private true)
    `(def ~(vary-meta name assoc :test `(fn [] ~@body))
    `(defn ~fn-name
    `(defn ~name
    `(defn ~name ~doc ~meta
    `(deftype* ~(symbol (name (ns-name *ns*)) (name tagname)) ~classname ~fields
    `(do
    `(do
    `(do
    `(do
    `(do
    `(do (if (#'clojure.pprint/level-exceeded) 
    `(do ~@(map #(list 'clojure.core/import* %)
    `(do ~@(map (fn [a]
    `(doto ~definition (alter-meta! assoc :test (fn [] ~@body)))
    `(extend ~c
    `(fn [cache#]
    `(fn [~t ~@args]
    `(if (clojure.lang.LockingTransaction/isRunning)
    `(let []
    `(let []
    `(let []
    `(let [] 
    `(let [iter# ~(emit-bind (to-groups seq-exprs))]
    `(let [n# (clojure.lang.RT/longCast ~n)]
    `(let [n# (long ~n)]
    `(let [temp# ~tst]
    `(let [temp# ~tst]
    `(let [values# (list ~@args)
    `(let [~g ~expr
    `(let [~g ~expr
    `(let [~g ~expr
    `(let [~g ~expr
    `(let [~gpred ~pred
    `(loop ~(apply vector count-var 0 bindings)
    `(reify clojure.core.ArrayManager
    `(temp/do-template ~argv (is ~expr) ~@args)
    `(try ~@body
    `(try ~@body
    `(when-let [xs# (seq ~xs)]
    a)
    accept - accept fn symbol to invoke
    already loaded
    an atom and compared for equality."
    arg-navigator))
    arg-navigator))
    args
    args - to pass to accept-fn"
    argument. If coll is nil, returns nil."
    by their indexes, with results returned as vectors.
    c. Returns true or false"
    client-id - client identifier
    clojure.inspector
    clojure.java.io
    clojure.lang.PersistentList/EMPTY)
    clojure.parallel)
    clojure.pprint
    cnt (count data)
    colcnt (count row1)
    conn - client socket
    contains val at index. Note - index must be <= (count vector)."
    def {:forms [(def symbol doc-string? init?)]
    default).
    definition))
    do {:forms [(do exprs*)]
    empty, returns nil.  (seq nil) returns nil. seq also works on
    err - err stream
    f))
    format)))
    format)))
    h))))
    happen at different 'places' depending on the concrete type."
    identified libs directly or indirectly load via require or use
    if {:forms [(if test then else?)]
    in - in stream
    keyword to bring in all public vars.
    ks)))
    length-reached))
    lib's namespace in the current namespace.
    m)))
    macro
    map m as its metadata."
    method (.getMethodName e)] 
    monitor-enter {:forms [(monitor-enter x)]
    monitor-exit {:forms [(monitor-exit x)]
    name (fn ([params* ] exprs*)+)) with any doc-string or attrs added
    name - server name
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    navigator))
    new {:forms [(Classname. args*) (new Classname args*)]
    nil
    nil)
    nil)
    opts))
    out - out stream
    path                Run a script from a file or resource
    pmap (reduce1 (fn [m ^java.beans.PropertyDescriptor pd]
    proxy)
    proxy)
    quote {:forms [(quote form)]
    r))
    r)))
    recur {:forms [(recur exprs*)]
    rest
    returns the same mutable object."
    right f1
    same (hashed/sorted) type, that contains the mapping of key(s) to
    section)) 
    set! {:forms[(set! var-symbol expr)
    should not be used on any Iterable whose iterator repeatedly
    socket))
    spec
    special-form
    target))
    test-1 then-1
    test-n then-n
    that implement Iterable. Note that seqs cache values, thus seq
    the rest."
    throw {:forms [(throw expr)]
    to the var metadata. prepost-map defines a map with optional keys
    tr))
    true (Integer/parseInt p))
    true))
    try {:forms [(try expr* catch-clause* finally-clause?)]
    typeref
    user> (print-table (map #(vector % (* % %) (* % % %)) (range 1 11)) 8)
    v (fn [k] ((pmap k)))
    val(s). When applied to a vector, returns a new vector that
    valf))
    vals (if (map? row1) vals identity)]
    var {:forms [(var symbol)]
    writer
    x
    x
    x))
    {'uuid #'clojure.uuid/default-uuid-reader}
    {:file nil :line nil}))
    {:nrows (count v) 
    {:nrows (count v) 
    {:status
    {\newline "\\n"
   #(format-ascii pr-str %1 %2 %3))
   #(format-ascii print-str %1 %2 %3))
   #(format-integer 10 %1 %2 %3))
   #(format-integer 16 %1 %2 %3))
   #(format-integer 2 %1 %2 %3))
   #(format-integer 8 %1 %2 %3))
   #{ :at :colon :both } {}
   #{ :at :colon :both } {}
   #{ :at :colon :both } {}
   #{ :at :colon :both } {}
   #{ :at :colon :both } {}
   #{ :at :colon :both } {}
   #{ :at :colon :both } {}
   #{ :at :colon :both} {}
   #{ :at :colon :both} {}
   #{ :at :colon :both} {}
   #{ :at :pretty } {}
   #{ :at } {}
   #{ :at } {}
   #{ :at } {}
   #{ :at } {}
   #{ :colon :at :both} { :right \), :allows-separator nil, :else nil }
   #{ :colon :at :both} { :right \}, :allows-separator false }
   #{ :colon :at } { :right \], :allows-separator true, :else :last }
   #{ :colon :at } {}
   #{ :colon } { :separator true } nil) 
   #{ :pretty } {}
   #{ } {}
   #{ } {}
   #{ } {}
   #{:at :colon :both :pretty} {}
   #{:at :colon :both} {}
   #{:colon :at :both :pretty} { :right \>, :allows-separator true, :else :first }
   #{:colon :at} {}
   #{:colon} {}
   #{:colon} {} 
   #{}
   '(defn cl-format 
   '(defn cl-format 
   '(defn pprint-defn [writer alis]
   '(defn- -write 
   'is' call 'report' to indicate results.  The argument given to
   'report' will be a map with a :type key.  See the documentation at
   (-> (.getClassName t))))
   (-> (typename t)
   (. *out* (append \space))
   (. Array (newInstance type (int len))))
   (. Array (set array idx val))
   (. clojure.lang.LispReader (read stream (boolean eof-error?) eof-value recursive?)))
   (. clojure.lang.LispReader (read stream opts))))
   (. clojure.lang.PersistentHashMap (create keyvals))))
   (. clojure.lang.RT (dissoc map key)))
   (. clojure.lang.RT (get map key not-found))))
   (. clojure.lang.RT (get map key)))
   (. clojure.lang.RT (subvec v start end))))
   (. set (disjoin key)))
   (.printStackTrace t)
   (<= (count v) n) (reduce reducef (combinef) v)
   ([coll f val] (iter-reduce coll f val)))
   ([coll f val] (seq-reduce coll f val)))
   ([coll f val] (seq-reduce coll f val)))
   ([coll f val] (seq-reduce coll f val)))
   ([coll f val] (seq-reduce coll f val)))
   ([coll f val] val))
   ([coll f] (f))
   ([coll f] (iter-reduce coll f))
   ([coll f] (seq-reduce coll f))
   ([coll f] (seq-reduce coll f))
   ([coll f] (seq-reduce coll f))
   ([coll f] (seq-reduce coll f))
   ([map key val & kvs]
   ([map key val] (clojure.lang.RT/assoc map key val))
   ([x y & more]
   ([x y] (. clojure.lang.Numbers and x y))
   (alter-var-root #'global-hierarchy derive tag parent) nil)
   (and (is-annotation? c)
   (apply aget (aget array idx) idxs)))
   (apply aset (aget array idx) idx2 idxv)))
   (apply f current-value-of-vol args). Returns the value that
   (apply prn xs)))
   (assert (instance? clojure.lang.Named parent))
   (assert (namespace parent))
   (assert (not= tag parent))
   (assert (or (class? tag) (and (instance? clojure.lang.Named tag) (namespace tag))))
   (assert (or (class? tag) (instance? clojure.lang.Named tag)))
   (assert-args
   (assert-args
   (assert-valid-fdecl fdecl)
   (assoc m k (apply f (get m k) x y z more))))
   (assoc m k (f (get m k) x y z)))
   (assoc m k (f (get m k) x y)))
   (assoc m k (f (get m k) x)))
   (assoc m k (f (get m k))))
   (case
   (class? t) (with-meta {'clojure.core.protocols/datafy
   (class? x) x
   (clojure.core.protocols/coll-reduce
   (clojure.core/extend-type AClass Protocol 
   (clojure.core/extend-type AType Protocol 
   (clojure.core/extend-type BType Protocol 
   (clojure.core/extend-type nil Protocol 
   (clojure.lang.PersistentHashSet/create keys)))
   (clojure.lang.PersistentTreeMap/create comparator keyvals)))
   (clojure.lang.PersistentTreeMap/create keyvals)))
   (clojure.lang.PersistentTreeSet/create comparator keys)))
   (clojure.lang.PersistentTreeSet/create keys)))
   (clojure.lang.Reflector/prepRet (.getComponentType (class array)) (. Array (get array idx))))
   (clojure.string/replace \"Almost Pig Latin\" #\"\\b(\\w)(\\w+)\\b\" \"$2$1ay\")
   (clojure.string/replace-first \"swap first two words\"
   (coll? form) (outer (into (empty form) (map inner form)))
   (commute *loaded-libs* #(reduce1 conj %1 %2)
   (cond
   (cond
   (cond
   (cond
   (consume
   (consume 
   (contains? prim->class x) (prim->class x)
   (decimal? x) (>= (.ulp (.stripTrailingZeros (bigdec 0))) 1) ; true iff no fractional part
   (defn my-fixture [f]
   (defn test-ns-hook []
   (deftest addition
   (deftest arithmetic
   (deftest subtraction
   (do
   (dorun coll)
   (dorun n coll)
   (doto (Thread.
   (drop 1 (interleave (repeat sep) coll))))
   (empty? v) (combinef)
   (error-el (:message m)
   (failure-el (:message m)
   (finally 
   (finish-case)))
   (finish-suite)))
   (first
   (first 
   (fjinvoke
   (float? x)   (= x (Math/floor x))
   (fn
   (fn
   (fn
   (fn
   (fn
   (fn
   (fn [& args] (apply f arg1 arg2 arg3 (concat more args)))))
   (fn [[s offset flags]]
   (fn [diff1 diff2]
   (fn [f1]
   (fn [f1]
   (fn [f1]
   (fn [f1]
   (fn [f1]
   (fn [f1]
   (fn [f1]
   (fn [params arg-navigator offsets]
   (fn [params arg-navigator offsets]
   (fn [params arg-navigator offsets]
   (fn [params arg-navigator offsets]
   (fn [params arg-navigator offsets]
   (fn [params navigator offsets]
   (fn [params navigator offsets]
   (fn [remainder]
   (fn [result fd]
   (fn [rf]
   (fn [rf]
   (fn [rf]
   (fn [rf]
   (fn [rf]
   (fn [rf]
   (fn [rf]
   (if (:at params)
   (if (:at params)
   (if (:at params)
   (if (< x y)
   (if (<= x y)
   (if (= x y)
   (if (== x y)
   (if (> x y)
   (if (>= x y)
   (if (and (instance? Long start) (instance? Long end) (instance? Long step))
   (if (and (instance? Long start) (instance? Long end))
   (if (and (seq xrel) (seq yrel))
   (if (clojure.lang.Util/equiv x y)
   (if (instance? Long end)
   (if (nil? x) "" (. x (toString))))
   (if (not (tokens-fit? this (getf :buffer)))
   (if (not= x y)
   (if (or (:at params) (:colon params))
   (if (seq coll)
   (if (vector? coll)
   (if args
   (if-let [nmore (next more)]
   (if-let [s (seq s)]
   (inc-report-counter :error)
   (instance? clojure.lang.IMapEntry form)
   (instance? clojure.lang.IPersistentVector o)
   (instance? clojure.lang.IRecord form)
   (instance? clojure.lang.Seqable x) :seqable
   (instance? java.util.Map x) :seqable
   (instance? java.util.Set x) :seqable
   (integer? x) true
   (into (array-map) ; start with the default values, make sure the order is right
   (into {} (for [[k [v1 v2]] m] [k v2]))])
   (is (.startsWith \"abcde\" \"ab\"))
   (is (= 4 (+ 2 2)))
   (is (= 5 (+ 2 2)) \"Crazy arithmetic\")
   (is (instance? Integer 256))
   (is (thrown-with-msg? ArithmeticException #\"Divide by zero\"
   (is (thrown? ArithmeticException (/ 1 0))) 
   (iterate inc' 0))
   (iterator [_]
   (java.io File)))
   (lazy-seq
   (lazy-seq
   (lazy-seq
   (lazy-seq
   (lazy-seq
   (let [[file line] (t/file-position 5)
   (let [[r s k] (if (<= (count xrel) (count yrel))
   (let [^BlockingQueue q (if (instance? BlockingQueue n-or-q)
   (let [^clojure.core.ArrayManager am (ams-check t)
   (let [^clojure.core.ArrayManager am (ams-check t)
   (let [^clojure.core.ArrayManager am (ams-check t)
   (let [^clojure.core.ArrayManager am (ams-check t)
   (let [^clojure.core.ArrayManager am (ams-check t)]
   (let [actual (:actual m)]
   (let [asig
   (let [aval (as-set-value a)
   (let [bases (map #(or (resolve %) (throw (Exception. (str "Can't resolve: " %)))) 
   (let [dims (cons dim more-dims)
   (let [form (bindings 0) tst (bindings 1)]
   (let [form (bindings 0) tst (bindings 1)]
   (let [form (bindings 0) tst (bindings 1)]
   (let [form (bindings 0) tst (bindings 1)]
   (let [include (mk-bound-fn sc test key)]
   (let [include (mk-bound-fn sc test key)]
   (let [iter (.iterator coll)]
   (let [iter (.iterator coll)]
   (let [kx (k x) ky (k y)
   (let [kx (k x) ky (k y)
   (let [lb (:logical-block token)]
   (let [lb (getf :logical-blocks)
   (let [lb (getf :logical-blocks)]
   (let [lb (struct logical-block (getf :logical-blocks) nil (ref 0) (ref 0)
   (let [m (re-matcher re s)]
   (let [mod-case-writer (cond
   (let [n (+ 2 (.. Runtime getRuntime availableProcessors))
   (let [nexti (+ i (.alength am anode))]
   (let [pos (getf :pos)]
   (let [pre-line (.getLineNumber reader)
   (let [r  ^clojure.lang.Ref (setup-reference (ref x) options)
   (let [ret (. set (disjoin key))]
   (let [ret (.assoc coll key val)]
   (let [ret (.without map key)]
   (let [ret (dissoc map key)]
   (let [s (.s str-seq)
   (let [split (quot (count v) 2)
   (let [step (fn step [cs]
   (let [step (fn step [cs]
   (let [step (fn step [xs seen]
   (let [tp (:parents h)
   (let [var (:var m)]
   (let [walk (fn walk [node]
   (letfn [(mapi [idx coll]
   (list? form) (outer (apply list (map inner form)))
   (loop [buffer (getf :buffer)]
   (loop [cls (class s)
   (loop [lb (:parent lb)]
   (loop [result val
   (loop [v  (vector-of t x1 x2 x3 x4)
   (map
   (map #(let [val (first %1)]
   (map access-flag
   (map-entry? o)
   (map-entry? x) :entry
   (map-passing-context 
   (map? arg) (into-array String (map (fn [[k v]] (str (name k) "=" v)) arg))
   (nil? (next arglist)) (seq (first arglist))
   (nil? (seq coll)) true
   (nil? arg) nil
   (nil? arglist) nil
   (not (apply = x y more))))
   (or (= child parent)
   (outer (clojure.lang.MapEntry/create (inner (key form)) (inner (val form))))
   (parse-flags (.getModifiers constructor) :method)))
   (parse-flags (.getModifiers field) :field)))
   (parse-flags (.getModifiers method) :method)))
   (pr x)
   (pred (first coll)) (recur pred (next coll))
   (print "  actual: ")
   (print-diagnostics data)))
   (print-diagnostics data)))
   (print-diagnostics data)))
   (print-tap-diagnostic (pr-str data))))
   (print-tap-fail (t/testing-vars-str data))
   (print-tap-fail (t/testing-vars-str data))
   (print-tap-pass (t/testing-vars-str data))
   (print-tap-plan (+ (:pass data) (:fail data) (:error data)))))
   (println "\nERROR in" (testing-vars-str m))
   (println "\nRan" (:test m) "tests containing"
   (println "\nTesting" (ns-name (:ns m)))))
   (println "expected:" (pr-str (:expected m)))
   (println (:fail m) "failures," (:error m) "errors.")))
   (ratio? x)   (let [^clojure.lang.Ratio r x]
   (read *in*))
   (read *in*))
   (read stream eof-error? eof-value false))
   (read stream true nil))
   (read {} stream))
   (reduce
   (reduce #(apply assoc %1 %2) {} (filter #(first (nth % 1)) (zipmap (keys (:params def)) params))) ; add the specified parameters, filtering out nils
   (reduce (fn [counts x]
   (reduce [_ f init]
   (reduce1 *' (*' x y) more)))
   (reduce1 +' (+' x y) more)))
   (reduce1 -' (-' x y) more)))
   (reduce1 / (/ x y) more)))
   (reduce1 max (max x y) more)))
   (reduce1 min (min x y) more)))
   (ref-set (:done-nl lb) true)
   (ref-set (:intra-block-nl lb) false)
   (run-tests 'your.namespace 'some.other.namespace)
   (seq? form) (outer (doall (map inner form)))
   (seq? v) (let [[nested nv] v
   (sequential? x) :seq
   (setf :buffer (conj (getf :buffer) token))
   (setf :mode :buffering)
   (sort (fn [x y] (. comp (compare (keyfn x) (keyfn y)))) coll)))
   (sort compare coll))
   (sort-by keyfn compare coll))
   (start-suite (name (ns-name (:ns m))))))
   (stop-server (:server *session*)))
   (subvec v start (count v)))
   (sun.misc.Signal/handle
   (symbol (.getName constructor))
   (symbol (.getName field))
   (symbol (.getName method))
   (symbol? v) (let [ev (eval v)]
   (t/inc-report-counter :error)
   (t/inc-report-counter :error)
   (t/inc-report-counter :fail)
   (t/inc-report-counter :fail)
   (t/inc-report-counter :pass)
   (t/inc-report-counter :pass)))
   (testing \"Arithmetic\"
   (throw t)))
   (try
   (try
   (typename (Type/getType c)))
   (typesym (.getDeclaringClass constructor))
   (typesym (.getDeclaringClass field))
   (typesym (.getDeclaringClass method))
   (typesym (.getReturnType method))
   (typesym (.getType field))
   (use-fixtures :each (fn [f] setup... (f) cleanup...))
   (use-fixtures :each fixture1 fixture2 ...)
   (use-fixtures :once fixture1 fixture2 ...)
   (vec (map typesym (.getExceptionTypes constructor)))
   (vec (map typesym (.getExceptionTypes method)))
   (vec (map typesym (.getParameterTypes constructor)))
   (vec (map typesym (.getParameterTypes method)))
   (vector? v) (let [avec (.visitArray av name)]
   (when (. m (find))
   (when (and (seq coll) (pos? n))
   (when (seq *testing-contexts*) (println (testing-contexts-str)))
   (when set
   (when set
   (when-let [[e :as s] (. sc seqFrom end-key false)]
   (when-let [[e :as s] (. sc seqFrom start-key true)]
   (when-let [cb (getf :logical-block-callback)] (cb :start))
   (when-let [message (:message m)] (println message))
   (when-let [s (seq coll)]
   (with-lock lock
   (with-test
   ({"-r"     repl-opt
   -> \"first swap two words\""
   -> \"lmostAay igPay atinLay\""
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.0"}
   :added "1.1"}
   :added "1.1"}
   :added "1.1"}
   :added "1.1"}
   :added "1.1"}
   :added "1.1"}
   :added "1.2"
   :added "1.2"
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.2"}
   :added "1.3"
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.3"}
   :added "1.5"}
   :added "1.6"
   :added "1.6"}
   :added "1.7"}
   :added "1.9"}
   :added "1.9"}
   :arglists '([name [& fields] & opts+specs])}
   :arglists '([name [& fields] & opts+specs])}
   :arglists '([name doc-string? attr-map? [params*] body]
   :arglists '([name doc-string? attr-map? [params*] prepost-map? body]
   :arglists '([pred coll])
   :arglists '([pred coll])
   :arglists '([t] [t & elements])}
   :arglists '([x])
   :arglists '([x])
   :arglists '([x])
   :arglists '([x])
   :arglists '([x])
   :bases            a set of names of the type's bases
   :clojure.error/phase (:execution et al per clojure.main/ex-triage) ;;iff error occurred
   :declaring-class  name of the declarer
   :deprecated "1.1"}
   :deprecated "1.2"}
   :deprecated "1.2"}
   :deprecated "1.2"}
   :deprecated "1.3"}
   :doc "Creates a new list containing the items."
   :doc "Evaluates x and tests if it is an instance of the class
   :doc "Mark circular structures (N.B. This is not yet used)"}
   :doc "Mark repeated structures rather than repeat them (N.B. This is not yet used)"}
   :doc "Maximum number of lines to print in a pretty print instance (N.B. This is not yet used)"}
   :doc "Return a seq of all but the last item in coll, in linear time"
   :doc "Return the last item in coll, in linear time"
   :doc "Return true if x implements IPersistentMap"
   :doc "Return true if x implements IPersistentVector"
   :doc "Return true if x implements ISeq"
   :doc "Return true if x is a Character"
   :doc "Return true if x is a String"
   :doc "Returns a possibly empty seq of the items after the first. Calls seq on its
   :doc "Returns a seq of the items after the first. Calls seq on its
   :doc "Returns a seq on the collection. If the collection is
   :doc "Returns an object of the same type and value as obj, with
   :doc "Returns false if (pred x) is logical true for any x in coll,
   :doc "Returns false if (pred x) is logical true for every x in
   :doc "Returns the first item in the collection. Calls seq on its
   :doc "Returns the metadata of obj, returns nil if there is no metadata."
   :doc "assoc[iate]. When applied to a map, returns a new map of the
   :doc "conj[oin]. Returns a new collection with the xs
   :else
   :else        false))
   :else (.visit av name v)))
   :else (cons (first arglist) (spread (next arglist)))))
   :else (let [strx (str x)]
   :else (loop [this this
   :else (outer form)))
   :else :atom))
   :else false))
   :error are called when an assertion passes, fails, and throws an
   :exception-types  vector of exception type names
   :exception-types  vector of exception type names
   :extend-via-metadata true
   :flags            a set of keywords naming the boolean attributes
   :flags            keyword naming boolean attributes of the member
   :form string ;;iff successfully read
   :forms '[(fn name? [params* ] exprs*) (fn name? ([params* ] exprs*)+)]}
   :inline (fn  [x] `(. clojure.lang.Numbers (num ~x)))
   :inline (fn  [x] `(. clojure.lang.RT (booleanCast ~x)))
   :inline (fn  [x] `(. clojure.lang.RT (count ~x)))
   :inline (fn  [x] `(. clojure.lang.RT (~(if *unchecked-math* 'uncheckedIntCast 'intCast) ~x)))
   :inline (fn [num] `(. clojure.lang.Numbers (isNeg ~num)))
   :inline (fn [num] `(. clojure.lang.Numbers (isPos ~num)))
   :inline (fn [num] `(. clojure.lang.Numbers (isZero ~num)))
   :inline (fn [x y] `(. clojure.lang.Numbers (quotient ~x ~y)))}
   :inline (fn [x y] `(. clojure.lang.Numbers (remainder ~x ~y)))}
   :inline (fn [x y] `(. clojure.lang.Util compare ~x ~y))
   :inline (fn [x] (list 'clojure.lang.Util/identical x nil))}
   :inline (nary-inline 'max)}
   :inline (nary-inline 'min)}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1 2}
   :inline-arities #{1}
   :inline-arities #{1}
   :inline-arities #{2 3}
   :inline-arities #{2 3}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{2}
   :inline-arities #{3}
   :inline-arities >0?
   :inline-arities >0?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :inline-arities >1?
   :make-input-stream (fn [x opts]
   :make-output-stream (fn [x opts]
   :make-writer (fn [x opts] (make-writer (make-output-stream x opts) opts))
   :members          a set of the type's members. Each member is a map
   :ms long ;;eval time in milliseconds
   :name             name of the type 
   :ns ns-name-string
   :parameter-types  vector of parameter type names
   :parameter-types  vector of parameter type names
   :return-type      return type name
   :return-type (typesym (Type/getReturnType md))})
   :see-also [["http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node200.html#SECTION002633000000000000000" 
   :special-form true, :url nil}
   :static true
   :static true
   :static true
   :static true
   :static true
   :static true
   :static true
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :static true}
   :tag Boolean}
   :tag Boolean}
   :tag String}
   :tag clojure.lang.ISeq
   :tag clojure.lang.ISeq
   :tag clojure.lang.ISeq
   :tag clojure.lang.Volatile}
   :type             type name
   :val string} ;chars from during-eval *err*
   :val string} ;chars from during-eval *out*
   :val val ;;eval result
   :val val} ;values from tap>
   :while test, :when test.
   ;options
   <http://www.gigamonkeys.com/book/practical-building-a-unit-test-framework.html>
   A fixture is just a function that calls another function passed as
   ASSERTIONS
   All the test reporting functions write to the var *test-out*.  By
   All typerefs are normalized into symbols. If you need to
   As of Clojure SVN rev. 1221, this does not work with defmacro.
   Attach \"once\" fixtures to the current namespace like this:
   Boolean/TYPE "Boolean/TYPE"
   By default, these functions will search for all tests defined in
   Byte/TYPE "Byte/TYPE"
   Callers should generally prefer the higher level API provided by
   Calls to \"testing\" may be nested, and all of the strings will be
   Character/TYPE "Character/TYPE"
   Collections are iterated in a nested fashion, rightmost fastest,
   Common options include
   Countable
   DEFINING TESTS
   DOCUMENTING TESTS
   Default implementations always return a java.io.BufferedInputStream.
   Default implementations always return a java.io.BufferedOutputStream.
   Default implementations always return a java.io.BufferedReader.
   Default implementations always return a java.io.BufferedWriter.
   Default implementations are defined for InputStream, File, URI, URL,
   Default implementations are defined for OutputStream, File, URI, URL,
   Default implementations are provided for Reader, BufferedReader,
   Default implementations are provided for Writer, BufferedWriter,
   Double/TYPE "Double/TYPE"
   EXTENDING TEST-IS (ADVANCED)
   Example:
   Example:
   FIXTURES
   Fixtures allow you to run code before and after tests, to set up
   Fixtures are attached to namespaces in one of two ways.  \"each\"
   Foo
   For additional event types, see the examples in the code.
   For pattern / string, $1, $2, etc. in the replacement string are
   For pattern / string, $1, $2, etc. in the replacement string are
   INSIDE a \"deftest\" or \"with-test\" form (see below).
   If (cmap ch) is nil, append ch to the new string.
   If (cmap ch) is non-nil, append (str (cmap ch)) instead."
   If argument is a String, it tries to resolve it first as a URI, then
   If test is not nil, evaluates then with binding-form bound to the
   If the argument is a String, it tries to resolve it first as a URI, then
   If the argument is a String, it tries to resolve it first as a URI, then
   If the argument is a String, it tries to resolve it first as a URI, then
   If you are writing a custom assert-expr method, call this function
   If you don't specify any namespaces, the current namespace is
   Implies that deref'ing the provided vars will succeed. Returns true if no vars are provided."
   Implies that set!'ing the provided vars will succeed.  Returns true if no vars are provided."
   In addition, you can document groups of assertions with the
   InputStream, File, URI, URL, Socket, byte arrays, character arrays,
   Integer/TYPE "Integer/TYPE"
   Iterable
   Key specific to methods:
   Keys common to all members:
   Keys specific to constructors:
   Keys specific to fields:
   Long/TYPE "Long/TYPE"
   Note that, unlike RSpec, the \"testing\" macro may only be used
   Note: Fixtures and test-ns-hook are mutually incompatible.  If you
   Note: test-ns-hook prevents execution of fixtures (see below).
   OMITTING TESTS FROM PRODUCTION CODE
   Options:
   Otherwise returns nil."
   OutputStream, File, URI, URL, Socket, and String.
   P
   Peter Seibel's \"Practical Common Lisp\"
   PrintWriter.  For example, it could be a file opened with
   RUNNING TESTS
   Reflect on a typeref, returning a map with :bases, :flags, and
   Reflect on the type of obj (or obj itself if obj is a class).
   Return value and options are the same as for type-reflect. "
   Returns a lazy seq of n xs."
   Returns server socket."
   Run tests with the function \"(run-tests namespaces...)\":
   SAVING TEST OUTPUT TO A FILE
   Section 4.2 of the JVM spec, 2nd ed.:
   See also replace-first.
   See also replace.
   See http://clojure.org/data_structures#hash for full algorithms."
   See http://clojure.org/data_structures#hash for full algorithms."
   See http://clojure.org/data_structures#hash for full algorithms."
   See http://code.google.com/p/clojure/issues/detail?id=51
   Short/TYPE "Short/TYPE"})
   Should be used inside with-open to ensure the InputStream is properly
   Should be used inside with-open to ensure the OutputStream is
   Should be used inside with-open to ensure the Reader is properly
   Should be used inside with-open to ensure the Writer is properly
   Socket, and String arguments.
   Socket, byte array, and String arguments.
   The 'event' argument is a map.  It will always have a :type key,
   The \"expected:\" line shows you the original expression, and the
   The \"testing\" strings will be a list in \"*testing-contexts*\", and
   The core of the library is the \"is\" macro, which lets you make
   The fixture1, fixture2 are just functions like the example above.
   The names of the nested tests will be joined in a list, like
   The other kind of fixture, a \"once\" fixture, is only run once,
   The other way lets you define tests separately from the rest of
   The replacement is literal (i.e. none of its characters are treated
   The replacement is literal (i.e. none of its characters are treated
   There are two special assertions for testing exceptions.  The
   There are two ways to define tests.  The \"with-test\" macro takes
   They can also be anonymous functions, like this:
   This creates functions named \"addition\" and \"subtraction\", which
   When test is not nil, evaluates body with binding-form bound to the
   You can bind the variable \"*load-tests*\" to false when loading or
   You can extend the behavior of the \"is\" macro by defining new
   You can plug in your own test-reporting framework by rebinding
   You can type an \"is\" expression directly at the REPL, which will
   Your \"report\" function should wrap any printing calls in the
   [ :colnum [1 Integer] :colinc [1 Integer] ] 
   [ :count [1 Integer] ] 
   [ :count [1 Integer] ] 
   [ :count [1 Integer] ] 
   [ :d [2 Integer] :n [1 Integer] :w [0 Integer] :padchar [\space Character]]
   [ :max-iterations [nil Integer] ]
   [ :mincol [0 Integer] :colinc [1 Integer] :minpad [0 Integer] :padchar [\space Character] ] 
   [ :mincol [0 Integer] :colinc [1 Integer] :minpad [0 Integer] :padchar [\space Character] ] 
   [ :mincol [0 Integer] :padchar [\space Character] :commachar [\, Character] 
   [ :mincol [0 Integer] :padchar [\space Character] :commachar [\, Character] 
   [ :mincol [0 Integer] :padchar [\space Character] :commachar [\, Character] 
   [ :mincol [0 Integer] :padchar [\space Character] :commachar [\, Character] 
   [ :n [1 Integer] ] 
   [ :n [nil Integer] ] 
   [ :selector [nil Integer] ]
   [ :w [nil Integer] :d [nil Integer] :e [nil Integer] :k [1 Integer] 
   [ :w [nil Integer] :d [nil Integer] :e [nil Integer] :k [1 Integer] 
   [ :w [nil Integer] :d [nil Integer] :k [0 Integer] :overflowchar [nil Character] 
   [ ]
   [ ]
   [ ] 
   [ ] 
   [:base [nil Integer] :mincol [0 Integer] :padchar [\space Character] :commachar [\, Character] 
   [:char-format [nil Character]]
   [:mincol [0 Integer] :colinc [1 Integer] :minpad [0 Integer] :padchar [\space Character]]
   [:n [0 Integer]]
   []
   [] 
   [_  f1 init]
   [_ f val]
   [_ n combinef reducef]
   [a b]
   [branch? children root]
   [c]
   [clojure.lang LineNumberingPushbackReader]
   [java.io Reader Writer PrintWriter BufferedWriter BufferedReader InputStreamReader OutputStreamWriter]
   [java.net InetAddress Socket ServerSocket SocketException]
   [java.util.concurrent.locks ReentrantLock]))
   [n] (if (integer? n)
   [nil nil nil]
   [s f val]
   [s f val]
   [s f val]
   [s offset {}]))
   [str-seq f val]
   [t]
   \"(arithmetic addition)\", in failure reports.  You can use nested
   \"(is (thrown-with-msg? c re ...))\" does the same thing and also
   \"(is (thrown? c ...))\" form tests if an exception of class c is
   \"actual:\" shows you what actually happened.  In this case, it
   \"each\" fixtures can be attached to the current namespace like this:
   \"false\" on the last line is the value returned from the
   \"is\" takes an optional second argument, a string describing the
   \"testing\" macro, which takes a string followed by any number of
   \"with-test-out\" macro, which rebinds *out* to the current value
   ^String prefix ^String per-line-prefix ^String suffix]
   `(if (not ~test) ~then ~else)))
   `(if-let ~bindings ~then nil))
   `(if-some ~bindings ~then nil))
   `(let [and# ~x]
   a defn or def form as its first argument, followed by any number
   a namespace and run them in an undefined order.  However, if you
   a relative path, else IllegalArgumentException."
   an argument.  It looks like this:
   an equivalent vector, with nil for any missing keys"
   and String.
   and nested coll-exprs can refer to bindings created in prior
   appropriate fixtures applied."
   are composing tests, as in the \"arithmetic\" example above, you
   are using test-ns-hook, fixture functions will *never* be run.
   arg that returns a sequence of the children. Will only be called on
   arguments for 'report'."
   around ALL the tests in the namespace.  \"once\" fixtures are useful
   as a local file name.  URIs with a 'file' protocol are converted to
   as a local file name.  URIs with a 'file' protocol are converted to
   as a local file name.  URIs with a 'file' protocol are converted to
   as a local file name.  URIs with a 'file' protocol are converted to
   assertion.  This message will be included in the error report.
   assertions of any arbitrary expression:
   assertions.  The string will be included in failure reports.
   atom before and after the reset."
   be created by deftest, set-test, or with-test.  Use this to omit
   be unequivocally converted to the requested kind of stream.
   being created by \"with-test\" or \"deftest\".
   binding-form/collection-expr pairs, each followed by zero or more
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   branch? must be a fn of one arg that returns true if passed a node
   called during expansion of the \"is\" macro, so they should return
   can be called like any other function.  Therefore, tests can be
   char / char
   char / char
   children relative to the parent."
   clearing out database tables.
   clojure.java.io/writer.
   clojure.lang.IReduceInit
   clojure.lang.Sequential)
   closed."
   closed."
   closed."
   code.)
   coll)
   coll))
   collection implementing Iterable.
   collection implementing Iterable. For maps, the iterator should
   compiling code in production.  This will prevent any tests from
   conditional-newline)
   consistent with =, different from .hashCode.
   current value. Returns newval."
   database connections, or for time-consuming tasks.
   default, this is the same as *out*, but you can rebind it to any
   definition.
   descriptors are described in section 4.3.2 of the JVM spec, 2nd ed.:
   different report formats (e.g., TAP, JUnit).  Assertions such as
   documented otherwise. If you want sequence-y behavior instead,
   dollar-float)
   e.g. passing a mutable implementation of CharSequence, then
   entries. Called by clojure.core/reduce-kv, and has same
   establishing a consistent before/after state for each test, like
   exception, respectively.  In that case, the event will also have
   exponential-float)
   expression re:
   expression.  The \"is\" macro always returns the result of the
   faster than first/next recursion. Called by clojure.core/reduce."
   fixed-float)
   fixtures are run repeatedly, once for each test function created
   flag-descriptors))
   flags))                                ; and finally add the flags
   for tasks that only need to be performed once, like establishing
   from s as follows:
   functions. (This is not idiomatic in general-purpose application
   general than String. In ordinary usage you will almost always
   general-float)
   grouped and composed, in a style similar to the test framework in
   hash-basis is the combined collection hash, count is the number
   host platform. In Java, this is CharSequence, which is more
   http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#14152"
   http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#14757"
   i.e. substituting true for :unknown if necessary."
   if no loader is specified."
   in ks. If ks are not specified, use the keys of the first item in rows."
   in-reader out-fn & {:keys [valf readf] :or {valf read-string, readf #(read %1 false %2)}}]
   inner expression.
   java.util.regex.Matcher's appendReplacement method.
   java.util.regex.Matcher's appendReplacement method.
   joined together with spaces in the final report, in a style
   ks, and then a line of output for each row, corresponding to the keys
   local file names.
   local file names.
   local file names.
   local file names.
   logical-block-or-justify)
   match/replacement can be:
   match/replacement can be:
   methods for the \"assert-expr\" multimethod.  These methods are
   methods where those are available and efficient.
   modifiers, and yields a lazy sequence of evaluations of expr.
   named \"test-ns-hook\" that runs your tests in the correct order:
   names uses slashes instead of dots, e.g. java/lang/String. See
   necessary escaping of special characters in the replacement."
   new value.  Returns a lazy seq of partitions.  Returns a stateful
   nodes for which branch? returns true. Root is the root node of the
   normalize a typeref yourself, call typesym."
   of *test-out*.
   of assertions.  The tests will be stored as metadata on the
   of elements included in the basis. Note this is the hash code
   offset-sign offset-hours offset-minutes]
   offset-sign offset-hours offset-minutes]
   offset-sign offset-hours offset-minutes]
   offset])
   or for a spec if given a keyword"
   parenthesized group in the pattern.  If you wish your replacement
   parenthesized group in the pattern.  If you wish your replacement
   pass concrete strings. If you are doing something unusual,
   passing nil will result in a NullPointerException unless
   pattern / (string or function of match).
   pattern / (string or function of match).
   print a message if it fails.
   probably do not want the \"addition\" and \"subtraction\" tests run
   properly closed."
   quoted forms to be evaluated.
   reader, writer, input-stream, and output-stream."
   remainder))
   replacement argument.  See also documentation for
   replacement argument.  See also documentation for
   replacement for a pattern match in replace or replace-first, do the
   reported.  Standard events with :type value of :pass, :fail, and
   return map entries whose hash is computed as
   return-types to meths."
   script-opt))
   semantics (just different arg order)."
   separated by an optional separator."
   separately.  In that case, you must define a special function
   set-indent)
   shows that (+ 2 2) returned 4, which is not = to 5.  Finally, the
   similar to RSpec <http://rspec.info/>
   specially) for all cases above except pattern / string.
   specially) for all cases above except pattern / string.
   string / string
   string / string
   string being manipulated is the first argument to a function;
   string r to be used literally, use (re-quote-replacement r) as the
   string r to be used literally, use (re-quote-replacement r) as the
   substituted with the string that matched the corresponding
   substituted with the string that matched the corresponding
   such as ASM that need to find and read classbytes from files."
   tests that the message on the exception matches the regular
   tests to set up a context shared by several tests.
   tests when compiling or loading production code."
   that can have children (but may not).  children must be a fn of one
   that carries a map of additional data."
   the \"report\" function: (report event)
   the appropriate tree structure"
   the context in which tests should be run.
   the file they represent."
   the following keys:
   the host platform.
   the top of test_is.clj for more information on the types of
   the various Java I/O stream types, on top of anything that can
   the vars being tested will be a list in \"*testing-vars*\".
   thread-safety is your responsibility."
   thrown:
   to pass test results to report."
   transducer when no collection is provided."
   true arg))
   type's name."
   use a sequence.
   used.  To run all tests in all namespaces, use \"(run-all-tests)\".
   val)
   val)
   value of test"
   value of test, if not, yields else"
   versions treat the first argument as parent and subsequent args as
   via a function of key and val faster than first/next recursion over map
   was swapped in."
   when there is a conflict"
   whose value will be a keyword signaling the type of event being
   will take any implementation of the correct *interface* on the
   with \"deftest\" or \"with-test\".  \"each\" fixtures are useful for
   write high-performing loop/recurs instead of using higher-order
   your code, even in a different namespace:
   {:directive char,
   {:inline (nary-inline 'and)
   {\newline "newline"
   }
   }
   }
  "
  ""
  "'Updates' a value in a nested associative structure, where ks is a
  "'Updates' a value in an associative structure, where k is a
  "(defrecord name [fields*]  options* specs*)
  "(deftype name [fields*]  options* specs*)
  ".adds x to acc and returns acc"
  "A TypeReference can be unambiguously converted to a type name on
  "A clojure.lang.Namespace object representing the current namespace."
  "A convenience macro that pretty prints the last thing output. This is
  "A good fdecl looks like (([a] ...) ([a b] ...)) near the end of defn."
  "A high-performance combining fn that yields the catenation of the
  "A java.io.Reader object representing standard input for read operations.
  "A java.io.Writer object representing standard error for print operations.
  "A java.io.Writer object representing standard output for print operations.
  "A macro that expands into an extend call. Useful when you are
  "A map of keys to options.
  "A protocol is a named set of named methods and their signatures:
  "A sequence of the supplied command line arguments, or nil if
  "A transducer which concatenates the contents of each input, which must be a
  "A tree seq on java.io.Files"
  "A tree seq on the xml elements as per xml/parse"
  "A version of loop that iterates at most *print-length* times. This is designed 
  "Add an alias in the current namespace to another
  "Add file and line information to a test result and call report.
  "Adds a new string to the list of testing contexts.  May be nested,
  "Adds a watch function to an agent/atom/var/ref reference. The watch
  "Adds elements in coll to the current namespace metadata as the
  "Adds to the list of local Javadoc paths."
  "Adds to the list of remote Javadoc URLs.  package-prefix is the
  "Adds x to the transient collection, and return coll. The 'addition'
  "Alpha - subject to change.
  "Alpha - subject to change.
  "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,
  "An implementation of a Common Lisp compatible format function. cl-format formats its
  "Applies f to each value in coll, splitting it each time f returns a
  "Applies f to every value in the reduction of coll, concatenating the result
  "Applies f to every value in the reduction of coll. Foldable."
  "Applies fn f to the argument list formed by prepending intervening arguments to args."
  "Associates a value in a nested associative structure, where ks is a
  "Assumption: The input string consists of one or more decimal digits,
  "Atomically alters the root binding of var v by applying f to its
  "Atomically resets the metadata for a namespace/var/ref/agent/atom"
  "Atomically sets the metadata for a namespace/var/ref/agent/atom to be:
  "Atomically sets the value of atom to newval if and only if the
  "Atomically swaps the value of atom to be:
  "Atomically swaps the value of atom to be:
  "Attempts to coerce its argument into an open java.io.InputStream.
  "Attempts to coerce its argument into an open java.io.OutputStream.
  "Attempts to coerce its argument into an open java.io.Reader.
  "Attempts to coerce its argument into an open java.io.Writer.
  "Attempts to return x as data.
  "Binds name to expr, evaluates the first form in the lexical context
  "Bitwise and with complement"
  "Bitwise and"
  "Bitwise complement"
  "Bitwise exclusive or"
  "Bitwise or"
  "Bitwise shift left"
  "Bitwise shift right"
  "Bitwise shift right, without sign-extension."
  "Blocks the current thread (indefinitely!) until all actions
  "Blocks the current thread until all actions dispatched thus
  "Builds 3-arity reducing fn given names of wrapped fn and key, and k/v impl."
  "Builds a combining fn out of the supplied operator and identity
  "Builds another arity of the fn that returns a fn awaiting the last
  "Call .write on Writer (getf :base) with proper type-hinting to
  "Call the -main function from a namespace with string arguments from
  "Called by the clojure.lang.Repl.main stub to run a repl with args
  "Called by the clojure.lang.Script.main stub to run a script with args
  "Calls test-vars on every var interned in the namespace, with fixtures."
  "Cancels the future, if possible."
  "Capitalizes the words in a string. If first? is false, don't capitalize the 
  "Casts to boolean[]"
  "Casts to bytes[]"
  "Casts to chars[]"
  "Casts to double[]"
  "Casts to float[]"
  "Casts to int[]"
  "Casts to long[]"
  "Casts to shorts[]"
  "Causes the multimethod to prefer matches of dispatch-val-x over dispatch-val-y
  "Checks multiple assertions with a template expression.
  "Clear bit at index n"
  "Coerce between various 'resource-namish' things."
  "Coerce to BigDecimal"
  "Coerce to BigInt"
  "Coerce to BigInteger"
  "Coerce to Number"
  "Coerce to boolean"
  "Coerce to byte"
  "Coerce to byte. Subject to rounding or truncation."
  "Coerce to char"
  "Coerce to char. Subject to rounding or truncation."
  "Coerce to double"
  "Coerce to double. Subject to rounding."
  "Coerce to float"
  "Coerce to float. Subject to rounding."
  "Coerce to int"
  "Coerce to int. Subject to rounding or truncation."
  "Coerce to long"
  "Coerce to long. Subject to rounding or truncation."
  "Coerce to short"
  "Coerce to short. Subject to rounding or truncation."
  "Coerces coll to a (possibly empty) sequence, if it is not already
  "Common initialize routine for repl, script, and null opts"
  "Comparator. Returns a negative number, zero, or a positive number
  "Compiles format-str into a compiled format which can be used as an argument
  "Compiles the namespace named by the symbol lib into a set of
  "Composes a collection of fixtures, in order.  Always returns a valid
  "Composes two fixture functions, creating a new fixture function
  "Concatenates arrays of given type."
  "Construct a data representation of a reader conditional.
  "Construct a data representation of a tagged literal from a
  "Construct a java.sql.Timestamp, which has nanosecond precision."
  "Construct a java.util.Calendar, preserving the timezone
  "Construct a java.util.Date, which expresses the original instant as
  "Constructs a data representation for a StackTraceElement: [class method file line]"
  "Constructs a data representation for a Throwable with keys:
  "Constructs an array-map. If any keys are equal, they are handled as
  "Convert Java class name and method symbol to source symbol, either a
  "Convert a Clojure namespace name to a legal Java package name."
  "Convert a Java field descriptor to a Clojure class symbol. Field
  "Convert a Java internal name to a Clojure class symbol. Internal
  "Convert a number less than 1000 to a cardinal english string"
  "Convert a number less than 1000 to a ordinal english string
  "Convert an associative-by-numeric-index collection into
  "Convert reflection bitflags into a set of keywords."
  "Converts first character of the string to upper-case, all other
  "Converts string to all lower-case."
  "Converts string to all upper-case."
  "Copies input to output.  Returns nil or throws IOException.
  "Create a new arg-navigator from the sequence with the position set to 0"
  "Create a new namespace named by the symbol if one doesn't already
  "Create an indent at this point in the pretty printing stream. This defines how 
  "Create an instance of ExceptionInfo, a RuntimeException subclass
  "Create and output an exception report for a Throwable to target.
  "Creates a hierarchy object for use with derive, isa? etc."
  "Creates a new Java interface with the given name and method sigs.
  "Creates a new multimethod with the associated dispatch function.
  "Creates a new seq containing the items prepended to the rest, the
  "Creates a new vector containing the args."
  "Creates a new vector containing the contents of coll. Java arrays
  "Creates a new vector of a single primitive type t, where t is one
  "Creates a new zipper structure. 
  "Creates a parallel array from coll. ops, if supplied, perform
  "Creates a queued seq on another (presumably lazy) seq s. The queued
  "Creates an array of booleans"
  "Creates an array of bytes"
  "Creates an array of chars"
  "Creates an array of doubles"
  "Creates an array of floats"
  "Creates an array of ints"
  "Creates an array of longs"
  "Creates an array of objects"
  "Creates an array of shorts"
  "Creates and installs a new method of multimethod associated with dispatch-value. "
  "Creates and returns a Ref with an initial value of x and zero or
  "Creates and returns a Volatile with an initial value of val."
  "Creates and returns a lazy sequence of structmaps corresponding to
  "Creates and returns an Atom with an initial value of x and zero or
  "Creates and returns an agent with an initial value of state and
  "Creates and returns an array of instances of the specified class of
  "DEPRECATED
  "DEPRECATED: Use 'agent-error' instead.
  "DEPRECATED: Use 'repeat' instead.
  "DEPRECATED: Use 'restart-agent' instead.
  "Default :caught hook for repl"
  "Default :prompt hook for repl"
  "Default :read hook for repl. Reads from *in* which must either be an
  "Default map of data reader functions provided by Clojure. May be
  "Defines a test function with no arguments.  Test functions may call
  "Delete file f. If silently is nil or false, raise an exception on failure, else return the value of silently."
  "Delivers the supplied value to the promise, releasing any pending
  "Demonstrates the behavior of postwalk by printing each form as it is
  "Demonstrates the behavior of prewalk by printing each form as it is
  "Detects and rejects non-trivial cyclic load dependencies. The
  "Diff associative things a and b, comparing only keys in ks."
  "Diff associative things a and b, comparing only the key k."
  "Dispatch a potentially blocking action to an agent. Returns the
  "Dispatch an action to an agent. Returns the agent immediately.
  "Dispatch an action to an agent. Returns the agent immediately.
  "Do not use this directly - use defrecord"
  "Do not use this directly - use deftype"
  "Elides the first n values from the reduction of coll."
  "Ends the reduction of coll after consuming n values."
  "Ends the reduction of coll when (pred val) returns logical false."
  "Enhanced :read hook for repl supporting :repl/quit."
  "Equality. Returns true if x equals y, false if not. Same as
  "Equality. Returns true if x equals y, false if not. Same as Java
  "Equivalent to (fold cat append! coll)"
  "Establishes a parent/child relationship between parent and
  "Evals expressions in str, prints each non-nil result using prn"
  "Evaluates body in a context in which *in* is bound to a fresh
  "Evaluates body with *read-eval* set to a \"known\" value,
  "Evaluates expr and prints the time it took.  Returns the value of
  "Evaluates expr and throws an exception if it does not evaluate to
  "Evaluates exprs in a context in which *out* is bound to a fresh
  "Evaluates exprs one at a time, from left to right. If a form
  "Evaluates exprs one at a time, from left to right. If a form
  "Evaluates test. If logical false, evaluates and returns then expr,
  "Evaluates test. If logical false, evaluates body in an implicit do."
  "Evaluates test. If logical true, evaluates body in an implicit do."
  "Evaluates the exprs in a lexical context in which the symbols in
  "Evaluates the form data structure (not text!) and returns the result."
  "Evaluates x then calls all of the methods and functions with the
  "Execute body with modified test reporting functions that produce
  "Execute body with modified test-is reporting functions that write
  "Execute body with the pretty print dispatch function bound to function."
  "Execute the body as a pretty printing logical block with output to *out* which 
  "Executes body in the context of thread-local bindings for several vars
  "Executes exprs in an implicit do, while holding the monitor of x.
  "Executes the format with the arguments."
  "Executes the no-arg fns in parallel, returning a lazy sequence of
  "Expands into code that creates a fn that expects to be passed an
  "Expands to code which yields a lazy sequence of the concatenation
  "Experimental - like defmacro, except defines a named function whose
  "Experimental.
  "Factory functions that create ready-to-use, buffered versions of
  "Figure out which kind of brackets to use"
  "Finds or creates a var named by the symbol name in the namespace
  "Flip bit at index n"
  "Flushes the output stream that is the current value of
  "For a list or queue, returns a new list/queue without the first
  "For a list or queue, same as first, for a vector, same as, but much
  "For all the values, v, in the map, replace them with [v v1]"
  "For use in macros.  argv is an argument list, as in defn.  expr is
  "Format a roman numeral using the specified look-up table"
  "Formats a string using java.lang.String.format, see java.util.Formatter for format
  "Generates and immediately loads the bytecode for the specified
  "Generic assertion macro.  'form' is any predicate test.
  "Generic, reusable, read-eval-print loop. By default, reads from *in*,
  "Get a map with the Var/value pairs which is currently in effect for the
  "Get the value of the field named by the argument (which should be a keyword)."
  "Gets the max-history of a ref, or sets it and returns the ref"
  "Gets the min-history of a ref, or sets it and returns the ref"
  "Gets the validator-fn for a var/ref/agent/atom."
  "Gets the value in the var object"
  "Given a foldable collection, and a transformation function xf,
  "Given a map of replacement pairs and a vector/collection, returns a
  "Given a multimethod and a dispatch value, returns the dispatch fn
  "Given a multimethod, returns a map of dispatch values -> dispatch fns"
  "Given a multimethod, returns a map of preferred value -> set of other values"
  "Given a reducible collection, and a transformation function xf,
  "Given a regular expression or stringable thing, return a seq of all
  "Given a replacement string that you wish to be a literal
  "Given a string representation of a fn class,
  "Given a string representation of a fn class,
  "Given a typeref, create a legal Clojure symbol version of the
  "Given a typeref, return implied resource name. Used by Reflectors
  "Given the same arg(s) as for file, creates all parent directories of
  "Groups vars by their namespace and runs test-vars on them with
  "Helper so that callers can pass a Clojure map for the :env to sh."
  "Helper to get just the file name part of a path or nil"
  "Helper to get the relative path to the source file or nil"
  "Helper to return an error message string from an exception."
  "If an io! block occurs in a transaction, throws an
  "If coll is counted? returns its count, else will count at most the first n
  "If coll is empty, returns nil, else coll"
  "If form represents a macro form, returns its expansion,
  "If no denominators are supplied, returns 1/numerator,
  "If no ys are supplied, returns the negation of x, else subtracts
  "If no ys are supplied, returns the negation of x, else subtracts
  "If passed a namespace, returns it. Else, when passed a symbol,
  "If set to logical true, when printing an object, its metadata will also
  "If the namespace defines a function named test-ns-hook, calls that.
  "If the next character on stream s is a newline, skips it, otherwise
  "If v has a function in its :test metadata, calls that function,
  "If x is a Delay, returns the (possibly cached) value of its expression, else returns x"
  "If x is already reduced?, returns it, else returns (reduced x)"
  "If x is reduced?, returns (deref x), else returns x"
  "Ignores body, yields nil"
  "Implementation detail. Subject to change."
  "Implementation detail. Subject to change."
  "Implementations of protocol methods can be provided using the extend construct:
  "Implements a prepl on in-reader and out-fn by forwarding to a
  "Increments the named counter in *report-counters*, a ref to a map.
  "Initialize repl in user namespace and make standard repl requires."
  "Initiates a shutdown of the thread pools that back the agent
  "Insert the decimal point at the right spot in the number to match an exponent"
  "Insert the decimal point at the right spot in the number to match an exponent"
  "Inserts the item as the left sibling of the node at this loc,
  "Inserts the item as the leftmost child of the node at this loc,
  "Inserts the item as the right sibling of the node at this loc,
  "Inserts the item as the rightmost child of the node at this loc,
  "Installs a function as a new method of multimethod associated with dispatch-value. "
  "Internal helper for diff."
  "Is set1 a subset of set2?"
  "Is set1 a superset of set2?"
  "Like 'require', but serializes loading.
  "Like 'require, but also refers to each lib's namespace using
  "Like core/reduce except:
  "Like deftest but creates a private var."
  "Like map, except f is applied in parallel. Semi-lazy in that the
  "Like postwalk, but does pre-order traversal."
  "Like print-stack-trace but prints chained exceptions (causes)."
  "Like read, and taking the same args. stream must be a LineNumberingPushbackReader.
  "Like var-get but returns nil if the var is unbound."
  "List comprehension. Takes a vector of one or more
  "Load a script"
  "Loads Clojure code from resources in classpath. A path is interpreted as
  "Loads Clojure source from a file or resource given its path. Paths
  "Loads a lib given its name and forces a load of any libs it directly or
  "Loads a lib given its name. If need-ns, ensures that the associated
  "Loads a lib with options"
  "Loads libs, interpreting libspecs, prefix lists, and flags for
  "Loads libs, skipping any that are already loaded. Each argument is
  "Make a newline if *out* is not already at the beginning of the line. If *out* is
  "Makes a function which can directly run format-in. The function is
  "Makes a function which can directly run format-in. The function is
  "Map from reader tag symbols to data reader Vars.
  "Map ugly type names to something simpler"
  "Maps an expression across an array a, using an index named idx, and
  "Mix final collection hash for ordered or unordered collections.
  "Modulus of num and div. Truncates toward negative infinity."
  "Move a maximal element of coll according to fn k (which returns a
  "Moves to the next loc in the hierarchy, depth-first. When reaching
  "Moves to the previous loc in the hierarchy, depth-first. If already
  "Must be called in a transaction. Protects the ref from modification
  "Must be called in a transaction. Sets the in-transaction-value of
  "Must be called in a transaction. Sets the in-transaction-value of
  "Must be called in a transaction. Sets the value of ref.
  "No repl or script opt present, just bind args and run inits"
  "Non-atomically swaps the value of the volatile as if:
  "Normally, actions sent directly or indirectly during another action
  "Open url in a browser"
  "Opens a browser window displaying the javadoc for the argument.
  "Opens a reader on f and reads all its contents, returning a string.
  "Opens url (a string) in the default system web browser.  May not
  "Opposite of slurp.  Opens f with writer, writes content, then
  "Parse clojure.server.* from properties to produce a map of server configs."
  "Parses and loads the source s, which can be a File, InputStream or
  "Passes the given strings to Runtime.exec() to launch a sub-process.
  "Performs a depth-first, post-order traversal of form.  Calls f on
  "Pop one set of bindings pushed with push-binding before. It is an error to
  "Prepends a symbol or a seq to coll"
  "Pretty print a single reference (import, use, etc.) from a namespace decl"
  "Pretty print object to the optional output writer. If the writer is not provided, 
  "Print a conditional newline to a pretty printing stream. kind specifies if the 
  "Print a java.sql.Timestamp as RFC3339 timestamp, always in UTC."
  "Print a java.util.Calendar as RFC3339 timestamp, preserving timezone."
  "Print a java.util.Date as RFC3339 timestamp, always in UTC."
  "Print args to *err* in name = value format"
  "Print help text for main"
  "Println to *err*"
  "Prints a Clojure-oriented stack trace of tr, a Throwable.
  "Prints a Clojure-oriented view of one element in a stack trace."
  "Prints a TAP 'not ok' line.  msg is a string, with no line breaks"
  "Prints a TAP 'ok' line.  msg is a string, with no line breaks"
  "Prints a TAP diagnostic line.  data is a (possibly multi-line)
  "Prints a TAP plan line like '1..n'.  n is the number of tests"
  "Prints a collection of maps in a textual table. Prints table headings
  "Prints a sorted directory of public vars in a namespace"
  "Prints a stack trace of the exception, to the depth requested. If none supplied, uses the root cause of the
  "Prints documentation for a var or special form given its name,
  "Prints documentation for any var whose documentation or name
  "Prints formatted output, as per format"
  "Prints the class and message of a Throwable. Prints the ex-data map
  "Prints the object(s) to the output stream that is the current value
  "Prints the object(s) to the output stream that is the current value
  "Prints the source code for the given symbol, if it can find it.
  "Produce string parts for the mantissa (normalized 1-9) and exponent"
  "Protocol for collection types that can implement reduce faster than
  "Protocol for concrete associative types that can reduce themselves
  "Protocol for concrete seq types that can reduce themselves
  "Protocol for reflection implementers."
  "REPL utility.  Prints a brief stack trace for the root cause of the
  "REPL with predefined hooks for attachable socket server."
  "Reads from reader, which must be a LineNumberingPushbackReader, while capturing
  "Reads one object from the string s. Optionally include reader
  "Reads one object from the string s. Returns nil when s is nil or empty.
  "Reads the next line from stream that is the current value of *in* ."
  "Reads the next object from stream, which must be an instance of
  "Reads the next object from stream, which must be an instance of
  "Realizes a copy of the coll as a parallel array, with any bounds/filters/maps applied"
  "Recursively compares a and b, returning a tuple of
  "Recursively performs all possible macroexpansions in form."
  "Recursively transforms all map keys from keywords to strings."
  "Recursively transforms all map keys from strings to keywords."
  "Recursively transforms form by replacing keys in smap with their
  "Recursively transforms form by replacing keys in smap with their
  "Reduces a collection using a (potentially parallel) reduce-combine
  "Reduces a seq, ignoring any opportunities to switch to a more
  "Reduces an associative collection. f should be a function of 3
  "Reduces an expression across an array a, using an index named idx,
  "Reduces via IReduceInit if possible, else naively."
  "Register INT signal handler.  After calling this, Ctrl-C will cause
  "Remove f from the tap set."
  "Removes a parent/child relationship between parent and
  "Removes a watch (set by add-watch) from a reference"
  "Removes all of the methods of multimethod."
  "Removes all trailing newline \\n or return \\r characters from
  "Removes the alias for the symbol from the namespace."
  "Removes the last item from a transient vector. If
  "Removes the mappings for the symbol from the namespace."
  "Removes the method of multimethod associated with dispatch-value."
  "Removes the namespace named by the symbol. Use with caution.
  "Removes the node at loc, returning the loc that would have preceded
  "Removes values in the reduction of coll for which (pred val)
  "Removes whitespace from both ends of string."
  "Removes whitespace from the left side of string."
  "Removes whitespace from the right side of string."
  "Repeatedly calls macroexpand-1 on form until it no longer
  "Repeatedly copies expr (in a do block) for each group of arguments
  "Repeatedly executes body (presumably for side-effects) with
  "Repeatedly executes body while test expression is true. Presumes
  "Replaces all instance of match with replacement in s.
  "Replaces the first instance of match with replacement in s.
  "Replaces the node at this loc with the value of (f node args)"
  "Replaces the node at this loc, without moving"
  "Resolves namespace-qualified sym per 'resolve'. If initial resolve
  "Retains values in the reduction of coll for which (pred val)
  "Return a function which constructs an instant by calling constructor
  "Return a lazy sequence of all but the last n (default 1) items in coll"
  "Return a new string, using cmap to escape each character ch
  "Return a random element of the (sequential) collection. Will have
  "Return a random permutation of coll"
  "Return a set of the declared constructors of class as a Clojure map."
  "Return a set of the declared constructors of class as a Clojure map."
  "Return a set of the declared fields of class as a Clojure map."
  "Return a set that is the first set without elements of the remaining sets"
  "Return a set that is the intersection of the input sets"
  "Return a set that is the union of the input sets"
  "Return index of value (string or char) in s, optionally searching
  "Return last index of value (string or char) in s, optionally
  "Return the list of remainders (essentially the 'digits') of val in the given base"
  "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT"
  "Return the number of times that val occurs at the start of sequence aseq,
  "Return true if coll implements Indexed, indicating efficient lookup by index"
  "Return true if the seq function is supported for x"
  "Return true if the value is the data representation of a reader conditional"
  "Return true if the value is the data representation of a tagged literal"
  "Return true if x is a Boolean"
  "Return true if x is a Double"
  "Return true if x is a Keyword"
  "Return true if x is a Symbol"
  "Return true if x is a byte array"
  "Return true if x is a fixed precision integer"
  "Return true if x is a java.net.URI"
  "Return true if x is a java.util.UUID"
  "Return true if x is a keyword with a namespace"
  "Return true if x is a keyword without a namespace"
  "Return true if x is a map entry"
  "Return true if x is a negative fixed precision integer"
  "Return true if x is a non-negative fixed precision integer"
  "Return true if x is a positive fixed precision integer"
  "Return true if x is a symbol or keyword with a namespace"
  "Return true if x is a symbol or keyword without a namespace"
  "Return true if x is a symbol or keyword"
  "Return true if x is a symbol with a namespace"
  "Return true if x is a symbol without a namespace"
  "Return true if x satisfies Inst"
  "Return true iff x is a PrettyWriter"
  "Return val as a string in the given base"
  "Return val as a string in the given base, using clojure.core/format if supported
  "Returns (possibly transformed) v in the context of coll and k (a
  "Returns [lifted-ns lifted-map] or nil if m can't be lifted."
  "Returns a (possibly unmunged) string representation of a StackTraceElement"
  "Returns a (possibly unmunged) string representation of a StackTraceElement"
  "Returns a (potentially-ragged) 2-dimensional array of Objects
  "Returns a Keyword with the given namespace and name if one already
  "Returns a Keyword with the given namespace and name.  Do not use :
  "Returns a Symbol with the given namespace and name. Arity-1 works
  "Returns a clone of the Java array. Works on arrays of known
  "Returns a collection of the types explicitly extending protocol"
  "Returns a fn that, given an instance of a structmap with the basis,
  "Returns a function defined by the given fntail, which will install the
  "Returns a function that takes any number of arguments and returns x."
  "Returns a function that takes one arg and uses that as an exception message
  "Returns a function, which will install the same bindings in effect as in
  "Returns a java.io.File, passing each arg to as-file.  Multiple-arg
  "Returns a lazy (infinite!) sequence of repetitions of the items in coll."
  "Returns a lazy (infinite!, or length n if supplied) sequence of xs."
  "Returns a lazy seq of every nth item in coll.  Returns a stateful
  "Returns a lazy seq of nums from start (inclusive) to end
  "Returns a lazy seq of the elements of coll separated by sep.
  "Returns a lazy seq of the first item in each coll, then the second etc."
  "Returns a lazy seq of the intermediate values of the reduction (as
  "Returns a lazy seq representing the concatenation of the elements in the supplied colls."
  "Returns a lazy sequence consisting of the result of applying f to
  "Returns a lazy sequence consisting of the result of applying f to 0
  "Returns a lazy sequence of all but the first n items in coll.
  "Returns a lazy sequence of lists like partition, but may include
  "Returns a lazy sequence of lists of n items each, at offsets step
  "Returns a lazy sequence of successive items from coll while
  "Returns a lazy sequence of successive matches of pattern in string,
  "Returns a lazy sequence of the elements of coll with duplicates removed.
  "Returns a lazy sequence of the first n items in coll, or all items if
  "Returns a lazy sequence of the items in coll for which
  "Returns a lazy sequence of the items in coll for which
  "Returns a lazy sequence of the items in coll starting from the
  "Returns a lazy sequence of the nodes in a tree, via a depth-first walk.
  "Returns a lazy sequence of the non-nil results of (f index item). Note,
  "Returns a lazy sequence of the non-nil results of (f item). Note,
  "Returns a lazy sequence of the values of the exprs, which are
  "Returns a lazy sequence of x, (f x), (f (f x)) etc. f must be free of side-effects"
  "Returns a lazy sequence removing consecutive duplicates in coll.
  "Returns a map containing only those entries in map whose key is in keys"
  "Returns a map from distinct items in coll to the number of times
  "Returns a map of all the mappings for the namespace."
  "Returns a map of summary statistics (min. max, size, min-index, max-index, 
  "Returns a map of the aliases for the namespace."
  "Returns a map of the distinct values of ks in the xrel mapped to a
  "Returns a map of the elements of coll keyed by the result of
  "Returns a map of the import mappings for the namespace."
  "Returns a map of the intern mappings for the namespace."
  "Returns a map of the public intern mappings for the namespace."
  "Returns a map of the refer mappings for the namespace."
  "Returns a map that consists of the rest of the maps conj-ed onto
  "Returns a map that consists of the rest of the maps conj-ed onto
  "Returns a map with the keys mapped to the corresponding vals."
  "Returns a memoized version of a referentially transparent function. The
  "Returns a new branch node, given an existing node and new
  "Returns a new coll consisting of to-coll with all of the items of
  "Returns a new coll consisting of to-coll with all of the items of
  "Returns a new coll consisting of to-coll with all of the items of
  "Returns a new hash set with supplied keys.  Any equal keys are
  "Returns a new sorted set with supplied keys, using the supplied
  "Returns a new sorted set with supplied keys.  Any equal keys are
  "Returns a new structmap instance with the keys of the
  "Returns a new structmap instance with the keys of the
  "Returns a new symbol with a unique name. If a prefix string is
  "Returns a new vector consisting of the realized items in coll, sorted, 
  "Returns a new, persistent version of the transient collection, in
  "Returns a new, transient version of the collection, in constant time."
  "Returns a number one greater than num. Does not auto-promote
  "Returns a number one greater than num. Supports arbitrary precision.
  "Returns a number one greater than x, a long.
  "Returns a number one greater than x, an int.
  "Returns a number one less than num. Does not auto-promote
  "Returns a number one less than num. Supports arbitrary precision.
  "Returns a number one less than x, a long.
  "Returns a number one less than x, an int.
  "Returns a parallel array of the distinct elements of coll"
  "Returns a persistent vector of the items in vector from
  "Returns a promise object that can be read with deref/@, and set,
  "Returns a proxy that wraps writer, capitalizing all words"
  "Returns a proxy that wraps writer, capitalizing the first word"
  "Returns a proxy that wraps writer, converting all characters to lower case"
  "Returns a proxy that wraps writer, converting all characters to upper case"
  "Returns a random floating point number between 0 (inclusive) and
  "Returns a random integer between 0 (inclusive) and n (exclusive)."
  "Returns a reducible/iterable application of the transducers
  "Returns a rel of the elements of xrel with only the keys in ks"
  "Returns a rel of the maps in xrel with the keys in kmap renamed to the vals in kmap"
  "Returns a seq of nodes leading to this loc"
  "Returns a seq of the children of node at loc, which must be a branch"
  "Returns a seq of the items in coll in reverse order. Not lazy."
  "Returns a seq of the last n items in coll.  Depending on the type
  "Returns a seq of the left siblings of this loc"
  "Returns a seq of the right siblings of this loc"
  "Returns a seq on a java.util.Enumeration"
  "Returns a seq on a java.util.Iterator. Note that most collections
  "Returns a sequence of all namespaces."
  "Returns a sequence of the map's keys, in the same order as (seq map)."
  "Returns a sequence of the map's values, in the same order as (seq map)."
  "Returns a set of the distinct elements of coll."
  "Returns a set of the elements for which pred is true"
  "Returns a sorted seq of symbols naming public vars in
  "Returns a sorted sequence of the items in coll, where the sort
  "Returns a sorted sequence of the items in coll. If no comparator is
  "Returns a sorted set of symbols naming the currently loaded libs"
  "Returns a string from exception data, as produced by ex-triage.
  "Returns a string of all elements in coll, as returned by (seq coll),
  "Returns a string of the source code for the given symbol, if it can
  "Returns a string representation of the current test context. Joins
  "Returns a string representation of the current test.  Renders names
  "Returns a structure basis object."
  "Returns a transducer that ends transduction when pred returns true
  "Returns a transient map that doesn't contain a mapping for key(s)."
  "Returns a vector [filename line-number] for the nth call up the
  "Returns a vector consisting of the result of applying f to the
  "Returns a vector containing the (realized) elements of coll, 
  "Returns a vector containing the non-nil (realized) elements of coll"
  "Returns a vector of [(take n coll) (drop n coll)]"
  "Returns a vector of [(take-while pred coll) (drop-while pred coll)]"
  "Returns a vector of the items in coll for which
  "Returns a zipper for nested sequences, given a root sequence"
  "Returns a zipper for nested vectors, given a root vector"
  "Returns a zipper for xml elements (as from xml/parse),
  "Returns an analysis of the phase, error, cause, and location of an error that occurred
  "Returns an array of Objects containing the contents of coll, which
  "Returns an array with components set to the values in aseq. The array's
  "Returns an asm Type object for c, which may be a primitive class
  "Returns an empty collection of the same category as coll, or nil"
  "Returns an implementation of java.util.Comparator based upon pred."
  "Returns an instance of java.util.regex.Matcher, for use, e.g. in
  "Returns an instance of java.util.regex.Pattern, for use, e.g. in
  "Returns clojure version as a printable string."
  "Returns exception data (a map) if ex is an IExceptionInfo.
  "Returns generic assertion code for any functional predicate.  The
  "Returns generic assertion code for any test, including macros, Java
  "Returns items from coll with random probability of prob (0.0 -
  "Returns its argument."
  "Returns non-nil if nums all have the equivalent
  "Returns non-nil if nums are in monotonically decreasing order,
  "Returns non-nil if nums are in monotonically increasing order,
  "Returns non-nil if nums are in monotonically non-decreasing order,
  "Returns non-nil if nums are in monotonically non-increasing order,
  "Returns s with its characters reversed."
  "Returns some (random) element of the coll if it satisfies the bound/filter/map"
  "Returns the :type metadata of x, or its Class if none"
  "Returns the Class of x"
  "Returns the URL for a named resource. Use the context class loader
  "Returns the cause of ex if ex is a Throwable.
  "Returns the denominator part of a Ratio."
  "Returns the difference of x and y, both int.
  "Returns the difference of x and y, both long.
  "Returns the division of x by y, both int.
  "Returns the error-handler of agent a, or nil if there is none.
  "Returns the error-mode of agent a.  See set-error-mode!"
  "Returns the exception thrown during an asynchronous action of the
  "Returns the first logical true value of (pred x) for any x in coll,
  "Returns the global var named by the namespace-qualified symbol, or
  "Returns the greatest of the nums."
  "Returns the groups from the most recent match/find. If there are no
  "Returns the handler associated with a main option"
  "Returns the handler associated with an init opt"
  "Returns the hash code of its argument. Note this is the hash code
  "Returns the hash code, consistent with =, for an external ordered
  "Returns the hash code, consistent with =, for an external unordered
  "Returns the history count of a ref"
  "Returns the immediate and indirect children of tag, through a
  "Returns the immediate and indirect parents of tag, either via a Java type
  "Returns the immediate and indirect superclasses and interfaces of c, if any"
  "Returns the immediate parents of tag, either via a Java type
  "Returns the immediate superclass and direct interfaces of c, if any"
  "Returns the initial cause of an exception or error by peeling off all of
  "Returns the initial cause of an exception or error by peeling off all of
  "Returns the java.io.Writer passed in wrapped in a pretty writer proxy, unless it's 
  "Returns the key of the map entry."
  "Returns the last 'cause' Throwable in a chain of Throwables."
  "Returns the least of the nums."
  "Returns the length of the Java array. Works on arrays of all
  "Returns the lines of text from rdr as a lazy sequence of strings.
  "Returns the loc of the left sibling of the node at this loc, or nil"
  "Returns the loc of the leftmost child of the node at this loc, or
  "Returns the loc of the leftmost sibling of the node at this loc, or self"
  "Returns the loc of the parent of the node at this loc, or nil if at
  "Returns the loc of the right sibling of the node at this loc, or nil"
  "Returns the loc of the rightmost sibling of the node at this loc, or self"
  "Returns the map entry for key, or nil if key not present."
  "Returns the map with the keys in kmap renamed to the vals in kmap"
  "Returns the map with the vals mapped to the keys."
  "Returns the match, if any, of string to pattern, using
  "Returns the maximum element, presuming Comparable elements, unless
  "Returns the message attached to ex if ex is a Throwable.
  "Returns the minimum element, presuming Comparable elements, unless
  "Returns the name String of a string, symbol or keyword."
  "Returns the name of the namespace, a symbol."
  "Returns the namespace String of a symbol or keyword, or nil if not present."
  "Returns the namespace named by the symbol or nil if it doesn't exist."
  "Returns the negation of x, a long.
  "Returns the negation of x, an int.
  "Returns the next regex match, if any, of string to pattern, using
  "Returns the node at loc"
  "Returns the nth next of coll, (seq coll) when n is 0."
  "Returns the nth rest of coll, coll when n is 0."
  "Returns the number of items in the collection. (count nil) returns
  "Returns the numerator part of a Ratio."
  "Returns the product of nums. (*') returns 1. Supports arbitrary precision.
  "Returns the product of nums. (*) returns 1. Does not auto-promote
  "Returns the product of x and y, both int.
  "Returns the product of x and y, both long.
  "Returns the realized contents of the parallel array pa as a Clojure vector"
  "Returns the reduction of the realized elements of coll
  "Returns the remainder of division of x by y, both int.
  "Returns the result of applying concat to the result of applying map
  "Returns the root cause of throwables"
  "Returns the root directory path for a lib"
  "Returns the root resource path for a lib"
  "Returns the substring of s beginning at start inclusive, and ending
  "Returns the sum of nums. (+') returns 0. Supports arbitrary precision.
  "Returns the sum of nums. (+) returns 0. Does not auto-promote
  "Returns the sum of x and y, both int.
  "Returns the sum of x and y, both long.
  "Returns the value at the index. get returns nil if index out of
  "Returns the value at the index/indices. Works on Java arrays of all
  "Returns the value in a nested associative structure,
  "Returns the value in the map entry."
  "Returns the value mapped to key, not-found or nil if key not present."
  "Returns the var or Class to which a symbol will be resolved in the
  "Returns the x for which (k x), a number, is greatest.
  "Returns the x for which (k x), a number, is least.
  "Returns true given any argument."
  "Returns true if (= child parent), or child is directly or indirectly derived from
  "Returns true if (pred x) is logical true for every x in coll, else
  "Returns true if a value has been produced for a promise, delay, future or lazy sequence."
  "Returns true if all of the vars provided as arguments have any bound value, root or thread-local.
  "Returns true if all of the vars provided as arguments have thread-local bindings.
  "Returns true if argument is a function or a symbol that resolves to
  "Returns true if atype extends protocol"
  "Returns true if coll has no items - same as (not (seq coll)).
  "Returns true if future f is cancelled"
  "Returns true if future f is done"
  "Returns true if key is present in the given collection, otherwise
  "Returns true if loc represents the end of a depth-first walk"
  "Returns true if n is a BigDecimal"
  "Returns true if n is a Ratio"
  "Returns true if n is a floating point number"
  "Returns true if n is a rational number"
  "Returns true if n is an integer"
  "Returns true if n is even, throws an exception if n is not an integer"
  "Returns true if n is odd, throws an exception if n is not an integer"
  "Returns true if no two of the arguments are ="
  "Returns true if num is greater than zero, else false"
  "Returns true if num is less than zero, else false"
  "Returns true if num is zero, else false"
  "Returns true if s names a special form"
  "Returns true if the collection of ints can fit within the
  "Returns true if the given test summary indicates all tests
  "Returns true if the node at loc is a branch"
  "Returns true if v is of type clojure.lang.Var"
  "Returns true if x implements Fn, i.e. is an object created via fn."
  "Returns true if x implements IFn. Note that many data structures
  "Returns true if x implements IPersistentCollection"
  "Returns true if x implements IPersistentList"
  "Returns true if x implements IPersistentSet"
  "Returns true if x is a Number"
  "Returns true if x is a future"
  "Returns true if x is a libspec"
  "Returns true if x is a record"
  "Returns true if x is a volatile."
  "Returns true if x is an instance of Class"
  "Returns true if x is logical false, false otherwise."
  "Returns true if x is nil, false otherwise."
  "Returns true if x is not nil, false otherwise."
  "Returns true if x is the result of a call to reduced"
  "Returns true if x is the value false, false otherwise."
  "Returns true if x is the value true, false otherwise."
  "Returns true if x satisfies the protocol"
  "Returns, in constant time, a seq of the items in rev (which
  "Run a script from a file, resource, or standard in with args and inits"
  "Runs all tests in all namespaces; prints results.
  "Runs all tests in the given namespaces; prints results.
  "Runs body with *out* bound to the value of *test-out*."
  "Runs the exprs (in an implicit do) in a transaction that encompasses
  "Runs the supplied procedure (via reduce), for purposes of side
  "Same as (def name (create-struct keys...))"
  "Same as (not (= obj1 obj2))"
  "Same as (refer 'clojure.core <filters>)"
  "Same as pr followed by (newline). Observes *flush-on-newline*"
  "Same as print followed by (newline)"
  "Searches for a URL for the given class name.  Tries
  "Sequentially read and evaluate the set of forms contained in the
  "Sequentially read and evaluate the set of forms contained in the
  "Set bit at index n"
  "Set the pretty print dispatch function to a function matching (fn [obj] ...)
  "Set the value of the field SYM to NEW-VAL"
  "Set to true when compiling files, false otherwise."
  "Sets *ns* to the namespace named by name (unevaluated), creating it
  "Sets the ExecutorService to be used by send"
  "Sets the ExecutorService to be used by send-off"
  "Sets the directory for use with sh, see sh for details."
  "Sets the environment for use with sh, see sh for details."
  "Sets the error-handler of agent a to handler-fn.  If an action
  "Sets the error-mode of agent a to mode-keyword, which must be
  "Sets the precision and rounding mode to be used for BigDecimal operations.
  "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
  "Sets the value at the index/indices. Works on Java arrays of
  "Sets the value in the var object to val. The var must be
  "Sets the value of atom to newval without regard for the
  "Sets the value of atom to newval. Returns [old new], the value of the
  "Sets the value of volatile to newval without regard for the
  "Skips whitespace characters on stream s. Returns :line-start, :stream-end,
  "Specifies the directory where 'compile' will write out .class
  "Splits s on \\n or \\r\\n."
  "Splits string on a regular expression.  Optional argument limit is
  "Start a repl with args and inits. Print greeting if no eval options were
  "Start a socket server given the specified opts:
  "Start accept function, to be invoked on a client thread, given:
  "Start all servers specified in the system properties."
  "Stop all servers ignores all errors, and returns nil."
  "Stop server with name or use the server-name from *session* if none supplied.
  "Tab at this point in the pretty printing stream. kind specifies whether the tab
  "Take a linearly compiled format and process the bracket directives to give it 
  "Take a map that has pairs in the value slots and produce a pair of
  "Take a sequence of parts, add scale numbers (e.g., million) and combine into a string
  "Take an as-file-able thing and return a string if it is
  "Take care of leading and trailing zeros in decomposed floats"
  "Takes a Java object and returns a read-only implementation of the
  "Takes a binary predicate, an expression, and a set of clauses.
  "Takes a body of expressions and yields a Delay object that will
  "Takes a body of expressions and yields a future object that will
  "Takes a body of expressions that returns an ISeq or nil, and yields
  "Takes a case expression, default expression, and a sequence of test constants
  "Takes a collection of [msig meth] and returns a seq of maps from
  "Takes a directive definition and the list of actual parameters and
  "Takes a fn f and returns a fn that takes the same arguments as f,
  "Takes a function f and fewer than the normal arguments to f, and
  "Takes a function f, and returns a function that calls f, replacing
  "Takes a function of no args and yields a future object that will
  "Takes a function of no args, presumably with side effects, and
  "Takes a map of Var/value pairs. Installs for the given Vars the associated
  "Takes a map of Var/value pairs. Installs for the given Vars the associated
  "Takes a proxy class and any arguments for its superclass ctor and
  "Takes a proxy instance and a map of strings (which must
  "Takes a proxy instance and a map of strings (which must
  "Takes a proxy instance and returns the proxy's fn map."
  "Takes a reducing function f of 2 args and returns a fn suitable for
  "Takes a sequence of int-sized test constants and a corresponding sequence of
  "Takes a sequence of test constants and a corresponding sequence of then
  "Takes a set of functions and returns a fn that is the composition
  "Takes a set of functions and returns a fn that is the juxtaposition
  "Takes a set of predicates and returns a function f that returns the first logical true value
  "Takes a set of predicates and returns a function f that returns true if all of its
  "Takes a set of test/expr pairs. It evaluates each test one at a
  "Takes an expression and a set of test/form pairs. Threads expr (via ->)
  "Takes an expression and a set of test/form pairs. Threads expr (via ->>)
  "Takes an expression, and a set of clauses.
  "Takes an optional single class followed by zero or more
  "Takes any definition form (that returns a Var) as the first argument.
  "Takes any nested combination of sequential things (lists, vectors,
  "Takes any nested combination of sequential things (lists, vectors,
  "Temporarily redefines Vars during a call to func.  Each val of
  "Test bit at index n"
  "Tests if 2 arguments are the same object"
  "The default, empty, fixture function.  Just calls its argument."
  "The path of the file being evaluated, as a String.
  "The pretty print dispatch chunk for the ns macro"
  "The pretty print dispatch function for pretty printing Clojure code."
  "The pretty print dispatch function for simple data structure format."
  "The version info for Clojure core, as a map containing :major :minor
  "Threads the expr through the forms. Inserts x as the
  "Threads the expr through the forms. Inserts x as the
  "Throw if opts does not contain prop."
  "Throws a ClassCastException if x is not a c, else returns x."
  "Throws a CompilerException with a message if pred is true"
  "Throws an exception if the given option map contains keys not listed
  "To read an instant as a java.sql.Timestamp, bind *data-readers* to a
  "To read an instant as a java.util.Calendar, bind *data-readers* to a map with
  "To read an instant as a java.util.Date, bind *data-readers* to a map with
  "Transforms a sequence of test constants and a corresponding sequence of then
  "Translate the string representation of a param to the internalized
  "Traverses form, an arbitrary data structure.  inner and outer are
  "Trim all instances of c from the beginning of sequence s"
  "Trim all instances of c from the end of sequence s"
  "True if s ends with substr."
  "True if s includes substr."
  "True if s is nil, empty, or contains only whitespace."
  "True if s starts with substr."
  "Usage: java -cp clojure.jar clojure.main [init-opt*] [main-opt] [arg*]
  "Use to call a superclass method in the body of a proxy method. 
  "Used by the 'is' macro to catch unexpected exceptions.
  "Used to build a positional factory for a given type/record.  Because of the
  "Useful when you want to provide several implementations of the same
  "Validate server config options"
  "WARNING: This is a low-level function. Prefer high-level macros like
  "When an agent is failed, changes the agent state to new-state and
  "When applied to a transient map, adds mapping of key(s) to
  "When compiling, generates compiled bytecode for a class with the
  "When compiling, generates compiled bytecode for an interface with
  "When expr is not nil, threads it into the first form (via ->),
  "When expr is not nil, threads it into the first form (via ->>),
  "When lazy sequences are produced via functions that have side
  "When lazy sequences are produced via functions that have side
  "When no data reader is found for a tag and *default-data-reader-fn*
  "When passed 2 rels, returns the rel corresponding to the natural
  "When set to logical false, strings and characters will be printed with
  "When set to logical true, objects will be printed in a way that preserves
  "When set to true, output will be flushed whenever a newline is printed.
  "When set to true, the compiler will emit warnings when reflection is
  "While bound to true, compilations of +, -, *, inc, dec and the
  "With no args, returns the empty string. With one arg x, returns
  "Wrap base-writer in a PrettyWriter with the specified right-margin and miser-width"
  "Wrap test runs in a fixture function to perform setup and
  "Wraps x in a way such that a reduce will terminate with the value x"
  "Write an object subject to the current bindings of the printer control variables.
  "Write an object to *out* subject to the current bindings of the printer control 
  "Writes a platform-specific newline to *out*"
  "a REPL with structured output (for programs)
  "adds f, a fn of one argument, to the tap set. This function will be called with anything sent via tap>.
  "binding => binding-form init-expr
  "binding => var-symbol init-expr
  "binding => var-symbol temp-value-expr
  "bindings => [name init ...]
  "bindings => binding-form test
  "bindings => binding-form test
  "bindings => binding-form test
  "bindings => binding-form test
  "bindings => name n
  "bindings => name n
  "bindings => x xs
  "class-and-interfaces - a vector of class names
  "creates a graphical (Swing) inspector on the supplied hierarchical data"
  "creates a graphical (Swing) inspector on the supplied object"
  "creates a graphical (Swing) inspector on the supplied regular
  "defs name to have the root value of the expr iff the named var has no root value,
  "defs the supplied var names with no bindings, useful for making forward declarations."
  "determine whether a given compiled format has any directives that depend on the
  "disj[oin]. Returns a new set of the same (hashed/sorted) type, that
  "disj[oin]. Returns a transient set of the same (hashed/sorted) type, that
  "dissoc[iate]. Returns a new map of the same (hashed/sorted) type,
  "f should be a function of 2 arguments. If val is not supplied,
  "fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)
  "form => fieldName-symbol or (instanceMethodName-symbol args*)
  "implements java.io.PrintWriter given flush-fn, which will be called
  "import-list => (package-symbol class-name-symbols*)
  "keyval => key val
  "keyval => key val
  "keyval => key val
  "params => positional-params* , or positional-params* & next-param
  "pr to a string, returning it"
  "prepl bound to *in* and *out*, suitable for use with e.g. server/repl (socket-repl).
  "print to a string, returning it"
  "println to a string, returning it"
  "prn to a string, returning it"
  "quot[ient] of dividing numerator by denominator."
  "reduce with a transformation of f (xf). If init is not
  "refers to all public vars of ns, subject to filters.
  "reify is a macro with the following structure:
  "remainder of dividing numerator by denominator."
  "returns the rational value of num"
  "returns true if a number is actually an integer (that is, has no fractional part)"
  "returns true if x is a Delay created with delay"
  "same as (ns-resolve *ns* symbol) or (ns-resolve *ns* &env symbol)"
  "same as defn, yielding non-public def"
  "sc must be a sorted collection, test(s) one of <, <=, > or
  "sc must be a sorted collection, test(s) one of <, <=, > or
  "sends x to any taps. Will not block. Returns true if there was room in the queue,
  "takes a collection of hashes and returns [shift mask] or nil if none found"
  "test [v] finds fn at key :test in var metadata and calls it,
  "trampoline can be used to convert algorithms requiring mutual
  "transaction-flags => TBD, pass nil for now
  "varbinding=> symbol init-expr
  "zips all the way up and returns the root node, reflecting any
  #"(\d\d\d\d)(?:-(\d\d)(?:-(\d\d)(?:[T](\d\d)(?::(\d\d)(?::(\d\d)(?:[.](\d+))?)?)?)?)?)?(?:[Z]|([-+])(\d\d):(\d\d))?")
  #(let [ret (rf %1 %2)]
  #{"clojure.core" "clojure.core.reducers" "clojure.core.protocols" "clojure.data" "clojure.datafy"
  '...' to represent the remaining items. The root binding is nil
  '[[clojure.repl :refer (source apropos dir pst doc find-doc)]
  'actual' argument will contain the form with all its sub-forms
  'clojure.read.eval' System properties can be set on the command line
  'expected' argument to 'report' will contains the original form, the
  'msg' is an optional message to attach to the assertion.
  'require loads a lib by loading its root resource. The root resource path
  'use accepts additional options in libspecs: :exclude, :only, :rename.
  '{. {:url "java_interop#dot"
  ((find-var 'clojure.java.browse-ui/open-url-in-swing) url))
  ((get (methods print-method) clojure.lang.IPersistentVector) v w))
  ((get (methods print-method) clojure.lang.ISeq) v w))
  ((if (symbol? s) symbol str) (clojure.lang.Compiler/munge (str s))))
  ((juxt a b c) x) => [(a x) (b x) (c x)]"
  (-> "os.name" System/getProperty .toLowerCase
  (-> (clojure.string/replace s "+" (URLEncoder/encode "+" "UTF-8"))
  (-> (reduce (fn [v o] (if (pred o) (conj! v o) v))
  (-> (typename typeref)
  (-> e Throwable->map ex-triage ex-str))
  (-> x (bit-shift-right shift) (bit-and mask)))
  (. (. System (getProperties)) (get \"os.name\"))
  (. (par coll) (reduce (reducer f) base)))
  (. (par coll) any))
  (. c (cast x)))
  (. clojure.lang.Numbers (rationalize num)))
  (. multifn addMethod dispatch-val func))
  (. multifn preferMethod dispatch-val-x dispatch-val-y))
  (.. (.getSimpleName c) 
  (.. (pall coll) (precumulate (reducer f) init)))
  (.. SAXParserFactory (newInstance) (newSAXParser) (parse s ch)))
  (.. System (getProperties) (get \"os.name\"))
  (.. s toString toLowerCase))
  (.. s toString toUpperCase))
  (.add b x))
  (.addAlias *ns* alias (the-ns namespace-sym)))
  (.append w \"))
  (.asTransient coll))
  (.chunk b))
  (.chunkedFirst s))
  (.chunkedMore s))
  (.chunkedNext s))
  (.contains (.toString s) substr))
  (.denominator ^clojure.lang.Ratio r))
  (.dispatch a (binding [*agent* a] (binding-conveyor-fn f)) args executor))
  (.endsWith (.toString s) substr))
  (.fold m n combinef reducef fjinvoke fjtask fjfork fjjoin)))
  (.getAliases (the-ns ns)))
  (.getErrorHandler a))
  (.getErrorMode a))
  (.getMappings (the-ns ns)))
  (.getName (the-ns ns)))
  (.getTime (construct-calendar years months days
  (.kvreduce amap f init)))
  (.numerator ^clojure.lang.Ratio r))
  (.offer tapq (if (nil? x) ::tap-nil x)))
  (.persistent coll))
  (.pop coll))
  (.removeAlias (the-ns ns) sym))
  (.removeWatch reference key))
  (.replace (str ns) \- \_))
  (.reset vol newval))
  (.setErrorHandler a handler-fn))
  (.setErrorMode a mode-keyword))
  (.startsWith (.toString s) substr))
  (.toString (.reverse (StringBuilder. s))))
  (.unmap (the-ns ns) sym))
  (.write ^Writer (get-field this :base) c))
  (.write w " ")
  (.write w " ")
  (.write w "#")
  (.write w "#")
  (.write w "#")
  (.write w "#=(")
  (.write w "#=(")
  (.write w "#=(")
  (.write w "#=(find-ns ")
  (.write w "#?")
  (.write w "#\"")
  (.write w "#error {\n :cause ")
  (.write w "#object[")
  (.write w ")"))
  (.write w ")"))
  (.write w ")"))
  (.write w ")"))
  (.write w ". ")
  (.write w "/create ")
  (.write w "/create ")
  (.write w "M"))
  (.write w "N"))
  (.write w "]"))
  (.write w "nil"))
  (.write w "}"))
  (.write w (.getName (class m)))
  (.write w (.getName (class r)))
  (.write w (.getName (class r)))
  (.write w (.getName ^Class (class o)))
  (.write w (.getName ^Class (class o)))
  (.write w (.getName c)))
  (.write w (format "0x%x " (System/identityHashCode o)))
  (.write w (str "#=(var " (.name (.ns o)) "/" (.sym o) ")")))
  (.write w (str "#uuid \"" (str uuid) "\"")))
  (.write w (str b))
  (.write w (str b))
  (.write w (str o)))
  (.write w (str o)))
  (.write w (str o)))
  (.write w (str o)))
  (:import
  (:import
  (:import (java.io ByteArrayOutputStream StringWriter)
  (:import (java.io LineNumberReader InputStreamReader PushbackReader)
  (:import (java.io StringReader BufferedWriter FileWriter)
  (:import (java.net URI)))
  (:import (java.util.regex Pattern Matcher)
  (:import (org.xml.sax ContentHandler Attributes SAXException)
  (:import [java.util Calendar Date GregorianCalendar TimeZone]
  (:refer-clojure :exclude (replace remove next)))
  (:refer-clojure :exclude (replace reverse))
  (:refer-clojure :exclude [read read-string]))
  (:refer-clojure :exclude [reduce map mapcat filter remove take take-while drop flatten cat])
  (:refer-clojure :exclude [with-bindings])
  (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)
  (:require [clojure.core.protocols :as p]))
  (:require [clojure.java.shell :as sh]
  (:require [clojure.set :as set]))
  (:require [clojure.set :as set]))
  (:require [clojure.spec.alpha :as spec])
  (:require [clojure.spec.alpha :as spec])
  (:require [clojure.stacktrace :as stack]
  (:require [clojure.string :as str]
  (:require [clojure.string :as str]))
  (:require [clojure.template :as temp]
  (:require [clojure.test :as t]
  (:require [clojure.walk :as walk]))
  (:require [clojure.walk :as walk]))
  (:type token))
  (:type-tag token))
  (:use [clojure.java.browse :only (browse-url)] )
  (:use [clojure.java.io :only (as-file copy)])
  (< (- (apply max (seq ints)) (apply min (seq ints))) max-switch-table-size))
  (= s (clojure.lang.Compiler/munge s)))
  (Constructor.
  (Eduction. (apply comp (butlast xforms)) (last xforms)))
  (Field.
  (Long/parseLong s))
  (Matcher/quoteReplacement (.toString ^CharSequence replacement)))
  (Method.
  (String/format fmt (to-array args)))
  (System/exit 0))
  ([ ^CharSequence s ^Pattern re limit]
  ([& keys]
  ([& keys]
  ([& keyvals]
  ([& keyvals]
  ([& keyvals]
  ([& namespaces]
  ([]
  ([]
  ([]
  ([]
  ([]
  ([]
  ([] #{})
  ([] #{})
  ([] ())
  ([] (. Math (random)))
  ([] (. clojure.lang.PersistentArrayMap EMPTY))
  ([] (apply run-tests (all-ns)))
  ([] (gensym "G__"))
  ([] (java.util.ArrayList.))
  ([] (lazy-seq nil))
  ([] (pst 12))
  ([] (read+string *in*))
  ([] (run-tests *ns*))
  ([] (set-break-handler! (thread-stopper)))
  ([] (thread-stopper (Thread/currentThread)))
  ([] (transient []))
  ([] 0)
  ([] 0)
  ([] 1)
  ([] 1)
  ([] [])
  ([] [])
  ([] identity)
  ([] nil)
  ([] nil)
  ([] nil)
  ([] true)
  ([] {})
  ([^CharSequence s ^Pattern re]
  ([^CharSequence s value ^long from-index]
  ([^CharSequence s value ^long from-index]
  ([^CharSequence s value]
  ([^CharSequence s value]
  ([^Class a ^Class b]
  ([^Class type dim & more-dims]
  ([^Class type len]
  ([^Throwable e depth]
  ([^Throwable tr n]
  ([^Writer writer max-columns]
  ([^clojure.lang.IAtom atom f x y & args] (.swap atom f x y args)))
  ([^clojure.lang.IAtom atom f x y] (.swap atom f x y))
  ([^clojure.lang.IAtom atom f x] (.swap atom f x))
  ([^clojure.lang.IAtom atom f] (.swap atom f))
  ([^clojure.lang.IFn f a b c d & args]
  ([^clojure.lang.IFn f args]
  ([^clojure.lang.IFn f x args]
  ([^clojure.lang.IFn f x y args]
  ([^clojure.lang.IFn f x y z args]
  ([^clojure.lang.IPersistentSet set key]
  ([^clojure.lang.ITransientAssociative coll key val & kvs]
  ([^clojure.lang.ITransientAssociative coll key val] (.assoc coll key val))
  ([^clojure.lang.ITransientCollection coll x]
  ([^clojure.lang.ITransientMap map key & ks]
  ([^clojure.lang.ITransientMap map key] (.without map key))
  ([^clojure.lang.ITransientSet set key & ks]
  ([^clojure.lang.ITransientSet set key]
  ([^clojure.lang.LineNumberingPushbackReader stream eof-error? eof-value recursive?]
  ([^clojure.lang.Ref ref n]
  ([^clojure.lang.Ref ref n]
  ([^clojure.lang.Ref ref]
  ([^clojure.lang.Ref ref]
  ([^clojure.lang.Sorted sc start-test start-key end-test end-key]
  ([^clojure.lang.Sorted sc start-test start-key end-test end-key]
  ([^clojure.lang.Sorted sc test key]
  ([^clojure.lang.Sorted sc test key]
  ([^java.lang.Iterable coll f val]
  ([^java.lang.Iterable coll f]
  ([^java.util.Comparator comp coll]
  ([^java.util.concurrent.Future fut timeout-ms timeout-val]
  ([^java.util.concurrent.Future fut]
  ([^java.util.regex.Matcher m]
  ([^java.util.regex.Pattern re s]
  ([^long n]
  ([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]
  ([a b c d e f & args]
  ([a b c d] [a b c d])
  ([a b c] [a b c])
  ([a b] [a b])
  ([a] [a])
  ([a] a) 
  ([arg]                      
  ([args] (seq args))
  ([array idx & idxs]
  ([array idx idx2 & idxv]
  ([array idx val]
  ([array idx]
  ([aseq]
  ([bindings then else & oldform]
  ([bindings then else & oldform]
  ([bindings then]
  ([bindings then]
  ([c1 c2 & colls]
  ([c1 c2]
  ([c1] (lazy-seq c1))
  ([child parent] (isa? global-hierarchy child parent))
  ([coll & ops]
  ([coll comp] (. (par coll) max comp)))
  ([coll comp] (. (par coll) min comp)))
  ([coll comp] (pa-to-vec (. (pall coll) sort comp))))
  ([coll comp] (summary-map (. (par coll) summary comp))))
  ([coll f val]
  ([coll f]
  ([coll index not-found] (. clojure.lang.RT (nth coll index not-found))))
  ([coll index] (. clojure.lang.RT (nth coll index)))
  ([coll xf]
  ([coll xf]
  ([coll]
  ([coll]
  ([coll]
  ([coll]
  ([coll]
  ([coll]
  ([coll]
  ([coll] 
  ([coll] (. (par coll) max))
  ([coll] (. (par coll) min))
  ([coll] (drop-last 1 coll))
  ([coll] (pa-to-vec (. (pall coll) sort)))
  ([coll] (sequence (dedupe) coll)))
  ([coll] (summary-map (. (par coll) summary)))
  ([coll] coll)
  ([combinef reducef coll] (fold 512 combinef reducef coll))
  ([comparator & keys]
  ([comparator & keyvals]
  ([ctor]
  ([e-or-depth]
  ([end]
  ([env sym] (ns-resolve *ns* env sym)))
  ([f & args]
  ([f & colls]
  ([f & opts]
  ([f arg1 arg2 arg3 & more]
  ([f arg1 arg2 arg3]
  ([f arg1 arg2]
  ([f arg1]
  ([f c1 c2 c3 & colls]
  ([f c1 c2 c3 & colls]
  ([f c1 c2 c3]
  ([f c1 c2 c3]
  ([f c1 c2]
  ([f c1 c2]
  ([f cf]
  ([f coll & colls]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll]
  ([f coll] (reduce f (f) coll))
  ([f g & fs]
  ([f g h & fs]
  ([f g h]
  ([f g]
  ([f g]
  ([f init coll]
  ([f init coll]
  ([f init coll]
  ([f val coll]
  ([f x y z]
  ([f x y]
  ([f x]
  ([f]
  ([f]
  ([f]
  ([f]
  ([f]
  ([f]
  ([f]
  ([f]
  ([f] (comp (map f) cat))
  ([f] (completing f identity))
  ([f] (lazy-seq (cons (f) (repeatedly f))))
  ([f] f)
  ([f] f)
  ([form msg] `(try-expr ~msg ~form)))
  ([form] `(is ~form nil))
  ([format args]
  ([h child parent]
  ([h tag parent]
  ([h tag parent]
  ([h tag] (if (class? tag)
  ([h tag] (not-empty
  ([h tag] (not-empty
  ([in enc]
  ([in] (stream-to-string in (.name (Charset/defaultCharset))))
  ([k x y & more]
  ([k x y & more]
  ([k x y] (if (< (k x) (k y)) x y))
  ([k x y] (if (> (k x) (k y)) x y))
  ([k x] x)
  ([k x] x)
  ([keyfn ^java.util.Comparator comp coll]
  ([keyfn coll]
  ([ks rows]
  ([left right]
  ([m k f x y z & more]
  ([m k f x y z]
  ([m k f x y]
  ([m k f x]
  ([m k f]
  ([m ks f & args]
  ([m ks not-found]
  ([m ks]
  ([map key & ks]
  ([map key not-found]
  ([map key]
  ([map key]
  ([map] map)
  ([msg map cause]
  ([msg map]
  ([n ^ClassLoader loader] (.getResource loader n)))
  ([n coll]
  ([n coll]
  ([n coll]
  ([n coll]
  ([n coll]
  ([n coll]
  ([n coll]
  ([n coll] (map (fn [x _] x) coll (drop n coll))))
  ([n combinef reducef coll]
  ([n f] (take n (repeatedly f))))
  ([n step coll]
  ([n step coll]
  ([n step pad coll]
  ([n x] (clojure.lang.Repeat/create n x)))
  ([n-or-q s]
  ([n]
  ([n]
  ([n]
  ([n] (* n (rand))))
  ([n] (resource n (.getContextClassLoader (Thread/currentThread))))
  ([name]
  ([name]
  ([name] (cond (keyword? name) name
  ([name] (cond (keyword? name) name
  ([ns ^clojure.lang.Symbol name]
  ([ns env sym]
  ([ns name val]
  ([ns name] (clojure.lang.Keyword/find ns name)))
  ([ns name] (clojure.lang.Keyword/intern ns name)))
  ([ns name] (clojure.lang.Symbol/intern ns name)))
  ([ns sym]
  ([object writer]
  ([object] (pprint object *out*)) 
  ([op unchecked-op]
  ([op] (nary-inline op op))
  ([opts ^LineNumberingPushbackReader reader line-number]
  ([opts ^clojure.lang.LineNumberingPushbackReader stream]
  ([opts s] (clojure.lang.RT/readString s opts)))
  ([opts s] (when s (clojure.lang.EdnReader/readString s opts))));   Copyright (c) Rich Hickey. All rights reserved.
  ([opts stream]
  ([opts stream]
  ([p1 p2 p3 & ps]
  ([p1 p2 p3 & ps]
  ([p1 p2 p3]
  ([p1 p2 p3]
  ([p1 p2]
  ([p1 p2]
  ([p]
  ([p]
  ([parent child & more]
  ([parent child]             
  ([pred coll]
  ([pred coll]
  ([pred coll]
  ([pred coll]
  ([pred retf]
  ([pred]
  ([pred]
  ([pred]
  ([pred] (filter (complement pred)))
  ([pred] (halt-when pred nil))
  ([prefix-string] (. clojure.lang.Symbol (intern (str prefix-string (str (. clojure.lang.RT (nextID))))))))
  ([prob coll]
  ([prob]
  ([re] (apply run-tests (filter #(re-matches re (name (ns-name %))) (all-ns)))))
  ([reducef coll] (fold reducef reducef coll))
  ([ref timeout-ms timeout-val]
  ([ref] (if (instance? clojure.lang.IDeref ref)
  ([rows] (print-table (keys (first rows)) rows)))
  ([s startparse]
  ([s1 s2 & sets]
  ([s1 s2 & sets] 
  ([s1 s2 & sets] 
  ([s1 s2]
  ([s1 s2]
  ([s1 s2] 
  ([s1] s1)
  ([s1] s1)
  ([s1] s1)
  ([s] (clojure.lang.RT/readString s))
  ([s] (parse s startparse-sax))
  ([s] (read-string {:eof nil} s))
  ([s] (seque 100 s))
  ([sep coll]
  ([sep]
  ([separator coll]
  ([set key & ks]
  ([set] set)
  ([set] set)
  ([size init-val-or-seq] (. clojure.lang.Numbers boolean_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers byte_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers char_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers double_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers float_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers int_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers long_array size init-val-or-seq)))
  ([size init-val-or-seq] (. clojure.lang.Numbers short_array size init-val-or-seq)))
  ([size-or-seq] (. clojure.lang.Numbers boolean_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers byte_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers char_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers double_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers float_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers int_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers long_array size-or-seq))
  ([size-or-seq] (. clojure.lang.Numbers short_array size-or-seq))
  ([size-or-seq] (. clojure.lang.RT object_array size-or-seq)))
  ([smap coll]
  ([smap]
  ([start end step]
  ([start end]
  ([state & options]
  ([stream eof-error? eof-value recursive?]
  ([stream eof-error? eof-value]
  ([stream eof-error? eof-value] (read+string stream eof-error? eof-value false))
  ([stream format args]
  ([stream]
  ([stream]
  ([stream] (read+string stream true nil))
  ([sym] (ns-resolve *ns* sym))
  ([t x1 x2 x3 x4 & xn]
  ([t x1 x2 x3 x4]
  ([t x1 x2 x3]
  ([t x1 x2]
  ([t x1]
  ([t]
  ([tag parent]
  ([tag parent] (alter-var-root #'global-hierarchy underive tag parent) nil)
  ([tag] (ancestors global-hierarchy tag))
  ([tag] (descendants global-hierarchy tag))
  ([tag] (parents global-hierarchy tag))
  ([test msg] `(when-not ~test (fail ~msg)))
  ([test then else]
  ([test then] `(if-not ~test ~then nil))
  ([test] `(verify ~test ~(str "failed: " (pr-str test)))))
  ([thread] (fn [msg] (.stop thread (Error. msg)))))
  ([to from]
  ([to xform from]
  ([to] to)
  ([tr n]
  ([tr] (print-cause-trace tr nil))
  ([tr] (print-stack-trace tr nil))
  ([type aseq]
  ([v start end]
  ([v start]
  ([visitor m i]
  ([visitor m] (add-annotations visitor m nil))
  ([writer] (column-writer writer *default-page-width*))
  ([x & more]
  ([x & next]
  ([x & next]
  ([x & options]
  ([x & options] (setup-reference (atom x) options)))
  ([x form & more] `(.. (. ~x ~form) ~@more)))
  ([x form] `(. ~x ~form))
  ([x message]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & more]
  ([x y & zs]
  ([x y]
  ([x y] (. clojure.lang.Numbers (add x y)))
  ([x y] (. clojure.lang.Numbers (addP x y)))
  ([x y] (. clojure.lang.Numbers (divide x y)))
  ([x y] (. clojure.lang.Numbers (equiv x y)))
  ([x y] (. clojure.lang.Numbers (gt x y)))
  ([x y] (. clojure.lang.Numbers (gte x y)))
  ([x y] (. clojure.lang.Numbers (lt x y)))
  ([x y] (. clojure.lang.Numbers (lte x y)))
  ([x y] (. clojure.lang.Numbers (max x y)))
  ([x y] (. clojure.lang.Numbers (min x y)))
  ([x y] (. clojure.lang.Numbers (minus x y)))
  ([x y] (. clojure.lang.Numbers (minusP x y)))
  ([x y] (. clojure.lang.Numbers (multiply x y)))
  ([x y] (. clojure.lang.Numbers (multiplyP x y)))
  ([x y] (. clojure.lang.Numbers andNot x y))
  ([x y] (. clojure.lang.Numbers or x y))
  ([x y] (. clojure.lang.Numbers xor x y))
  ([x y] (clojure.lang.Util/equals x y))
  ([x y] (clojure.lang.Util/equiv x y))
  ([x y] (clojure.lang.Util/identical x y)))
  ([x y] (not (= x y)))
  ([x y] (not (= x y)))
  ([x]
  ([x]
  ([x] (. clojure.lang.Numbers (minus x)))
  ([x] (. clojure.lang.Numbers (minusP x)))
  ([x] (/ 1 x))
  ([x] (cast Number x))
  ([x] (cast Number x))
  ([x] (cast Number x))
  ([x] (cast Number x))
  ([x] (clojure.lang.RT/isReduced x)))
  ([x] (clojure.lang.Repeat/create x))
  ([x] (lazy-seq x))
  ([x] (new clojure.lang.Atom x))
  ([x] (new clojure.lang.Ref x))
  ([x] false)
  ([x] true)
  ([x] true)
  ([x] true)
  ([x] true)
  ([x] true)
  ([x] true)
  ([x] true)
  ([x] true)
  ([x] x)
  ([x] x)
  ([x] x)
  ([x] x)
  ([xform coll & colls]
  ([xform coll]
  ([xform f coll] (transduce xform f (f) coll))
  ([xform f init coll]
  ([xrel yrel km] ;arbitrary key mapping
  ([xrel yrel] ;natural join
  (\$
  (\% 
  (\&
  (\(
  (\) [] #{} {} nil) 
  (\* 
  (\; [:min-remaining [nil Integer] :max-columns [nil Integer]] 
  (\<
  (\> [] #{:colon} {} nil) 
  (\? 
  (\A 
  (\B
  (\C
  (\D
  (\E
  (\F
  (\G
  (\I
  (\O
  (\P
  (\R
  (\S 
  (\T
  (\W 
  (\X
  (\[
  (\] [] #{} {} nil) 
  (\^ [:arg1 [nil Integer] :arg2 [nil Integer] :arg3 [nil Integer]] 
  (\_
  (\newline ;; Whitespace supression is handled in the compilation loop
  (\{
  (\| 
  (\} [] #{:colon} {} nil) 
  (\~ 
  (^InputStream resolve-class [this name]
  (^Object remove [_ ^int i] (throw (UnsupportedOperationException.)))
  (^String [] "")
  (^String [^Object x]
  (^String [^String s start end] (. s (substring start end))))
  (^String [^String s start] (. s (substring start)))
  (^String [x & ys]
  (^boolean remove [_ o] (throw (UnsupportedOperationException.)))
  (^clojure.lang.IPersistentVector [^clojure.lang.IAtom2 atom f x y & args] (.swapVals atom f x y args)))
  (^clojure.lang.IPersistentVector [^clojure.lang.IAtom2 atom f x y] (.swapVals atom f x y))
  (^clojure.lang.IPersistentVector [^clojure.lang.IAtom2 atom f x] (.swapVals atom f x))
  (^clojure.lang.IPersistentVector [^clojure.lang.IAtom2 atom f] (.swapVals atom f))
  (^int alength [arr])
  (^int tailoff [])
  (^objects toArray [this ^objects arr]
  (^void ppflush []))
  (^{:added "1.2"} make-input-stream [x opts] "Creates a BufferedInputStream. See also IOFactory docs.")
  (^{:added "1.2"} make-output-stream [x opts] "Creates a BufferedOutputStream. See also IOFactory docs."))
  (^{:added "1.2"} make-reader [x opts] "Creates a BufferedReader. See also IOFactory docs.")
  (^{:added "1.2"} make-writer [x opts] "Creates a BufferedWriter. See also IOFactory docs.")
  (^{:added "1.3"} diff-similar [a b] "Implementation detail. Subject to change."))
  (^{:added "1.3"} equality-partition [x] "Implementation detail. Subject to change."))
  (^{:tag java.io.File, :added "1.2"} as-file [x] "Coerce argument to a file.")
  (^{:tag java.net.URL, :added "1.2"} as-url [x] "Coerce argument to a URL."))
  (aclone [arr])
  (add [_ i o] (throw (UnsupportedOperationException.)))
  (add [_ o] (throw (UnsupportedOperationException.)))
  (add-ns-meta ::each-fixtures args))
  (add-ns-meta ::once-fixtures args))
  (addAll [_ c] (throw (UnsupportedOperationException.)))
  (addAll [_ i c] (throw (UnsupportedOperationException.)))
  (aget [arr ^int i])
  (alter @this assoc sym new-val))
  (alter-meta! *ns* assoc key coll))
  (alter-var-root #'*data-readers*
  (and (:separator (:bracket-info (:def this)))
  (and (<= (count set1) (count set2))
  (and (>= (count set1) (count set2))
  (and (class? c)
  (and (divisible? year 4)
  (and (not (nil? class-name))
  (and (zero? (:fail summary 0))
  (and *print-level* (>= *current-level* *print-level*)))
  (and atype (.isAssignableFrom ^Class (:on-interface protocol) atype)))
  (apply action-fn state-of-agent args)"
  (apply action-fn state-of-agent args)"
  (apply action-fn state-of-agent args)"
  (apply f (meta obj) args) as its metadata."
  (apply f current-value-of-atom args). Note that f may be called
  (apply f current-value-of-atom args). Note that f may be called
  (apply f its-current-meta args)
  (apply fun in-transaction-value-of-ref args)
  (apply fun in-transaction-value-of-ref args)
  (apply fun most-recently-committed-value-of-ref args)
  (apply hash-map (mapcat 
  (apply load-libs :require args))
  (apply require clojure.main/repl-requires))
  (apply send-via clojure.lang.Agent/pooledExecutor a f args))
  (apply send-via clojure.lang.Agent/soloExecutor a f args))
  (apply str (interpose " " (reverse *testing-contexts*))))
  (apply str (interpose "."
  (apply str (map #(escape-xml-map % %) text)))
  (apply type-reflect (if (class? obj) obj (class obj)) options))
  (array [^int size])
  (arrayFor [^int i])
  (arrayFor [this i]
  (as-file [_] nil)
  (as-file [f] f)
  (as-file [s] (File. s))
  (as-file [u]
  (as-file [u] (as-file (as-url u))))
  (as-url [_] nil)
  (as-url [f] (.toURL (.toURI f)))
  (as-url [s] (URL. s))  
  (as-url [u] (.toURL u))
  (as-url [u] u)
  (aset [arr ^int i val]))
  (aset a i (rand-int i)))
  (assert (even? (count clauses)))
  (assert (even? (count clauses)))
  (assert (every? symbol? argv))
  (assert (vector? argv))
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assert-args
  (assoc (Throwable->map ex) :phase phase))
  (assoc (meta nspace) :name (ns-name nspace)))
  (assoc (or (special-doc-map name-symbol) (meta (resolve name-symbol)))
  (assoc [this k v]
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assoc default-streams-impl
  (assocN [this i val]
  (atom? node))
  (bar-me (Foo. 1 2 3) 42)
  (binding [*compile-files* true]
  (binding [*format-str* format-str]
  (binding [*out* *err*]
  (binding [*out* *err*]
  (binding [*print-level* (and (not *print-dup*) *print-level* (dec *print-level*))]
  (binding [*report-counters* (ref *initial-report-counters*)]
  (boolean
  (boolean (:append opts)))
  (boolean (:on-interface maybe-p)))
  (boolean (find-protocol-impl protocol x)))
  (boolean (or (implements? protocol atype) 
  (case (System/getProperty "java.specification.version")
  (check-enumerated-arg kind #{:line :section :line-relative :section-relative})
  (check-enumerated-arg kind #{:linear :miser :fill :mandatory})
  (check-enumerated-arg relative-to #{:block :current})
  (check-flags def flags)
  (chunkedFirst [_] (ArrayChunk. am anode offset (.alength am anode)))
  (chunkedMore [this]
  (chunkedNext [_] 
  (clear [_] (throw (UnsupportedOperationException.)))
  (clojure.lang.ChunkBuffer. capacity))
  (clojure.lang.Compiler/demunge fn-name))
  (clojure.lang.Compiler/demunge fn-name))
  (clojure.lang.EnumerationSeq/create e))
  (clojure.lang.RT/addURL url))
  (clojure.lang.RT/chunkIteratorSeq iter))
  (clojure.lang.ReaderConditional/create form splicing?))
  (clojure.lang.Reduced. x))
  (clojure.lang.TaggedLiteral/create tag form))
  (clojure.lang.Util/hashCombine x (clojure.lang.Util/hash y)))
  (clojure.lang.Var/getThreadBindings))
  (clojure.lang.Var/popThreadBindings))
  (clojure.lang.Var/pushThreadBindings bindings))
  (clojure.lang.Volatile. val))
  (coll-fold
  (coll-fold [coll n combinef reducef]))
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce
  (coll-reduce [coll f] [coll f val]))
  (coll-reduce [this f1] (clojure.core.protocols/coll-reduce this f1 (f1)))
  (combinef))
  (compareTo [this o]
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond
  (cond 
  (cond 
  (cond 
  (cond 
  (cond (= width (count s)) s
  (cond->
  (condp = expr
  (cons [this o]
  (cons [this val]
  (consume
  (consume 
  (consume extract-param [s offset false]))
  (contains [this o] (boolean (some #(= % o) this)))
  (containsAll [this c] (every? #(.contains this %) c))
  (containsKey [this k]
  (count (seq parent)))
  (count (val e)))
  (count [_] (- end off))
  (count [_] cnt)
  (count [_] cnt)
  (count [this]
  (count parent))
  (datafy [_] nil)
  (datafy [c]
  (datafy [n]
  (datafy [o] "return a representation of o as data (default identity)"))
  (datafy [r]
  (datafy [x]
  (datafy [x] x))
  (def ^:dynamic *clojure-version*
  (defaults to the current namespace). All inherited methods,
  (definterface MyInterface
  (defprotocol AProtocolName
  (defprotocol P 
  (deftype Foo [a b c] 
  (delay
  (diff-similar
  (diff-similar [a b]
  (diff-similar [a b]
  (do
  (do-copy (ByteArrayInputStream. input) output opts))
  (do-copy (ByteArrayInputStream. input) output opts))
  (do-copy (ByteArrayInputStream. input) output opts))
  (do-copy (CharArrayReader. input) output opts))
  (do-copy (CharArrayReader. input) output opts))
  (do-copy (CharArrayReader. input) output opts))
  (do-copy (StringReader. input) output opts))
  (do-copy (StringReader. input) output opts))
  (do-copy (StringReader. input) output opts))
  (do-copy input output (when opts (apply hash-map opts))))
  (do-curried name doc meta args body))
  (do-reflect [_ typeref]
  (do-reflect [_ typeref]
  (do-reflect [reflector typeref]))
  (do-rfn f1 k fkv))
  (doAssoc [^int level node ^int i val]))
  (doAssoc [this level node i val]
  (doall
  (doseq [[^clojure.lang.Var v build] (:method-builders protocol)]
  (doseq [[ns vars] (group-by (comp :ns meta) vars)]
  (doseq [[opt arg] inits]
  (doseq [[proto mmap] (partition 2 proto+mmaps)]
  (doseq [^String path paths]
  (doseq [line (.split ^String data "\n")]
  (doseq [m method-syms]
  (doseq [prop [:name :port :accept]] (required opts prop))
  (doseq [server (parse-props system-props)]
  (doseq [token tokens]
  (dosync
  (dosync
  (dosync
  (dosync
  (dosync
  (dosync 
  (dosync 
  (dosync 
  (dosync (commute *local-javadocs* conj path)))
  (dosync (commute *remote-javadocs* assoc package-prefix url)))
  (dosync (if (= c (int \newline))
  (dosync (set-field this :max new-max))
  (dosync (setf :logical-block-callback f)))
  (dosync (setf :miser-width new-miser-width)))
  (dosync (setf :trailing-white-space nil))
  (dosync (setf :trailing-white-space nil)))
  (dotimes [n (* *depth* 4)] (print " ")))
  (doto (GregorianCalendar. years (dec months) days hours minutes seconds)
  (doto (JFrame. "Clojure Inspector")
  (doto (JFrame. "Clojure Inspector")
  (doto (JFrame. "Clojure Inspector")
  (doto (Timestamp.
  (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))"
  (doto acc (.add x)))
  (dropFirst [_]
  (e.g. sets and maps) implement IFn"
  (element-content
  (emit-element x))
  (emit-extend-protocol p specs))
  (emit-extend-type t specs))
  (emit-protocol name opts+sigs))
  (empty [_]
  (empty [_] (new Vec am 0 5 EMPTY-NODE (.array am 0) nil))                             
  (entryAt [this k]
  (equality-partition [x] :atom)
  (equality-partition [x] :map))
  (equality-partition [x] :sequential)
  (equality-partition [x] :set)
  (equals [this o]
  (equiv [this o]
  (equiv [this o]
  (every? #(.getThreadBinding ^clojure.lang.Var %) vars))
  (every? #(.isBound ^clojure.lang.Var %) vars))
  (exclusive), by step, where start defaults to 0, step to 1, and end to
  (extend AType
  (extend MyType
  (extend-protocol Protocol
  (extend-type MyType 
  (f base an-element) might be performed many times, i.e. base is not
  (f))
  (filter (complement pred) coll))
  (filter (complement sequential?)
  (filter-key val (partial instance? Class) (ns-map ns)))
  (finish-element 'testcase true))
  (finish-element 'testsuite true))
  (finish-element tag false)
  (first
  (first
  (first [_] (.aget am anode offset))
  (flatten nil) returns an empty sequence."
  (fn
  (fn [e]
  (fn [fixture-type & args] fixture-type))
  (fn [g] (f1 (fn [] (f2 g)))))
  (fn [input output opts] [(type input) (type output)]))
  (fn [msg form]
  (fn [rf]
  (fn [years months days hours minutes seconds nanoseconds
  (fn m
  (fold cat append! coll))
  (folder coll
  (folder coll
  (folder coll
  (folder coll
  (foldvec v n combinef reducef))
  (foo 
  (for [^Constructor ctor (. super (getDeclaredConstructors))
  (force tap-loop)
  (force tap-loop)
  (format-roman new-roman-table params navigator offsets))
  (format-roman old-roman-table params navigator offsets))
  (get (find-protocol-impl protocol x) methodk))
  (get [this i] (.nth this i))
  (get-child (val e) index))
  (get-field this :base))
  (get-field this :cur))
  (get-field this :line))
  (get-field this :max))
  (getf :miser-width))
  (hashCode [this]
  (hasheq [this]
  (if (#{'invoke 'invokeStatic} method)
  (if (. ^Class (first bases) (isInterface))
  (if (.map cache)
  (if (.startsWith path "@")
  (if (:colon (:right-params params))
  (if (= (getf :mode) :writing)
  (if (= :pass (:type data))
  (if (= a b)
  (if (= a b) [nil nil a] [a b nil]))
  (if (= enc :bytes)
  (if (> (count alis) 3) 
  (if (> (count params) (count (:params def)))
  (if (>= position (:pos navigator))
  (if (and (sequential? form) (function? (first form)))
  (if (class? typeref)
  (if (clojure.lang.Numbers/isZero (clojure.lang.RT/count chunk))
  (if (counted? coll)
  (if (end? loc)
  (if (end? loc)
  (if (every? symbol? params)
  (if (fits-table? tests)
  (if (instance? (:on-interface protocol) x)
  (if (instance? ParallelArrayWithMapping coll)
  (if (instance? String e)
  (if (instance? clojure.lang.IDeref *out*)
  (if (instance? clojure.lang.IEditableCollection to)
  (if (instance? clojure.lang.IObj o)
  (if (instance? clojure.lang.IReduceInit coll)
  (if (instance? clojure.lang.LineNumberingPushbackReader *in*)
  (if (instance? clojure.lang.Namespace x)
  (if (java.util.concurrent.ForkJoinTask/inForkJoinPool)
  (if (macosx?)
  (if (map? v)
  (if (neg? e)
  (if (neg? k)
  (if (next alis) 
  (if (next alis) 
  (if (or
  (if (or (= (:type token) :mandatory)
  (if (or (instance? Class c) (prim->class c))
  (if (or *print-dup* *print-readably*)
  (if (or *print-dup* *print-readably*)
  (if (or d w)
  (if (pretty-writer? writer) 
  (if (qualified-symbol? sym)
  (if (ratio? x)
  (if (reduced? x) (deref x) x))
  (if (reduced? x) x (reduced x)))
  (if (seq alis)
  (if (seq alis)
  (if (seq attrs)
  (if (seq pclasses)
  (if (seq stacktrace)
  (if (sequential? reference)
  (if (set? coll)
  (if (set? s) s (into #{} s)))
  (if (string? (first opts))
  (if (string? x) x (. ^clojure.lang.Named x (getName))))
  (if (symbol? named)
  (if (symbol? valf)
  (if (symbol? x)
  (if (symbol? x)
  (if (vector? form)
  (if (zero? val)
  (if *load-tests*
  (if *print-dup*
  (if *print-readably*
  (if *print-readably*
  (if *print-readably*
  (if *print-readably*
  (if *print-readably*
  (if *verbose-defrecords*
  (if ks
  (if pretty (indent))
  (if pretty (indent))
  (if pretty (println))
  (if pretty (println)))
  (if s
  (if-let [arg-num (sym *symbol-map*)]
  (if-let [buf (getf :buffer)]
  (if-let [cause (.getCause tr)]
  (if-let [s (format-simple-number x)]
  (if-let [special-name ('{& fn catch try finally try} name)]
  (if-not (choices arg)
  (if-not (pprint-reader-macro alis)
  (if-not (pprint-reader-macro alis) 
  (in-ns 'user)
  (in-ns 'user)
  (indent *out* relative-to n))
  (indent)
  (indexOf [this o]
  (insert-decimal (expand-fixed m e d) e))
  (inst-ms* [inst] (.getTime ^java.util.Date inst)))
  (inst-ms* [inst] (.toEpochMilli ^java.time.Instant inst)))
  (inst-ms* [inst]))
  (inst-ms* inst))
  (instance? Number x))
  (instance? clojure.lang.IChunkedSeq s))
  (instance? clojure.lang.IRecord x))
  (instance? clojure.lang.ReaderConditional value))
  (instance? clojure.lang.TaggedLiteral value))
  (instance? clojure.lang.Volatile x))
  (intern (create-ns (symbol (namespace sym)))
  (internal-reduce
  (internal-reduce
  (internal-reduce
  (internal-reduce
  (internal-reduce
  (internal-reduce [seq f start]))
  (into (sorted-map) m))
  (into {} 
  (into {} (for [[k v] m] [k [v v1]])))
  (into1 (sorted-map)
  (invoke [this k]
  (io! "await in transaction"
  (is (thrown-with-msg? c re body)) checks that an instance of c is
  (is (thrown? c body)) checks that an instance of c is thrown from
  (is-leaf (val e)))
  (isEmpty [_] (zero? cnt))
  (iterator [this]
  (java.util.UUID/fromString form))
  (java.util.concurrent.ForkJoinTask/adapt f))
  (keys (:impls protocol)))
  (kv-reduce [amap f init]))
  (lastIndexOf [this o]
  (lazy-cat xs ys zs) === (concat (lazy-seq xs) (lazy-seq ys) (lazy-seq zs))"
  (length [_] cnt)
  (let [ [arg arg-navigator] (next-arg arg-navigator) 
  (let [ rst (:rest navigator) ]
  (let [EOF (Object.)
  (let [[[eol-str] new-navigator] (when-let [else (:else params)]
  (let [[^Double arg navigator] (next-arg navigator)
  (let [[a b] (split-at-newline tokens)]
  (let [[arg _] (next-arg navigator)
  (let [[arg arg-navigator] (next-arg arg-navigator)]
  (let [[arg navigator] (next-arg arg-navigator)
  (let [[arg navigator] (next-arg arg-navigator)
  (let [[arg navigator] (next-arg navigator)
  (let [[arg navigator] (next-arg navigator)]
  (let [[arg navigator] (next-arg navigator)]
  (let [[arg navigator] (next-arg navigator)]
  (let [[c navigator] (next-arg navigator)
  (let [[c navigator] (next-arg navigator)]
  (let [[char navigator] (next-arg navigator)]
  (let [[cmd opts] (parse-args args)
  (let [[inits [sep & args]] (split-with (complement #{"--"}) args)]
  (let [[inits [sep & args]] (split-with (complement #{"--"}) args)]
  (let [[interfaces methods] (parse-opts+specs opts+specs)]
  (let [[m ^String e] (float-parts-base f)
  (let [[m1 e1] (if (neg? e)
  (let [[mname] (remove valid-java-method-name (map (comp str first) methods))]
  (let [[ns lift-map] (lift-ns m)]
  (let [[ns lift-map] (when (not (record? amap))
  (let [[options body] (parse-lb-options #{:prefix :per-line-prefix :suffix} args)]
  (let [[opts specs] (parse-opts opts+specs)
  (let [[package classname] (package-class name)]
  (let [[pairs new-navigator] 
  (let [[pre-args [args expr]] (split-with (comp not vector?) decl)]
  (let [[raw-format navigator] (next-arg navigator)
  (let [[raw-params [rest offset]] (extract-params s offset)
  (let [[real-param new-navigator]
  (let [[subex remainder] (collect-clauses (:bracket-info (:def this))
  (let [[x xs] bindings]
  (let []
  (let [^"[C" buffer (make-array Character/TYPE (buffer-size opts))
  (let [^"[C" buffer (make-array Character/TYPE (buffer-size opts))
  (let [^"[C" buffer (make-array Character/TYPE (buffer-size opts))]
  (let [^Character f (first s) 
  (let [^Class c (if (instance? Class class-or-object) 
  (let [^File f (as-file x)]
  (let [^StackTraceElement s (nth (.getStackTrace (new java.lang.Throwable)) n)]
  (let [^String macro-char (reader-macros (first alis))]
  (let [^String s (.toLowerCase (.toString f))
  (let [^String s (.toString s)
  (let [^String tws (getf :trailing-white-space)] 
  (let [^java.text.DateFormat utc-format (.get thread-local-utc-date-format)]
  (let [^java.text.DateFormat utc-format (.get thread-local-utc-timestamp-format)]
  (let [al (java.util.ArrayList. coll)]
  (let [allowed (:flags def)]
  (let [arg (:selector params)
  (let [argdecls (map
  (let [args (rest form)
  (let [args (second alis)
  (let [attrs {:name classname}]
  (let [base (fn [^Throwable t]
  (let [base-sym (first alis)]
  (let [bents (partition 2 bindings)
  (let [bindings (get-thread-bindings)]
  (let [buckets (loop [m {} ks tests vs thens]
  (let [buffer (make-array Byte/TYPE (buffer-size opts))]
  (let [c (. x (getClass))
  (let [c (.read s)]
  (let [c (class o)]
  (let [c (count argv)]
  (let [cache  (.__methodImplCache pf)
  (let [calstr (format "%1$tFT%1$tT.%1$tL%1$tz" c)
  (let [capped (ref false)] 
  (let [cargs (vec (butlast args))]
  (let [cl (.. Thread currentThread getContextClassLoader)]
  (let [cl (.getContextClassLoader (Thread/currentThread))]
  (let [class (.getClassName e)
  (let [classname (with-meta (symbol (str (namespace-munge *ns*) "." cname)) (meta cname))
  (let [classname (with-meta (symbol (str (namespace-munge *ns*) "." cname)) (meta cname))
  (let [clause (first (:clauses params))]
  (let [clauses (:clauses params)
  (let [cnt (count parts)]
  (let [colnum (:colnum params) 
  (let [colrel (:colnum params) 
  (let [compiled-format (if (string? format-in) (compile-format format-in) format-in)
  (let [core "clojure.core"]
  (let [count-var (gensym "length-count")
  (let [cv (new ClassWriter (. ClassWriter COMPUTE_MAXS))
  (let [d (java.util.concurrent.CountDownLatch. 1)
  (let [d (root-resource lib)]
  (let [default-encoding "UTF-8" ;; see sh doc string
  (let [default-options {:prefix "-" :load-impl-ns true :impl-ns (ns-name *ns*)}
  (let [docstring   (if (string? (first options))
  (let [eof (Object.)
  (let [f (binding-conveyor-fn f)
  (let [f (fn [[k v]] (if (keyword? k) [(name k) v] [k v]))]
  (let [f (fn [[k v]] (if (string? k) [(keyword k) v] [k v]))]
  (let [file (.getFileName el)
  (let [file (.getFileName el)
  (let [file-path (.replace classname \. File/separatorChar)
  (let [flags (filter keyword? args)
  (let [fn-name (symbol (str '-> nom))
  (let [format-str (get java-base-formats base)]
  (let [frame (clojure.lang.Var/cloneThreadBindingFrame)]
  (let [full-message (str message \newline *format-str* \newline 
  (let [g (gensym)
  (let [g (gensym)
  (let [g (gensym)
  (let [g (gensym)
  (let [garr (gensym)
  (let [ge (with-meta (gensym) {:tag Object})
  (let [gname name
  (let [gname name
  (let [gpred (gensym "pred__")
  (let [hashcode #(clojure.lang.Util/hash %)
  (let [hint (fn [specs]
  (let [htmlpane (javax.swing.JEditorPane. url)]
  (let [hundreds (quot num 100)
  (let [hundreds (quot num 100)
  (let [i (.lastIndexOf name ".")]
  (let [i (first bindings)
  (let [i (first bindings)
  (let [impls (parse-impls specs)]
  (let [impls (parse-impls specs)]
  (let [iname (.replace (str name) "." "/")
  (let [iname (symbol (str (munge (namespace-munge *ns*)) "." (munge name)))
  (let [inames (into1 (sorted-set) (map #(.getName ^Class %) interfaces))]
  (let [kind (if (:colon params) 
  (let [klass (nth form 1)
  (let [klass (second form)
  (let [l (seq l)]
  (let [last-was-whitespace? (ref true)] 
  (let [lb (:logical-block newl)]
  (let [lb (:logical-block newl)]
  (let [lb (:logical-block newl)]
  (let [lb (:logical-block nl)
  (let [lb (:logical-block token)]
  (let [lb (struct logical-block nil nil (ref 0) (ref 0) (ref false) (ref false))
  (let [len (.length s)]
  (let [len (.length s)]
  (let [len (count s)]
  (let [len (count s)]
  (let [len-1 (dec (count s))]
  (let [length-reached (and 
  (let [lib (if prefix (symbol (str prefix \. lib)) lib)
  (let [lines (.split s "\n" -1)]
  (let [loc (str (or path source "REPL") ":" (or line 1) (if column (str ":" column) ""))
  (let [m (re-matcher param-pattern s)
  (let [m (re-matcher re s)]
  (let [m (re-matcher re s)]
  (let [m (re-matcher re s)]
  (let [m (rem num div)]
  (let [matches? (if (instance? java.util.regex.Pattern str-or-pattern)
  (let [max (apply max-key k coll)]
  (let [max-count (:max-iterations params)
  (let [max-count (:max-iterations params)
  (let [max-count (:max-iterations params)
  (let [max-count (:max-iterations params)
  (let [maxcol (get-max-column (getf :base))]
  (let [mem (atom {})]
  (let [message (when (string? (first body)) (first body))
  (let [methodk (keyword method)
  (let [miser-width (get-miser-width this)
  (let [name-str (name type-name)]
  (let [newpos (+ (:pos navigator) position)]
  (let [nl (first buffer) 
  (let [nl (first buffer) 
  (let [non-syms (remove symbol? fields)]
  (let [not-exposable? (fn [^java.lang.reflect.Method meth]
  (let [not-overridable? (fn [^java.lang.reflect.Method meth]
  (let [ns (the-ns ns)]
  (let [ns (the-ns ns)]
  (let [ns (the-ns ns)]
  (let [old-meta (meta #'*print-pprint-dispatch*)]
  (let [options (merge {:stream true} (apply hash-map kw-args))]
  (let [options-map (apply hash-map options)
  (let [opts (apply hash-map options)]
  (let [opts (apply hash-map options)]
  (let [pending (and (instance? clojure.lang.IPending o)
  (let [pre (seq (take-while #(not (nl-t? %)) tokens))]
  (let [prefix (format "#<%s@%x%s: "
  (let [process-reference
  (let [push-content (fn [e c]
  (let [rdr (-> (java.io.StringReader. s)
  (let [relative-to (if (:colon params) :current :block)]
  (let [result ^long
  (let [result ^long
  (let [result ^long
  (let [result ^long
  (let [root-bind (fn [m]
  (let [row1 (first data)
  (let [rrf (preserving-reduced rf)]
  (let [rst (:rest navigator)]
  (let [s (.toString s)
  (let [s (.toString s)]
  (let [s (.toString s)]
  (let [s (.toString s)]
  (let [s (seq s)]
  (let [sb (StringBuilder.)]
  (let [script @*open-url-script*
  (let [specials '#{__meta __hash __hasheq __extmap}]
  (let [specs (map #(if (and (seq? %) (= 'quote (first %))) (second %) %)
  (let [stacktrace (.getStackTrace exception)]
  (let [start-class c]
  (let [step (fn step [recform exprs]
  (let [t (with-meta (gensym "target")
  (let [tag (fn [x] (or (:tag (meta x)) Object))
  (let [target (make-array type (apply + (map count xs)))]
  (let [test (if (coll? val) (set val) #{val})]
  (let [to-groups (fn [seq-exprs]
  (let [token (first context)]
  (let [tr (.getStackTrace ex)]
  (let [v (if (vector? c) c (vec c))]
  (let [v (p/datafy x)]
  (let [v (vec (sort (map (fn [[k v]] (vector k v)) c)))]
  (let [v (with-meta vol {:tag 'clojure.lang.Volatile})]
  (let [va (get a k)
  (let [valf (resolve-fn valf)
  (let [valf (resolve-fn valf)
  (let [var-ize (fn [var-vals]
  (let [w (:w params)
  (let [which-out (try (:out (sh/sh "which" "xdg-open"))
  (let [{:keys [address port name accept args bind-err server-daemon client-daemon]
  (let [{:keys [ancestors reflector]}
  (let [{:keys [cause data via trace]} (Throwable->map o)
  (let [{:keys [file line]} m]
  (let [{:keys [init need-prompt prompt flush read eval print caught]
  (let [{:keys [nrows get-value get-label]} provider]
  (let [{:keys [via trace phase] :or {phase :execution}} datafied-throwable
  (letfn [(inner [form]
  (list 'if test (cons 'do body)))
  (list 'new 'clojure.lang.LazySeq (list* '^{:once true} fn* [] body)))
  (listIterator [this i]
  (listIterator [this] (.listIterator this 0))
  (load "instant"))
  (load (root-resource lib))
  (load-script path))
  (locking clojure.lang.RT/REQUIRE_LOCK
  (loop [[^Character c & r :as s] (seq (.pattern ^java.util.regex.Pattern p))
  (loop [body body
  (loop [c (.read s)]
  (loop [cause t]
  (loop [cause t]
  (loop [child (:parent child)]
  (loop [clauses clauses
  (loop [context initial-context
  (loop [context initial-context
  (loop [context initial-context
  (loop [format format]
  (loop [index (.length s)]
  (loop [index (.length s)]
  (loop [index (int 0)
  (loop [mm {}
  (loop [opts {} [k v & rs :as s] s]
  (loop [ret (set (bases class)) cs ret]
  (loop [ret {} s specs]
  (loop [s (seq coll), lead (seq (drop n coll))]
  (loop [s (seq s)
  (loop [x x, forms forms]
  (loop [x x, forms forms]
  (m/repl
  (make-input-stream x (when opts (apply hash-map opts))))
  (make-output-stream x (when opts (apply hash-map opts))))
  (make-reader (InputStreamReader. is (encoding opts)) opts))
  (make-reader x (when opts (apply hash-map opts))))
  (make-writer (OutputStreamWriter. os (encoding opts)) opts))
  (make-writer x (when opts (apply hash-map opts))))
  (merge
  (merge                                ; create the result map
  (message-el 'error
  (message-el 'failure message (pr-str expected) (pr-str actual)))
  (meta [_] _meta)
  (meta ^{:k :v} (reify Object (toString [this] \"foo\")))
  (methodName [args*] body)*
  (methodName [args*] body)*
  (methodName [args+] body)*
  (methodname [args*] body)
  (methodname [args*] body)
  (more [this]
  (name ([params*] body) ([params+] body) ...)
  (nav [_ _ x] x))
  (nav [coll k v] "return (possibly transformed) v in the context of coll and k (a key/index or nil),
  (newPath [edit ^int level node])
  (newPath [this edit ^int level node]
  (next [this] 
  (nl *out* kind))
  (not (coll? x)))
  (not (divisible? num div)))
  (ns foo.bar
  (nth (seq parent) index))
  (nth [_ i] (.aget am arr (+ off i)))
  (nth [this i not-found]
  (nth [this i]
  (nth coll (rand-int (count coll))))
  (nth parent index))
  (on a File)."
  (or
  (or (.delete (file f))
  (or (:buffer-size opts) 1024))
  (or (:encoding opts) "UTF-8"))
  (or (get (meta x) :type) (class x)))
  (or (instance? Double n)
  (or (instance? Integer n)
  (or (integer? n) (ratio? n) (decimal? n)))
  (or (some (fn [t] (when (every? #(isa? t %) rtypes) t)) rtypes)
  (or (symbol? x)
  (or (when-let [match (re-find #"^[^$]+\$[^$]+" name)]
  (or ({:line-start request-prompt :stream-end request-exit}
  (or ({:line-start request-prompt :stream-end request-exit}
  (or @(:done-nl lb)
  (p/nav coll k v))
  (pa-to-vec (. (pall coll) allUniqueElements)))
  (pa-to-vec (. (pall coll) removeConsecutiveDuplicates)))
  (pa-to-vec (. (pall coll) removeNulls)))
  (par [11 2 3 2] 
  (parse-timestamp (validated construct-calendar) cs))
  (parse-timestamp (validated construct-date) cs))
  (parse-timestamp (validated construct-timestamp) cs))
  (peek [this]
  (persistent!
  (persistent!
  (pop [this]
  (popTail [^int level node])
  (popTail [this level node]
  (postwalk (fn [x] (if (contains? smap x) (smap x) x)) form))
  (postwalk (fn [x] (print "Walked: ") (prn x) x) form))
  (pprint
  (pprint 
  (pprint 
  (pprint 
  (pprint-logical-block :prefix "(" :suffix ")"
  (pprint-logical-block :prefix "(" :suffix ")"
  (pprint-logical-block :prefix "(" :suffix ")"
  (pprint-logical-block :prefix "[" :suffix "]"
  (pprint-logical-block :prefix "[" :suffix "]"
  (pred item) returns logical false. pred must be free of side-effects.
  (pred item) returns logical true. pred must be free of side-effects.
  (pred item) returns logical true. pred must be free of side-effects.
  (pred item) returns logical true. pred must be free of side-effects."
  (pretty-writer base-writer right-margin miser-width))
  (prewalk (fn [x] (if (contains? smap x) (smap x) x)) form))
  (prewalk (fn [x] (if (seq? x) (macroexpand x) x)) form))
  (prewalk (fn [x] (print "Walked: ") (prn x) x) form))
  (print ">")
  (print (apply format fmt args)))
  (print (escape-xml content)))
  (print (str "<" tag))
  (print (str "</" tag ">"))
  (print-args o w)
  (print-calendar c w))
  (print-calendar c w))
  (print-ctor m #(print-map (seq %1) print-dup %2) w))
  (print-ctor o
  (print-ctor o (fn [o w]) w))
  (print-date d w))
  (print-date d w))
  (print-dup (.name n) w)
  (print-map m print-dup w)
  (print-map r pr-on w))
  (print-meta m w)
  (print-meta m w)
  (print-meta o w)
  (print-meta o w)
  (print-meta o w)
  (print-meta r w)
  (print-meta r w)
  (print-meta s w)
  (print-meta v w)
  (print-method (:form o) w))
  (print-method (:form o) w))
  (print-method (:tag o) w)
  (print-method [(symbol (.getClassName o)) (symbol (.getMethodName o)) (.getFileName o) (.getLineNumber o)] w))
  (print-method o w))
  (print-method rep w)
  (print-object o w))
  (print-prefix-map nil m print-one w))
  (print-sequential
  (print-sequential "#{" pr-on " " "}" (seq s) w))
  (print-sequential "(" pr-on " " ")" o w))
  (print-sequential "[" pr-on " " "]" v w))
  (print-sequential "[" print-dup " " "]" o w)
  (print-simple o w))
  (print-simple o w))
  (print-stack-trace (root-cause *e) 8))
  (print-tagged-object o (deref-as-map o) w))
  (print-tagged-object o (str o) w))
  (print-tap-diagnostic (str "expected:" (pr-str (:expected data))))
  (print-throwable o w))
  (print-timestamp ts w))
  (print-timestamp ts w))
  (printf " (%s:%d)" (or (.getFileName e) "") (.getLineNumber e)))
  (printf "%s: %s" (.getName (class tr)) (.getMessage tr))
  (printf "%s=> " (ns-name *ns*)))
  (println "-------------------------")
  (println "<?xml version='1.0' encoding='UTF-8'?>")
  (println "WARNING: add-classpath is deprecated")
  (println "WARNING: clojure.lang.Repl is deprecated.
  (println "WARNING: clojure.lang.Script is deprecated.
  (println "not ok" msg))
  (println "ok" msg))
  (println (:doc (meta (var main)))))
  (println (or spec (str (when n (str (ns-name n) "/")) nm)))
  (println (str "1.." n)))
  (println))
  (prn)
  (proxy [AbstractTableModel] []
  (proxy [Ops$BinaryOp] []
  (proxy [Ops$BinaryPredicate] []
  (proxy [Ops$IntAndObjectPredicate] []
  (proxy [Ops$IntAndObjectToObject] []
  (proxy [Ops$Op] []
  (proxy [Ops$Predicate] []
  (proxy [Ops$Reducer] []
  (proxy [ThreadLocal] []
  (proxy [ThreadLocal] []
  (proxy [TreeModel] []
  (proxy [java.io.Writer] []
  (proxy [java.io.Writer] []
  (push-thread-bindings binding-map)
  (pushTail [^int level ^clojure.core.VecNode parent ^clojure.core.VecNode tailnode])
  (pushTail [this level parent tailnode]
  (reduce
  (reduce
  (reduce
  (reduce #(proc %2) nil coll)
  (reduce (fn [ret [k v]] (f ret k v)) init amap))
  (reduce [_ f init]
  (reduce compose-fixtures default-fixture fixtures))
  (reduce reducef (combinef) coll))
  (reducer coll
  (reducer coll
  (reducer coll
  (removeAll [_ c] (throw (UnsupportedOperationException.)))
  (repl :init (fn []
  (report
  (require '(clojure zip [set :as s]))"
  (require 'clojure.java.browse-ui)
  (resolve-class [this typeref]
  (resolve-class [this typeref] (this typeref))
  (retainAll [_ c] (throw (UnsupportedOperationException.)))
  (reverse
  (reverse 
  (root-cause throwable))
  (rseq [this]
  (satisfies? Inst x))
  (second
  (second
  (seq (let [f \"foo\"] 
  (seq [_] (concat (seq left) (seq right)))
  (seq [this] 
  (seq [this] this)
  (set (map
  (set (map
  (set (map
  (set [_ i e] (throw (UnsupportedOperationException.)))
  (set! *command-line-args* args)
  (set! *depth* (dec *depth*))
  (set! *depth* (inc *depth*)))
  (set! clojure.lang.Agent/pooledExecutor executor))
  (set! clojure.lang.Agent/soloExecutor executor))
  (size [_] cnt)
  (some #{:fred} coll)"
  (sort (map first (ns-publics (the-ns (get (ns-aliases *ns*) ns ns))))))
  (split s #"\r?\n"))
  (start-element 'testcase true {:name name :classname classname}))
  (start-element tag false (if message {:message message} {}))
  (str (:major *clojure-version*)
  (str (let [f \"foo\"] 
  (str \" (:data token) (:trailing-white-space token) \"))
  (str \/
  (str prefix mymethod) (default prefix: \"-\") in a
  (struct compiled-directive (fn [_ a _] (print s) a) nil { :string s } offset))
  (subList [this a z] (subvec this a z))
  (such as 'java.lang.String)"
  (such as Integer/TYPE), any other class (such as Double), or a
  (swap! tapset conj f)
  (swap! tapset disj f)
  (sym @@this))
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (t/with-test-out
  (tailoff [_] 
  (take 100 (for [x (range 100000000) y (range 1000000) :while (< y x)] [x y]))"
  (test-constant1 ... test-constantN)  result-expr
  (test-vars (vals (ns-interns ns))))
  (throw (UnsupportedOperationException. "pprint-tab is not yet implemented")))
  (throw-if (and need-ns (not (find-ns lib)))
  (throw-if (and prefix (pos? (.indexOf (name lib) (int \.))))
  (toArray [this] (into-array Object this))
  (try
  (try
  (try
  (try 
  (try (var-get v)
  (typename
  (typename
  (typename [o] "Returns Java name as returned by ASM getClassName, e.g. byte[], java.lang.String[]"))
  (typename [s] (str/replace (str s) "<>" "[]"))
  (typesym (Type/getObjectType d)))
  (typesym (Type/getType d)))
  (valAt [this k not-found]
  (valAt [this k] (.valAt this k nil))
  (validate-fields fields name)
  (validate-fields fields name)
  (validate-generate-class-options options-map)
  (validate-opts opts)
  (vals (reduce1 (fn [m [msig meth]]
  (vec
  (vec (. pa getArray)))
  (vec (map vectorize (diff-associative
  (walk (partial postwalk f) f form))
  (walk (partial prewalk f) identity (f form)))
  (walk/postwalk-replace (zipmap argv values) expr))
  (when (:message data)
  (when (:splicing? o) (.write w "@"))
  (when (empty? fdecl) (throw (IllegalArgumentException.
  (when (instance? IExceptionInfo ex)
  (when (instance? Throwable ex)
  (when (instance? Throwable ex)
  (when (instance? clojure.lang.IMeta o)
  (when (instance? clojure.lang.IPersistentCollection coll)
  (when (nil? (get opts prop))
  (when (or (not (integer? port)) (not (< -1 port 65535)))
  (when (pos? (.getQueueCount a))
  (when (seq (apply disj (apply hash-set (keys options)) valid-keys))
  (when (seq m)
  (when (seq t/*testing-contexts*)
  (when (some #(-> % first clojure.core/name (.contains "-")) methods)
  (when (some #{path} (rest *pending-paths*))
  (when (some identity maps)
  (when (some identity maps)
  (when *load-tests*
  (when *load-tests*
  (when *load-tests*
  (when *print-namespace-maps*
  (when *report-counters*
  (when arglists
  (when c
  (when c
  (when doc (println " " doc))
  (when forms
  (when full-path
  (when full-path
  (when n
  (when pred
  (when require
  (when-let [^String suffix (:suffix (:logical-block token))] 
  (when-let [^String tws (getf :trailing-white-space)]
  (when-let [cb (getf :logical-block-callback)] (cb :end))
  (when-let [e (agent-error a)]
  (when-let [info (ex-data tr)]
  (when-let [line (.readLine rdr)]
  (when-let [m (meta o)]
  (when-let [parent (.getParentFile ^File (apply file f more))]
  (when-let [t (:test (meta v))]
  (when-let [v (resolve x)]
  (when-not (= target "none")
  (when-not (some #(= eval-opt (init-dispatch (first %))) inits)
  (when-not (vector? fields)
  (with-bindings
  (with-bindings
  (with-bindings
  (with-lock lock
  (with-meta (set (map #(rename-keys % kmap) xrel)) (meta xrel)))
  (with-meta (set (map #(select-keys % ks) xrel)) (meta xrel)))
  (with-meta obj (apply f (meta obj) args)))
  (with-open [^java.io.Writer w (apply jio/writer f options)]
  (with-open [bout (ByteArrayOutputStream.)]
  (with-open [in (-> input FileInputStream. .getChannel)
  (with-open [in (FileInputStream. input)]
  (with-open [in (FileInputStream. input)]
  (with-open [out (FileOutputStream. output)]
  (with-open [out (FileOutputStream. output)]
  (with-open [rdr (clojure.lang.LineNumberingPushbackReader.
  (with-out-str
  (with-test-out
  (with-test-out
  (with-test-out
  (with-test-out
  (with-test-out (inc-report-counter :pass)))
  (with-test-out (prn m)))
  (withMeta [_ m] (new Vec am cnt shift root tail m))
  (write-line this)
  (write-to-base ^String (:data token)))
  (write-to-base ^String (pp-newline))
  (zero? (mod num div)))
  ({"-i"     init-opt
  )
  )
  * = not yet supported
  * All sequential things are treated as associative collections
  * Everything else (including strings!) is treated as
  * For equal a and b, return [nil nil a].
  * Maps are subdiffed where keys match and values differ.
  * Sets are never subdiffed.
  ***This setting implies that the full power of the reader is in play,
  *command-line-args* *1 *2 *3 *e"
  *initial-report-counters*.  Returns the final, dereferenced state of
  *load-tests* true)
  *loaded-libs* (ref (sorted-set)))
  *loading-verbosely* false)
  *local-javadocs* first, then *remote-javadocs*.  Returns a string."
  *out*"
  *pending-paths* ())
  *print-level*, the printer prints '#' to represent it. The root binding
  *print-meta* *print-length* *print-level* *compile-path*
  *report-counters*."
  - the JVM supports only one class with a given name per
  - time-offset is optional (defaults to +00:00)
  - timestamp can elide trailing components
  - we only parse the timestamp format
  -Dclojure.read.eval=unknown, in which case the default binding
  .unread and collapsing CR, LF, and CRLF into a single \\newline. Options
  0.  Also works on strings, arrays, and Java Collections and Maps"
  1.0).  Returns a transducer when no collection is provided."
  2nd key and value, etc. If coll contains no entries, returns init
  :as takes a symbol as its argument and makes that symbol an alias to the
  :author "Jason Sankey"}
  :base                Base to use for writing rationals    Current value of *print-base*
  :circle*             If true, mark circular structures    Current value of *print-circle*
  :clojure.core/eval-file meta are explicitly set on the read value."
  :constructors {[param-types] [super-param-types], ...}
  :continue (the default if an error-handler is given) or :fail (the
  :default
  :default - A function of two args, that will, if present and no reader is found for a tag,
  :dir     override the process dir with a String or java.io.File.
  :disable-locals-clearing - set to true to disable clearing, useful for using a debugger
  :dispatch            The pretty print dispatch function   Current value of *print-pprint-dispatch*
  :elide-meta - a collection of metadata keys to elide during compilation.
  :env     override the process env with a map (or the underlying Java
  :eof - value to return on end-of-file. When not supplied, eof throws an exception.
  :error-handler handler-fn
  :error-mode mode-keyword
  :exclude list-of-symbols
  :exposes {protected-field-name {:get name :set name}, ...}
  :exposes-methods {super-method-name exposed-name, ...}
  :extend-via-metadata true
  :extend-via-metadata true
  :extends [interface ...]
  :extends aclass
  :factory name
  :hierarchy
  :impl-ns name
  :implements [interface ...]
  :in      may be given followed by any legal input source for
  :in-enc  option may be given followed by a String, used as a character
  :incremental and :qualifier keys. Feature releases may increment
  :init name
  :init-impl-ns true. All options of gen-class are
  :length              Maximum elements to show in sublists Current value of *print-length*
  :level               Maximum depth                        Current value of *print-level*
  :lines*              Maximum lines of output              Current value of *print-lines*
  :load-impl-ns boolean
  :load-ns - if true, importing the record class will cause the
  :load-ns - if true, importing the type class will cause the
  :main boolean
  :max-history (default 10)
  :members. In the discussion below, names are always Clojure symbols.
  :meta metadata-map
  :meta metadata-map
  :meta metadata-map
  :methods [ [name [param-types] return-type], ...]
  :methods [ [name [param-types] return-type], ...]
  :min-history (default 0)
  :minor and/or :major, bugfix releases will increment :incremental.
  :miser-width         Width to enter miser mode            Current value of *print-miser-width*
  :name aname
  :name aname
  :no-print true
  :only list-of-symbols
  :out-enc option may be given followed by :bytes or a String. If a
  :post-init name
  :prefix string
  :pretty              If true, do pretty printing          Current value of *print-pretty*
  :radix               If true, prepend a radix specifier   Current value of *print-radix*
  :readably*           If true, print readably              Current value of *print-readably*
  :readers  - a map of tag symbols to data-reader functions to be considered before default-data-readers.
  :refer takes a list of symbols to refer from the namespace or the :all
  :reload forces loading of all the identified libs even if they are
  :reload-all implies :reload and also forces loading of all libs that the
  :rename map-of-fromsymbol-tosymbol
  :ret and :tap vals will be processed by valf, a fn of one argument
  :ret and :tap vals will be processed by valf, a fn of one argument
  :right-margin        The column for the right margin      Current value of *print-right-margin*
  :state name
  :static true}
  :static true}
  :stream              Writer for output or nil             true (indicates *out*)
  :suppress-namespaces If true, no namespaces in symbols    Current value of *print-suppress-namespaces*
  :validator validate-fn
  :validator validate-fn
  :validator validate-fn
  :verbose triggers printing information about each load, alias, and refer
  ; see http://code.google.com/p/clojure-contrib/issues/detail?id=32
  ; the implementation of this function resides in another namespace to be loaded "on demand"
  ; this fixes a bug on mac os x where the process turns into a GUI app
  ;; (is (thrown-with-msg? c re expr))
  ;; (is (thrown? c expr))
  ;; (with re-find) the regular expression re.
  ;; Also asserts that the message string of the exception matches
  ;; Asserts that evaluating expr throws an exception of class c.
  ;; Asserts that evaluating expr throws an exception of class c.
  ;; Returns the exception thrown.
  ;; SimpleDateFormat is not thread-safe, so we use a ThreadLocal proxy for access.
  ;; SimpleDateFormat is not thread-safe, so we use a ThreadLocal proxy for access.
  ;; TODO: detect errors in cases where colon not allowed
  ;; Test if x is an instance of y.
  ;; handles vectors and ranges
  ;; http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4228335
  ;; http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4228335
  ;; neither .getName not .getSimpleName returns the right thing, so best to delegate to Type
  ;; nil test: always fail
  ;; try/catch needed to mask exception on Windows without Cygwin
  ;;(:use [clojure.repl :only (demunge root-cause stack-element-str)])
  ;;aseqs are iterable, masking internal-reducers
  ;;can't fold, single reduce
  ;;for range
  ;;vector's chunked seq is faster than its iter
  ;method signatures
  ;todo - cache
  ;todo - cache
  <classpath>/x/y/, and its root resource is <classpath>/x/y/z.clj, or
  <classpath>/x/y/z.cljc if <classpath>/x/y/z.clj does not exist. The
  == (\\f \\o \\o))
  == \"foo\"
  == {:k :v}"
  => 17"
  => 45
  >=. Returns a reverse seq of those entries with keys ek for
  >=. Returns a seq of those entries with keys ek for
  A 'lib' is a named set of resources in classpath whose contents define a
  A flag is a keyword.
  A libspec is a lib name or a vector containing a lib name followed by
  Adds the url (String or URL object) to the classpath per
  All definitions a lib makes should be in its associated namespace.
  Alpha, subject to change."
  Alpha, subject to change."
  Alpha, subject to change."
  Alpha, subject to change."
  At the commit point of the transaction, sets the value of ref to be:
  By default, constructors are created for the generated class which
  CRLF to a single \\newline."
  Calls out-fn with data, one of:
  Cannot be used to remove the clojure namespace."
  Catches and handles Java exceptions."}
  Chas Emerick, Allen Rohner, and Stuart Halloway",
  Class
  Class objects can be obtained by using their imported or
  ClassLoader
  Clears any exceptions thrown during asynchronous actions of the
  Clojure function or Java class and method."
  Clojure namespace specified by :impl-ns
  Clojure support code for the class as a resource from the classpath,
  Clojure. Default reader tags are defined in
  Closing the input or passing the form :repl/quit will cause it to return
  CollFold
  Collection."
  Comparison rules:
  Consider a lib named by the symbol 'x.y.z; it has the root directory
  Creates new bindings for the (already-existing) vars, with the
  Currently there are no options.
  Default: \"-\" Methods called e.g. Foo will be looked up in vars called
  Default: the name of the current ns. Implementations of methods will be 
  Default: true. Causes the static initializer for the generated class
  Defaults to System/err, wrapped in a PrintWriter"
  Defaults to System/in, wrapped in a LineNumberingPushbackReader"
  Defaults to System/out, wrapped in an OutputStreamWriter"
  Defaults to \"classes\""
  Defaults to current namespace if none given.  Returns a map
  Defaults to false."
  Defaults to false."
  Defaults to false."
  Defaults to true"
  Defaults to true."
  Defines a function"
  Deprecated in 1.2: The information needed for test reporting is
  Does not close any streams except those it opens itself 
  Does not interpret #! as comment to end of line because only one
  Does not print chained exceptions (causes)."
  Does nothing if *report-counters* is nil."
  Dynamically generates compiled bytecode for class with the given
  Dynamically generates compiled bytecode for class with the given
  Each clause can take the form of either:
  Each clause can take the form of either:
  Each spec consists of a protocol or interface name followed by zero
  Each spec consists of a protocol or interface name followed by zero
  Each spec consists of the protocol or interface name followed by zero
  Evaluates body in a try expression with names bound to the values
  Evaluates the exprs in a lexical context in which the symbols in
  Example (will fail): (binding [*read-eval* false] (read-string \"#=(* 2 21)\"))
  Example:
  Example: (apply-template '[x] '(+ x x) '[2])
  Example: (are [x y] (= x y)  
  Example: (is (= 4 (+ 2 2)) \"Two plus two should be 4\")
  Example: (macroexpand '(do-template [x y] (+ y x) 2 4 3 5))
  Example: (source filter)"
  Example: (source-fn 'filter)"
  Executes the exprs in a context in which the symbols are bound to
  Execution then jumps back to the recursion point, a loop or fn method."}
  Expands into a member access (.) of the first member on the first
  Expands to code which creates a instance of a proxy class that
  Expands to: 
  File
  Filter preds remove elements from processing when the array is realized. pred
  Flags
  For data structure interop use clojure.edn/read"
  For data structure interop use clojure.edn/read-string"
  For each clause, (pred test-expr expr) is evaluated. If it returns
  For each name in class-name-symbols, adds a mapping from name to the
  For each public interned var in the namespace named by the symbol,
  Future changes may make these equivalent."
  Given (defrecord TypeName ...), two factory functions will be
  Given (deftype TypeName ...), a factory function called ->TypeName
  HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP."
  Hierarchies are type-like relationships that do not depend upon type
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IOFactory
  IPersistentMap, and all of their superinterfaces.
  If any levels do not exist, hash-maps will be created."
  If during eval an attempt is made to read *in* it will read from in-reader unless :stdin is supplied
  If file is specified but cannot be written, falls back to stderr."
  If metadata-map is supplied, it will become the metadata on the
  If metadata-map is supplied, it will become the metadata on the
  If metadata-map is supplied, it will become the metadata on the
  If not supplied, the constructor args are passed directly to
  If supplied and true, a static public main function will be generated. It will
  If supplied, a (set of) public static factory function(s) will be
  If supplied, a public final instance field with the given name will be
  If supplied, names a function that will be called with the arguments
  If supplied, names a function that will be called with the object as
  If test is true, evaluates then with binding-form bound to the value of
  If the mode is :fail, the agent will become failed and will stop
  If there are multiple such xs, the last one is returned."
  If there are multiple such xs, the last one is returned."
  If true, splicing? indicates read-cond-splicing."
  If you are supplying the definitions explicitly (i.e. not reusing
  IllegalArgumentException is thrown."
  IllegalStateException, else runs body in an implicit do. If the
  In addition, defrecord will define type-and-value-based =,
  In all subsequent sections taking types, the primitive types can be
  In all subsequent sections taking types, the primitive types can be
  In the method bodies, the (unqualified) name can be used to name the
  In the method bodies, the (unqualified) name can be used to name the
  Input may be an InputStream, Reader, File, byte[], char[], or String.
  Interim function preferred over 'require' for known asynchronous loads.
  Internally binds *report-counters* to a ref initialized to
  Interprets comma as whitespace and semicolon as comment to end of line.
  It is sometimes necessary to call the superclass' implementation of an
  It will be called every time an object of this class is created,
  It's common for Clojure code to depend on several libs whose names have
  Iterable
  Its return value is ignored.
  JUnit (http://junit.org/) is the most popular unit-testing library
  JUnit-compatible XML output."
  Java parlance). defprotocol is dynamic, has no special compile-time 
  Java x.equals(y) except it also works for nil, and compares
  JavaReflector is good when you have a class in hand, or use
  Keyword              Meaning                              Default value
  Libs
  Libspecs
  LineNumberingPushbackReader or duplicate its behavior of both supporting
  Map fns will be used to transform elements when the array is
  Method definitions take the form:
  Method definitions take the form:
  Method maps are maps of the keyword-ized method names to ordinary
  Methods should be supplied for all methods of the desired
  Methods should be supplied for all methods of the desired
  Methods should be supplied for all methods of the desired
  Multimethods expect the value of the hierarchy option to be supplied as
  No implementations are provided. Docs can be specified for the
  Normally refs accumulate history dynamically as needed to deal with
  Note - index must be <= (count vector). Returns coll."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to overflow."
  Note - uses a primitive operator subject to truncation."
  Note - uses a primitive operator subject to truncation."
  Note :>> is an ordinary keyword.
  Note that methods with a maximum of 18 parameters are supported.
  Note that multiple independent extend clauses can exist for the same
  Note that read can execute code (controlled by *read-eval*),
  Note that read-string can execute code (controlled by *read-eval*),
  Note that you should not use this interface with deftype or
  Note, expansion captures 'this"
  Note, when binding dynamically make sure to merge with previous value.
  Note: Actually, the test body goes in the :test metadata on the var,
  Note: This breaks some reporting features, such as line numbers."
  Object
  Object
  Object
  Object
  One constructor will be defined, taking the designated fields.  Note
  One or more interfaces, the methods of which will be implemented by the class.
  One or more interfaces, which will be extended by this interface.
  Only elements from start (inclusive) to end (exclusive) will be
  Optional argument is a regular expression; only namespaces with
  Optionally takes one or more elements to populate the vector."
  Options are
  Options are expressed as sequential keywords and arguments (in any order).
  Options are expressed as sequential keywords and arguments (in any order).
  Options are key-value pairs and may be one of:
  Options are key/value pairs and may be one of
  Options should be a set of key/value pairs, all except for :name are
  Options should be a set of key/value pairs, all except for :name are optional:
  Options:
  Opts is a persistent map with valid keys:
  Otherwise returns nil."
  Otherwise returns nil."
  Otherwise, calls test-all-vars on the namespace.  'ns' is a
  Output may be an OutputStream, Writer, or File.
  Paths may be absolute or relative in the filesystem or relative to
  Please use the idiom (seq x) rather than (not (empty? x))"
  Pops the installed bindings after f returned. Returns whatever f returns."
  Possible values of :qualifier include \"GA\", \"SNAPSHOT\", \"RC-x\" \"BETA-x\""
  Prefix Lists
  Prints a maximum of n stack frames (default: unlimited).
  Reader tags without namespace qualifiers are reserved for
  Reads data in the edn format (subset of Clojure data):
  Reads data in the edn format (subset of Clojure data):
  Recognized flags: :reload, :reload-all, :verbose
  Recognized options:
  Recognizes all Clojure data structures. Consumes seqs as with doall."
  Recognizes all Clojure data structures. Consumes seqs as with doall."
  Reflector
  Reflector
  Remaining body goes in the :test metadata function for that Var.
  Remember f in order to remove-tap"
  Repeatedly executes body (presumably for side-effects) with name
  Repeatedly executes body (presumably for side-effects) with name
  Returns [old new], the value of the atom before and after the swap."
  Returns a new hash map with supplied mappings.  If any keys are
  Returns a new sorted map with supplied mappings, using the supplied
  Returns a new sorted map with supplied mappings.  If any keys are
  Returns a sequence of the exceptions thrown during asynchronous
  Returns a stateful transducer when no collection is provided."
  Returns a stateful transducer when no collection is provided."
  Returns a stateful transducer when no collection is provided."
  Returns a transducer when no collection is provided."
  Returns a transducer when no collection is provided."
  Returns a transducer when no collection is provided."
  Returns a transducer when no collection is provided."
  Returns a vector containing the object read and the (whitespace-trimmed) string read."
  Returns the proxy."
  Returns true if server stopped successfully, nil if not found, or throws if
  Returns val."
  Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once"
  Runs the exprs (in an implicit do) in a transaction that encompasses
  See also:
  See also: *"
  See also: +"
  See also: -"
  See also: dec"
  See also: inc"
  See clojure.java.io/reader for a complete list of supported arguments."
  See clojure.template/do-template for an explanation of
  See set-error-handler!"
  Seqs cache values, thus iterator-seq should not be used on any
  Sets :test metadata of the named var to a fn with the given body.
  Short, Byte and Clojure collections."
  Since the implementations of the methods of the generated class
  Special forms:
  Specifies the superclass, the non-private methods of which will be
  String
  String naming a URI. Returns a tree of the xml/element struct-map,
  StringReader initialized with the string s."
  StringWriter.  Returns the string created by any nested printing
  Subsequently, in a thread from a thread pool, the state of the agent
  Subsequently, in a thread supplied by executor, the state of the agent
  Supported options:
  Supported options:
  Supported options:
  TAP is a simple text-based syntax for reporting test results.  TAP
  TAP output"
  Takes a map of Var/value pairs. Binds each Var to the associated value for
  Takes a vector of function specs and a body, and generates a set of
  Temporarily redefines Vars while executing the body.  The
  The argument and return types can be hinted on the arg and
  The argument and return types can be hinted on the arg and
  The arguments and semantics for :exclude, :only, and :rename are the same
  The class will have implementations of several (clojure.lang)
  The class will have the (by default, immutable) fields named by
  The class will have the (immutable) fields named by
  The default binding can be controlled by the system property
  The default dispatch value, defaults to :default
  The docstring and attr-map are optional.
  The first line summarizes the exception phase and location.
  The first symbol in each pair is a tag that will be recognized by
  The following would load the libraries clojure.zip and clojure.set
  The generated class automatically defines all of the non-private
  The init options may be repeated and mixed freely, but must appear before
  The interfaces names must be valid interface types. If a method fn
  The line number on re-read is the passed line-number unless :line or
  The method return types and parameter types may be specified with type hints,
  The package-qualified name of the class to be generated
  The package-qualified name of the class to be generated
  The return type can be indicated by a type hint on the method name,
  The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN,
  The skip-check is a set of case ints for which post-switch equivalence
  The subsequent lines describe the cause."
  The system property can also be set to 'unknown' via
  The test-constants are not evaluated. They must be compile-time
  The value used for hierarchical dispatch (e.g. ::square is-a ::shape)
  The var must already exist.  Does not modify the value of the var.
  They all expand into calls to the dot operator at macroexpansion time."}
  This function may (briefly) block (e.g. for streams), and will never impede calls to tap>,
  This may be used to define a helper function which runs on a different
  This parameter is used to specify the signatures of the methods of
  This requires that the symbol resolve to a Var defined in a
  Throwable
  Thus fun should be commutative, or, failing that, you must accept
  To use this library, wrap any calls to
  To use, wrap any calls to clojure.test/run-tests in the
  To write the output to a file, rebind clojure.test/*test-out* to
  Tries *local-javadocs* first, then *remote-javadocs*."
  Two constructors will be defined, one taking the designated fields
  Type
  URI
  URL
  URLClassLoader.addURL"
  Unlike cond and condp, case does a constant-time dispatch, the
  UnsupportedOperationException will be thrown should it be
  Usage: (with-precision 10 (/ 1M 3))
  Useful for mocking out functions during testing."
  Uses thread-stopper if no function given."
  When *load-tests* is false, deftest is ignored."
  When *load-tests* is false, only evaluates the definition, ignoring
  When *load-tests* is false, set-test is ignored."
  When :extend-via-metadata is true, values can extend protocols by
  When AOT compiling, generates compiled bytecode for a class with the
  When AOT compiling, generates compiled bytecode for a class with the
  When Clojure starts, it searches for files named 'data_readers.clj'
  When set to logical false in the thread-local binding,
  When test is true, evaluates body with binding-form bound to the value of test"
  When there is no file, e.g. in the REPL, the value is not defined."
  Will release the monitor of x in all circumstances."
  With no options or args, runs an interactive Read-Eval-Print Loop
  You can bind :env or :dir for multiple operations using with-sh-env
  You don't call this."
  You might get more than one :out or :err per eval, but exactly one :ret
  [ & directives ]
  [ format-str ]
  [& agents]
  [& args]
  [& args]
  [& args]
  [& args]
  [& args]
  [& args]
  [& args]
  [& args]
  [& args] (apply load-libs :require :use args))
  [& bases]
  [& body]
  [& body]
  [& body]
  [& body]
  [& body]
  [& body]
  [& body]
  [& body]
  [& body]
  [& body] `(future-call (^{:once true} fn* [] ~@body)))
  [& body])
  [& clauses]
  [& colls]
  [& exprs]
  [& exprs]
  [& filters]
  [& fns] (pmap #(%) fns))
  [& fntail]
  [& import-symbols-or-lists]
  [& keys]
  [& maps]
  [& more]
  [& more]
  [& more]
  [& names] `(do ~@(map #(list 'def (vary-meta % assoc :declared true)) names)))
  [& options]
  [& options]
  [& options]
  [& options]
  [& opts+specs]
  [& pairs]
  [& paths]
  [& sigs]
  [& vars]
  [& vars]
  [& xforms]
  [& xs]
  [& xs]
  [& xs]
  [& xs]
  [& {:keys [valf] :or {valf pr-str}}]
  [(. meth (getName)) (seq (. meth (getParameterTypes))) (. meth getReturnType)])
  [(cond 
  [(into {} (for [[k [v1 v2]] m] [k v1]))
  [(symbol (.getClassName o)) (symbol (.getMethodName o)) (.getFileName o) (.getLineNumber o)])
  [[^String p offset]]
  [[_ & args] inits]
  [[_ main-ns & args] inits]
  [[f1 k] fkv]
  [[name flag & contexts]]
  [[path & args] inits]
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  []
  [] (. clojure.lang.Agent shutdown))
  [] (clojure.lang.Agent/releasePendingSends))
  [] (clojure.lang.Namespace/all))
  [] @*loaded-libs*)
  [] `(pprint *1))
  [] {:parents {} :descendants {} :ancestors {}})
  [^CharSequence cs]
  [^CharSequence cs]
  [^CharSequence cs]
  [^CharSequence replacement]
  [^CharSequence s ^CharSequence substr]
  [^CharSequence s ^Character match replace]
  [^CharSequence s ^Pattern re f]
  [^CharSequence s ^String match ^String replace]
  [^CharSequence s ^String substr]
  [^CharSequence s ^String substr]
  [^CharSequence s cmap]
  [^CharSequence s match replacement]
  [^CharSequence s match replacement]
  [^CharSequence s re f]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^CharSequence s]
  [^Class c x]
  [^Class c]
  [^Class class]
  [^Class cls]
  [^Class cls]
  [^Class cls]
  [^IPersistentMap this o]
  [^IProxy proxy mappings]
  [^IProxy proxy mappings]
  [^IProxy proxy]
  [^InputStream is opts]
  [^Number x] (clojure.lang.RT/byteCast x))
  [^Number x] (clojure.lang.RT/doubleCast x))
  [^Number x] (clojure.lang.RT/floatCast x))
  [^Number x] (clojure.lang.RT/longCast x))
  [^Number x] (clojure.lang.RT/shortCast x))
  [^Number x] (clojure.lang.RT/uncheckedByteCast x))
  [^Number x] (clojure.lang.RT/uncheckedDoubleCast x))
  [^Number x] (clojure.lang.RT/uncheckedFloatCast x))
  [^Number x] (clojure.lang.RT/uncheckedIntCast x))
  [^Number x] (clojure.lang.RT/uncheckedLongCast x))
  [^Number x] (clojure.lang.RT/uncheckedShortCast x))
  [^Object f]
  [^Object x]
  [^OutputStream os opts]
  [^Socket conn name client-id in out err accept args]
  [^StackTraceElement el]
  [^StackTraceElement el]
  [^StackTraceElement o]
  [^String class-name]
  [^String classname]
  [^String d]
  [^String full-path]
  [^String full-path]
  [^String host port ^Reader
  [^String md]
  [^String name daemon & body]
  [^String path]
  [^String s]
  [^String s]
  [^Throwable e]
  [^Throwable ex class-name]
  [^Throwable exception depth]
  [^Throwable o]
  [^Throwable t & {:keys [target]
  [^Throwable t]
  [^Throwable t]
  [^Writer this 
  [^Writer this ^String s] 
  [^clojure.lang.Agent a f & args]
  [^clojure.lang.Agent a f & args]
  [^clojure.lang.Agent a, handler-fn]
  [^clojure.lang.Agent a, mode-keyword]
  [^clojure.lang.Agent a, new-state & options]
  [^clojure.lang.Agent a]
  [^clojure.lang.Agent a]
  [^clojure.lang.Agent a] (.getError a))
  [^clojure.lang.Agent a] (restart-agent a (.deref a)))
  [^clojure.lang.IAtom atom newval] (.reset atom newval))
  [^clojure.lang.IAtom atom oldval newval] (.compareAndSet atom oldval newval))
  [^clojure.lang.IEditableCollection coll]
  [^clojure.lang.IPending x] (.isRealized x))
  [^clojure.lang.IRef iref validator-fn] (. iref (setValidator validator-fn)))
  [^clojure.lang.IRef reference key fn] (.addWatch reference key fn))
  [^clojure.lang.IRef reference key]
  [^clojure.lang.ITransientCollection coll]
  [^clojure.lang.ITransientVector coll]
  [^clojure.lang.MultiFn multifn dispatch-val func]
  [^clojure.lang.MultiFn multifn dispatch-val-x dispatch-val-y]
  [^clojure.lang.MultiFn multifn dispatch-val] (.getMethod multifn dispatch-val))
  [^clojure.lang.MultiFn multifn] (.getMethodTable multifn))
  [^clojure.lang.MultiFn multifn] (.getPreferTable multifn))
  [^clojure.lang.Named x]
  [^clojure.lang.Ref ref fun & args]
  [^clojure.lang.Ref ref fun & args]
  [^clojure.lang.Ref ref val]
  [^clojure.lang.Ref ref]
  [^clojure.lang.Ref ref]
  [^clojure.lang.Reversible rev]
  [^clojure.lang.Sorted sc test key]
  [^clojure.lang.Symbol tag form]
  [^clojure.lang.Var v f & args] (.alterRoot v f args))
  [^clojure.lang.Var x val] (. x (set val)))
  [^clojure.lang.Var x] (. x (get)))
  [^clojure.lang.Volatile vol newval]
  [^java.io.BufferedReader rdr]
  [^java.io.Writer writer]
  [^java.io.Writer writer]
  [^java.io.Writer writer]
  [^java.io.Writer writer]
  [^java.lang.reflect.Constructor constructor]
  [^java.lang.reflect.Field field]
  [^java.lang.reflect.Method method]
  [^java.sql.ResultSet rs]
  [^java.sql.Timestamp ts, ^java.io.Writer w]
  [^java.sql.Timestamp ts, ^java.io.Writer w]
  [^java.sql.Timestamp ts, ^java.io.Writer w]
  [^java.util.Calendar c, ^java.io.Writer w]
  [^java.util.Calendar c, ^java.io.Writer w]
  [^java.util.Calendar c, ^java.io.Writer w]
  [^java.util.Collection acc x]
  [^java.util.Collection coll]
  [^java.util.Collection coll]
  [^java.util.Date d, ^java.io.Writer w]
  [^java.util.Date d, ^java.io.Writer w]
  [^java.util.Date d, ^java.io.Writer w]
  [^java.util.Map$Entry e]
  [^java.util.Map$Entry e]
  [^java.util.concurrent.Future f] (.cancel f true))
  [^java.util.concurrent.Future f] (.isCancelled f))
  [^java.util.concurrent.Future f] (.isDone f))
  [^java.util.regex.Matcher m]
  [^java.util.regex.Pattern re s]
  [^java.util.regex.Pattern re s]
  [^java.util.regex.Pattern re s]
  [^long hash-basis ^long count] (clojure.lang.Murmur3/mixCollHash hash-basis count))
  [_ _]
  [_ f init]
  [a b k]
  [a b ks]
  [a b]
  [a b]
  [a b]
  [a idx ret expr]
  [a idx ret init expr]
  [a]
  [alias namespace-sym]
  [alis]
  [amap f init]
  [amap f init]
  [arg]
  [arglist]
  [args inits]
  [args inits]
  [args]
  [args]
  [args]
  [argv expr & args]
  [argv expr & values]
  [argv expr values]
  [array] (. clojure.lang.RT (aclone array)))
  [array] (. clojure.lang.RT (alength array)))
  [aseq val]
  [atype & proto+mmaps]
  [base val]
  [base val]
  [base val]
  [base-writer right-margin miser-width]
  [binding-map & body]
  [binding-map f & args]
  [binding-map func]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings & body]
  [bindings]
  [branch? children make-node root]
  [c & ctor-args]
  [c]
  [case-f test-f tests thens]
  [char, 
  [class-and-interfaces args & fs]
  [class-or-object]
  [clazz method]
  [coll f val]
  [coll k v]
  [coll key] (. clojure.lang.RT (contains coll key)))
  [coll n combinef reducef]
  [coll n combinef reducef]
  [coll n]
  [coll n]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll]
  [coll] 
  [coll] (. clojure.lang.RT (peek coll)))
  [coll] (. clojure.lang.RT (pop coll)))
  [coll] (. clojure.lang.RT (toArray coll)))
  [coll] (clojure.lang.Cycle/create (seq coll)))
  [coll] (clojure.lang.Murmur3/hashOrdered coll))
  [coll] (clojure.lang.Murmur3/hashUnordered coll))
  [coll] (clojure.lang.RT/count coll))
  [coll] (instance? clojure.lang.Associative coll))
  [coll] (instance? clojure.lang.Counted coll))
  [coll] (instance? clojure.lang.Indexed coll))
  [coll] (instance? clojure.lang.Reversible coll))
  [coll] (instance? clojure.lang.Sequential coll))
  [coll] (instance? clojure.lang.Sorted coll))
  [coll] (not (seq coll)))
  [coll] (when (seq coll) coll))
  [content]
  [d]
  [data]
  [data]
  [datafied-throwable]
  [def params flags offset]
  [definition & body]
  [dir & forms]
  [dir]
  [e & clauses]
  [e]
  [e]
  [e]
  [env & forms]
  [ex phase]
  [ex]
  [ex]
  [ex]
  [executor ^clojure.lang.Agent a f & args]
  [executor]
  [executor]
  [expr & clauses]
  [expr & clauses]
  [expr & forms]
  [expr & forms]
  [expr name & forms]
  [expr-sym default tests thens]
  [expr-sym default tests thens]
  [expr]
  [f & [silently]]
  [f & maps]
  [f & more]
  [f base coll]
  [f coll]
  [f coll]
  [f coll]
  [f content & options]
  [f form]
  [f form]
  [f x] (clojure.lang.Iterate/create f x) )
  [f1 f2]
  [f]
  [f]
  [f]
  [f]
  [f]
  [f]
  [f]
  [f]
  [f]
  [fdecl]
  [fields name]
  [fixtures]
  [flags context]
  [flags-ignored-for-now & body]
  [flush-fn close-fn]
  [fmt & args]
  [fn-name]
  [fn-name]
  [fnspecs & body]
  [form ^Boolean splicing?]
  [form]
  [form]
  [form]
  [form]
  [form]
  [form]
  [form] (. clojure.lang.Compiler (eval form)))
  [format-in]
  [format-in]
  [format]
  [format]
  [function & body]
  [function]
  [hashes]
  [in-reader out-fn & {:keys [stdin]}]
  [in]
  [inner outer form]
  [input output & opts]
  [inst]
  [ints]
  [iter]
  [k coll]
  [key coll]
  [keys vals]
  [kind colnum colinc] 
  [kind] 
  [lib need-ns require]
  [lib need-ns require]
  [lib]
  [lib]
  [lib]
  [loc f & args]
  [loc item]
  [loc item]
  [loc item]
  [loc item]
  [loc node children]
  [loc node]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc]
  [loc] (loc 0))
  [lock-expr & body]
  [m [k & ks] v]
  [m e]
  [m k]
  [m n combinef reducef]
  [m v1]
  [m]
  [m]
  [m]
  [m]
  [m]
  [m]
  [m]
  [m] (reduce (fn [m [k v]] (assoc m v k)) {} m))
  [map key] (. clojure.lang.RT (find map key)))
  [map keyseq]
  [map kmap]
  [map] (. clojure.lang.RT (keys map)))
  [map] (. clojure.lang.RT (vals map)))
  [maybe-p]
  [message expected actual]
  [message expected actual]
  [meth & args]
  [mm-name & options]
  [msg form]
  [msg form]
  [msg form]
  [msg]
  [msg]
  [msg]
  [multifn dispatch-val & fn-tail]
  [n coll]
  [n coll]
  [n coll]
  [n coll]
  [n coll]
  [n x] (take n (repeat x)))
  [n]
  [n]
  [n]
  [n]
  [n]
  [n]
  [n] (instance? BigDecimal n))
  [n] (instance? clojure.lang.Ratio n))
  [n] (int (rand n)))
  [n] (not (even? n)))
  [name & args]
  [name & body]
  [name & body]
  [name & body]
  [name & decl]
  [name & decls]
  [name & keys]
  [name & opts+sigs]
  [name & references]
  [name & sigs]
  [name classname]
  [name declaring-class parameter-types exception-types flags])
  [name doc meta args & body]
  [name doc meta args body]
  [name expr]
  [name fields & opts+specs]
  [name fields & opts+specs]
  [name return-type declaring-class parameter-types exception-types flags])
  [name type declaring-class flags])
  [name-vals-vec & body]
  [name]
  [name]
  [name]
  [name]
  [name]
  [named]
  [new-instance]
  [nom classname fields]
  [ns sym]
  [ns sym]
  [ns-sym & filters]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [ns]
  [nsname]
  [num div]
  [num div]
  [num div]
  [num div]
  [num div]
  [num]
  [num]
  [num]
  [num] (. clojure.lang.Numbers (isNeg num)))
  [num] (. clojure.lang.Numbers (isPos num)))
  [num] (. clojure.lang.Numbers (isZero num)))
  [obj & options]
  [object & kw-args]
  [object]
  [op ctor]
  [opt]
  [opt]
  [options & valid-keys]
  [opts prop]
  [opts]
  [opts]
  [p & specs]
  [p (zipmap (map #(-> % first keyword) fs)
  [pa] (pa-to-vec (pall pa)))
  [package classname]
  [package-prefix url]
  [params body]
  [parts offset]
  [path]
  [path]
  [path]
  [precision & exprs]
  [pred coll]
  [pred coll]
  [pred coll]
  [pred coll]
  [pred coll]
  [pred coll]
  [pred coll]
  [pred expr & clauses]
  [pred fmt & args]
  [pred xset]
  [pred]
  [prefix arg & more-args]
  [prefix lib & options]
  [proc coll]
  [promise val] (promise val))
  [props]
  [protocol atype]
  [protocol x]
  [protocol]
  [r]
  [r]
  [rdr] (. clojure.lang.Compiler (load rdr)))
  [re-string-or-pattern]
  [reference]
  [relative-to n] 
  [request-prompt request-exit]
  [request-prompt request-exit]
  [rf]
  [rf]
  [root]
  [root]
  [root]
  [root]
  [s & body]
  [s & inits]
  [s & vals]
  [s c]
  [s c]
  [s f val]
  [s first?]
  [s key]
  [s]
  [s]
  [s]
  [s]
  [s]
  [s]
  [s] (if (instance? java.util.regex.Pattern s)
  [seq-exprs & body]
  [seq-exprs body-expr]
  [set1 set2]
  [set1 set2]
  [smap form]
  [smap form]
  [stacktrace]
  [str-or-pattern]
  [str]
  [stream enc]
  [string & body]
  [summary]
  [sym new-val]
  [sym]
  [sym]
  [sym] (. clojure.lang.Var (find sym)))
  [sym] (clojure.lang.Namespace/find sym))
  [sym] (clojure.lang.Namespace/findOrCreate sym))
  [sym] (clojure.lang.Namespace/remove sym))
  [system-props]
  [t & specs]
  [t]
  [table params navigator offsets]
  [tag message expected-str actual-str]
  [tag pretty & [attrs]]
  [tag pretty]
  [tagname cname fields interfaces methods opts]
  [tagname cname fields interfaces methods opts]
  [test & body]
  [test & body]
  [test & body]
  [tests thens skip-check-set] where no tests have the same hash. Each set of
  [tests thens]
  [things-only-in-a things-only-in-b things-in-both].
  [throwable]
  [timeout-ms & agents]
  [to from]
  [to from]
  [tr]
  [tr]
  [type & xs]
  [typeref & options]
  [typeref]
  [url]
  [url]
  [url]
  [url]
  [v n combinef reducef]
  [v n combinef reducef]
  [v]
  [v]
  [v]
  [v] (instance? clojure.lang.Var v))
  [val]
  [value]
  [value]
  [vars]
  [vars]
  [vol f & args]
  [writer format-in & args]
  [writer]
  [x & body]
  [x & forms]
  [x & forms]
  [x & forms]
  [x & opts]
  [x & opts]
  [x & opts]
  [x & opts]
  [x coll]
  [x n] (. clojure.lang.Numbers clearBit x n))
  [x n] (. clojure.lang.Numbers flipBit x n))
  [x n] (. clojure.lang.Numbers setBit x n))
  [x n] (. clojure.lang.Numbers shiftLeft x n))
  [x n] (. clojure.lang.Numbers shiftRight x n))
  [x n] (. clojure.lang.Numbers testBit x n))
  [x n] (. clojure.lang.Numbers unsignedShiftRight x n))
  [x w]
  [x y] (. clojure.lang.Numbers (unchecked_add x y)))
  [x y] (. clojure.lang.Numbers (unchecked_int_add x y)))
  [x y] (. clojure.lang.Numbers (unchecked_int_divide x y)))
  [x y] (. clojure.lang.Numbers (unchecked_int_multiply x y)))
  [x y] (. clojure.lang.Numbers (unchecked_int_remainder x y)))
  [x y] (. clojure.lang.Numbers (unchecked_int_subtract x y)))
  [x y] (. clojure.lang.Numbers (unchecked_minus x y)))
  [x y] (. clojure.lang.Numbers (unchecked_multiply x y)))
  [x y] (. clojure.lang.Util (compare x y)))
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x]
  [x] (. clojure.lang.Delay (force x)))
  [x] (. clojure.lang.Numbers (dec x)))
  [x] (. clojure.lang.Numbers (decP x)))
  [x] (. clojure.lang.Numbers (inc x)))
  [x] (. clojure.lang.Numbers (incP x)))
  [x] (. clojure.lang.Numbers (num x)))
  [x] (. clojure.lang.Numbers (unchecked_dec x)))
  [x] (. clojure.lang.Numbers (unchecked_inc x)))
  [x] (. clojure.lang.Numbers (unchecked_int_dec x)))
  [x] (. clojure.lang.Numbers (unchecked_int_inc x)))
  [x] (. clojure.lang.Numbers (unchecked_int_negate x)))
  [x] (. clojure.lang.Numbers (unchecked_minus x)))
  [x] (. clojure.lang.Numbers not x))
  [x] (. clojure.lang.RT (charCast x)))
  [x] (. clojure.lang.RT (intCast x)))
  [x] (. clojure.lang.RT (uncheckedCharCast x)))
  [x] (. clojure.lang.Util (hasheq x)))
  [x] (and (ident? x) (nil? (namespace x))))
  [x] (and (instance? clojure.lang.IDeref x) (:pretty-writer @@x)))
  [x] (and (int? x)
  [x] (and (int? x)
  [x] (and (int? x)
  [x] (and (keyword? x) (nil? (namespace x))))
  [x] (and (symbol? x) (nil? (namespace x))))
  [x] (boolean (and (ident? x) (namespace x) true)))
  [x] (boolean (and (keyword? x) (namespace x) true)))
  [x] (boolean (and (symbol? x) (namespace x) true)))
  [x] (clojure.lang.RT/booleanCast x))
  [x] (clojure.lang.RT/canSeq x))
  [x] (clojure.lang.Util/identical x false))
  [x] (clojure.lang.Util/identical x nil))
  [x] (clojure.lang.Util/identical x true))
  [x] (cond
  [x] (cond
  [x] (cond
  [x] (fn [& args] x))
  [x] (if (nil? x)
  [x] (if x false true))
  [x] (instance? Boolean x))
  [x] (instance? Class x))
  [x] (instance? Double x))
  [x] (instance? clojure.lang.Delay x))
  [x] (instance? clojure.lang.Fn x))
  [x] (instance? clojure.lang.IFn x))
  [x] (instance? clojure.lang.IPersistentCollection x))
  [x] (instance? clojure.lang.IPersistentList x))
  [x] (instance? clojure.lang.IPersistentSet x))
  [x] (instance? clojure.lang.Keyword x))
  [x] (instance? clojure.lang.Symbol x))
  [x] (instance? java.net.URI x))
  [x] (instance? java.util.UUID x))
  [x] (instance? java.util.concurrent.Future x))
  [x] (not (nil? x)))
  [x] (or (instance? Long x)
  [x] (or (keyword? x) (symbol? x)))
  [x] true)
  [x] x)
  [xrel kmap]
  [xrel ks]
  [xrel ks]
  [xs] `(. clojure.lang.Numbers booleans ~xs))
  [xs] `(. clojure.lang.Numbers bytes ~xs))
  [xs] `(. clojure.lang.Numbers chars ~xs))
  [xs] `(. clojure.lang.Numbers doubles ~xs))
  [xs] `(. clojure.lang.Numbers floats ~xs))
  [xs] `(. clojure.lang.Numbers ints ~xs))
  [xs] `(. clojure.lang.Numbers longs ~xs))
  [xs] `(. clojure.lang.Numbers shorts ~xs))
  [year]
  [years months days hours minutes seconds nanoseconds
  [years months days hours minutes seconds nanoseconds
  [years months days hours minutes seconds nanoseconds
  [{:clojure.error/keys [phase source path line column symbol class cause spec]
  [{:keys [methods]}]
  [{:keys [name extends methods]}]
  [{:keys [name port accept] :as opts}]
  \\newline. repl-read:
  \\newline."
  ^Class [^Object x] (if (nil? x) x (. x (getClass))))
  ^Class [typeref classloader]
  ^GregorianCalendar
  ^String [fmt & args]
  ^clojure.lang.IPersistentVector [^clojure.lang.IAtom2 atom newval] (.resetVals atom newval))
  ^clojure.lang.Namespace [x]
  ^long
  ^long
  ^long
  ^{:author "Chris Houser, Christophe Grand, Stephen Gilardi, Michel Salim"
  ^{:author "Chris Houser, Stuart Halloway",
  ^{:author "Christophe Grand",
  ^{:author "Christophe Grand, Stuart Sierra",
  ^{:author "Stuart Halloway",
  ^{:author "Stuart Sierra",
  ^{:author "Stuart Sierra, Chas Emerick, Stuart Halloway",
  ^{:author "Stuart Sierra, with contributions and suggestions by 
  ^{:doc "Generic reporting function, may be overridden to plug in
  ^{:doc "Internal helper for copy"
  ^{:doc "Sets the value at the index/indices. Works on arrays of boolean. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of byte. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of char. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of double. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of float. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of int. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of long. Returns val."
  ^{:doc "Sets the value at the index/indices. Works on arrays of short. Returns val."
  ^{:doc "True by default.  If set to false, no test functions will
  ^{:macro true
  ^{:private true
  ^{:private true
  ^{:private true :doc
  ^{:private true}
  __extmap, __hash and __hasheq are currently reserved and should not
  `((fn loading# []
  `(. clojure.lang.LockingTransaction
  `(. ~(with-meta multifn {:tag 'clojure.lang.MultiFn}) addMethod ~dispatch-val (fn ~@fn-tail)))
  `(alter @~'this assoc ~sym ~new-val))
  `(alter-meta! (var ~name) merge (assoc ~meta :doc ~docstring)))
  `(binding [*ns* *ns*
  `(binding [*out* *test-out*]
  `(binding [*print-pprint-dispatch* ~function]
  `(binding [*read-eval* (if (= :unknown *read-eval*) true *read-eval*)]
  `(binding [*sh-dir* ~dir]
  `(binding [*sh-env* ~env]
  `(binding [*testing-contexts* (conj *testing-contexts* ~string)]
  `(binding [t/report junit-report
  `(binding [t/report tap-report]
  `(bound-fn* (fn ~@fntail)))
  `(clojure.core/refer '~'clojure.core ~@filters))
  `(concat ~@(map #(list `lazy-seq %) colls)))
  `(def ^{:private true}
  `(def ~name (create-struct ~@keys)))
  `(do
  `(do (when-not ~(first pairs)
  `(do-report {:type :fail, :message ~msg}))
  `(doseq [v# (dir-fn '~nsname)]
  `(doto (Thread. (fn [] ~@body) ~name)
  `(fn
  `(let [^Writer w# (getf :base)]
  `(let [a# ~a l# (alength a#)
  `(let [a# ~a l# (alength a#)]
  `(let [am# (ams ~t)]
  `(let [base-writer# ~base-writer
  `(let [format-in# ~format-in
  `(let [format-in# ~format-in
  `(let [klass# ~(nth form 1)
  `(let [lockee# ~(with-meta lock-expr {:tag 'java.util.concurrent.locks.ReentrantLock})]
  `(let [lockee# ~x]
  `(let [s# (new java.io.StringWriter)]
  `(let [start# (. System (nanoTime))
  `(let [v# (def ~name)]
  `(let [value# ~form]
  `(let [~@(interleave (take-nth 2 name-vals-vec)
  `(let [~name ~expr
  `(let* ~(destructure bindings) ~@body))
  `(letfn* ~(vec (interleave (map first fnspecs)
  `(loop []
  `(pcalls ~@(map #(list `fn [] %) exprs)))
  `(prerr ~@(cons (list 'quote prefix) (mapcat #(list (list 'quote %) "=" %)
  `(println (or (source-fn '~n) (str "Source not found"))))
  `(sync nil ~@exprs))
  `(throw (RuntimeException. ~msg)))
  `(try
  `(try ~(assert-expr msg form)
  `(with-bindings* ~binding-map (fn [] ~@body)))
  `(with-open [s# (-> (java.io.StringReader. ~s) clojure.lang.LineNumberingPushbackReader.)]
  `(with-redefs-fn ~(zipmap (map #(list `var %) (take-nth 2 bindings))
  `(~sym @@~'this))
  a :clear-actions true option is given, any actions queued on the
  a Comparator comp is supplied"
  a Comparator comp is supplied"
  a Seqable object that will invoke the body only the first time seq
  a Var.  After func is called with no args, the root values of all
  a failed agent is restarted with :clear-actions true or shutdown-agents was called."
  a first-class fn. name may be type-hinted with the method receiver's
  a fn, in which case the corresponding method will revert to the
  a function (not a macro)."
  a function called (str prefix main).
  a namespace for which the .clj is in the classpath.  Returns nil if
  a namespace or namespace alias. Looks for aliases in *ns*"
  a nil first argument to f with the supplied value x. Higher arity
  a parser"
  a quoted expression using the symbols in argv.  values is a sequence
  a reference type e.g. a var (i.e. via the Var-quote dispatch macro #'
  a transducer when no collections are provided"
  abbreviated as 's'.
  accept 2 arguments, index and item. Returns a stateful transducer when
  accepted"
  accepting new 'send' and 'send-off' actions, and any previously
  action that caused the error nor the error itself ever happened.
  action throws an exception or if validate-fn rejects a new state --
  actions immediately. This has no impact on actions sent during a
  actions of the agent."
  adding metadata where keys are fully-qualified protocol function
  adds a mapping from the name of the var to the var to the current
  after the first true test expression."
  after trampoline returns."
  agent and the exception."
  agent if the agent is failed.  Returns nil if the agent is not
  agent immediately. Subsequently, in a separate thread, the state of
  agent that were being held while it was failed will be discarded,
  agent will remain failed with its old state and error.  Watchers, if
  agent, allowing subsequent actions to occur."
  agent. validate-fn must be nil or a side-effect-free fn of one
  also works for strings, Java arrays, regex Matchers and Lists, and,
  an exception) will be the return value of the transducer. If retf
  an initial value as with sequential reduce."
  an interface to a protocol. This is primarily to facilitate interop
  and 'data_readers.cljc' at the root of the classpath. Each such file
  and :main below) will be found similarly prefixed. By default, the
  and a corresponding sequence of then expressions. Returns a tuple of
  and any supplied args and return the new value, and returns a new
  and any supplied args and return the new value, and returns a new
  and arg types can be indicated by a type hint on arg names. If you
  and as such should be used only with trusted sources.
  and as such should be used only with trusted sources.
  and counted. The single argument version will build a combining fn
  and enumeration.  See Huet"
  and f is not called. Note that reduce-kv is supported on vectors,
  and its value will be returned if no clause matches. If no default
  and map->TypeName, taking a map of keywords to field values."
  and no clause matches, an IllegalArgumentException is thrown.
  and return value named ret, initialized to init, setting ret to the
  and returns the in-transaction-value of ref.
  and returns the in-transaction-value of ref."
  and the first item of coll, followed by applying f to 1 and the second
  and the first value in coll, then applying f to that result and the
  and the real function (the value of the var) calls test-var on
  and those fields can be accessed directly.
  and those fields can be accessed directly. Fields can be qualified
  and when that result is not nil, through the next etc"
  and when that result is not nil, through the next etc"
  and will defined Java .hashCode and .equals consistent with the
  and with-sh-dir.
  any main option. The appearance of any eval option before running a repl
  any registered watches will have their functions called. The watch fn
  any, will NOT be notified of the new state.  Throws an exception if
  any. If f returns a fn, calls that fn with no arguments, and
  apart. If step is not supplied, defaults to n, i.e. the partitions
  applies the rightmost of fns to the args, the next
  apply-template will recursively replace argument symbols in expr
  applying f to that result and the 2nd item, etc. If coll contains no
  applying f to that result and the 3rd item, etc. If coll contains no
  are evaluated in order.  Returns x.
  are held until the action completes (changes the agent's
  are made in parallel (unlike let); all init-exprs are evaluated
  are optional. The only methods that can be supplied are those
  are optional. The only methods that can be supplied are those
  are optional:
  are sequential keyword-value pairs. Available options and their defaults:
  are triggered only by root binding changes, not thread-local
  arg-navigator :seq :rest :pos )
  args (left-to-right).
  args - a (possibly empty) vector of arguments to the superclass
  argument that triggers a logical false result against the original predicates."
  argument that triggers a logical true result against the original predicates."
  argument, followed by the next member on the result, etc. For
  argument, which will be passed the intended new state on any state
  argument, which will be passed the intended new state on any state
  argument, which will be passed the intended new state on any state
  argument.  If there are no more items, returns nil."
  argument."
  arguments in argv, an argument vector as in defn.
  arguments, (combinef) must produce its identity element. These
  arguments, not just the one(s) being nil-patched."
  arguments. Returns the result of applying f to init, the first key
  arguments. This may be used to define a helper function which runs on a
  arity is constrained to the number of expected fields and an ArityException
  array [& items]
  array ret."
  as a normal Clojure data structure by the reader.
  as in a stack trace element, returns a readable version."
  as in a stack trace element, returns a readable version."
  as next/butlast."
  as those documented for clojure.core/refer."
  as valid, else returns nil."
  aseq if present, or Object. All values in aseq must be compatible with
  aset-boolean setBoolean boolean)
  aset-byte setByte byte)
  aset-char setChar char)
  aset-double setDouble double)
  aset-float setFloat float)
  aset-int setInt int)
  aset-long setLong long)
  aset-short setShort short)
  assert-valid-fdecl (fn [fdecl]))
  at end (defaults to length of string), exclusive."
  at the end, stays there."
  at the root, returns nil."
  atom. validate-fn must be nil or a side-effect-free fn of one
  attrs, and content. Other parsers can be supplied by passing
  automatically and can not be substituted.
  automatically and can not be substituted.
  automatically and can not be substituted.
  automatically creates the maps required by extend.  Propagates the
  avoid reflection."
  avoid this, sort a copy of the array."
  avoid this, sort a copy of the array."
  based on Throwable data, as returned by Throwable->map. All attributes other than phase
  be in the classpath."
  be printed in a form that can be read back by the reader.
  be provided to override protected methods, they have no other access
  be used to force any effects. Walks through the successive nexts of
  be used to force any effects. Walks through the successive nexts of
  be used when defining your own records.
  be wrapped in (not...)."
  before any pending sends if agent or ref. Note that an atom's or
  before the vars are bound to their new values."
  beginning of the package name that has docs at this URL."
  beginning with @ or @/ are considered relative to classpath."
  behavior can be controlled by :load-impl-ns
  behavior of an existing instance without changing its identity.
  being run by the agent throws an exception or doesn't pass the
  being the entire match."
  binding where ever possible.
  binding-map will replace the root value of its key which must be
  bindings after body was evaluated. Returns the value of body."
  bindings and filtering as provided by \"for\".  Does not retain
  bindings of functions to their names. All of the names are available
  block, unless the variant of deref with timeout is used. All
  blocking. See also - realized?."
  bodies. Note well that mutable fields are extremely difficult to use
  body is the expansion, calls to which may be expanded inline as if
  body, fails if not; then returns the thing thrown.
  bound to integers from 0 through n-1."
  bound to integers from 0 through n-1."
  bounds, nth throws an exception unless not-found is supplied.  nth
  branch? is a fn that, given a node, returns true if can have
  but blocking indefinitely may cause tap values to be dropped.
  but is easier to write, read, and understand."
  but must occur inside a test function (deftest)."
  but stores the values unboxed internally.
  by invoking the Var #'my.project.foo/bar on the vector [1 2 3]. The
  by other transactions.  Returns the in-transaction-value of
  call test-ns-hook instead of testing all vars.
  call, any such use will throw an exception."
  called, the returned function calls f with args + additional args."
  called. If a method fn is not provided for an interface method, an
  called. Method fns are closures and can capture the environment in
  called."
  calls. See also - realized?"
  calls."
  can be a useful diagnostic tool to ensure that all of your reads
  can be a vector or sorted-map), in reverse order. If rev is empty returns nil"
  can be any Collection.  Maps to java.util.Collection.toArray()."
  can be read by the reader"
  can be skipped."
  case-map is a map of int case values to [test then] tuples, and switch-type
  certain transforms may inject or skip items."  {:added "1.7"}
  change. If the new state is unacceptable, the validate-fn should
  change. If the new state is unacceptable, the validate-fn should
  change. If the new state is unacceptable, the validate-fn should
  changes will be visible in all threads.  Useful for mocking out
  char-escape-string
  character of lookahead is available. The stream must either be an
  characters to lower-case."
  checking must not be done (the cases holding the above condp thens)."
  child can be either a namespace-qualified symbol or keyword or a
  children is a fn that, given a branch node, returns a seq of its
  children, even if it currently doesn't.
  children, returns a new branch node with the supplied children.
  children.
  children. The loc is only used to supply the constructor."
  clashes. Use :use in the ns macro in preference to calling this directly."
  class (for calls to new, instance? etc).
  class (for calls to new, instance? etc).
  class as a type hint on the first argument of all fns.
  class named by package.name to the current namespace. Use :import in the ns
  class of x, as a symbol."
  class org.mydomain.MyClass with a method named mymethod, gen-class
  class)
  class)
  class. Note that a class generated this way can be loaded only once
  class. Static methods can be specified with ^{:static true} in the
  class. h must be a hierarchy obtained from make-hierarchy, if not
  classes must be fully qualified.
  classes must be fully qualified.
  classes to load.
  classes. The resulting value is cached and used for any subsequent
  classfiles. The source for the lib must be in a proper
  classloader. Subsequent to generation you can import it into any
  classpath-relative directory. The output files will go into the
  classpath-relative if it begins with a slash or relative to the root
  classpath. Classpath-relative paths have prefix of @ or @/"
  clauses are not considered sequentially.  All manner of constant
  clojure-version
  clojure.core)
  clojure.core.IVecImpl
  clojure.core.protocols.InternalReduce
  clojure.core.protocols/CollReduce
  clojure.core.reducers
  clojure.core.server
  clojure.core/default-data-readers but may be overridden in
  clojure.core/refer. Use :use in the ns macro in preference to calling
  clojure.data
  clojure.datafy
  clojure.edn
  clojure.java.browse
  clojure.java.browse-ui)
  clojure.java.io/writer)."
  clojure.java.javadoc
  clojure.java.shell
  clojure.lang.APersistentMap$KeySeq
  clojure.lang.APersistentMap$ValSeq
  clojure.lang.ASeq
  clojure.lang.Associative
  clojure.lang.Counted
  clojure.lang.Counted
  clojure.lang.Fn
  clojure.lang.IChunk
  clojure.lang.IChunkedSeq
  clojure.lang.IChunkedSeq
  clojure.lang.IFn
  clojure.lang.IHashEq
  clojure.lang.ILookup
  clojure.lang.IMeta
  clojure.lang.IObj
  clojure.lang.IPersistentCollection
  clojure.lang.IPersistentStack
  clojure.lang.IPersistentVector
  clojure.lang.IReduceInit
  clojure.lang.IRef
  clojure.lang.ISeq
  clojure.lang.Indexed
  clojure.lang.Indexed
  clojure.lang.LazySeq
  clojure.lang.Namespace
  clojure.lang.PersistentVector
  clojure.lang.Reversible
  clojure.lang.Seqable
  clojure.lang.Seqable
  clojure.lang.Seqable
  clojure.lang.Sequential ;marker, no methods
  clojure.lang.StringSeq
  clojure.lang.Symbol
  clojure.main
  clojure.reflect
  clojure.repl
  clojure.stacktrace)
  clojure.string
  clojure.template
  clojure.test
  clojure.test.junit
  clojure.test.tap
  clojure.test/run-tests in the with-tap-output macro,
  clojure.walk)
  clojure.xml
  clojure.zip
  closes f. Options passed to clojure.java.io/writer."
  closures, and can refer to the surrounding local scope:
  code reuse/mixins without derivation or composition. You can extend
  code-dispatch
  coercions will be done without overflow checks. While bound
  coll, else true."
  collection and is at a level greater than or equal to the value bound to
  collection, into the reduction."
  collection, its items are at level 1; and so on. If an object is a
  collection."
  collection."
  collisions)."
  colls of (f val). Foldable."
  combined with comp. Note that these applications will be
  common.  By producing compatible output from tests, this tool
  comparator.  Any equal keys are handled as if by repeated uses of
  comparator.  If any keys are equal, they are handled as if by
  compares numbers and collections in a type-independent manner. x
  comparison."
  compiled-directive :func :def :params :offset)
  compiling. If :gen-class is not supplied, when compiled only an
  complete stack trace."
  component type is type if provided, or the type of the first value in
  composing predicates return a logical true value against all of its arguments, else it returns
  computation not complete. When applied to a promise, will block
  computationally intensive functions where the time of f dominates
  conj."
  consecutively, and so must be commutative. Also note that 
  consistent with =, and thus is different than .hashCode for Integer,
  constant (the case int), and their respective thens are combined into:
  constant time. The transient collection cannot be used after this
  constructed object is returned."}
  constructed to deal with more arguments.  It does this by building a straight
  constructor signature. When you supply this, you must supply an :init
  constructor(s).
  constructor.
  constructor. op must be associative and ctor called with no args
  containing the contents of coll, which can be any Collection of any
  contains no items, returns init and f is not called. Note that
  context k for Indexed/Associative/ILookup colls if possible, but not
  continues to repeat, until the return value is not a fn, then
  contract for java.util.Map.
  convenient.
  correctly, and are present only to facilitate the building of higher
  correspond to methods of the proxy superclass/superinterfaces) to
  correspond to methods of the proxy superclass/superinterfaces) to
  correspond to the target object ('this' in Java parlance). Thus
  correspond to the target object ('this' in Java parlance). Thus
  correspond to the target object ('this' in Java parlance). Thus
  corresponding elements of the 2 collections.
  corresponding elements, in the order they appeared in coll."
  corresponding to the ns name, :main true, :impl-ns same as ns, and
  corresponding val in smap.  Returns a transducer when no collection
  counted, providing the identity collections are reducible, seqable
  created with make-hierarchy.
  created with the derive function used to augment the root ancestor
  created with the given name, and the same signature(s) as the
  created. You must supply an :init function in order to provide a
  created."
  creates and returns an instance of the proxy."
  ctor pulling the extra args out of the & overage parameter.  Finally, the
  current assertion."
  current thread."
  current value of *in*.
  current value of *in*.
  current value of the atom is identical to oldval. Returns true if
  current value plus any args"
  current value. Returns newval."
  data of the form to the created object.
  data reader function is invoked on the form AFTER it has been read
  data structure of the same type, then applies outer to the result.
  data, which must be a sequential data structure of data structures
  data_readers.clj file above, the Clojure reader would parse this
  data_readers.clj, data_readers.cljc, or by rebinding this Var."
  datafy will return the value of clojure.core.protocols/datafy. If
  date-fullyear   = 4DIGIT
  date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on
  date-month      = 2DIGIT  ; 01-12
  days           1             31        1 (actual max days depends
  declared in the protocols/interfaces.  Note that method bodies are
  declared in the protocols/interfaces.  Note that method bodies are
  def-aset [name method coerce]
  default (refer 'clojure.core) is used.  Use of ns is preferred to
  default :read hook, *in* must either be an instance of
  default behavior. Note that this function can be used to update the
  default expression can follow the clauses, and its value will be
  default if no error-handler is given) -- see set-error-mode! for
  default of Object) must be correct, for both arguments and return
  default), an exception will be thrown for the unknown tag."
  default-streams-impl)
  defaulting to Object if omitted.
  defaults to (count vector). This operation is O(1) and very fast, as
  defaults to Object.
  defaults to the global hierarchy"
  defaults to the global hierarchy"
  defdirectives 
  defined: ->TypeName, taking positional parameters for the fields,
  defprotocol will automatically generate a corresponding interface,
  deftype [type-name & fields]
  deftype, reify), then metadata definitions, then external
  deref with timeout is used. See also - realized?."
  derefs. A subsequent call to deliver on a promise will have no effect."
  description of the options."
  desired namespaces just like any other class. See gen-class for a
  details."
  different thread, but needs the same bindings in place."
  directory for the current namespace otherwise."
  directory specified by *compile-path*, and that directory too must
  disambiguate - a missing hint implies Object.
  dispatched thus far, from this thread or agent, to the agent(s) have
  do not overlap. If a pad collection is supplied, use its elements as
  do-copy
  does not contain key(s)."
  does not contain key(s)."
  doesn't evaluate any of the other expressions, otherwise it returns
  duplicate loads can be skipped."
  e.g. in the example case, ``org/mydomain/MyClass__init.class``. This
  each element of ret to the evaluation of expr, returning the new
  each sub-form, uses f's return value in place of the original.
  effect, and defines no new types or classes. Implementations of 
  effects, any effects other than those needed to produce the first
  effects, any effects other than those needed to produce the first
  effects, on successive items in the collection. Returns nil"
  either :fail or :continue.  If an action being run by the agent
  either a libspec that identifies a lib, a prefix list that identifies
  element in the seq do not occur until the seq is consumed. doall can
  element in the seq do not occur until the seq is consumed. dorun can
  elements of coll using its seq"
  elements of the 2 collections."
  else expr is unevaluated"
  else is not supplied it defaults to nil."}
  else nil.  One common idiom is to use a set as pred, for example
  else returns form."
  else returns numerator divided by all of the denominators."
  else true."
  entries are {(case-f test) [(test-f test) then]}."
  equal, they are handled as if by repeated uses of assoc."
  equal, they are handled as if by repeated uses of assoc."
  error-handler may be called (see set-error-handler!), after which,
  etc.) and returns their contents as a single, flat foldable
  etc.) and returns their contents as a single, flat lazy sequence.
  evaluate any of the other expressions, otherwise it returns the
  evaluated in parallel"
  evaluated.  If the predicate returns false, the 'actual' form will
  evaluates and yields then, otherwise, evaluates and yields else. If
  evaluation of expr at each step, returning ret."
  exception message shows the dependency chain with the cycle
  exception message."
  executed, the root values of all the Vars will be set back to their
  exhausted.  Any remaining items in other colls are ignored. Function
  exhausted.  Any remaining items in other colls are ignored. Function
  exist, returns it or the already-existing namespace of the same
  exists after loading. If require, records the load so any duplicate loads
  exists.  This function will not intern a new keyword. If the keyword
  expands into:
  expands into:
  expands to:
  expression is provided and no clause matches, an
  expression is true. Note that, unlike cond branching, cond-> threading does
  expression, a vector can be used to match a list if needed. The
  expressions are acceptable in case, including numbers, strings,
  expressions into a sorted map to be consumed by case*. The form of the map
  expressions. Returns a tuple of [shift mask case-map switch-type skip-check]
  exprs and any nested calls.  Starts a transaction if none is already
  exprs and any nested calls.  Starts a transaction if none is already
  exsting functions or mixin maps), you may find it more convenient to
  extend takes a type/class (or interface, see below), and one or more
  extend-type:
  extends?, satisfies?, extenders"
  extensions (extend, extend-type, extend-protocol)
  f => (name [params*] body) or
  f must be free of side-effects"
  f on each element. The value at each key will be a vector of the
  f should accept number-of-colls arguments. Returns a transducer when
  f should accept number-of-colls arguments."
  f2 must be a function of two arguments, which will be an element of
  f2 must be a function of two arguments, which will be corresponding
  failed."
  false if not (dropped)."
  false)
  false. Note that f is short-circuiting in that it will stop execution on the first
  false."
  far (from this thread or agent) to the agents have occurred, or the
  fields, which can have type hints. Protocols/interfaces and methods
  fields, which can have type hints. Protocols/interfaces and methods
  files. This directory must be in the classpath for 'compile' to
  filter-key [keyfn pred amap]
  filters can include at most one each of:
  final value, you must wrap it in some data structure and unpack it
  finally-clause => (finally expr*)
  find it.  This requires that the symbol resolve to a Var defined in
  first arg, which is bound to 'this. Note that while method fns can
  first expression in body is a literal string, will use that as the
  first item for which (pred item) returns logical false.  Returns a
  first/next recursion. Called by clojure.core/reduce. Baseline
  fixture function, even if the collection is empty."
  flag-descriptors
  fn (right-to-left) to the result, etc."
  fn must be a fn of 4 args: a key, the reference, its old-state, its
  fn of a LineNumberingPushbackReader and EOF value or a symbol naming
  fn will be transformed by xf. xf is a function of reducing fn to
  fn will be transformed by xf. xf is a function of reducing fn to
  fns (which must take arguments matching the corresponding method,
  fns (which must take arguments matching the corresponding method,
  fns may be called from multiple threads simultaneously. Var watchers
  fns. A single class, if provided, must be first. If not provided it
  fns. This facilitates easy reuse of existing fns and fn maps, for
  followed by a metadata map (nil for none) and an extension field
  following forms:
  for Java.  As such, tool support for JUnit output formats is
  for an input. When retf is supplied it must be a fn of 2 arguments -
  for use in the implementation.
  form:
  forward from from-index. Return nil if value not found."
  forward type/record ctor call in the <=20 case, and a call to the same
  forwarding to load-lib"
  found."
  from make-hierarchy, if not supplied defaults to the global
  from make-hierarchy, if not supplied defaults to the global
  from the latter (left-to-right) will be combined with the mapping in
  from-coll conjoined. A transducer may be supplied."
  from-coll conjoined."
  from-coll conjoined."
  fully-qualified class name given as a string or symbol
  fully-qualified name of a Var which will be invoked by the reader to
  fully-qualified name.  Class objects for the primitive types can be
  functions dispatch on the type of their first argument, which is
  functions during testing."
  functions in an implementing Clojure namespace. Given a generated
  functions.  Applies inner to each element of form, building up a
  generate public getter/setter methods exposing the protected field(s)
  generated methods, and init and main functions (see :methods, :init,
  get, but such use of accessors should be limited to known
  getf 
  given a root element"
  given fields, and, optionally, methods for protocols and/or
  given fields, and, optionally, methods for protocols and/or
  given name (a symbol), prepends the current ns as the package, and
  given name (a symbol), prepends the current ns as the package, and
  given package-qualified :name (which, as all names in these
  global hierarchy map.  However, a hierarchy relationship can be
  groups."
  groups."
  handled as if by repeated uses of conj."
  handled as if by repeated uses of conj."
  has not already been interned, it will return nil.  Do not use :
  has not been explicitly bound to either true or false. This setting
  has the same effects, if any, and returns the opposite truth value."
  have methods corresponding to the protocol functions, and the
  head should *not* pass the target object, it will be supplied
  head should *not* pass the target object, it will be supplied
  head should *not* pass the target object, it will be supplied
  here.
  here."
  hierarchy"
  hierarchy. Note: does not work on Java type inheritance
  higher performance at the expense of higher memory use."
  highlighted. Ignores the trivial case of a file attempting to load
  hints should be reserved for disambiguation.
  hints should be reserved for disambiguation.
  hours          0             23        0  on month and year)
  how all the identified libs are loaded. Use :require in the ns macro
  http://edn-format.org
  http://edn-format.org
  http://search.cpan.org/~petdance/TAP-1.0.0/TAP.pm
  http://testanything.org/ and
  identity) on the result argument."
  if by repeated uses of assoc."
  if needed.  references can be zero or more of: (:refer-clojure ...)
  if not nil, close-fn will be called with no arguments when .close is called"
  if present."
  if the mode is :continue, the agent will continue as if neither the
  if the symbol is fully qualified, the var/Class to which it resolves
  if val is a seq itself, count the number of times any element of val
  immediately after all the inherited constructors have completed.
  immediately apparent to you, you should not be using them.
  implementation defined in terms of Iterable."
  implementation will be dynamically sought by the generated class in
  implementation."
  implementations are checked first for direct definitions (defrecord,
  implements the named class/interface(s) by calling the supplied
  implications of :volatile-mutable or :unsynchronized-mutable are not
  in *testing-vars* as a list, then the source file and line of
  in O(n) time, for sequences."
  in all of the definitions of the functions, as well as the body."
  in preference to calling this directly.
  in the keyword strings, it will be added automatically."
  in the keyword strings, it will be added automatically."
  in user code. Use the 'locking' macro."}
  in user code. Use the 'locking' macro."}
  in values.  values are automatically partitioned by the number of
  including syntax that can cause code to execute. It should never be
  independent method definitions must be supplied.  If overloaded with
  indicating no limit."
  indirectly loads. If need-ns, ensures that the associated namespace
  individual calls to in-ns/require/use/import:
  individually, while :once wraps the whole run in a single function."
  infinity. When step is equal to 0, returns an infinite sequence of
  inheritance of implementation since a class can inherit from more
  inheritance relationship or a relationship established via derive. h
  inheritance relationship or a relationship established via derive. h
  inheritance. By default Clojure's multimethods dispatch off of a
  init options:
  init)
  input test constants with the same hash is replaced with a single test
  instance of LineNumberingPushbackReader or duplicate its behavior of both
  instance of LineNumberingPushbackReader or duplicate its behavior of both
  instance:
  instead of [] so they can be part of a Clojure symbol.
  interface declarations.  Note also that recur calls to the method
  interface declarations. Note also that recur calls to the method
  interface declarations. Note also that recur calls to the method
  interfaces generated automatically: IObj (metadata support) and
  interfaces.
  interfaces. 
  interfaces. If not supplied class defaults to Object.  Creates an
  invoke the body in another thread, and will cache the result and
  invoke the body only the first time it is forced (with force or deref/@), and
  invoke the function in another thread, and will cache the result and
  is :unknown and all reads will fail in contexts where *read-eval*
  is called, and will cache the result and return it on all subsequent
  is derived from the lib name in the following manner:
  is either :sparse or :compact, and skip-check is a set of case ints for which
  is either :sparse or :compact."
  is nil indicating no limit."
  is non-nil, it will be called with two arguments,
  is not present, or the not-found value if supplied."
  is not provided for a class method, the superclass method will be
  is not supplied, the input that triggered the predicate will be
  is provided."
  is returned and f is not called.  If val is supplied, returns the
  is thrown during a test.  Defaults to nil, which means print the 
  is true.  Note that, unlike cond branching, cond->> threading does not short circuit
  it already exists.  If init is supplied, it is evaluated, and the
  it can't find the source.  For most REPL usage, 'source' is more
  it if not already forced. When applied to a future, will block if
  it in a depth-first walk."
  it were a macro. Cannot be used with variadic (&) args."
  it will be passed the (completed) result so far and the input that
  it will not perform a linear search for a value.  See also 'some'."
  item in coll, etc, until coll is exhausted. Thus function f should
  item, for a vector, returns a new vector without the last item. If
  items in each coll, until any one of the colls is exhausted.  Any
  items of each coll, followed by the set of second
  items, f must accept no arguments as well, and reduce returns the
  items, returns val and f is not called."
  iterator that repeatedly returns the same mutable object."
  its behavior of both supporting .unread and collapsing all of CR, LF, and
  its wrappers"
  its wrappers"
  itself because that can occur when a gen-class'd class loads its
  itself.
  itself. They are for experts only - if the semantics and
  java -Dclojure.read.eval=false ...
  java.io.PushbackReader or some derivee.  stream defaults to the
  java.io.PushbackReader or some derivee.  stream defaults to the
  java.lang package can be used without a package qualifier. All other
  java.lang package can be used without a package qualifier. All other
  java.lang.Class
  java.lang.Comparable
  java.lang.Iterable
  java.lang.Object
  java.time.Instant
  java.util.Collection
  java.util.Comparator.  Guaranteed to be stable: equal elements will
  java.util.Comparator.  Guaranteed to be stable: equal elements will
  java.util.Date
  java.util.List
  java.util.List
  java.util.List
  java.util.Map
  java.util.Map
  java.util.Set
  java.util.Set
  java.util.regex.Matcher.find().  Uses re-groups to return the
  java.util.regex.Matcher.matches().  Uses re-groups to return the
  join. When passed an additional keymap, joins on the corresponding
  key and f is a function that will take the old value
  key/index or nil). Callers should attempt to provide the key/index
  keys - where values are not supplied they will default to nil.
  keys."
  keyvals can also contain keys not in the basis."
  last item in second form, etc."
  last item in the first form, making a list of it if it is not a
  last of which will be treated as a sequence."
  last-one-in-wins behavior.  commute allows for more concurrency than
  leave out all hints, reify will try to match on same name/arity
  leaves the stream untouched. Returns :line-start, :stream-end, or :body
  let (fn* let [&form &env & decl] (cons 'let* decl)))
  level constructs, such as Clojure's reference types, in Clojure
  level to print. Each argument to print is at level 0; if an argument is a
  lib resources.
  lib)
  library of Clojure code. Lib names are symbols and each lib is associated
  like this:
  like this:
  limit. Otherwise, it must be bound to an integer indicating the maximum
  limit. Otherwise, it must be bound to an integer indicating the maximum
  limitation of 20 arguments to Clojure functions, this factory needs to be
  list (. clojure.lang.PersistentList creator))
  list already. If there are more forms, inserts the first form as the
  list already. If there are more forms, inserts the first form as the
  lists are used to group multiple constants that map to the same
  literals, and need not be quoted.  If the expression is equal to a
  load the code via some other method."
  logical false. Note that f is short-circuiting in that it will stop execution on the first
  logical true, the clause is a match. If a binary clause matches, the
  logical true."
  longs, will throw on overflow. See also: *'"
  longs, will throw on overflow. See also: +'"
  longs, will throw on overflow. See also: -'"
  longs, will throw on overflow. See also: dec'"
  longs, will throw on overflow. See also: inc'"
  looked up in this namespace.
  macro and will be used as a macro by the compiler when it is
  macro in preference to calling this directly."
  macroexpand-1 nor macroexpand expand macros in subforms."
  main options:
  make-node is a fn that, given an existing node and a seq of
  map (nil for none), and one taking only the fields (using nil for
  map abstraction based upon its JavaBean properties."
  maps, the first having all the first elements of the pairs and the
  match the signature(s) of the constructors for the superclass. This
  max-table-switch-size, false otherwise."
  may happen at different 'places' depending on the concrete type."
  maybe-destructured
  memoized version of the function keeps a cache of the mapping from arguments
  meta and extension fields). Note that the field names __meta,
  metadata from the name symbol.  Returns the var."
  metadata, :clojure.datafy/obj will be set on the metadata to the
  method calls, or isolated symbols."
  method in the protocol(s)/interface(s) - this is preferred. If you
  methodname symbols. If not supplied, they will be inferred, so type
  methodname symbols. If not supplied, they will be inferred, so type
  methods for interfaces will take one more argument than do the
  methods for interfaces will take one more argument than do the
  methods for interfaces will take one more argument than do the
  methods of Object. Note that a parameter must be supplied to
  methods of Object. Note that a parameter must be supplied to
  methods of Object. Note that the first parameter must be supplied to
  methods of its superclasses/interfaces. This parameter can be used
  minutes        0             59        0
  months         1             12        1
  more efficient than, last. If the collection is empty, returns nil."
  more items, the printer will print items up to the limit followed by
  more options (in any order):
  more options (in any order):
  more than one.  By default, pr and prn print in a way that objects
  most recent exception."
  most recent repl exception (*e), and a depth of 12."
  most-recently-committed value of ref. When applied to a var, agent
  multiple libs whose names share a common prefix, or a flag that modifies
  multiple times, and thus should be free of side effects.
  multiple times, and thus should be free of side effects.  Returns
  must be a function of one argument whose return will be processed
  must be a hierarchy obtained from make-hierarchy, if not supplied
  must be a hierarchy obtained from make-hierarchy, if not supplied
  must contain a literal map of symbols, like this:
  must either be an instance of LineNumberingPushbackReader or duplicate
  must implement Comparable"
  must precede maps. ops must be a set of keyword value pairs of the
  must return an identity value for it."
  my.ns/Protocol, an interface: my.ns.Protocol. The interface will
  n (default 1) (exclusive)."
  n (default 512), each of which is reduced with reducef (with a seed
  n items ahead of the consumer. n-or-q can be an integer n buffer
  name => symbol
  name also locates its root directory within classpath using Java's
  name in reverse order."
  name, in a package with the same name as the current namespace, the
  name, in a package with the same name as the current namespace, the
  name."
  names matching the regular expression (with re-matches) will be
  namespace (unless found in the environment), else nil.  Note that
  namespace (usually by using the ns macro) and load any additional
  namespace exists after loading. If require, records the load so any
  namespace for which the .clj is in the classpath.
  namespace map literal syntax. It defaults to false, but the REPL binds
  namespace object or a symbol.
  namespace-qualified by the ns enclosing the definition The resulting
  namespace.  Throws an exception if name is already mapped to
  namespace. Arguments are two symbols: the alias to be used, and
  nanoseconds    0      999999999        0  when minutes is 59)
  navigator)
  navigator)
  necessary to complete last partition upto n items. In case there are
  need not be present in the namespace."
  needed to resolve Java method calls or field accesses.
  needed.
  nested groups, returns a string of the entire match. If there are
  nested groups, returns a vector of the groups, the first element
  nested structure.  If any levels do not exist, hash-maps will be
  new state on any state change. If the new state is unacceptable, the
  new-state. Whenever the reference's state might have been changed,
  next-param => binding-form
  nil
  nil
  nil
  nil
  nil
  nil if no children"
  nil if no var with that name."
  nil)
  nil)
  nil)
  nil)
  nil)
  nil)
  nil)
  nil)
  nil)
  no collection is provided."
  no collection is provided."
  no collection is provided."
  non-alphanumeric characters converted to the appropriate escape sequences.
  none were supplied"
  not be reordered.  If coll is a Java array, it will be modified.  To
  not be reordered.  If coll is a Java array, it will be modified.  To
  not closures, the local environment includes only the named fields,
  not closures, the local environment includes only the named fields,
  not enough padding elements, return a partition with less than n items."
  not short circuit after the first true test expression."
  not supplied, the root binding of the var is unaffected."}
  not yet finished, calls to deref/@ will block, unless the variant
  not yet finished, calls to deref/@ will block, unless the variant of
  nothing. The gen-class construct contains no implementation, as the
  now on :file and :line keys in the result map."
  ns (which can be a symbol or a namespace), setting its root binding
  nsname__init.class will be generated. If :refer-clojure is not used, a
  number of items of each collection to print. If a collection contains
  number) to the front of coll."
  number-of-colls arguments"
  numbers and collections in a type-independent manner.  Clojure's immutable data
  object and any args and calls the named instance method on the
  object passing the args. Use when you want to treat a Java method as
  obtained using, e.g., Integer/TYPE."
  occur in Clojure functions, they have no access to the inherited
  occur in considered contexts. You can also accomplish this in a
  occurred.  Will block on failed agents.  Will never return if
  occurring, does nothing. Returns the number of actions dispatched."
  occurs at the beginning of aseq"
  of *out*.  Prints the object(s), separated by spaces if there is
  of *out*.  print and println produce output for human consumption."
  of :int :long :float :double :byte :short :char or :boolean. The
  of after a read fault). History is limited, and the limit can be set
  of applying (the transformed) xf to init and the first item in coll,
  of coll may be no better than linear time.  For vectors, see also subvec."
  of deref with timeout is used. See also - realized?."
  of equal length"
  of second items in each coll, until any one of the colls is
  of symbol in the current namespace (*ns*) or locates such a var if
  of that binding, then binds name to that result, repeating for each
  of that protocol for one or more types. Expands into calls to
  of the collection and the corresponding index, whose return will be
  of the inits, and a finally clause that calls (.close name) on each
  of the supplied colls.  Each coll expr is not evaluated until it is
  of these reductions are then reduced with combinef (default
  of those fns.  The returned fn takes a variable number of args,
  of those fns.  The returned fn takes a variable number of args, and
  of values to be used for the arguments.
  offset-hours   0             23        0
  offset-minutes 0             59        0
  offset-sign   -1              1        0
  old values.  These temporary changes will be visible in all threads.
  old/new-state rather than derefing the reference. Note also that watch
  on a class if passed a class
  on a type returns a map with keys :bases, :flags, and :members.
  on strings, keywords, and vars."
  on-the-fly filtering or transformations during parallel realization
  once only, with deliver. Calls to deref/@ prior to delivery will
  once, but any effects on Refs will be atomic."
  once, but any effects on Refs will be atomic."
  one arg, returns the concatenation of the str values of the args."
  one. Will not force a lazy seq. (sequence nil) yields (), When a
  only 2 you can add the arity-1 with 'completing'. Returns the result
  operation:
  operations may be performed in parallel, but the results will
  optional:
  options expressed as sequential keywords and arguments.
  options, as specified in read.
  opts is a map as per clojure.edn/read"
  opts is a map that can include the following keys:
  or :body to indicate the relative location of the next character on s.
  or a symbol naming same (default pr-str)
  or a symbol naming same (default read-string). If that function
  or agent, supporting the creation of Java objects with transactional
  or asynchronous mutation semantics.
  or atom, returns its current state. When applied to a delay, forces
  or calculation. ops form a chain, and bounds must precede filters,
  or more method bodies:
  or more method bodies:
  or more method bodies:
  or the var special form)."
  or:    (with-precision 10 :rounding HALF_DOWN (/ 1M 3))
  order is determined by comparing (keyfn item).  If no comparator is
  original value of x, and :clojure.datafy/class to the name of the
  other tests or exprs. (cond) returns nil."
  other tests, so tests may be composed.  If you compose tests, you
  otherwise else expr, if supplied, else nil."
  otherwise false."
  otherwise false."
  otherwise false."
  otherwise false."
  otherwise those held actions will proceed.  The new-state must pass
  overridden by binding *data-readers*."
  overridden by the class. If not provided, defaults to Object.
  overridden method.  Those methods may be exposed and referred in 
  package name to classpath-relative path mapping. All resources in a lib
  parallel computation stays ahead of the consumption, but doesn't
  param"
  parameter may be used to explicitly specify constructors, each entry
  parameters, can be a string or symbol), and writes the .class file
  parameters, can be a string or symbol), and writes the .class file
  parent, either via a Java type inheritance relationship or a
  parse the form following the tag. For example, given the
  particular scope by binding *read-eval* to :unknown
  partitions with fewer than n items at the end.  Returns a stateful
  pass each string of the String[] argument as a separate argument to
  passed to the constructor of the class named by Classname. The
  per reduce) of coll by f, starting with init."
  performance-critical areas."
  performed every time reduce/iterator is called."
  plus an additional (explicit) first arg corresponding to this, and
  plus an additional (explicit) first arg corresponding to this, and
  polymorphic functions and a protocol object. All are
  pop bindings without pushing before."
  pop-thread-bindings wrapped in a try-finally!
  positional-param => binding-form
  positions (y, z). Note that the function f can take any number of
  post-switch equivalence checking must not be done (occurs with hash
  pred2 must be a function of two arguments, which will be
  pred2 must be a function of two arguments, which will be an element
  predicate as its argument, the result of that call being the return
  prefix is not supplied, the prefix is 'G__'."
  prefix, the names that remain must not contain any periods.
  prefixFoo in the implementing ns.
  present"
  preserve order."
  presuming Comparable elements, unless a Comparator comp is supplied"
  presuming Comparable elements, unless a Comparator comp is supplied"
  presuming failure will throw exception"
  print nested objects. If it is bound to logical false, there is no
  printer will print. If it is bound to logical false, there is no
  processed via boolean.
  processed when the array is realized.
  producer."
  protected fields of the superclass. This parameter can be used to
  protocol + method map pairs. It will extend the polymorphism of the
  protocol all at once. Takes a single protocol and the implementation
  protocol overall and for each method. The above yields a set of
  protocol will automatically work with instances of the interface.
  protocol's methods to call the supplied methods when an AType is
  protocol(s) and interface(s). You can also define overrides for
  protocol(s) and interface(s). You can also define overrides for
  protocol(s) and interface(s). You can also define overrides for
  protocol-or-interface-or-Object
  protocol-or-interface-or-Object
  protocol-or-interface-or-Object
  provided as the first argument. 
  provided."
  providing a mapping from a constructor signature to a superclass
  providing iterators implement Iterable and thus support seq directly.
  proxied."
  queued actions will be held until a 'restart-agent'.  Deref will
  quoted. (:gen-class ...), when supplied, defaults to :name
  range of indexes. 'contains?' operates constant or logarithmic time;
  rdr must implement java.io.BufferedReader."
  re-establishes the bindings that existed before.  The new bindings
  re-find) the regular expression re."
  re-find."
  re-groups."
  re-matcher."
  read demands. If you know in advance you will need history you can
  reads forms to eval from in-reader (a LineNumberingPushbackReader)
  realize the entire result unless required. Only useful for
  realized. f must be a function of one argument.
  recur works to method heads The method bodies of reify are lexical
  recursion without stack consumption. Calls f with supplied args, if
  reduce1
  reduced values. The result is reducible, foldable, seqable and
  reducef). combinef must be associative, and, when called with no
  reducing fn."
  reducing fn."
  ref to:
  ref to:
  ref's state may have changed again prior to the fn call, so use
  ref-set."
  ref. Allows for more concurrency than (ref-set ref @ref)"
  ref. validate-fn must be nil or a side-effect-free fn of one
  reference types. Returns val."
  referred to by their Java names (int, float etc), and classes in the
  referred to by their Java names (int, float etc), and classes in the
  reify always implements clojure.lang.IObj and transfers meta
  reify, as they support the protocol directly:
  relationship established via derive. h must be a hierarchy obtained
  relationship established via derive. h must be a hierarchy obtained
  relationships."
  remaining items in other colls are ignored. The transform should accept
  remote [io-]prepl over a socket.  Messages will be read by readf, a
  repeated uses of assoc."
  repetition. A prefix list contains the shared prefix followed by libspecs
  replace in parallel the root value of its Var.  After the body is
  replacement at the leaves of the tree first."
  replacement at the root of the tree first."
  report :type)
  represents a macro form, then returns it.  Note neither
  requests for the same class set. Returns a Class object."
  required and corresponds to the implicit target object ('this' in 
  requires one non-Java-ish convention: array brackets are <>
  reserved and should not be used when defining your own types.
  respectively, except the arguments are unevaluated and need not be
  result of applying f to val and the first item in coll, then
  result of calling f with no arguments.  If coll has only 1 item, it
  result-expr is returned, if a ternary clause matches, its result-fn,
  resulting vector complies with the interface of vectors in general,
  return false or throw an exception.  handler-fn is called if an
  return false or throw an exception. validate-fn will be called on
  return false or throw an exception."
  return it on all subsequent calls to deref/@. If the computation has
  return it on all subsequent calls to deref/@. If the computation has
  return value named ret, initialized to a clone of a, then setting
  returned by one of its composing predicates against any of its arguments, else it returns
  returned function should be (slightly) more efficient than using
  returned if no clause matches. If no default expression is provided
  returned. If the predicate never returns true the transduction is
  returning due to timeout, logical true otherwise."
  returns a fn that takes a variable number of additional args. When
  returns a foldable collection, where any supplied reducing
  returns a logical true value, or returns that value and doesn't
  returns a reducible collection, where any supplied reducing
  returns a vector containing the result of applying each fn to the
  returns an infinite (or length n if supplied) lazy sequence of calls
  returns an instance of a proxy class derived from the supplied
  returns false.  Note that for numerically indexed collections like
  returns logical false (nil or false), and returns that value and
  returns logical true. Foldable."
  returns logical true. Foldable."
  returns that non-fn value. Note that if you want to return a fn as a
  returns the in-transaction-value of ref, else returns the
  returns the namespace named by it, throwing an exception if not
  returns the result of applying f to the first 2 items in coll, then
  returns the value at the key.  The key must be in the basis. The
  root binding of the var is set to the resulting value.  If init is
  root is the root node."
  root resource should contain code to create the lib's
  running on this thread. Any uncaught exception will abort the
  running on this thread. Any uncaught exception will abort the
  same (default #(read %1 false %2)),
  same arity in an interface you must specify complete hints to
  same bindings in effect as in the thread at the time bound-fn was called.
  same type. Clojure's immutable data structures define equals() (and
  searching backward from from-index. Return nil if value not found."
  second all the second elements of the pairs"
  second item in second form, etc."
  second item in the first form, making a list of it if it is not a
  seconds        0             60        0 (though 60 is only valid
  see set-error-handler! for details.  The mode-keyword may be either
  select a subset, via inclusion or exclusion, or to provide a mapping
  seq calls. See also - realized?"
  seq to reside in memory at one time."
  seq will produce a concrete seq in the background, and can get up to
  sequence of keys and f is a function that will take the old value
  sequence of keys and v is the new value and returns a new nested structure.
  set :min-history to ensure it will be available when first needed (instead
  set happened, else false"
  set of first items of each coll, followed by applying f to the set
  set of second items in each coll, until any one of the colls is
  set of the maps in xrel with the corresponding values of ks."
  set!s. Keys must be unique per reference, and can be used to remove
  setf
  sets the proxy's fn map.  Returns the proxy."
  setup-reference [^clojure.lang.ARef r options]
  several languages.  For more information on TAP, see
  sh returns a map of
  should also define a function named test-ns-hook; run-tests will
  should be contained in the directory structure under its root directory.
  side-effect-free fn of one argument, which will be passed the intended
  side-effects.  Returns a stateful transducer when no collection is
  side-effects.  Returns a transducer when no collection is provided."
  signature's metadata. Do not repeat superclass/interface signatures
  simple-dispatch
  size, or an instance of java.util.concurrent BlockingQueue. Note
  some side-effect will cause test to become false/nil. Returns nil"
  something else in the current namespace. Filters can be used to
  specialized implementation."
  specified the old way"
  specified the old way"
  specifier. 
  stack.
  start (inclusive) to end (exclusive).  If end is not supplied,
  start. When start is equal to end, returns empty list."
  startparse, a fn taking a source and a ContentHandler and returning
  state). This function can be used to dispatch any pending sent
  stateful transducer when no collection is provided."
  static initializer for the generated class will attempt to load the
  step function that accepts both 1 and 2 arguments, if it accepts
  still work, returning the state of the agent before the error."
  strategy. The collection is partitioned into groups of approximately
  stream/file"
  string syntax"
  string"
  string.  Similar to Perl's chomp."
  string."
  strings in *testing-contexts* with spaces."
  structure-basis. keyvals may contain all, some or none of the basis
  structure-basis. vals must be supplied for basis keys in order -
  structure.  If the key does not exist, nil is passed as the old value."
  structures define equals() (and thus =) as a value, not an identity,
  subsequent derefs will return the same delivered value without
  successive form, returning the result of the last form."
  summarizing test results."
  supplied defaults to, and modifies, the global hierarchy."
  supplied defaults to, and modifies, the global hierarchy."
  supplied initial values, executes the exprs in an implicit do, then
  supplied, (f) will be called to produce it. f should be a reducing
  supplied, the name is prefix# where # is some unique number. If
  supplied, uses compare.  comparator must implement
  supplied, uses compare.  comparator must implement
  supply any hints at all, no inference is done, so all hints (or
  supplying the definitions explicitly inline, extend-type
  support can be exploited.
  supported. The :gen-class directive is ignored when not
  supported."
  supporting .unread and collapsing all of CR, LF, and CRLF into a single
  supporting .unread and collapsing all of CR, LF, and CRLF to a single
  suppresses the usual repl greeting message: \"Clojure ~(clojure-version)\".
  symbols and values are function implementations. Protocol
  symbols, keywords, and (Clojure) composites thereof. Note that since
  system. Running actions will complete, but no new actions will be
  tag symbol and a form."
  tag. Parent must be a namespace-qualified symbol or keyword and
  tag. h must be a hierarchy obtained from make-hierarchy, if not
  tap output can happen at any time (i.e. between evals)
  teardown. Using a fixture-type of :each wraps every test
  temp-value-exprs will be evaluated and each resulting value will
  templates.
  test, if not, yields else"
  test-constant result-expr
  test-constant, the corresponding result-expr is returned. A single
  test-constants need not be all of the same type."
  test-expr :>> result-fn
  test-expr result-expr
  tested."
  than one interface, both of which extend the protocol. It is TBD how
  that combines their behavior."
  that does not contain a mapping for key(s)."
  that often need to be set!: *ns* *warn-on-reflection* *math-context*
  that reading from a seque can block if the reader gets ahead of the
  that the field names __meta, __extmap, __hash and __hasheq are currently
  that would apply to that value, or nil if none apply and no default"
  the AsmReflector for \"hands off\" reflection without forcing
  the Clojure reader. The second symbol in the pair is the
  the Vars will be set back to their old values.  These temporary
  the agent is not failed."
  the agent will be set to the value of:
  the binding-forms are bound to their respective init-exprs or parts
  the binding-forms are bound to their respective init-exprs or parts
  the bindings of the recursion point to the values of the exprs.
  the collection and the corresponding index.
  the collection is empty, throws an exception.  Note - not the same
  the collection is empty, throws an exception. Returns coll"
  the command line."
  the component type. Class objects for the primitive types can be obtained
  the coordination overhead."
  the current thread. Each call *MUST* be accompanied by a matching call to
  the end, returns a distinguished loc detectable via end?. If already
  the eval reader (#=) and record/type literal syntax are disabled in read/load.
  the first argument, followed by the arguments to the constructor.
  the first.  If a key occurs in more than one map, the mapping from
  the first.  If a key occurs in more than one map, the mapping(s)
  the generated interface.  Do not repeat superinterface signatures
  the given function f to be called with a single argument, the signal.
  the given package-qualified :name (which, as all names in these
  the head of the sequence. Returns nil."
  the last. If no expressions are supplied, returns nil."}
  the latter (left-to-right) will be the mapping in the result."
  the maximum number of splits. Not lazy. Returns vector of the splits."
  the new method implementation by a local name.
  the protocol methods can be provided using extend.
  the read string. If the read is successful, reset the line number and re-read.
  the result by calling (f val-in-result val-in-latter)."
  the resulting vector shares structure with the original and no
  the rows in the java.sql.ResultSet rs"
  the same performance characteristics as nth for the given
  the same prefix. When specifying libs, prefix lists can be used to reduce
  the seq, does not retain the head and returns nil."
  the seq, retains the head and returns it, thus causing the entire
  the set of first items of each coll, followed by applying f to the
  the specified dimension(s).  Note that a class object is required.
  the superclass constructor and the state will be nil
  the symbolic name of the target namespace. Use :as in the ns macro in preference
  the tag and the value.  If *default-data-reader-fn* is nil (the
  the tests."
  the thread at the time bound-fn* was called and then call f with any given
  the top"
  the transform to the items in coll(s), i.e. to the set of first
  the validator if any, or restart will throw an exception and the
  the value has been transformed and the result supports
  the value of the corresponding expr and doesn't evaluate any of the
  the value of the last expr. (and) returns true."
  the value that was swapped in."
  the watch mechanism."
  the watch with remove-watch, but are otherwise considered opaque by
  the ys from x and returns the result. Does not auto-promote
  the ys from x and returns the result. Supports arbitrary precision.
  their type when read in later.
  their values"
  then applying xf to that result and the 2nd item, etc. If coll
  then expressions. Returns a tuple of [shift mask case-map switch-type] where
  then un-fails the agent so that sends are allowed again.  If
  there are fewer than n.  Returns a stateful transducer when
  there is an error closing the socket."
  therein. Acts as a recur target."
  therein."
  they appear."
  this directly.
  this means false return values will be included.  f must be free of
  this means false return values will be included.  f must be free of
  this will return :fred if :fred is in the sequence, otherwise nil:
  thread, but needs the same bindings in place."
  through each form for which the corresponding test
  through each form for which the corresponding test expression
  thrown AND that the message on the exception matches (with
  throws an exception or doesn't pass the validator fn, an
  throws, :val will be unprocessed.
  thus =) as a value, not an identity, comparison."
  time-hour       = 2DIGIT  ; 00-23
  time-minute     = 2DIGIT  ; 00-59
  time-numoffset  = ('+' / '-') time-hour ':' time-minute
  time-offset     = 'Z' / time-numoffset
  time-part       = time-hour [ ':' time-minute [ ':' time-second
  time-secfrac    = '.' 1*DIGIT
  time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second
  time.  If a test returns logical true, cond evaluates and returns
  timeout (in milliseconds) has elapsed. Returns logical false if
  timeout-val if the timeout (in milliseconds) is reached before a
  timestamp       = date-year [ '-' date-month [ '-' date-mday
  to :warn-on-boxed, same behavior as true, and a warning is emitted
  to a symbol different from the var's name, in order to prevent
  to calling this directly."
  to f and colls.  Thus function f should return a collection. Returns
  to fabricate one e.g. for sequences (pass nil). nav returns the
  to indicate the relative location of the next character on s. The stream
  to it"
  to protected members, nor to super, as these capabilities cannot be
  to reference the load code for the implementing namespace. Should be
  to results and, when calls with the same arguments are repeated often, has
  to specify the signatures of additional methods of the generated
  to specify which impl to use. You can extend a protocol on nil.
  to stop the given thread.  Defaults to the current thread"
  to the *compile-path* directory.  When not compiling, does
  to the *compile-path* directory.  When not compiling, does nothing.
  to the TypeReference protocol to indicate that they can be
  to the constructor. Must return [ [superclass-constructor-args] state] 
  to the items in coll. Transducers are applied in order as if
  to the var objects themselves, and must be accessed with var-get and
  to true."
  to val if supplied. The namespace must exist. The var will adopt any
  transaction and flow out of dosync. The exprs may be run more than
  transaction and flow out of sync. The exprs may be run more than
  transaction commit, when all refs have their final values.
  transaction, which are still held until commit. If no action is
  transduce by adding an arity-1 signature that calls cf (default -
  transducer is supplied, returns a lazy sequence of applications of
  transducer when no collection is provided."
  transducer when no collection is provided."
  tree."
  triggered the predicate, and its return value (if it does not throw
  trimming is done."
  true when implementing-ns is the default, false if you intend to
  true)
  true, at which point (set! afield aval) will be supported in method
  type in order to avoid reflective calls."
  type, not all protocols need be defined in a single extend call.
  type. If a method is overloaded in a protocol/interface, multiple
  types."
  types."
  types."
  unaffected."
  unambiguously resolved as a type name. The canonical format
  until a value is delivered.  The variant taking a timeout can be
  updates (via assoc) the proxy's fn map. nil can be passed instead of
  use the extend-type or extend-protocol macros.
  used for blocking references (futures and promises), and will return
  used with untrusted sources. See also: clojure.edn/read.***
  using function f. Note f will not necessarily be called
  using java.util.regex.Matcher.find(), each such match processed with
  using, e.g., Integer/TYPE."
  val(s). When applied to a transient vector, sets the val at index.
  validator fn, handler-fn will be called with two arguments: the
  validator-fn should return false or throw an exception. If the current state (root
  value (type-independent), otherwise false"
  value for the state. Note that, though final, the state can be a ref
  value if var) is not acceptable to the new validator, an exception
  value is available. See also - realized?."
  value obtained by calling (combinef) with no arguments). The results
  value of clojure.core.protocols/nav."
  value of condp. A single default expression can follow the clauses,
  value of key."
  value of the last expression. (or) returns nil."
  value of x supplied at the front of the given arguments.  The forms
  values as thread-local bindings. Then calls f with the supplied arguments.
  values as thread-local bindings. Then executes body. Pops the installed
  values.  Like clojure/replace but works on any data structure.  Does
  values.  Like clojure/replace but works on any data structure.  Does
  var-set"
  vars with per-thread bindings to the init-exprs.  The symbols refer
  vector/seq with any elements = a key in smap replaced with the
  vectors and Java arrays, this tests if the numeric key is within the
  versions can replace arguments in the second and third
  via boolean.
  walked.  Returns form."
  walked.  Returns form."
  was originally developed for Perl, and now has implementations in
  were successful, false otherwise."
  when .flush() is called, with a string built up since the last call to .flush().
  when compilation uses boxed math. Default: false."
  when x is logically 'less than', 'equal to', or 'greater than'
  where case-map is a map of int case values to [test then] tuples, switch-type
  where ks is a sequence of keys. Returns nil if the key
  where the keys will be the ordinals."
  where values are not supplied they will default to nil."
  which (test (.. sc comparator (compare ek key)) 0) is true"
  which (test (.. sc comparator (compare ek key)) 0) is true"
  which has the keys :tag, :attrs, and :content. and accessor fns tag,
  which must be a unary function, is called with the result of the
  which proxy is called. Each method fn takes an additional implicit
  will be aliased and should not be modified."
  will be called synchronously, on the agent's thread if an agent,
  will be defined, taking positional parameters for the fields"
  will be set to the value of:
  will be set to the value of:
  will be thrown and the validator will not be changed."
  will be thrown at runtime if the actual arg count does not match."
  will cache the result and return it on all subsequent force
  will generate an implementation that looks for a function named by 
  with (zero? (count x)). See also foldcat."
  with *testing-vars* bound to (conj *testing-vars* v)."
  with :max-history."
  with a Clojure namespace and a Java package that share its name. A lib's
  with the host (e.g. Java) but opens the door to incidental multiple
  with the metadata :volatile-mutable true or :unsynchronized-mutable
  with the same name as the protocol, i.e. given a protocol:
  with the shared prefix removed from the lib names. After removing the
  with the supplied identity constructor. Tests for identity
  with the syntax of refer-clojure/require/use/import/load/gen-class
  with their corresponding values, returning a modified expr.
  with-junit-output macro, like this:
  without any consecutive duplicates"
  without moving"
  without moving"
  without moving"
  work on all platforms.  Returns url on success, nil if not
  work.
  write-to-base
  writes the .class file to the *compile-path* directory.
  writes the .class file to the *compile-path* directory.
  writes to *out*, and prints exception summaries to *err*. If you use the
  x.equals(y) except it also works for nil. Boxed numbers must have
  x.toString().  (str nil) returns the empty string. With more than
  y. Same as Java x.compareTo(y) except it also works for nil, and
  years          0           9999      N/A (s must provide years)
  yield an instance of some derivee of Throwable."}
  your own PrintWriter (perhaps opened using
  zero or more options (in any order):
  {
  {
  {
  {
  {
  {
  {
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0"
  {:added "1.0", :forms '[(letfn [fnspecs*] exprs*)],
  {:added "1.0", :special-form true,
  {:added "1.0", :special-form true, :forms '[(let [bindings*] exprs*)]}
  {:added "1.0", :special-form true, :forms '[(loop [bindings*] exprs*)]}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"}
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.0"})
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"}
  {:added "1.1"} 
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.10"}
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2"
  {:added "1.2" :arglists '[[object]]} 
  {:added "1.2" :arglists '[[object]]} 
  {:added "1.2",
  {:added "1.2",
  {:added "1.2",
  {:added "1.2", :arglists '[[options* body]]}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"}
  {:added "1.2"} 
  {:added "1.2"} 
  {:added "1.2"} 
  {:added "1.2"} 
  {:added "1.2"} ;; Present since 1.2, but made public in 1.5.
  {:added "1.3"
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"}
  {:added "1.3"})
  {:added "1.4"
  {:added "1.4"
  {:added "1.4"}
  {:added "1.4"}
  {:added "1.4"}
  {:added "1.4"})
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.5"}
  {:added "1.6"
  {:added "1.6"
  {:added "1.6"
  {:added "1.6"
  {:added "1.6"}
  {:added "1.6"}
  {:added "1.6"}
  {:added "1.7"
  {:added "1.7"
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.7"}
  {:added "1.8"}
  {:added "1.8"}
  {:added "1.8"}
  {:added "1.8"}
  {:added "1.8"}
  {:added "1.8"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:added "1.9"}
  {:arglists '([name docstring? attr-map? dispatch-fn & options])
  {:arglists '([name docstring? attr-map? references*])
  {:arglists '([xform* coll])
  {:deprecated "1.8"}
  {:dynamic true
  {:dynamic true, :added "1.1"}
  {:inline (fn  [c i & nf] `(. clojure.lang.RT (nth ~c ~i ~@nf)))
  {:inline (fn  [m k & nf] `(. clojure.lang.RT (get ~m ~k ~@nf)))
  {:inline (fn  [x] `(. clojure.lang.RT (doubleCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (longCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedByteCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedCharCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedDoubleCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedFloatCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedIntCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedLongCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (uncheckedShortCast ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (~(if *unchecked-math* 'uncheckedByteCast 'byteCast) ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (~(if *unchecked-math* 'uncheckedCharCast 'charCast) ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (~(if *unchecked-math* 'uncheckedFloatCast 'floatCast) ~x)))
  {:inline (fn  [x] `(. clojure.lang.RT (~(if *unchecked-math* 'uncheckedShortCast 'shortCast) ~x)))
  {:inline (fn [& args] `(. clojure.lang.Numbers boolean_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers byte_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers char_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers double_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers float_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers int_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers long_array ~@args))
  {:inline (fn [& args] `(. clojure.lang.Numbers short_array ~@args))
  {:inline (fn [a i v] `(. clojure.lang.RT (aset ~a (int ~i) ~v)))
  {:inline (fn [a i] `(. clojure.lang.RT (aget ~a (int ~i))))
  {:inline (fn [a] `(. clojure.lang.RT (aclone ~a)))
  {:inline (fn [a] `(. clojure.lang.RT (alength ~a)))
  {:inline (fn [arg] `(. clojure.lang.RT object_array ~arg))
  {:inline (fn [x n] `(. clojure.lang.Numbers (shiftLeft ~x ~n)))
  {:inline (fn [x n] `(. clojure.lang.Numbers (shiftRight ~x ~n)))
  {:inline (fn [x n] `(. clojure.lang.Numbers (unsignedShiftRight ~x ~n)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (equiv ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (gt ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (gte ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (lt ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (lte ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_add ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_int_add ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_int_divide ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_int_multiply ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_int_remainder ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_int_subtract ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_minus ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Numbers (unchecked_multiply ~x ~y)))
  {:inline (fn [x y] `(. clojure.lang.Util equals ~x ~y))
  {:inline (fn [x y] `(. clojure.lang.Util equiv ~x ~y))
  {:inline (fn [x y] `(. clojure.lang.Util identical ~x ~y))
  {:inline (fn [x] `(. clojure.lang.Numbers (decP ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (incP ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (not ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (unchecked_dec ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (unchecked_inc ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (unchecked_int_dec ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (unchecked_int_inc ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (unchecked_int_negate ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (unchecked_minus ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (~(if *unchecked-math* 'unchecked_dec 'dec) ~x)))
  {:inline (fn [x] `(. clojure.lang.Numbers (~(if *unchecked-math* 'unchecked_inc 'inc) ~x)))
  {:inline (fn [x] `(clojure.lang.RT/isReduced ~x ))
  {:inline (nary-inline 'add 'unchecked_add)
  {:inline (nary-inline 'addP)
  {:inline (nary-inline 'andNot)
  {:inline (nary-inline 'divide)
  {:inline (nary-inline 'minus 'unchecked_minus)
  {:inline (nary-inline 'minusP)
  {:inline (nary-inline 'multiply 'unchecked_multiply)
  {:inline (nary-inline 'multiplyP)
  {:inline (nary-inline 'or)
  {:inline (nary-inline 'xor)
  {:make-reader (fn [x opts] (make-reader (make-input-stream x opts) opts))
  {:min (.min s) :max (.max s) :size (.size s) :min-index (.indexOfMin s) :max-index (.indexOfMax s)})
  {:name name :flag flag :contexts (set (map keyword contexts))})
  {:nrows 1 :get-value (fn [i] x) :get-label (fn [i] (.getName (class x)))})
  {:parameter-types (vec (map typesym (Type/getArgumentTypes md)))
  {:pre [(string? d)]}
  {:pre [(string? d)]}
  {:pre [(string? form)]}
  {:private true
  {:private true
  {:private true
  {:private true}
  {:redef true
  {:skip-wiki true}
  {:skip-wiki true}
  {:tag "[Ljava.lang.Object;"
  {:tag "[[Ljava.lang.Object;"
  {:tag :err
  {:tag :out
  {:tag :ret
  {:tag :tap
  {:tag BigDecimal
  {:tag BigInteger
  {:tag BigInteger
  {:tag BigInteger
  {:tag Boolean
  {:tag Boolean
  {:tag Boolean
  {:tag Boolean
  {:tag Boolean
  {:tag Boolean
  {:tag Boolean
  {:tag Boolean,
  {:tag Boolean,
  {:tag Number
  {:tag String
  {:tag String
  {:tag String
  {:tag String
  {:tag String
  {:tag String
  {:tag String
  {:tag String,
  {:tag String}
  {:tag clojure.lang.BigInt
  {:tag clojure.lang.Keyword
  {:tag clojure.lang.Keyword
  {:tag clojure.lang.Symbol
  {:tag java.util.regex.Matcher
  {:tag java.util.regex.Pattern
  {Float/TYPE "Float/TYPE"
  {})
  }
 "Defaults to true (or value specified by system property, see below)
 "Opens url (a string) in a Swing window."
 "Returns an object of the same type and value as obj, with
 "Returns true if coll implements Associative"
 "Returns true if coll implements Reversible"
 "Returns true if coll implements Sequential"
 "Returns true if coll implements Sorted"
 "Returns true if coll implements count in constant time"
 '(clojure.asm ClassWriter ClassVisitor Opcodes Type) 
 '(clojure.asm.commons Method GeneratorAdapter)
 '(clojure.lang IProxy Reflector DynamicClassLoader IPersistentMap PersistentHashMap RT))
 '(java.io Serializable NotSerializableException)
 '(java.lang.reflect Modifier Constructor)
 (. multifn removeMethod dispatch-val))
 (.reset multifn))
 (catch Throwable t
 (coll-fold
 (coll-fold
 (coll-fold
 (coll-fold
 (fn [fdecl]
 (fn ^:static assoc
 (kv-reduce
 (kv-reduce
 (kv-reduce
 (let [m (proxy-mappings this)]
 (let [results [46 38 22]]
 (load-data-readers)
 (par [11 2 3 2] 
 (print-ctor o #(print-sequential "[" print-dup " " "]" %1 %2) w))
 (ref (sorted-map
 (reify options* specs*)
 *1)
 *2)
 *3)
 *e)
 *print-base* 10)
 *print-circle* nil)
 *print-length* nil)
 *print-level* nil)
 *print-lines* nil)
 *print-miser-width* 40)
 *print-namespace-maps* false)
 *print-pprint-dispatch* nil)
 *print-pretty* true)
 *print-radix* nil)
 *print-right-margin* 72)
 *print-shared* nil)
 *print-suppress-namespaces* nil)
 *stack-trace-depth* nil)
 ;;slow path default
 Object
 There are 3 results: 46, 38, 22
 [^Class super interfaces]
 [^clojure.lang.IRef iref] (. iref (getValidator)))
 [^clojure.lang.IReference iref f & args] (.alterMeta iref f args))
 [^clojure.lang.IReference iref metadata-map] (.resetMeta iref metadata-map))
 [^clojure.lang.MultiFn multifn dispatch-val]
 [^clojure.lang.MultiFn multifn]
 [obj f & args]
 [url]
 ^{:arglists '([& items])
 ^{:arglists '([^Class c x])
 ^{:arglists '([^clojure.lang.IObj obj m])
 ^{:arglists '([coll x] [coll x & xs])
 ^{:arglists '([coll])
 ^{:arglists '([coll])
 ^{:arglists '([coll])
 ^{:arglists '([coll])
 ^{:arglists '([coll])
 ^{:arglists '([map key val] [map key val & kvs])
 ^{:arglists '([obj])
 ^{:arglists '([x seq])
 ^{:arglists '([x])
 ^{:arglists '([x])
 ^{:arglists '([x])
 ^{:arglists '([x])
 ^{:arglists '([x])
 ^{:arglists '(^clojure.lang.ISeq [coll])
 ^{:doc "*print-length* controls how many items of each collection the
 ^{:doc "*print-level* controls how many levels deep the printer will
 ^{:doc "*print-namespace-maps* controls whether the printer will print
 ^{:doc "Bind to true if you want write to use pretty printing", :added "1.2"}
 ^{:doc "Don't print namespaces with symbols. This is particularly useful when 
 ^{:doc "Like defn, but the resulting function name is declared as a
 ^{:doc "Pretty printing will try to avoid anything going beyond this column.
 ^{:doc "Print a radix specifier in front of integers and rationals. If *print-base* is 2, 8, 
 ^{:doc "Same as (def name (fn [params* ] exprs*)) or (def
 ^{:doc "Same as (first (first x))"
 ^{:doc "Same as (first (next x))"
 ^{:doc "Same as (first (next x))"
 ^{:doc "Same as (next (first x))"
 ^{:doc "Same as (next (next x))"
 ^{:doc "The base to use for printing integers and rationals."
 ^{:doc "The column at which to enter miser style. Depending on the dispatch table, 
 ^{:doc "The maximum depth of stack traces to print when an Exception
 ^{:doc "The pretty print dispatch function. Use with-pprint-dispatch or set-pprint-dispatch
 ^{:doc "bound in a repl thread to the most recent exception caught by the repl"
 ^{:doc "bound in a repl thread to the most recent value printed"
 ^{:doc "bound in a repl thread to the second most recent value printed"
 ^{:doc "bound in a repl thread to the third most recent value printed"
 ^{:macro true
 ^{:macro true
 ^{:private true,
 ^{:private true,
 ^{:private true,
 ^{:private true}
 ^{:tag Boolean
 ^{:tag Boolean
 `(proxy-call-with-super (fn [] (. ~'this ~meth ~@args))  ~'this ~(name meth)))
 assoc
 butlast (fn ^:static butlast [s]
 byte-array-type (class (make-array Byte/TYPE 0)))
 changes."
 char-array-type (class (make-array Character/TYPE 0)))
 char-name-string
 char? (fn ^:static char? [x] (instance? Character x)))
 clojure.lang.IKVReduce
 clojure.lang.IPersistentMap
 clojure.lang.IPersistentVector
 clojure.lang.PersistentHashMap
 conj (fn ^:static conj
 cons (fn* ^:static cons [x seq] (. clojure.lang.RT (cons x seq))))
 contains a match for re-string-or-pattern"
 defmacro (fn [&form &env
 defn (fn defn [&form &env name & fdecl]
 expr."
 ffirst (fn ^:static ffirst [x] (first (first x))))
 first (fn ^:static first [coll] (. clojure.lang.RT (first coll))))
 fn (fn* fn [&form &env & decl]
 fnext (fn ^:static fnext [x] (first (next x))))
 instance? (fn instance? [^Class c x] (. c (isInstance x))))
 last (fn ^:static last [s]
 loop (fn* loop [&form &env & decl] (cons 'loop* decl)))
 map? (fn ^:static map? [x] (instance? clojure.lang.IPersistentMap x)))
 meta (fn ^:static meta [x]
 next (fn ^:static next [x] (. clojure.lang.RT (next x))))
 nfirst (fn ^:static nfirst [x] (next (first x))))
 nil
 nil
 nnext (fn ^:static nnext [x] (next (next x))))
 not-any? (comp not some))
 not-every? (comp not every?))
 rest (fn ^:static rest [x] (. clojure.lang.RT (more x))))
 second (fn ^:static second [x] (first (next x))))
 seq (fn ^:static seq ^clojure.lang.ISeq [coll] (. clojure.lang.RT (seq coll))))
 seq? (fn ^:static seq? [x] (instance? clojure.lang.ISeq x)))
 sigs
 string? (fn ^:static string? [x] (instance? String x)))
 thread-locally bound."
 vector? (fn ^:static vector? [x] (instance? clojure.lang.IPersistentVector x)))
 with-meta (fn ^:static with-meta [^clojure.lang.IObj x m]
 without moving"
 {:added "1.0"
 {:added "1.0"
 {:added "1.0"
 {:added "1.0"
 {:added "1.0"
 {:added "1.0"
 {:tag String} 
"
"
"
")
"}
#_(defn =
#_(defn into
(-> dz down right right down right (replace '/) root)
(-> dz down right right down right)
(-> dz next next (edit str) next next next (replace '/) root)
(-> dz next next next next next next next next next remove (insert-right 'e) root)
(-> dz next next next next next next next next next remove root)
(-> dz next next next next next next next next next remove up (append-child 'e) root)
(-> dz next remove next remove root)
(. (var defmacro) (setMacro))
(. (var defn) (setMacro))
(add-doc-and-meta *clojure-version*
(add-doc-and-meta *command-line-args*
(add-doc-and-meta *compile-files*
(add-doc-and-meta *compile-path*
(add-doc-and-meta *compiler-options*
(add-doc-and-meta *err*
(add-doc-and-meta *file*
(add-doc-and-meta *flush-on-newline*
(add-doc-and-meta *in*
(add-doc-and-meta *ns*
(add-doc-and-meta *out*
(add-doc-and-meta *print-dup*
(add-doc-and-meta *print-meta*
(add-doc-and-meta *print-readably*
(add-doc-and-meta *read-eval*
(add-doc-and-meta *unchecked-math*
(add-doc-and-meta *warn-on-reflection*
(alias 'core 'clojure.core)
(alias 'parallel 'clojure.parallel)
(alter-meta! #'*agent* assoc :added "1.0")
(alter-meta! #'in-ns assoc :added "1.0")
(alter-meta! #'load-file assoc :added "1.0")
(alter-meta! (find-ns 'clojure.core) assoc :doc "Fundamental library of the Clojure language")
(comment
(comment
(comment
(comment
(comment
(comment
(comment
(comment "
(declare cat)
(declare collect-clauses)
(declare compile-format)
(declare default-reflector)
(declare diff)
(declare emit-nl)
(declare execute-format)
(declare flatten)
(declare format-logical-block)
(declare format-simple-number)
(declare gen-class)
(declare get-miser-width)
(declare init-navigator)
(declare justify-clauses)
(declare main)
(declare opt-base-str)
(declare pprint-simple-code-list)
(declare process-annotation)
(declare relative-reposition)
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def
(def  ^:dynamic ^{ :private true } *current-level* 0)
(def EMPTY-NODE (VecNode. nil (object-array 32)))
(def ^:declared ^:redef load)
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic
(def ^:dynamic *core-java-api*
(def ^:dynamic *current*)
(def ^:dynamic *depth*)
(def ^:dynamic *feeling-lucky* true)
(def ^:dynamic *feeling-lucky-url* "http://www.google.com/search?btnI=I%27m%20Feeling%20Lucky&q=allinurl:")
(def ^:dynamic *initial-report-counters*  ; used to initialize *report-counters*
(def ^:dynamic *local-javadocs* (ref (list)))
(def ^:dynamic *open-url-script* (atom :uninitialized))
(def ^:dynamic *remote-javadocs*
(def ^:dynamic *report-counters* nil)      ; bound to a ref of a map in test-ns
(def ^:dynamic *sb*)
(def ^:dynamic *session* nil)
(def ^:dynamic *sh-dir* nil)
(def ^:dynamic *sh-env* nil)
(def ^:dynamic *stack*)
(def ^:dynamic *state*) ; :element :chars :between
(def ^:dynamic *test-out* *out*)         ; PrintWriter for test reporting output
(def ^:dynamic *testing-contexts* (list)) ; bound to hierarchy of "testing" strings
(def ^:dynamic *testing-vars* (list))  ; bound to hierarchy of vars being tested
(def ^:dynamic *var-context*)
(def ^:dynamic *verbose-defrecords* false)
(def ^:dynamic ^{ :private true } *current-length* nil)
(def ^:dynamic ^{:private true} *code-table*
(def ^:dynamic ^{:private true} *default-page-width* 72)
(def ^:dynamic ^{:private true} *format-str* nil)
(def ^:dynamic ^{:private true} *symbol-map* {})
(def ^:dynamic ^{:private true} print-initialized false)
(def ^:private ^String system-newline
(def ^:private ^ThreadLocal thread-local-utc-date-format
(def ^:private ^ThreadLocal thread-local-utc-timestamp-format
(def ^:private core-namespaces
(def ^:private days-in-month
(def ^:private default-reflector
(def ^:private max-mask-bits 13)
(def ^:private max-switch-table-size (bit-shift-left 1 max-mask-bits))
(def ^:private pp-newline (memoize #(System/getProperty "line.separator")))
(def ^:private special-doc-map
(def ^:private timestamp
(def ^{:added "1.4" :dynamic true} *data-readers*
(def ^{:added "1.4"} default-data-readers
(def ^{:added "1.5" :dynamic true} *default-data-reader-fn*
(def ^{:doc "A sequence of lib specs that are applied to `require`
(def ^{:doc "The Java access bitflags, along with their friendly names and
(def ^{:private true :dynamic true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true}
(def ^{:private true} 
(def ^{:private true} 
(def ^{:private true} ams
(def ^{:private true} cached-compile (memoize compile-format))
(def ^{:private true} orig-pr pr)
(def ^{:private true} pprint-array (formatter-out "~<[~;~@{~w~^, ~:_~}~;]~:>"))
(def ^{:private true} pprint-hold-first (formatter-out "~:<~w~^ ~@_~w~^ ~_~@{~w~^ ~_~}~:>"))
(def ^{:private true} pprint-if (formatter-out "~:<~1I~w~^ ~@_~w~@{ ~_~w~}~:>"))
(def ^{:private true} pprint-pqueue (formatter-out "~<<-(~;~@{~w~^ ~_~}~;)-<~:>"))
(def ^{:private true} pprint-set (formatter-out "~<#{~;~@{~w~^ ~:_~}~;}~:>"))
(def ^{:private true} prim->class
(def ^{:private true} print-initialized true)
(def ^{:private true} reader-macros
(def ^{:private true} write-option-table
(def ^{:tag String
(def ^{:tag String 
(def a (make-array Object 1000000))
(def attrs (accessor element :attrs))
(def content (accessor element :content))
(def content-handler
(def data '[[a * b] + [c * d]])
(def default-streams-impl
(def dz (vector-zip data))
(def global-hierarchy)
(def map)
(def pool (delay (java.util.concurrent.ForkJoinPool.)))
(def primitives-classnames
(def tag (accessor element :tag))
(def unquote)
(def unquote-splicing)
(def v (range 1000000))
(def xs #{{:a 11 :b 1 :c 1 :d 4}
(def ys #{{:a 11 :b 11 :c 11 :e 5}
(def-aset
(def-aset
(def-aset
(def-aset
(def-aset
(def-aset
(def-aset
(def-aset
(defcurried drop
(defcurried filter
(defcurried flatten
(defcurried map
(defcurried mapcat
(defcurried remove
(defcurried take
(defcurried take-while
(defdirectives 
(definline booleans
(definline bytes
(definline chars
(definline doubles
(definline floats
(definline ints
(definline longs
(definline shorts
(definterface ArrayManager
(definterface IVecImpl
(definterface PrettyFlush
(defmacro
(defmacro ->
(defmacro ->>
(defmacro ..
(defmacro ^:private ams-check [t]
(defmacro ^:private defcurried
(defmacro ^:private fail
(defmacro ^:private rfn
(defmacro ^:private thread
(defmacro ^:private verify
(defmacro ^:private when-class [class-name & body]
(defmacro ^:private with-lock
(defmacro ^{:private true}
(defmacro ^{:private true}
(defmacro ^{:private true}
(defmacro ^{:private true} 
(defmacro ^{:private true} 
(defmacro ^{:private true} assert-args
(defmacro ^{:private true} binding-map [amap & body]
(defmacro ^{:private true} prlabel
(defmacro ^{:private true} with-pretty-writer [base-writer & body]
(defmacro add-doc-and-meta {:private true} [name docstring meta]
(defmacro amap
(defmacro and
(defmacro are
(defmacro areduce
(defmacro as->
(defmacro assert
(defmacro binding
(defmacro bound-fn
(defmacro case
(defmacro comment
(defmacro cond
(defmacro cond->
(defmacro cond->>
(defmacro condp
(defmacro declare
(defmacro definline
(defmacro definterface
(defmacro defmethod
(defmacro defmulti
(defmacro defn-
(defmacro defonce
(defmacro defprotocol 
(defmacro defrecord
(defmacro defstruct
(defmacro deftest
(defmacro deftest-
(defmacro deftype
(defmacro delay
(defmacro dir
(defmacro do-template
(defmacro doc
(defmacro doseq
(defmacro dosync
(defmacro dotimes
(defmacro dotimes
(defmacro doto
(defmacro extend-protocol 
(defmacro extend-type 
(defmacro fn
(defmacro for
(defmacro formatter
(defmacro formatter-out
(defmacro future
(defmacro gen-class 
(defmacro gen-interface
(defmacro if-let
(defmacro if-not
(defmacro if-some
(defmacro import
(defmacro io!
(defmacro is
(defmacro lazy-cat
(defmacro lazy-seq
(defmacro let
(defmacro letfn
(defmacro locking
(defmacro loop
(defmacro memfn
(defmacro mk-am {:private true} [t]
(defmacro ns
(defmacro or
(defmacro pp 
(defmacro pprint-logical-block 
(defmacro print-length-loop
(defmacro proxy
(defmacro proxy-super 
(defmacro pvalues
(defmacro refer-clojure
(defmacro reify 
(defmacro set-test
(defmacro some->
(defmacro some->>
(defmacro source
(defmacro sync
(defmacro testing
(defmacro time
(defmacro try-expr
(defmacro vswap!
(defmacro when
(defmacro when-first
(defmacro when-let
(defmacro when-not
(defmacro when-some
(defmacro while
(defmacro with-bindings
(defmacro with-bindings
(defmacro with-in-str
(defmacro with-junit-output
(defmacro with-loading-context [& body]
(defmacro with-local-vars
(defmacro with-open
(defmacro with-out-str
(defmacro with-pprint-dispatch 
(defmacro with-precision
(defmacro with-read-known
(defmacro with-redefs
(defmacro with-sh-dir
(defmacro with-sh-env
(defmacro with-tap-output
(defmacro with-test
(defmacro with-test-out
(defmethod assert-expr 'instance? [msg form]
(defmethod assert-expr 'thrown-with-msg? [msg form]
(defmethod assert-expr 'thrown? [msg form]
(defmethod assert-expr :always-fail [msg form]
(defmethod assert-expr :default [msg form]
(defmethod do-copy [File File] [^File input ^File output opts]
(defmethod do-copy [File OutputStream] [^File input ^OutputStream output opts]
(defmethod do-copy [File Writer] [^File input ^Writer output opts]
(defmethod do-copy [InputStream File] [^InputStream input ^File output opts]
(defmethod do-copy [InputStream OutputStream] [^InputStream input ^OutputStream output opts]
(defmethod do-copy [InputStream Writer] [^InputStream input ^Writer output opts]
(defmethod do-copy [Reader File] [^Reader input ^File output opts]
(defmethod do-copy [Reader OutputStream] [^Reader input ^OutputStream output opts]
(defmethod do-copy [Reader Writer] [^Reader input ^Writer output opts]
(defmethod do-copy [String File] [^String input ^File output opts]
(defmethod do-copy [String OutputStream] [^String input ^OutputStream output opts]
(defmethod do-copy [String Writer] [^String input ^Writer output opts]
(defmethod do-copy [byte-array-type File] [^"[B" input ^Writer output opts]
(defmethod do-copy [byte-array-type OutputStream] [^"[B" input ^OutputStream output opts]
(defmethod do-copy [byte-array-type Writer] [^"[B" input ^Writer output opts]
(defmethod do-copy [char-array-type File] [input ^File output opts]
(defmethod do-copy [char-array-type OutputStream] [input ^OutputStream output opts]
(defmethod do-copy [char-array-type Writer] [input ^Writer output opts]
(defmethod emit-nl? :fill [newl this section subsection]
(defmethod emit-nl? :linear [newl this section _]
(defmethod emit-nl? :mandatory [_ _ _ _]
(defmethod emit-nl? :miser [newl this section _]
(defmethod get-child :default [parent index]
(defmethod get-child :entry [e index]
(defmethod get-child :seqable [parent index]
(defmethod get-child-count :default [parent]
(defmethod get-child-count :entry [e]
(defmethod get-child-count :seqable [parent]
(defmethod is-leaf :default [node]
(defmethod is-leaf :entry [e]
(defmethod is-leaf :seqable [parent]
(defmethod junit-report :begin-test-ns [m]
(defmethod junit-report :begin-test-var [m]
(defmethod junit-report :default [_])
(defmethod junit-report :end-test-ns [_]
(defmethod junit-report :end-test-var [m]
(defmethod junit-report :error [m]
(defmethod junit-report :fail [m]
(defmethod junit-report :pass [m]
(defmethod list-provider :default [x]
(defmethod list-provider java.util.List [c]
(defmethod list-provider java.util.Map [c]
(defmethod print-dup Boolean [o w] (print-method o w))
(defmethod print-dup Class [^Class c, ^Writer w]
(defmethod print-dup Number [o, ^Writer w]
(defmethod print-dup String [s w] (print-method s w))
(defmethod print-dup clojure.lang.BigInt [o w] (print-method o w))
(defmethod print-dup clojure.lang.Fn [o, ^Writer w]
(defmethod print-dup clojure.lang.IPersistentCollection [o, ^Writer w]
(defmethod print-dup clojure.lang.IPersistentList [o w] (print-method o w))
(defmethod print-dup clojure.lang.IPersistentMap [m, ^Writer w]
(defmethod print-dup clojure.lang.IRecord [r, ^Writer w]
(defmethod print-dup clojure.lang.ISeq [o w] (print-method o w))
(defmethod print-dup clojure.lang.Keyword [o w] (print-method o w))
(defmethod print-dup clojure.lang.LazilyPersistentVector [o w] (print-method o w))
(defmethod print-dup clojure.lang.Namespace [^clojure.lang.Namespace n ^Writer w]
(defmethod print-dup clojure.lang.PersistentHashMap [o w] (print-method o w))
(defmethod print-dup clojure.lang.PersistentHashSet [o w] (print-method o w))
(defmethod print-dup clojure.lang.PersistentVector [o w] (print-method o w))
(defmethod print-dup clojure.lang.Ratio [o w] (print-method o w))
(defmethod print-dup clojure.lang.Symbol [o w] (print-method o w))
(defmethod print-dup clojure.lang.Var [^clojure.lang.Var o, ^Writer w]
(defmethod print-dup java.lang.Character [c w] (print-method c w))
(defmethod print-dup java.lang.Double [o w] (print-method o w))
(defmethod print-dup java.lang.Long [o w] (print-method o w))
(defmethod print-dup java.math.BigDecimal [o w] (print-method o w))
(defmethod print-dup java.sql.Timestamp
(defmethod print-dup java.util.Calendar
(defmethod print-dup java.util.Collection [o, ^Writer w]
(defmethod print-dup java.util.Date
(defmethod print-dup java.util.Map [m, ^Writer w]
(defmethod print-dup java.util.UUID [o w]
(defmethod print-dup java.util.regex.Pattern [p ^Writer w] (print-method p w))
(defmethod print-dup nil [o w] (print-method o w))
(defmethod print-method ::Vec [v w]
(defmethod print-method ::VecSeq [v w]
(defmethod print-method :default [o, ^Writer w]
(defmethod print-method Boolean [o, ^Writer w]
(defmethod print-method Class [^Class c, ^Writer w]
(defmethod print-method Double [o, ^Writer w]
(defmethod print-method Eduction [c, ^Writer w]
(defmethod print-method Float [o, ^Writer w]
(defmethod print-method Number [o, ^Writer w]
(defmethod print-method Object [o, ^Writer w]
(defmethod print-method StackTraceElement [^StackTraceElement o ^Writer w]
(defmethod print-method String [^String s, ^Writer w]
(defmethod print-method Throwable [^Throwable o ^Writer w]
(defmethod print-method clojure.lang.BigInt [b, ^Writer w]
(defmethod print-method clojure.lang.IDeref [o ^Writer w]
(defmethod print-method clojure.lang.IPersistentMap [m, ^Writer w]
(defmethod print-method clojure.lang.IPersistentSet [s, ^Writer w]
(defmethod print-method clojure.lang.IPersistentVector [v, ^Writer w]
(defmethod print-method clojure.lang.IRecord [r, ^Writer w]
(defmethod print-method clojure.lang.ISeq [o, ^Writer w]
(defmethod print-method clojure.lang.Keyword [o, ^Writer w]
(defmethod print-method clojure.lang.ReaderConditional [o ^Writer w]
(defmethod print-method clojure.lang.Symbol [o, ^Writer w]
(defmethod print-method clojure.lang.TaggedLiteral [o ^Writer w]
(defmethod print-method clojure.lang.Var [o, ^Writer w]
(defmethod print-method java.lang.Character [^Character c, ^Writer w]
(defmethod print-method java.math.BigDecimal [b, ^Writer w]
(defmethod print-method java.sql.Timestamp
(defmethod print-method java.util.Calendar
(defmethod print-method java.util.Date
(defmethod print-method java.util.List [c, ^Writer w]
(defmethod print-method java.util.Map [m, ^Writer w]
(defmethod print-method java.util.RandomAccess [v, ^Writer w]
(defmethod print-method java.util.Set [s, ^Writer w]
(defmethod print-method java.util.UUID [uuid ^java.io.Writer w]
(defmethod print-method java.util.regex.Pattern [p ^Writer w]
(defmethod print-method nil [o, ^Writer w]
(defmethod report :begin-test-ns [m]
(defmethod report :begin-test-var [m])
(defmethod report :default [m]
(defmethod report :end-test-ns [m])
(defmethod report :end-test-var [m])
(defmethod report :error [m]
(defmethod report :fail [m]
(defmethod report :pass [m]
(defmethod report :summary [m]
(defmethod table-model :default [x]
(defmethod tap-report :default [data]
(defmethod tap-report :error [data]
(defmethod tap-report :fail [data]
(defmethod tap-report :pass [data]
(defmethod tap-report :summary [data]
(defmethod tok :buffer-blob [token]
(defmethod tok :default [token]
(defmethod tok :nl-t [token]
(defmethod use-fixtures :each [fixture-type & args]
(defmethod use-fixtures :once [fixture-type & args]
(defmethod write-token :buffer-blob [^Writer this token]
(defmethod write-token :end-block-t [^Writer this token]
(defmethod write-token :indent-t [^Writer this token]
(defmethod write-token :nl-t [^Writer this token]
(defmethod write-token :start-block-t [^Writer this token]
(defmulti
(defmulti
(defmulti 
(defmulti 
(defmulti ^:dynamic junit-report :type)
(defmulti ^:dynamic tap-report :type)
(defmulti ^{:private true} emit-nl? (fn [t _ _ _] (:type t)))
(defmulti ^{:private true} tok :type-tag)
(defmulti ^{:private true} write-token #(:type-tag %2))
(defmulti assert-expr 
(defmulti get-child (fn [parent index] (collection-tag parent)))
(defmulti get-child-count collection-tag)
(defmulti is-leaf collection-tag)
(defmulti list-provider class)
(defmulti print-dup (fn [x writer] (class x)))
(defmulti print-method (fn [x writer]
(defmulti table-model class)
(defmulti use-fixtures
(defn
(defn *
(defn *'
(defn +
(defn +'
(defn -
(defn -'
(defn -cache-protocol-fn [^clojure.lang.AFunction pf x ^Class c ^clojure.lang.IFn interf]
(defn -reset-methods [protocol]
(defn /
(defn <
(defn <=
(defn =
(defn ==
(defn >
(defn >=
(defn StackTraceElement->vec
(defn Throwable->map
(defn ^:private >0? [n] (clojure.lang.Numbers/gt n 0))
(defn ^:private >1? [n] (clojure.lang.Numbers/gt n 1))
(defn ^:private ^:static
(defn ^:private check-valid-options
(defn ^:private deref-future
(defn ^:private elide-top-frames
(defn ^:private into1
(defn ^:private nary-inline
(defn ^:private preserving-reduced
(defn ^:static  ^clojure.lang.IChunk chunk-first ^clojure.lang.IChunk [^clojure.lang.IChunkedSeq s]
(defn ^:static ^clojure.lang.ChunkBuffer chunk-buffer ^clojure.lang.ChunkBuffer [capacity]
(defn ^:static ^clojure.lang.IChunk chunk [^clojure.lang.ChunkBuffer b]
(defn ^:static ^clojure.lang.ISeq chunk-next ^clojure.lang.ISeq [^clojure.lang.IChunkedSeq s]
(defn ^:static ^clojure.lang.ISeq chunk-rest ^clojure.lang.ISeq [^clojure.lang.IChunkedSeq s]
(defn ^:static await1 [^clojure.lang.Agent a]
(defn ^:static chunk-append [^clojure.lang.ChunkBuffer b x]
(defn ^:static chunk-cons [chunk rest]
(defn ^:static chunked-seq? [s]
(defn ^File file
(defn ^InputStream input-stream
(defn ^OutputStream output-stream
(defn ^Reader reader
(defn ^String as-relative-path
(defn ^String capitalize
(defn ^String escape
(defn ^String join
(defn ^String lower-case
(defn ^String re-quote-replacement
(defn ^String replace
(defn ^String replace-first
(defn ^String reverse
(defn ^String trim
(defn ^String trim-newline
(defn ^String triml
(defn ^String trimr
(defn ^String upper-case
(defn ^URL resource
(defn ^Writer writer
(defn ^java.io.PrintWriter PrintWriter-on
(defn ^{:private true
(defn ^{:private true}
(defn ^{:private true}
(defn ^{:private true}
(defn accessor
(defn aclone
(defn add-classpath
(defn add-local-javadoc
(defn add-remote-javadoc
(defn add-tap
(defn add-watch
(defn agent
(defn agent-error
(defn agent-errors
(defn aget
(defn alength
(defn alias
(defn all-ns
(defn alter
(defn alter-meta!
(defn alter-var-root
(defn ancestors
(defn any?
(defn append!
(defn append-child
(defn apply
(defn apply-template
(defn apropos
(defn array-map
(defn aset
(defn assert-any
(defn assert-predicate
(defn assoc!
(defn assoc-in
(defn associative?
(defn atom
(defn atom? [x]
(defn await
(defn await-for
(defn bases
(defn bean
(defn bigdec
(defn bigint
(defn biginteger
(defn binding-conveyor-fn
(defn bit-and
(defn bit-and-not
(defn bit-clear
(defn bit-flip
(defn bit-not
(defn bit-or
(defn bit-set
(defn bit-shift-left
(defn bit-shift-right
(defn bit-test
(defn bit-xor
(defn blank?
(defn boolean
(defn boolean-array
(defn boolean?
(defn bound-fn*
(defn bound?
(defn bounded-count
(defn branch?
(defn browse-url
(defn byte
(defn byte-array
(defn bytes?
(defn cast
(defn cat
(defn cat
(defn char
(defn char-array
(defn children
(defn cl-format 
(defn class
(defn class?
(defn clear-agent-errors
(defn coll?
(defn collection-tag [x]
(defn commute
(defn comp
(defn comparator
(defn compare
(defn compare-and-set!
(defn compile
(defn complement
(defn completing
(defn compose-fixtures
(defn concat
(defn conj!
(defn constantly
(defn construct-proxy
(defn contains?
(defn copy
(defn count
(defn counted?
(defn create-ns
(defn create-struct
(defn cycle
(defn datafy
(defn dec
(defn dec'
(defn decimal?
(defn dedupe
(defn delay?
(defn delete-file
(defn deliver
(defn demunge
(defn demunge
(defn denominator
(defn deref
(defn derive
(defn descendants
(defn destructure [bindings]
(defn diff
(defn difference
(defn dir-fn
(defn disj
(defn disj!
(defn dissoc
(defn dissoc!
(defn distinct
(defn distinct?
(defn do-report
(defn doall
(defn dorun
(defn double
(defn double-array
(defn double?
(defn down
(defn drop
(defn drop-last
(defn drop-while
(defn e
(defn edit
(defn eduction
(defn element-content
(defn emit [x]
(defn emit-element [e]
(defn empty
(defn empty?
(defn end?
(defn ends-with?
(defn ensure
(defn ensure-reduced
(defn enumeration-seq
(defn err->msg
(defn error-el
(defn error-handler
(defn error-mode
(defn eval
(defn even?
(defn every-pred
(defn every?
(defn ex-cause
(defn ex-data
(defn ex-info
(defn ex-message
(defn ex-str
(defn ex-triage
(defn extend 
(defn extenders 
(defn extends? 
(defn failure-el
(defn false?
(defn file-position
(defn file-seq
(defn filter
(defn filterv
(defn find
(defn find-doc
(defn find-keyword
(defn find-ns
(defn find-protocol-impl [protocol x]
(defn find-protocol-method [protocol methodk x]
(defn find-var
(defn finish-case
(defn finish-element
(defn finish-suite
(defn fjtask [^Callable f]
(defn flatten
(defn float
(defn float-array
(defn float?
(defn flush
(defn fn?
(defn fnil
(defn fold
(defn foldcat
(defn folder
(defn force
(defn format
(defn frequencies
(defn fresh-line
(defn function?
(defn future-call
(defn future-cancel
(defn future-cancelled?
(defn future-done?
(defn future?
(defn gen-and-load-class 
(defn gensym
(defn get
(defn get-in
(defn get-method
(defn get-possibly-unbound-var
(defn get-pretty-writer 
(defn get-proxy-class 
(defn get-thread-bindings
(defn get-validator
(defn group-by
(defn halt-when
(defn hash
(defn hash-combine [x y] 
(defn hash-map
(defn hash-ordered-coll
(defn hash-set
(defn hash-unordered-coll
(defn ident?
(defn identical?
(defn identity
(defn ifn?
(defn inc
(defn inc'
(defn inc-report-counter
(defn includes?
(defn indent
(defn index
(defn index-of
(defn indexed?
(defn init-proxy
(defn insert-child
(defn insert-left
(defn insert-right
(defn inspect
(defn inspect-table 
(defn inspect-tree 
(defn inst-ms
(defn inst?
(defn int
(defn int-array
(defn int?
(defn integer?
(defn interleave
(defn intern
(defn interpose
(defn intersection
(defn into
(defn into-array
(defn io-prepl
(defn isa?
(defn iterate
(defn iterator-seq
(defn javadoc
(defn join
(defn join-fixtures
(defn juxt
(defn keep
(defn keep-indexed
(defn key
(defn keys
(defn keyword
(defn keyword?
(defn keywordize-keys
(defn last-index-of
(defn left
(defn leftmost
(defn lefts
(defn line-seq
(defn list*
(defn list-model [provider]
(defn list?
(defn load
(defn load-reader
(defn load-script
(defn load-string
(defn loaded-libs
(defn long
(defn long-array
(defn macroexpand
(defn macroexpand-1
(defn macroexpand-all
(defn main
(defn make-array
(defn make-hierarchy
(defn make-node
(defn make-parents
(defn map
(defn map-entry?
(defn map-indexed
(defn map-invert
(defn mapcat
(defn mapv
(defn max
(defn max-key
(defn memoize
(defn merge
(defn merge-with
(defn message-el
(defn method-sig [^java.lang.reflect.Method meth]
(defn methods
(defn min
(defn min-key
(defn mix-collection-hash
(defn mk-bound-fn
(defn mod
(defn monoid
(defn munge [s]
(defn name
(defn namespace
(defn namespace-munge
(defn nat-int?
(defn nav
(defn neg-int?
(defn neg?
(defn newline
(defn next
(defn nil?
(defn node
(defn not
(defn not-empty
(defn not=
(defn ns-aliases
(defn ns-imports
(defn ns-interns
(defn ns-map
(defn ns-name
(defn ns-publics
(defn ns-refers
(defn ns-resolve
(defn ns-unalias
(defn ns-unmap
(defn nth
(defn nthnext
(defn nthrest
(defn num
(defn number?
(defn numerator
(defn object-array
(defn odd?
(defn old-table-model [data]
(defn package-class
(defn pany
(defn par
(defn parents
(defn parse
(defn parse-timestamp
(defn partial
(defn partition
(defn partition-all
(defn partition-by
(defn path
(defn pcalls
(defn pdistinct
(defn peek
(defn persistent!
(defn pfilter-dupes 
(defn pfilter-nils
(defn pmap
(defn pmax
(defn pmin
(defn pop
(defn pop!
(defn pop-thread-bindings
(defn pos-int?
(defn pos?
(defn postwalk
(defn postwalk-demo
(defn postwalk-replace
(defn pprint 
(defn pprint-indent 
(defn pprint-newline
(defn pprint-tab 
(defn pr
(defn pr-on
(defn pr-str
(defn preduce 
(defn prefer-method
(defn prefers
(defn prepl
(defn prev
(defn prewalk
(defn prewalk-demo
(defn prewalk-replace
(defn print
(defn print-cause-trace
(defn print-ctor [o print-args ^Writer w]
(defn print-diagnostics [data]
(defn print-simple [o, ^Writer w]
(defn print-stack-trace
(defn print-str
(defn print-table
(defn print-tap-diagnostic
(defn print-tap-fail 
(defn print-tap-pass
(defn print-tap-plan
(defn print-throwable
(defn print-trace-element
(defn printf
(defn println
(defn println-str
(defn prn
(defn prn-str
(defn project
(defn promise
(defn proxy-call-with-super [call this meth]
(defn proxy-mappings
(defn proxy-name
(defn psort 
(defn pst
(defn psummary 
(defn push-thread-bindings
(defn pvec 
(defn qualified-ident?
(defn qualified-keyword?
(defn qualified-symbol?
(defn quot
(defn rand
(defn rand-int
(defn rand-nth
(defn random-sample
(defn range
(defn ratio?
(defn rational?
(defn rationalize
(defn re-find
(defn re-groups
(defn re-matcher
(defn re-matches
(defn re-pattern
(defn re-seq
(defn read
(defn read
(defn read+string
(defn read-instant-calendar
(defn read-instant-date
(defn read-instant-timestamp
(defn read-line
(defn read-string
(defn read-string
(defn reader-conditional
(defn reader-conditional?
(defn realized?
(defn record?
(defn reduce
(defn reduce
(defn reduce-kv
(defn reduced
(defn reduced?
(defn reducer
(defn reductions
(defn ref
(defn ref-history-count
(defn ref-max-history
(defn ref-min-history
(defn ref-set
(defn refer
(defn reflect
(defn release-pending-sends
(defn rem
(defn remote-prepl
(defn remove
(defn remove
(defn remove-all-methods
(defn remove-method
(defn remove-ns
(defn remove-tap
(defn remove-watch
(defn rename
(defn rename-keys
(defn renumbering-read
(defn repeat
(defn repeatedly
(defn repl
(defn repl
(defn repl-caught
(defn repl-exception
(defn repl-init
(defn repl-prompt
(defn repl-read
(defn repl-read
(defn replace
(defn replace
(defn replicate
(defn report-error
(defn require
(defn requiring-resolve
(defn reset!
(defn reset-meta!
(defn reset-vals!
(defn resolve
(defn restart-agent
(defn resultset-seq
(defn reverse
(defn reversible?
(defn right
(defn rightmost
(defn rights
(defn root
(defn root-cause
(defn root-cause
(defn root-cause
(defn rseq
(defn rsubseq
(defn run!
(defn run-all-tests
(defn run-tests
(defn satisfies? 
(defn select
(defn select-keys
(defn send
(defn send-off
(defn send-via
(defn seq-zip
(defn seqable?
(defn seque
(defn sequence
(defn sequential?
(defn set
(defn set-agent-send-executor!
(defn set-agent-send-off-executor!
(defn set-break-handler!
(defn set-error-handler!
(defn set-error-mode!
(defn set-pprint-dispatch  
(defn set-validator!
(defn set?
(defn sh
(defn short
(defn short-array
(defn shuffle
(defn shutdown-agents
(defn simple-ident?
(defn simple-keyword?
(defn simple-symbol?
(defn skip-if-eol
(defn skip-whitespace
(defn slurp
(defn some
(defn some-fn
(defn some?
(defn sort
(defn sort-by
(defn sorted-map
(defn sorted-map-by
(defn sorted-set
(defn sorted-set-by
(defn sorted?
(defn source-fn
(defn special-symbol?
(defn spit
(defn split
(defn split-at
(defn split-lines
(defn split-with
(defn spread
(defn stack-element-str
(defn stack-element-str
(defn start-case
(defn start-element
(defn start-server
(defn start-servers
(defn start-suite
(defn startparse-sax [s ch]
(defn starts-with?
(defn stop-server
(defn stop-servers
(defn str
(defn stringify-keys
(defn struct
(defn struct-map
(defn subs
(defn subseq
(defn subset? 
(defn subvec
(defn successful?
(defn suite-attrs
(defn supers
(defn superset? 
(defn swap!
(defn swap-vals!
(defn symbol
(defn symbol?
(defn tagged-literal
(defn tagged-literal?
(defn take
(defn take-last
(defn take-nth
(defn take-while
(defn tap>
(defn test
(defn test-all-vars
(defn test-name
(defn test-ns
(defn test-var
(defn test-vars
(defn testing-contexts-str
(defn testing-vars-str
(defn the-ns
(defn thread-bound?
(defn thread-stopper
(defn to-array
(defn to-array-2d
(defn trampoline
(defn transduce
(defn transient
(defn tree-model [data]
(defn tree-seq
(defn true?
(defn type
(defn type-reflect
(defn unchecked-add
(defn unchecked-add-int
(defn unchecked-byte
(defn unchecked-char
(defn unchecked-dec
(defn unchecked-dec-int
(defn unchecked-divide-int
(defn unchecked-double
(defn unchecked-float
(defn unchecked-inc
(defn unchecked-inc-int
(defn unchecked-int
(defn unchecked-long
(defn unchecked-multiply
(defn unchecked-multiply-int
(defn unchecked-negate
(defn unchecked-negate-int
(defn unchecked-remainder-int
(defn unchecked-short
(defn unchecked-subtract
(defn unchecked-subtract-int
(defn underive
(defn union
(defn unreduced
(defn unsigned-bit-shift-right
(defn up
(defn update
(defn update-in
(defn update-proxy
(defn uri?
(defn use
(defn uuid?
(defn val
(defn validated
(defn vals
(defn var-get
(defn var-set
(defn var?
(defn vary-meta
(defn vec
(defn vector
(defn vector-of
(defn vector-zip
(defn volatile!
(defn volatile?
(defn vreset!
(defn walk
(defn with-bindings*
(defn with-redefs-fn
(defn write 
(defn write-out 
(defn xml-seq
(defn xml-zip
(defn zero?
(defn zipmap
(defn zipper
(defn- ^"[Ljava.lang.String;" as-env-strings 
(defn- ^Boolean append? [opts]
(defn- ^Class the-class [x] 
(defn- ^String encoding [opts]
(defn- ^String inc-s
(defn- ^Type asm-type
(defn- ^java.lang.reflect.Field find-field [^Class c f]
(defn- ^{:dynamic true} assert-valid-fdecl
(defn- abort? [context]
(defn- absolute-reposition [navigator position]
(defn- absolute-tabulation [params navigator offsets]
(defn- accept-connection
(defn- access-flag
(defn- aconcat
(defn- add-annotation [^clojure.asm.AnnotationVisitor av name v]
(defn- add-annotations
(defn- add-core-ns [amap]
(defn- add-english-scales
(defn- add-ns-meta
(defn- add-to-buffer [^Writer this token]
(defn- ancestor? [parent child]
(defn- as-set-value
(defn- assert-same-protocol [protocol-var method-syms]
(defn- atom-diff
(defn- base-str
(defn- binary-op [f]
(defn- binary-predicate [f]
(defn- boolean-conditional [params arg-navigator offsets]
(defn- brackets
(defn- bubble-max-key
(defn- buffer-length [l] 
(defn- buffer-size [opts]
(defn- build-positional-factory
(defn- c-write-char [^Writer this ^Integer c]
(defn- capitalize-string
(defn- capitalize-word-writer
(defn- case-map
(defn- check-arg-conditional [params arg-navigator offsets]
(defn- check-cyclic-dependency
(defn- check-enumerated-arg [arg choices]
(defn- check-flags [def flags]
(defn- choice-conditional [params arg-navigator offsets]
(defn- collect-clauses [bracket-info offset remainder]
(defn- column-writer   
(defn- compile-directive [s offset]
(defn- compile-format 
(defn- compile-raw-string [s offset]
(defn- conditional-newline [params navigator offsets]
(defn- construct-calendar
(defn- construct-date
(defn- construct-timestamp
(defn- constructor->map
(defn- consume [func initial-context]
(defn- consume-while [func initial-context]
(defn- convert-ratio [x]
(defn- core-class?
(defn- ctor-sigs [^Class super]
(defn- data-reader-urls []
(defn- data-reader-var [sym]
(defn- declared-constructors
(defn- declared-fields
(defn- declared-methods
(defn- default-fixture
(defn- default-uuid-reader [form]
(defn- deref-as-map [^clojure.lang.IDeref o]
(defn- descriptor [^Class c] (clojure.asm.Type/getDescriptor c))
(defn- diff-associative
(defn- diff-associative-key
(defn- diff-sequential
(defn- divisible?
(defn- do-curried
(defn- do-rfn [f1 k fkv]
(defn- dollar-float [params navigator offsets]
(defn- downcase-writer 
(defn- else-separator? [this] 
(defn- emit-defrecord 
(defn- emit-deftype*
(defn- emit-extend-protocol [p specs]
(defn- emit-extend-type [c specs]
(defn- emit-hinted-impl [c [p fs]]
(defn- emit-impl [[p fs]]
(defn- emit-method-builder [on-interface method on-method arglists extend-via-meta]
(defn- emit-nl [^Writer this nl]
(defn- emit-protocol [name opts+sigs]
(defn- end-block [^Writer this]
(defn- escape-class-name [^Class c]
(defn- escape-xml [text]
(defn- escaped-utf8-urlstring->str [s]
(defn- eval-opt
(defn- ex->data
(defn- execute-format 
(defn- execute-sub-format [format args base-args]
(defn- expand-fixed [m e d]
(defn- expand-method-impl-cache [^clojure.lang.MethodImplCache cache c f]
(defn- exponential-float [params navigator offsets]
(defn- extract-flags [s offset]
(defn- extract-param [[s offset saw-comma]]
(defn- extract-params [s offset] 
(defn- field->map
(defn- field-descriptor->class-symbol
(defn- file-and-line
(defn- file-name
(defn- file-path
(defn- filter-methods [^Class c invalid-method?]
(defn- fits-table?
(defn- fixed-float [params navigator offsets]
(defn- fjfork [task] (.fork ^java.util.concurrent.ForkJoinTask task))
(defn- fjinvoke [f]
(defn- fjjoin [task] (.join ^java.util.concurrent.ForkJoinTask task))
(defn- float-parts
(defn- float-parts-base
(defn- foldvec
(defn- format-ascii [print-func params arg-navigator offsets]
(defn- format-cardinal-english [params navigator offsets]
(defn- format-error [message offset] 
(defn- format-integer [base params arg-navigator offsets]
(defn- format-logical-block [params navigator offsets]
(defn- format-new-roman [params navigator offsets]
(defn- format-old-roman [params navigator offsets]
(defn- format-ordinal-english [params navigator offsets]
(defn- format-roman
(defn- format-simple-cardinal
(defn- format-simple-number [n]
(defn- format-simple-ordinal
(defn- general-float [params navigator offsets]
(defn- generate-class [options-map]
(defn- generate-interface
(defn- generate-proxy [^Class super interfaces]
(defn- get-column [this]
(defn- get-field [^Writer this sym]
(defn- get-fixed [m e d]
(defn- get-format-arg [navigator]
(defn- get-line [this]
(defn- get-max-column [this]
(defn- get-miser-width [^Writer this]
(defn- get-section [buffer]
(defn- get-sub-section [buffer]
(defn- get-super-and-interfaces [bases]
(defn- get-writer [this]
(defn- group-by* [unit lis]
(defn- group-by-sig
(defn- help-opt
(defn- imap-cons
(defn- implements? [protocol atype]
(defn- indent [^Writer this relative-to offset]
(defn- indivisible?
(defn- init-cap-writer
(defn- init-dispatch
(defn- init-navigator 
(defn- init-opt
(defn- initialize
(defn- inputstream->reader
(defn- insert-decimal
(defn- insert-scaled-decimal
(defn- int-and-object-predicate [f]
(defn- int-and-object-to-object [f]
(defn- integral?
(defn- interface-or-naive-reduce
(defn- internal-name->class-symbol
(defn- is-annotation? [c]
(defn- is-runtime-annotation? [^Class c]
(defn- iter-reduce
(defn- iterate-list-of-sublists [params navigator offsets]
(defn- iterate-main-list [params navigator offsets]
(defn- iterate-main-sublists [params navigator offsets]
(defn- iterate-sublist [params navigator offsets]
(defn- java-loc->source
(defn- javadoc-url
(defn- justify-clauses [params navigator offsets]
(defn- leap-year?
(defn- legacy-repl
(defn- legacy-script
(defn- level-exceeded []
(defn- libspec?
(defn- lift-ns
(defn- linear-nl? [this lb section]
(defn- load-all
(defn- load-data-reader-file [mappings ^java.net.URL url]
(defn- load-data-readers []
(defn- load-lib
(defn- load-libs
(defn- load-one
(defn- logical-block-or-justify [params navigator offsets]
(defn- ltrim
(defn- macosx? []
(defn- main-dispatch
(defn- main-opt
(defn- make-pretty-writer 
(defn- map-params
(defn- map-passing-context [func initial-context lis]
(defn- map-ref-type 
(defn- maybe-min-hash
(defn- merge-hash-collisions
(defn- method->map
(defn- miser-nl? [^Writer this lb section]
(defn- modify-case [make-writer params navigator offsets]
(defn- most-specific [rtypes]
(defn- multi-defn [alis has-doc-str?]
(defn- naive-seq-reduce
(defn- namespace-doc [nspace]
(defn- needs-pretty 
(defn- next-arg [ navigator ]
(defn- next-arg-or-nil [navigator]
(defn- nl [^Writer this type]
(defn- non-private-methods [^Class c]
(defn- normalize-slurp-opts
(defn- null-opt
(defn- op [f]
(defn- open-url-in-browser
(defn- open-url-in-swing
(defn- open-url-in-swing
(defn- open-url-script-val []
(defn- opt-base-str
(defn- outputstream->writer
(defn- overload-name [mname pclasses]
(defn- p-write-char [^Writer this ^Integer c]
(defn- pa-to-vec [pa]
(defn- pall
(defn- parse-args
(defn- parse-flags
(defn- parse-impls [specs]
(defn- parse-int [^String s]
(defn- parse-lb-options [opts body]
(defn- parse-method-descriptor
(defn- parse-opts [s]
(defn- parse-opts+specs [opts+specs]
(defn- parse-props
(defn- pcumulate [coll f init]
(defn- plain-character [params navigator offsets]
(defn- pll-mod-body [var-sym body]
(defn- pprint-anon-func [alis]
(defn- pprint-binding-form [binding-vec]
(defn- pprint-code-list [alis]
(defn- pprint-code-symbol [sym] 
(defn- pprint-cond [alis]
(defn- pprint-condp [alis]
(defn- pprint-defn [alis]
(defn- pprint-ideref [o]
(defn- pprint-let [alis]
(defn- pprint-list [alis]
(defn- pprint-map [amap]
(defn- pprint-ns
(defn- pprint-ns-reference
(defn- pprint-reader-macro [alis]
(defn- pprint-simple-code-list [alis]
(defn- pprint-simple-default [obj]
(defn- pprint-simple-list [alis]
(defn- pprint-vector [avec]
(defn- pr-with-base [x]
(defn- predicate [f]
(defn- pref
(defn- prefix-count
(defn- prep-hashes
(defn- prep-ints
(defn- prependss
(defn- prerr
(defn- pretty-character [params navigator offsets]
(defn- pretty-writer [writer max-columns miser-width]
(defn- pretty-writer? 
(defn- print-calendar
(defn- print-date
(defn- print-doc [{n :ns
(defn- print-map [m print-one w]
(defn- print-meta [o, ^Writer w]
(defn- print-object [o, ^Writer w]
(defn- print-prefix-map [prefix m print-one w]
(defn- print-sequential [^String begin, print-one, ^String sep, ^String end, sequence, ^Writer w]
(defn- print-tagged-object [o rep ^Writer w]
(defn- print-throwable [^Throwable o ^Writer w]
(defn- print-timestamp
(defn- process-annotation [av v]
(defn- process-bracket [this remainder]
(defn- process-clause [bracket-info offset remainder]
(defn- process-directive-table-element [ [ char params flags bracket-info & generator-fn ] ]
(defn- process-nesting
(defn- protected-final-methods [^Class c]
(defn- protocol?
(defn- readable-character [params navigator offsets]
(defn- realize-parameter [[param [raw-val offset]] navigator]
(defn- realize-parameter-list [parameter-map navigator]
(defn- reducer [f]
(defn- relative-reposition [navigator position]
(defn- relative-tabulation [params navigator offsets]
(defn- remainders
(defn- render-clauses [clauses navigator base-navigator]
(defn- repl-opt
(defn- replace-by
(defn- replace-first-by
(defn- replace-first-char
(defn- replace-first-str
(defn- required
(defn- resolve-fn [valf]
(defn- resource-name
(defn- right-bracket [this] (:right (:bracket-info (:def this))))
(defn- root-directory
(defn- root-resource
(defn- round-str [m e d w]
(defn- rtrim
(defn- script-opt
(defn- separator? [this] (:separator (:bracket-info (:def this))))
(defn- seq-reduce
(defn- serialized-require
(defn- set-field [^Writer this sym new-val] 
(defn- set-indent [params navigator offsets]
(defn- set-logical-block-callback [^Writer this f]
(defn- set-max-column [this new-max]
(defn- set-miser-width [^Writer this new-miser-width]
(defn- shift-mask [shift mask x]
(defn- single-defn [alis has-doc-str?]
(defn- sortmap [m]
(defn- special-doc [name-symbol]
(defn- split-at-newline [tokens]
(defn- stacktrace-file-and-line
(defn- start-block 
(defn- stream-to-bytes
(defn- stream-to-enc
(defn- stream-to-string
(defn- strip-ns
(defn- summary-map [s]
(defn- super-chain [^Class c]
(defn- table-ize [t m] 
(defn- throw-if
(defn- tokens-fit? [^Writer this tokens]
(defn- toks [toks] (map tok toks))
(defn- translate-param
(defn- tuple-map
(defn- two-forms [amap]
(defn- typeref->class
(defn- typesym
(defn- unzip-map
(defn- upcase-writer 
(defn- update-nl-state [lb]
(defn- use-method
(defn- valid-java-method-name
(defn- validate-fields
(defn- validate-generate-class-options
(defn- validate-opts
(defn- vectorize
(defn- write-buffered-output [^Writer this]
(defn- write-initial-lines 
(defn- write-line [^Writer this]
(defn- write-token-string [this tokens]
(defn- write-tokens [^Writer this tokens force-trailing-whitespace]
(defn- write-white-space [^Writer this]
(defn- xdg-open-loc []
(defn- zero-fill-right [^String s width]
(defonce ^:dynamic
(defonce ^:dynamic
(defonce ^:dynamic
(defonce ^:dynamic
(defonce ^:dynamic ; If folks have added stuff here, don't overwrite
(defonce ^:private ^java.util.concurrent.ArrayBlockingQueue tapq (java.util.concurrent.ArrayBlockingQueue. 1024))
(defonce ^:private lock (ReentrantLock.))
(defonce ^:private servers {})
(defonce ^:private tap-loop
(defonce ^:private tapset (atom #{}))
(defprotocol ClassResolver
(defprotocol CollFold
(defprotocol CollReduce
(defprotocol Datafiable
(defprotocol IKVReduce
(defprotocol Inst
(defprotocol InternalReduce
(defprotocol Navigable
(defprotocol Reflector
(defprotocol TypeReference
(defprotocol ^{:added "1.2"} Coercions
(defprotocol ^{:added "1.2"} IOFactory
(defprotocol ^{:added "1.3"} Diff
(defprotocol ^{:added "1.3"} EqualityPartition
(defrecord Constructor
(defrecord Field
(defrecord Method
(defstruct ^{:private true}
(defstruct ^{:private true}
(defstruct ^{:private true} logical-block
(defstruct ^{:private true} section :parent)
(defstruct element :tag :attrs :content)
(deftype ArrayChunk [^clojure.core.ArrayManager am arr ^int off ^int end]
(deftype AsmReflector [class-resolver]
(deftype Cat [cnt left right]
(deftype Eduction [xform coll]
(deftype JavaReflector [classloader]
(deftype Vec [^clojure.core.ArrayManager am ^int cnt ^int shift ^clojure.core.VecNode root tail _meta]
(deftype VecNode [edit arr])
(deftype VecSeq [^clojure.core.ArrayManager am ^clojure.core.IVecImpl vec anode ^int i ^int offset] 
(deftype buffer-blob :data :trailing-white-space :start-pos :end-pos)
(deftype end-block-t :logical-block :start-pos :end-pos)
(deftype indent-t :logical-block :relative-to :offset :start-pos :end-pos)
(deftype nl-t :type :logical-block :start-pos :end-pos)
(deftype start-block-t :logical-block :start-pos :end-pos)
(difference #{:a :b :c} #{:c :d :e})
(dotimes i (count a)
(end? (-> dz next next next next next next next next next remove next))
(extend BufferedInputStream
(extend BufferedOutputStream
(extend BufferedReader
(extend BufferedWriter
(extend File
(extend InputStream
(extend Object
(extend Object
(extend OutputStream
(extend Reader
(extend Socket
(extend String
(extend URI
(extend URL
(extend Writer
(extend byte-array-type
(extend char-array-type
(extend nil
(extend nil
(extend-protocol ClassResolver
(extend-protocol Coercions
(extend-protocol CollFold
(extend-protocol CollReduce
(extend-protocol Datafiable  
(extend-protocol Diff
(extend-protocol EqualityPartition
(extend-protocol Inst
(extend-protocol InternalReduce
(extend-protocol Navigable
(extend-protocol TypeReference
(extend-protocol clojure.core.protocols/IKVReduce
(extend-protocol clojure.core/Inst
(extend-protocol p/Datafiable
(import
(import '(clojure.lang Murmur3))
(import '(java.io Writer))
(import '(java.lang.reflect Array))
(import '(java.lang.reflect Modifier Constructor)
(import '(java.util.concurrent BlockingQueue LinkedBlockingQueue))
(import '(jsr166y.forkjoin ParallelArray ParallelArrayWithBounds ParallelArrayWithFilter 
(import '[clojure.asm ClassReader ClassVisitor Type Opcodes]
(import [clojure.lang IDeref]
(import [clojure.lang IDeref]
(import clojure.lang.ExceptionInfo clojure.lang.IExceptionInfo)
(in-ns 'clojure.core)
(in-ns 'clojure.core)
(in-ns 'clojure.core)
(in-ns 'clojure.core)
(in-ns 'clojure.core)
(in-ns 'clojure.pprint)
(in-ns 'clojure.pprint)
(in-ns 'clojure.pprint)
(in-ns 'clojure.pprint)
(in-ns 'clojure.pprint)
(in-ns 'clojure.pprint)
(in-ns 'clojure.pprint)
(in-ns 'clojure.reflect)
(index ys [:b])
(inspect-table [[1 2 3][4 5 6][7 8 9][10 11 12]])
(inspect-tree {:a 1 :b 2 :c [1 2 3 {:d 4 :e 5 :f [6 7 8]}]})
(intersection #{:a :b :c} #{:c :d :e})
(join xs (rename ys {:b :yb :c :yc}) {:a :a})
(join xs ys)
(lefts (right (down (right (right (down dz))))))
(let [properties (with-open [version-stream (.getResourceAsStream
(load "core/protocols")
(load "core_deftype")
(load "core_print")
(load "core_proxy")
(load "genclass")
(load "gvec")
(load "pprint/cl_format")
(load "pprint/column_writer")
(load "pprint/dispatch")
(load "pprint/pprint_base")
(load "pprint/pretty_writer")
(load "pprint/print_table")
(load "pprint/utilities")
(load "reflect/java")
(load "uuid")
(load-file "/Users/rich/dev/clojure/src/zip.clj")
(load-file "src/inspector.clj")
(load-file "src/parallel.clj")
(loop [loc dz]
(loop [loc dz]
(ns
(ns
(ns 
(ns 
(ns 
(ns 
(ns 
(ns 
(ns 
(ns 
(ns ^{:author "Stuart Halloway"
(ns ^{:doc
(ns ^{:doc "Clojure String utilities
(ns ^{:doc "DEPRECATED Wrapper of the ForkJoin library (JSR-166)."
(ns ^{:doc "Functional hierarchical zipper, with navigation, editing,
(ns ^{:doc "Functions to turn objects into data. Alpha, subject to change"}
(ns ^{:doc "Graphical object inspector for Clojure data structures."
(ns ^{:doc "Macros that expand to repeated copies of a template expression."
(ns ^{:doc "Print stack traces oriented towards Clojure, not Java."
(ns ^{:doc "Set operations such as union/intersection."
(ns ^{:doc "Socket server support"
(ns ^{:doc "The core Clojure language."
(ns ^{:doc "Top-level main function for Clojure REPL and scripts."
(ns ^{:doc "XML reading/writing."
(ns ^{:doc "clojure.test extension for JUnit-compatible XML output.
(ns ^{:doc "clojure.test extensions for the Test Anything Protocol (TAP)
(ns ^{:doc "edn reading."
(ns clojure.core.protocols)
(ns clojure.instant
(ns clojure.uuid)
(ns your.namespace.here
(path (right (down (right (right (down dz))))))
(pdistinct [1 2 3 2 1])
(preduce + 0
(preduce + 0 (psort a))
(preduce + 0 [1 2 3 2 1])
(prefer-method print-dup clojure.lang.IPersistentCollection clojure.lang.Fn)
(prefer-method print-dup clojure.lang.IPersistentCollection java.util.Collection)
(prefer-method print-dup clojure.lang.IPersistentCollection java.util.Map)
(prefer-method print-dup clojure.lang.IRecord clojure.lang.IPersistentCollection)
(prefer-method print-dup clojure.lang.IRecord clojure.lang.IPersistentMap)
(prefer-method print-dup clojure.lang.IRecord java.util.Map)
(prefer-method print-dup clojure.lang.ISeq clojure.lang.IPersistentCollection)
(prefer-method print-dup clojure.lang.ISeq java.util.Collection)
(prefer-method print-dup java.util.Collection clojure.lang.Fn)
(prefer-method print-dup java.util.Map clojure.lang.Fn)
(prefer-method print-method clojure.lang.IPersistentCollection java.util.Collection)
(prefer-method print-method clojure.lang.IPersistentCollection java.util.Map)
(prefer-method print-method clojure.lang.IPersistentCollection java.util.RandomAccess)
(prefer-method print-method clojure.lang.IRecord clojure.lang.IPersistentMap)
(prefer-method print-method clojure.lang.IRecord java.util.Map)
(prefer-method print-method clojure.lang.ISeq clojure.lang.IPersistentCollection)
(prefer-method print-method clojure.lang.ISeq java.util.Collection)
(prefer-method print-method java.util.RandomAccess java.util.List)
(println (sh "cat" "myimage.png" :out-enc :bytes)) ; reads binary file into bytes[]
(println (sh "cat" :in "x\u25bax\n"))
(println (sh "cmd" "/c dir 1>&2"))
(println (sh "echo" "x\u25bax" :out-enc "ISO-8859-1")) ; reads 4 single-byte chars
(println (sh "echo" "x\u25bax"))
(println (sh "ls" "-l" "/no-such-thing"))
(println (sh "ls" "-l"))
(println (sh "sed" "s/[aeiou]/oo/g" :in "hello there\n"))
(println (sh "sed" "s/[aeiou]/oo/g" :in (java.io.StringReader. "hello there\n")))
(psummary ;or pvec/pmax etc
(pvec (par [11 2 3 2] :filter-index (fn [x i] (> i x))))
(pvec (par [11 2 3 2] :filter-with [(fn [x y] (> y x)) [110 2 33 2]]))
(refer 'inspector)
(refer 'parallel)
(refer 'set)
(refer 'zip)
(require '[clojure.datafy :refer (datafy)]
(require '[clojure.java.io :as jio])
(right (down (right (right (down dz)))))
(rights (right (down (right (right (down dz))))))
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set! *warn-on-reflection* true)
(set-pprint-dispatch simple-dispatch)
(time (count (distinct a)))
(time (count (pdistinct a)))
(time (preduce + 0 (par (range 1000000) :map-index *)))
(time (preduce + 0 (par v :map  #(* % %))))
(time (preduce + 0 (par v :map-index *)))
(time (preduce + 0 a))
(time (reduce + 0 (map #(* % %) (range 1000000))))
(time (reduce + 0 (map #(* % %) v)))
(time (reduce + 0 a))
(try
(union #{:a :b :c} #{:c :d :e })
(up (up (right (down (right (right (down dz)))))))
(use-method code-dispatch :default pprint-simple-default)
(use-method code-dispatch clojure.lang.IDeref pprint-ideref)
(use-method code-dispatch clojure.lang.IPersistentMap pprint-map)
(use-method code-dispatch clojure.lang.IPersistentSet pprint-set)
(use-method code-dispatch clojure.lang.IPersistentVector pprint-vector)
(use-method code-dispatch clojure.lang.ISeq pprint-code-list)
(use-method code-dispatch clojure.lang.PersistentQueue pprint-pqueue)
(use-method code-dispatch clojure.lang.Symbol pprint-code-symbol)
(use-method code-dispatch nil pr)
(use-method simple-dispatch :default pprint-simple-default)
(use-method simple-dispatch clojure.lang.IDeref pprint-ideref)
(use-method simple-dispatch clojure.lang.IPersistentMap pprint-map)
(use-method simple-dispatch clojure.lang.IPersistentSet pprint-set)
(use-method simple-dispatch clojure.lang.IPersistentVector pprint-vector)
(use-method simple-dispatch clojure.lang.ISeq pprint-list)
(use-method simple-dispatch clojure.lang.PersistentQueue pprint-pqueue)
(use-method simple-dispatch clojure.lang.Var pprint-simple-default)
(use-method simple-dispatch nil pr)
(when-class "java.sql.Timestamp"
(with-pprint-dispatch code-dispatch 
(with-pprint-dispatch code-dispatch 
(with-pprint-dispatch code-dispatch 
(with-pprint-dispatch code-dispatch 
)
)
)
)
)
)
)
);;; cl_format.clj -- part of the pretty printer for Clojure
* Canonicalizes class names as Clojure symbols. Types can extend
* Create an implementation of Reflector.
* Create one or more implementations of TypeReference.
* Exposes the read side of reflection as pure data. Reflecting
* Pluggable Reflectors for different implementations. The default
* def default-reflector to be an instance that satisfies Reflector."}
* reflect (for REPL use) reflects on the class of an instance, or
* type-reflect reflects on something that implements TypeReference.
*out* must be a PrettyWriter if pretty printing is enabled. This is the responsibility
1. Strings are objects (as opposed to sequences). As such, the
2. Functions are generally not lazy, and call straight to host
3. Functions take advantage of String implementation details to
4. When a function is documented to accept a string argument, it
;        (. gen (invokeStatic class-type (. Method (getMethod "Class forName(String)"))))
;        (. gen push (str (.replace impl-pkg-name \- \_) "__init"))
;   (.. *ns* (intern sym) (setExported true))))
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   By using this software in any fashion, you are agreeing to be bound by
;   Common Public License 1.0 (http://opensource.org/licenses/cpl.php)
;   Copyright (c) Chris Houser, Dec 2008. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Copyright (c) Rich Hickey. All rights reserved.
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   The use and distribution terms for this software are covered by the
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   You must not remove this notice, or any other, from this software.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   the terms of this license.
;   which can be found in the file CPL.TXT at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;   which can be found in the file epl-v10.html at the root of this distribution.
;  (agent {:frame frame :data x :parent nil :index 0}))
;  (doseq [sym syms]
;  (prlabel a2b token)
;  (prlabel compiling format-str)
;  (prlabel lnl? @(:done-nl lb) (tokens-fit? this section))
;  (prlabel wt (:type token) (= (:type token) :mandatory))
;  (prlabel wt @(:done-nl (:logical-block token)))
;  [(. meth (getName)) (seq (. meth (getParameterTypes)))])
; A blob of characters (aka a string)
; A newline
; Utilities meant to be used interactively at the REPL
;(def x (xml/parse "http://arstechnica.com/journals.rssx"))
;(defn export [syms]
;(defn make-inspector [x]
;(defn method-sig [^java.lang.reflect.Method meth]
;(distinct (map first(keys (mapcat non-private-methods [Object IPersistentMap]))))
;(export '(tag attrs content parse element emit emit-element))
;(load-file "/Users/rich/dev/clojure/src/xml.clj")
;(pcumulate [1 2 3 2 1] + 0) ;broken, not exposed
;;
;;
;;
;;
;;
;;
;;
;;
;;
;;
;;                          (prlabel emit-nl (:type newl))
;;              ff (prlabel wts (toks result))
;;          (prlabel wl new-buffer)
;;         (prlabel wts (toks section)) (prlabel wts (:type newl)) (prlabel wts (toks remainder)) 
;;       (f (into (empty form) (map pf form)))
;;       (f form))))
;;     (if (coll? form)
;;     (prlabel wl1 (toks buffer))
;;    (prlabel wts (toks a) (toks b))
;;   (let [pf (partial walk f)]
;;   [f form]
;; (defn walk
;; (http://www.grammarbook.com/numbers/numbers.asp)
;; (unless we can somehow here make it call (shutdown-agents) later).
;; * December 15, 2008: replaced 'walk' with 'prewalk' & 'postwalk'
;; * December 9, 2008: first version
;; ----------------------------------------------------------------------
;; ----------------------------------------------------------------------
;; April 3, 2009
;; April 3, 2009
;; April 3, 2009
;; April 3, 2009
;; April 3, 2009
;; April 3, 2009
;; April 3, 2009
;; Author: Tom Faulhaber
;; Author: Tom Faulhaber
;; Author: Tom Faulhaber
;; Author: Tom Faulhaber
;; Author: Tom Faulhaber
;; Author: Tom Faulhaber
;; Author: Tom Faulhaber
;; Better to initialize it when we first need it, in browse-url.
;; By Stuart Sierra
;; CHANGE LOG
;; CHANGE LOG:
;; Check to see if a result is an abort (~^) construct
;; Copyright (c) Rich Hickey All rights reserved. The use and
;; DOCUMENTATION
;; DOCUMENTATION
;; December 15, 2008
;; December 15, 2008: first version
;; Dispatch for the basic data types when interpreted
;; Examine Clojure functions (Vars, really)
;; Flush the pretty-print buffer without flushing the underlying stream
;; Get an argument off the arg list and compile it if it's not already compiled
;; Handle Ctrl-C keystrokes
;; Handle the execution of "sub-clauses" in bracket constructions
;; Ignore these message types:
;; Implementations of specific dispatch table entries
;; Inspired by ClojureCheck by Meikel Brandmeyer:
;; Internal variables that keep track of where we are in the 
;; January 20, 2009: added "template?" and checks for valid template
;; January 6, 2009
;; Java-specific parts of clojure.reflect
;; June 2009
;; June 23, 2009
;; June 23, 2009: complete rewrite, eliminated _1,_2,... argument
;; License 1.0 (http://opensource.org/licenses/eclipse-1.0.php) which can be found
;; March 28, 2009
;; March 31, 2009
;; Note: I wanted to write:
;; Nothing is marked "private" here, so you can rebind things to plug
;; Number names from http://www.jimloy.com/math/billion.htm
;; Originally contributed by Stephen C. Gilardi
;; Public
;; Records
;; Revised to use proxy instead of gen-class April 2010
;; Revised to use proxy instead of gen-class April 2010
;; Support for the functional interface to the pretty printer
;; Support for the write function
;; TODO - return exponent as int to eliminate double conversion
;; TODO a real implementation for pprint-tab
;; TODO call format-error with offset
;; TODO check arg is positive int
;; TODO support for ~:; constructions
;; TODO: Support for tab directives
;; TODO: add variables for length, lines.
;; TODO: define ~E representation for Infinity
;; TODO: get the whole format wrapped so we can start the lb at any column
;; TODO: move these funcs somewhere more appropriate
;; TODO: refactor so that float-parts isn't called twice
;; TODO: support rationals. Back off to ~D/~A is the appropriate cases
;; TODO: support rationals. Back off to ~D/~A is the appropriate cases
;; TODO: support rationals. Back off to ~D/~A is the appropriate cases
;; TODO: support rationals. Back off to ~D/~A is the appropriate cases
;; TODO: support ~@; per-line-prefix separator
;; TODO: validate parameters when they come from arg list
;; Thanks to Chas Emerick, Allen Rohner, and Stuart Halloway for
;; The following are all exact copies of simple-dispatch
;; This just figures out whether to pass the request off to ~F or ~E based 
;; This module implements a column-aware wrapper around an instance of java.io.Writer
;; This module implements a wrapper around a java.io.Writer which implements the
;; This module implements some utility function used in formatting and pretty
;; This module implements the Common Lisp compatible format function as documented
;; This module implements the default dispatch tables for pretty printing code and
;; This module implements the generic pretty print functions and special variables
;; This multimethod will override test-is/report
;; This multimethod will override test/report
;; Variables that control the pretty printer
;; We could assign (open-url-script-val) to *open-url-script* right
;; We follow the rules for writing numbers from the Blue Book
;; We start with a couple of helpers
;; We use "short scale" for our units (see http://en.wikipedia.org/wiki/Long_and_short_scales)
;; You don't call these, but you can add methods to extend the 'is'
;; You use these in your tests.
;; as data (as opposed to code).
;; away in the def below, but clojure.java.shell/sh creates a future
;; based on original contribution by Chris Houser
;; but this throws a ClassCastException when applied to a map.
;; by Jason Sankey
;; by Stuart Sierra
;; by Stuart Sierra
;; by Stuart Sierra
;; by Stuart Sierra
;; contributions and suggestions.
;; copied from clojure.contrib.lazy-xml
;; core of the XP algorithm.
;; data.
;; dispatch.clj -- part of the pretty printer for Clojure
;; distribution terms for this software are covered by the Eclipse Public
;; evaluation
;; expressions.
;; for big things a sparse vector class would be better
;; http://kotka.de/projects/clojure/clojurecheck.html
;; http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node200.html#SECTION002633000000000000000)
;; in "Common Lisp the Language, 2nd edition", Chapter 22 (available online at:
;; in the file epl-v10.html at the root of this distribution. By using this
;; in your own testing or reporting frameworks.
;; is consumed by all the iterations
;; is consumed by all the iterations
;; java.util
;; lock protects servers
;; macro.  These define different kinds of tests, based on the first
;; next argument
;; nil/false without consuming the arg
;; of which is consumed with each iteration
;; on the algorithm in CLtL.
;; perhaps.
;; printing. The functions here could go in a more general purpose library,
;; redefine reduce with internal-reduce
;; reduce is defined again later after InternalReduce loads
;; software in any fashion, you are agreeing to be bound by the terms of
;; software.
;; someday this can be made codepoint aware
;; structure
;; sublists is used as the arglist for a single iteration.
;; symbol in the test expression.
;; syntax
;; test/junit.clj: Extension to clojure.test for JUnit-compatible XML output
;; that causes a long wait for the JVM to exit during Clojure compiles
;; the function to render ~$ directives
;; the function to render ~E directives
;; the function to render ~F directives
;; the function to render ~G directives
;; this license. You must not remove this notice, or any other, from this
;; ~:[...~] with the colon reads the next argument treating it as a truth value
;; ~:{...~} with the colon treats the next argument as a list of sublists. Each of the
;; ~@:{...~} with both colon and at sign uses the main argument list as a set of sublists, one
;; ~@[...~] with the at sign executes the conditional if the next arg is not
;; ~@{...~} with the at sign uses the main argument list as the arguments to the iterations
;; ~[...~] without any modifiers chooses one of the clauses based on the param or 
;; ~{...~} without any modifiers uses the next argument as an argument list that 
;;;
;;;
;;;
;;;
;;; 
;;; 
;;;                              (prlabel recurse (toks rem2))
;;;      and regular quotes).
;;;      completely lost.
;;;      where they deem them useful to help readability.
;;;  (prlabel tf? (get-column (getf :base) (buffer-length tokens))
;;; (def pprint-map (formatter-out "~<{~;~@{~<~w~^ ~_~w~:>~^, ~_~}~;}~:>"))
;;; (def pprint-simple-list (formatter-out "~:<~@{~w~^ ~_~}~:>"))
;;; (def pprint-vector (formatter-out "~<[~;~@{~w~^ ~_~}~;]~:>"))
;;; (possibly going forwards and backwards as it does so)
;;; *print-length*, *print-level* and *print-dup* are defined in clojure.core
;;; ,  - is whitespace and is lost (like all other whitespace). Formats can generate commas
;;; ------------------------------------------------------------------------
;;; ------------------------------------------------------------------------
;;; ------------------------------------------------------------------------
;;; ------------------------------------------------------------------------
;;; ------------------------------------------------------------------------
;;; :keyword, \char, or ""). The notable exception is #() which is special-cased.
;;; ;  - The comment character is absorbed by the reader and never is part of the form
;;; ASSERTION MACROS
;;; ASSERTION METHODS
;;; Add a buffer token to the buffer and see if it's time to start
;;; Argument navigators manage the argument list
;;; Code to manage the parameters and flags associated with each
;;; Common handling code for ~A and ~S
;;; DEFINING FIXTURES
;;; DEFINING TESTS
;;; Dispatch for the code table
;;; End forward references
;;; For testing
;;; Format something that looks like "if"
;;; Format something that looks like a defn or defmacro
;;; Format something that looks like a simple def (sans metadata, since the reader
;;; Format something with a binding form
;;; Format the namespace ("ns") macro. This is quite complicated because of all the
;;; Format the param and body sublists of a defn with multiple arities
;;; Format the params and body of a defn with a single arity
;;; Forward declarations
;;; Forward references
;;; Functions that support individual directives
;;; Functions to write tokens in the output buffer
;;; GLOBALS USED BY THE REPORTING FUNCTIONS
;;; Handle forms that can be "back-translated" to reader macros
;;; Helper functions for digesting formats in the various
;;; Helpers for dispatch function writing
;;; If necessary, wrap the writer in a PrettyWriter object
;;; If there are newlines in the string, print the lines up until the last newline, 
;;; Initialize the pretty-writer instance
;;; Macros that we can't deal with at all are:
;;; Macros to simplify dealing with types and classes. These are
;;; Methods for pretty-writer
;;; Methods for showing token strings for debugging
;;; Most other syntax stuff is dealt with directly by the formats (like (), [], {}, and #{})
;;; Not all reader macros can be dealt with this way or at all. 
;;; RUNNING TESTS: HIGH-LEVEL FUNCTIONS
;;; RUNNING TESTS: LOW-LEVEL FUNCTIONS
;;; Support for accessing the pretty printer from a format
;;; Support for case modification with ~(...~).
;;; Support for character formats (~C)
;;; Support for column-aware operations ~&, ~T
;;; Support for english formats (~R and ~:R)
;;; Support for real number formats
;;; Support for roman numeral formats (~@R and ~@:R)
;;; Support for the '~<...~>' justification directive
;;; Support for the '~[...~]' conditional construct in its
;;; Support for the '~{...~}' iteration construct in its
;;; Support for the integer directives ~D, ~X, ~O, ~B and some
;;; TEST RESULT REPORTING
;;; TODO implement output limiting
;;; TODO: figure out how to support capturing metadata in defns (we might need a 
;;; TODO: implement circle and shared
;;; TODO: inline these formatter statements into funcs so that we
;;; TODO: make dispatch items like "(let..." get counted in *print-length*
;;; TODO: make it possible to make these decisions at compile-time.
;;; TODO: should we just use *print-dup* here?
;;; TODO: support print-base and print-radix in cl-format
;;; TODO: support print-base and print-radix in rationals
;;; TODO: support ~:T section options for ~T
;;; TODO: use *print-dup* here (or is it supplanted by other variables?)
;;; TODO: xlated-val does not seem to be used here.
;;; Take a map with symbols as keys and add versions with no namespace.
;;; That is, if ns/sym->val is in the map, add sym->val to the result.
;;; The '~< directive has two completely different meanings
;;; The data structures used by pretty-writer
;;; The map of symbols that are defined in an enclosing #() anonymous function
;;; The master definitions for formatting lists in code (that is, (fn args...) or
;;; The table of directives we support, each with its params,
;;; These functions are actually pretty general.
;;; This is a bad idea, but it prevents us from leaking private symbols
;;; This is the equivalent of (formatter-out "~:<~1I~@{~w~^ ~_~}~:>"), but is
;;; This should all be replaced by really compiled formats anyway.
;;; USER-MODIFIABLE GLOBALS
;;; UTILITIES FOR ASSERTIONS
;;; UTILITIES FOR REPORTING FUNCTIONS
;;; Unfortunately, the current architecture decides what function
;;; Various support functions
;;; Verification of Extra-Grammatical Restrictions from RFC3339
;;; We do this by wrapping the underlying writer with
;;; We hide all of this behind a function, but clients need to
;;; When looking at the parameter list, we may need to manipulate
;;; Write all the tokens that have been buffered
;;; ^  - Adding metadata completely disappears at read time and the data appears to be
;;; `  - Is fully processed at read time into a lisp expression (which will contain concats
;;; a generic vector implementation for vectors of primitives
;;; a special writer to do the appropriate modification. This
;;; allows us to support arbitrary-sized output and sources
;;; are a little easier on the stack. (Or, do "real" compilation, a
;;; as the format statement moves through the list
;;; column_writer.clj -- part of the pretty printer for Clojure
;;; constructs
;;; convenience macros
;;; different flavors
;;; different flavors
;;; different forms supported and because programmers can choose lists or vectors
;;; directive in the format string.
;;; easier on the stack.
;;; emit-nl? method defs for each type of new line. This makes
;;; folded, so it is left to run-time to make the decision.
;;; in the '~<...~>' form it does justification, but with
;;; in various places.
;;; is longer than the available space on the line
;;; la Common Lisp)
;;; making the appropriate adjustments. Return the remainder of the string
;;; manage changing arg navigator
;;; of ~R
;;; or directly by printing the objects using Clojure's built-in print functions (like
;;; parser implementation
;;; phases of their lives.
;;; pprint.clj -- Pretty printer and Common Lisp compatible format function (cl-format) for Clojure
;;; pprint_base.clj -- part of the pretty printer for Clojure
;;; pretty printer.
;;; pretty_writer.clj -- part of the pretty printer for Clojure
;;; print integration
;;; properties, and the compilation function
;;; reader integration
;;; really utilities, but I'm experimenting with them here.
;;; special forms).
;;; special reader)
;;; stacktrace.clj: print Clojure-centric stack traces
;;; template.clj - anonymous functions that pre-evaluate sub-expressions
;;; test.clj: test framework for Clojure
;;; test_is/tap.clj: Extension to test for TAP output
;;; that may block.
;;; the argument list as well (for 'V' and '#' parameter types).
;;; the decision about whether to print this type of new line.
;;; to call at form parsing time before the sub-clauses have been
;;; utilities.clj -- part of the pretty printer for Clojure
;;; walk.clj - generic tree walker with replacement
;;; won't give it to us now).
;;; write-token-string is called when the set of tokens in the buffer
;;; writing
;;; ~<...~:>' it represents the logical block operation of the
;;; ~@ - Also fully eaten by the processing of ` and can't be used outside.
;;;;;;; case ;;;;;;;;;;;;;
;;;;;;;;; var stuff
;;;;;;;;;;; require/use/load, contributed by Stephen C. Gilardi ;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;; nested associative ops ;;;;;;;;;;;
;;;;;;;;;;;;;; some fj stuff ;;;;;;;;;;
;;;;;;;;;;;;;;;;; metadata ;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; end of redundantly copied from clojure.repl to avoid dep ;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; end of redundantly copied from clojure.repl to avoid dep ;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; redundantly copied from clojure.repl to avoid dep ;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; sequence fns  ;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;; sequence fns  ;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;; gen-interface ;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;; aggregate operations ;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;; collection-producing operations ;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;; editable collections ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;; protocols ;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;; definterface ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;; proxy ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;; reify/deftype ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; fn stuff ;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Refs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; clojure version number ;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; data readers ;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; futures (needs proxy);;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; fold impls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; helper files ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; printing ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; var documentation ;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;at this point all the support for syntax-quote exists;;;;;;;;;;;;;;;;;;;;;;
;;;TODO: if pretty print is not set, don't use pr but rather something that respects *print-base*, etc.
;;Bit ops
;;Collection stuff
;;do not construct this directly, use cat
;;list stuff
;;map stuff
;;math stuff
;;multimethods
;;redefine let and loop  with destructuring
;during bootstrap we don't have destructuring let, loop or fn, will redefine later
;equals-based
;equiv-based
;for now, built on gen-interface
;functional hierarchical zipper, with navigation, editing and enumeration
;redef into with batch support
;redefine fn with destructuring and pre/post conditions
;see Huet
;this doesn't work, passes null to reducer?
;will be redefed later with arg checks
Alpha - subject to change.
Before the body, the caller can optionally specify options: :prefix, :per-line-prefix, 
Colnum and colinc specify the target column and the increment to move the target
Common Lisp. Because pretty printing directives are directly integrated with
Design notes for clojure.string:
Detailed documentation on format control strings is available in the \"Common Lisp the 
For example functions, see simple-dispatch and code-dispatch in 
For example, when you want to generate column-aware output with multiple calls to cl-format, 
For example:
Grammar (of s):
If writer is nil, cl-format returns the formatted result string. Otherwise, cl-format 
In addition to the pprint function, this module contains cl-format, a text 
Instead, use clojure.main like this:
Instead, use clojure.main like this:
It is poor form to (:use clojure.string). Instead, use require
It prints a table of squares and cubes for the numbers from 1 to 10:
JSON, can be rendered by creating custom dispatch functions. 
Key features:
Language, 2nd edition\", Chapter 22 (available online at:
Normal library clients should use the standard \"write\" interface. "
Note this should only be used for the last one in the sequence"
Note: \"walk\" supports all Clojure data structures EXCEPT maps
Now when you run:
Out of the box, pprint supports a simple structured format for basic data 
Output is sent to *out* which must be a pretty printing writer.
Output is sent to *out* which must be a pretty printing writer."
Output is sent to *out* which must be a pretty printing writer."
Platform implementers must:
Prints to *out*:
See documentation for pprint and cl-format for more information or 
Set it to nil to have pprint let the line be arbitrarily long. This will ignore all 
THIS FUNCTION IS NOT YET IMPLEMENTED."
The following keyword arguments can be passed with values:
The format control string is a string to be output with embedded 'format directives' 
The function new-instant is called with the following arguments.
The parallel library wraps the ForkJoin library scheduled for inclusion in JDK 7:
These are all integers and will be non-nil. (The listed defaults
This function is intended for use when writing custom dispatch functions.
This function is intended for use when writing custom dispatch functions.
This function is intended for use when writing custom dispatch functions.
This function is intended for use when writing custom dispatch functions.
This method is primarily intended for use by pretty print dispatch functions that 
Though time-offset is syntactically optional, a missing time-offset
Two main entry points: 
Unlike RFC3339:
Use the kw-args argument to override individual variables for this call (and any 
Writer is an instance of java.io.Writer, true to output to *out* or nil to output 
You'll need jsr166y.jar in your classpath in order to use this
a map of flags and returns a map of the parameters and flags with defaults
a more powerful alternative to Clojure's standard format function.
after first validating that those arguments are in range and otherwise
already a pretty writer. Generally, it is unnecessary to call this function, since pprint,
already know that the pretty printer will have set up their environment appropriately.
and :suffix."
and a specialized format for Clojure source code. More advanced formats, 
and in the Common Lisp HyperSpec at 
and no other characters.  Return a string containing one or more
any recursive calls).
are the data to be formatted.
arguments to an output stream or string based on the format control string given. It 
array (pvec/psort/pfilter-nils/pfilter-dupes). Rather than perform
assumed. 
attachments - bounds precede filters precede mappings.  All operations
be used to convert into UTC."
by default when a new command-line REPL is started."} repl-requires
cl-format, it supports very concise custom dispatch. It also provides
clojure.pprint implements a flexible system for printing structured data
clojure.pprint.dispatch.clj."
collecting its stdout"}
column number or pretty printing"
complete documentation on the Clojure web site on GitHub.",
composite operations in steps, as would normally be done with
created with sorted-map-by.  There is no (obvious) way to retrieve
decimal digits containing a decimal number one larger than the input
defaults to returning v."))
describing how to format the various arguments passed in.
designed to be used with *out* set to an appropriate Writer. In particular,
do it like in this example:
easy to write recursive search-and-replace functions, as shown in
efficiently vectors, can be turned into parallel arrays for use by
etc. A parallel array can be realized into a Clojure vector using
exactly equivalent to (pprint *1)."
fails, attempts to require sym's namespace and retries."
fields, and Java class static fields."}
filled in. We check to make sure that there are the right types and number
fn [& args] ... and returns nil. This version of the formatter macro is
fn [stream & args] ... and returns nil unless the stream is nil (meaning 
following lines are indented. relative-to can be either :block or :current depending 
for improved performance"
for use in pretty-printer dispatch functions."
format-in can be either a control string or a previously compiled format."
format-in can be either a control string or a previously compiled format."
formatting function which is fully compatible with the format function in 
forward if the output is already past the original target.
fractional seconds with nanosecond precision. The timezone offset will
http://gee.cs.oswego.edu/dl/concurrency-interest/index.html
http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/clm/node200.html#SECTION002633000000000000000) 
http://www.lispworks.com/documentation/HyperSpec/Body/22_c.htm
in a pleasing, easy-to-understand format. Basic use of the pretty printer is 
including formats that don't look like Clojure data at all like XML and 
is :line, :section, :line-relative, or :section-relative. 
itself (not its value) is returned. The reader macro #'x expands to (var x)."}})
java -cp clojure.jar clojure.main -i init.clj -r args...")
java -cp clojure.jar clojure.main -i init.clj script.clj args...")
levels of nesting.",
library.  The basic idea is that Clojure collections, and most
map with this var as the value for the 'inst key. Timestamp preserves
mapping functions prior to realization/calculation, which happens as
milliseconds since the epoch, UTC."
miser style add newlines in more places to try to keep lines short allowing for further 
must be a pretty printing writer. When used from pprint or cl-format, this can be 
newline is :linear, :miser, :fill, or :mandatory. 
nil
nil
nil
non-mandatory newlines.",
not a pretty writer (which keeps track of columns), this function always outputs a newline."
of parameters as well."
of the caller.
of the function in place of the original.  This makes it fairly
offset is a factor of 10^3 to multiply by"
offset, but truncating the subsecond fraction to milliseconds."
offset."
only need to call par explicitly in order to attach bound/filter/map
ops. Parallel arrays support the attachment of bounds, filters and
or 16, then the radix specifier used is #b, #o, or #x, respectively. Otherwise the 
output to a string) in which case it returns the resulting string.
performance when you're using the same format string repeatedly"
plausible. The resulting function will throw an exception if called
preserved across calls, you will want to wrap them with this. 
pretty printing the results of macro expansions"
print the object to the currently bound value of *out*."
providing ops to par. Note that there is an order sensitivity to the
public definitions in all currently-loaded namespaces that match the
pvec.
radix specifier is in the form #XXr where XX is the decimal value of *print-base* "
realized, or to perform aggregate operations like preduce/pmin/pmax
recursive calls). Returns the string result if :stream is nil or nil otherwise.
returns nil.
seq), calls a function on every element, and uses the return value
sequences, maps and filters are instead attached and thus composed by
simple, just call pprint instead of println. More advanced users can use 
specified.
str-or-pattern."
string, or one character longer."
string.  The output string will always be the same length as the input
structures.  It takes any data structure (list, vector, map, set,
supports sophisticated formatting of structured data.
take collections and will call par if needed, so normally you will
the building blocks provided to create custom output formats. 
the current column position. n is an offset. 
the examples.
the kinds of objects to which they can apply."}
the result of any of several operations on the
the sorting function."}
then happen in parallel, using multiple threads and a sophisticated
this is meant to be used as part of a pretty printer dispatch method.
this library with the function par, although most of the functions
this var as the value for the 'inst key.  Calendar preserves the timezone
this var as the value for the 'inst key. The timezone offset will be used
to a pretty printing writer to which it should do its printing.
to a string, format-in is the format control string and the remaining arguments 
to cl-format just like a plain format string. Use this function for improved 
to convert into UTC."
to modify.",
variables. Use the kw-args argument to override individual variables for this call (and 
where obj is the object to pretty print. That function will be called with *out* set
whether the indent should be computed relative to the start of the logical block or
will be passed if the corresponding field is not present in s.)
will be treated as if the time-offset zero (+00:00) had been
with :as to specify a prefix, e.g.
with invalid arguments."
work-stealing system supported by fork-join, either when the array is
write, and cl-format all call it if they need to. However if you want the state to be 

Thanks for the idea! Here is a script to generate this https://gist.github.com/jeroenvandijk/901db90caa7854b36a80061fa7989655