diff --git a/.gitignore b/.gitignore
index a8a3b1b06..189376cf1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -172,3 +172,4 @@ $RECYCLE.BIN/
 
 # Mono
 *.userprefs
+/dist/
diff --git a/Clojure/Clojure.Compile/Clojure.Compile.csproj b/Clojure/Clojure.Compile/Clojure.Compile.csproj
index eda0a5226..af9e18d2f 100644
--- a/Clojure/Clojure.Compile/Clojure.Compile.csproj
+++ b/Clojure/Clojure.Compile/Clojure.Compile.csproj
@@ -125,19 +125,21 @@
     </BootstrapperPackage>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
   -->
   <PropertyGroup>
-    <PostBuildEvent Condition=" '$(Runtime)' == 'Mono' ">mono "$(TargetPath)" clojure.core clojure.core.protocols clojure.core.reducers clojure.main clojure.set clojure.zip  clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
-    <PostBuildEvent Condition=" '$(Runtime)' == '.Net' ">     "$(TargetPath)" clojure.core clojure.core.protocols clojure.core.reducers clojure.main clojure.set clojure.zip  clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
+    <PostBuildEvent Condition=" '$(Runtime)' == 'Mono' ">mono "$(TargetPath)" clojure.core clojure.core.protocols clojure.core.server clojure.core.reducers clojure.main clojure.set clojure.zip clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
+    <PostBuildEvent Condition=" '$(Runtime)' == '.Net' ">     "$(TargetPath)" clojure.core clojure.core.protocols clojure.core.server clojure.core.reducers clojure.main clojure.set clojure.zip clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
   </PropertyGroup>
   <PropertyGroup>
-    <PostBuildEvent>set clojure.compiler.direct-linking=$(DirectLinking)
-$(TargetPath) clojure.core clojure.core.protocols clojure.core.server clojure.core.reducers clojure.main clojure.set clojure.zip  clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
+    <PostBuildEvent Condition=" '$(Runtime)' == '.Mono' ">CLOJURE_COMPILER_DIRECT_LINKING=$(DirectLinking)
+$(TargetPath) clojure.core clojure.core.protocols clojure.core.server clojure.core.reducers clojure.main clojure.set clojure.zip clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
+    <PostBuildEvent Condition=" '$(Runtime)' == '.Net' ">set clojure.compiler.direct-linking=$(DirectLinking)
+$(TargetPath) clojure.core clojure.core.protocols clojure.core.server clojure.core.reducers clojure.main clojure.set clojure.zip clojure.walk clojure.stacktrace clojure.template clojure.test clojure.test.tap clojure.test.junit clojure.pprint clojure.clr.io clojure.repl clojure.clr.shell clojure.string clojure.data clojure.reflect clojure.edn</PostBuildEvent>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/Clojure/Clojure.Source/Clojure.Source.csproj b/Clojure/Clojure.Source/Clojure.Source.csproj
index 5ca5be1eb..980cd1963 100644
--- a/Clojure/Clojure.Source/Clojure.Source.csproj
+++ b/Clojure/Clojure.Source/Clojure.Source.csproj
@@ -263,6 +263,17 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="clojure\spec.clj">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="clojure\spec\test.clj">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="clojure\spec\gen.clj">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Clojure/Clojure.Source/clojure/clr/io.clj b/Clojure/Clojure.Source/clojure/clr/io.clj
index 64981b437..3a71238df 100644
--- a/Clojure/Clojure.Source/clojure/clr/io.clj
+++ b/Clojure/Clojure.Source/clojure/clr/io.clj
@@ -384,8 +384,8 @@
       (let [size (.Read input buffer 0 len)]
         (when (pos? size)
           (let [ cnt (.GetCharCount decoder buffer 0 size)
-                 chbuf (make-array Char cnt)]
-            (do (.GetChars decoder buffer 0 size chbuf 0)
+                 ^|System.Char[]| chbuf (make-array Char cnt)]
+            (do (.GetChars decoder buffer 0 (int size) chbuf 0)
                 (.Write output chbuf 0 cnt)
                 (recur))))))))
 
diff --git a/Clojure/Clojure.Source/clojure/clr/shell.clj b/Clojure/Clojure.Source/clojure/clr/shell.clj
index 4dd991162..0370f30d9 100644
--- a/Clojure/Clojure.Source/clojure/clr/shell.clj
+++ b/Clojure/Clojure.Source/clojure/clr/shell.clj
@@ -112,8 +112,8 @@ Halloway."}
   [& args]
   (let [[cmd opts] (parse-args args)
         {:keys [in in-enc out-enc]} opts
-        proc (Process/Start
-              (make-process-info cmd out-enc (:env opts) (:dir opts)))]
+        ^ProcessStartInfo process-info (make-process-info cmd out-enc (:env opts) (:dir opts))
+        proc (Process/Start process-info)]
     (future
      (with-open [stdin (.StandardInput proc)]
        (when in
diff --git a/Clojure/Clojure.Source/clojure/core.clj b/Clojure/Clojure.Source/clojure/core.clj
index 3cf8765aa..d78b5fe9b 100644
--- a/Clojure/Clojure.Source/clojure/core.clj
+++ b/Clojure/Clojure.Source/clojure/core.clj
@@ -529,6 +529,17 @@
    :static true}
   [x] (not (nil? x)))
 
+(defn boolean?
+  "Return true if x is a Boolean"
+  {:added "1.9"}
+  [x] (instance? Boolean x))
+
+(defn any?
+  "Returns true given any argument."
+  {:tag Boolean
+   :added "1.9"}
+  [x] true)
+
 (defn str
   "With no args, returns the empty string. With one arg x, returns
   x.toString().  (str nil) returns the empty string. With more than
@@ -585,10 +596,10 @@
   [& clauses]
     (when clauses
       (list 'if (first clauses)
-            (if (next clauses)
-                (second clauses)
-                (throw (ArgumentException.                           ;;;IllegalArgumentException.
-                         "cond requires an even number of forms")))
+            (if (next clauses)
+                (second clauses)
+                (throw (ArgumentException.                           ;;;IllegalArgumentException.
+                         "cond requires an even number of forms")))
             (cons 'clojure.core/cond (next (next clauses))))))           
 
 (defn keyword
@@ -650,7 +661,7 @@
   ([^clojure.lang.IFn f x y z args]
      (. f (applyTo (list* x y z args))))
   ([^clojure.lang.IFn f a b c d & args]
-     (. f (applyTo (cons a (cons b (cons c (cons d (spread args)))))))))
+     (. f (applyTo (cons a (cons b (cons c (cons d (spread args)))))))))
     
 (defn vary-meta
  "Returns an object of the same type and value as obj, with
@@ -744,12 +755,12 @@
    :static true}
   [x] (. clojure.lang.Delay (force x)))
     
-(defmacro if-not
+(defmacro if-not
   "Evaluates test. If logical false, evaluates and returns then expr, 
-  otherwise else expr, if supplied, else nil."  
+  otherwise else expr, if supplied, else nil."  
   {:added "1.0"}
-  ([test then] `(if-not ~test ~then nil))
-  ([test then else]
+  ([test then] `(if-not ~test ~then nil))
+  ([test then else]
    `(if (not ~test) ~then ~else)))
    
 (defn identical?
@@ -1350,17 +1361,17 @@
   {:inline (fn [x n] `(. clojure.lang.Numbers (unsignedShiftRight ~x ~n)))
    :added "1.6"}
   [x n] (. clojure.lang.Numbers unsignedShiftRight x n))
-
- (defn integer?
-  "Returns true if n is an integer"
+
+ (defn integer?
+  "Returns true if n is an integer"
   {:added "1.0"
    :static true}
-  [n]
-  (or (instance? Int32 n)      (instance? UInt32 n)     ;;; Integer -> Int32, added UInt32
-      (instance? Int64 n)      (instance? UInt64 n)     ;;; Long -> Int64, added UInt64
-	  (instance? clojure.lang.BigInt n)
-      (instance? BigInteger n) (instance? Char n)       ;;; added Char test
-      (instance? Int16 n)      (instance? UInt16 n)     ;;; Short -> Int16, added UInt16
+  [n]
+  (or (instance? Int32 n)      (instance? UInt32 n)     ;;; Integer -> Int32, added UInt32
+      (instance? Int64 n)      (instance? UInt64 n)     ;;; Long -> Int64, added UInt64
+	  (instance? clojure.lang.BigInt n)
+      (instance? BigInteger n) (instance? Char n)       ;;; added Char test
+      (instance? Int16 n)      (instance? UInt16 n)     ;;; Short -> Int16, added UInt16
       (instance? Byte n)  (instance? SByte n)))         ;;; Added SByte test
 
 (defn even?
@@ -1377,6 +1388,33 @@
    :static true}
   [n] (not (even? n)))
 
+(defn int?
+  "bad version of clojure jvm int?"
+  [x] (integer? x))
+
+(defn pos-int?
+  "Return true if x is a positive fixed precision integer"
+  {:added "1.9"}
+  [x] (and (int? x)
+           (pos? x)))
+
+(defn neg-int?
+  "Return true if x is a negative fixed precision integer"
+  {:added "1.9"}
+  [x] (and (int? x)
+           (neg? x)))
+
+(defn nat-int?
+  "Return true if x is a non-negative fixed precision integer"
+  {:added "1.9"}
+  [x] (and (int? x)
+           (not (neg? x))))
+
+(defn double?
+  "Return true if x is a Double"
+  {:added "1.9"}
+  [x] (instance? Double x))
+
 
 ;;
 
@@ -1435,14 +1473,14 @@
       true)))
 
 (defn contains?
-  "Returns true if key is present in the given collection, otherwise
-  returns false.  Note that for numerically indexed collections like
-  vectors and Java arrays, this tests if the numeric key is within the
-  range of indexes. 'contains?' operates constant or logarithmic time;
+  "Returns true if key is present in the given collection, otherwise
+  returns false.  Note that for numerically indexed collections like
+  vectors and Java arrays, this tests if the numeric key is within the
+  range of indexes. 'contains?' operates constant or logarithmic time;
   it will not perform a linear search for a value.  See also 'some'."
   {:added "1.0"
    :static true}
- [coll key] (. clojure.lang.RT (contains coll key)))
+ [coll key] (. clojure.lang.RT (contains coll key)))
 
 (defn get
   "Returns the value mapped to key, not-found or nil if key not present."
@@ -1555,6 +1593,41 @@
   [^clojure.lang.Named x]
     (. x (getNamespace)))
   
+(defn ident?
+  "Return true if x is a symbol or keyword"
+  {:added "1.9"}
+  [x] (or (keyword? x) (symbol? x)))
+
+(defn simple-ident?
+  "Return true if x is a symbol or keyword without a namespace"
+  {:added "1.9"}
+  [x] (and (ident? x) (nil? (namespace x))))
+
+(defn qualified-ident?
+  "Return true if x is a symbol or keyword with a namespace"
+  {:added "1.9"}
+  [x] (and (ident? x) (namespace x) true))
+
+(defn simple-symbol?
+  "Return true if x is a symbol without a namespace"
+  {:added "1.9"}
+  [x] (and (symbol? x) (nil? (namespace x))))
+
+(defn qualified-symbol?
+  "Return true if x is a symbol with a namespace"
+  {:added "1.9"}
+  [x] (and (symbol? x) (namespace x) true))
+
+(defn simple-keyword?
+  "Return true if x is a keyword without a namespace"
+  {:added "1.9"}
+  [x] (and (keyword? x) (nil? (namespace x))))
+
+(defn qualified-keyword?
+  "Return true if x is a keyword with a namespace"
+  {:added "1.9"}
+  [x] (and (keyword? x) (namespace x) true))
+  
 (defmacro locking
   "Executes exprs in an implicit do, while holding the monitor of x.
   Will release the monitor of x in all circumstances."
@@ -1739,14 +1812,14 @@
   
 ;;;;;;;;; var stuff
 
-(defmacro ^{:private true} assert-args 
-  [& pairs]
-  `(do (when-not ~(first pairs)
-         (throw (ArgumentException.                            ;;;IllegalArgumentException.
-                  (str (first ~'&form) " requires " ~(second pairs) " in " ~'*ns* ":" (:line (meta ~'&form))))))
-     ~(let [more (nnext pairs)]
-        (when more
-          (list* `assert-args more)))))
+(defmacro ^{:private true} assert-args 
+  [& pairs]
+  `(do (when-not ~(first pairs)
+         (throw (ArgumentException.                            ;;;IllegalArgumentException.
+                  (str (first ~'&form) " requires " ~(second pairs) " in " ~'*ns* ":" (:line (meta ~'&form))))))
+     ~(let [more (nnext pairs)]
+        (when more
+          (list* `assert-args more)))))
 
 (defmacro if-let
   "bindings => binding-form test
@@ -1782,7 +1855,7 @@
        (when temp#
          (let [~form temp#]
            ~@body)))))
-
+
 (defmacro if-some
   "bindings => binding-form test
 
@@ -1853,17 +1926,17 @@
    :static true}
   []
   (clojure.lang.Var/getThreadBindings))
-
-(defmacro binding
-  "binding => var-symbol init-expr
-
-  Creates new bindings for the (already-existing) vars, with the
-  supplied initial values, executes the exprs in an implicit do, then
+
+(defmacro binding
+  "binding => var-symbol init-expr
+
+  Creates new bindings for the (already-existing) vars, with the
+  supplied initial values, executes the exprs in an implicit do, then
   re-establishes the bindings that existed before.  The new bindings
   are made in parallel (unlike let); all init-exprs are evaluated
-  before the vars are bound to their new values."
+  before the vars are bound to their new values."
   {:added "1.0"}
-  [bindings & body]
+  [bindings & body]
   (assert-args
     (vector? bindings) "a vector for its binding"
     (even? (count bindings)) "an even number of forms in binding vector")
@@ -2040,17 +2113,17 @@
   [^clojure.lang.Agent a f & args]
   (.dispatch a (binding [*agent* a] (binding-conveyor-fn f)) args true))             ;;;  No CLR equivalent. keep old true/false style -- (apply send-via clojure.lang.Agent/soloExecutor a f args))
 
-(defn release-pending-sends
-  "Normally, actions sent directly or indirectly during another action
-  are held until the action completes (changes the agent's
-  state). This function can be used to dispatch any pending sent
-  actions immediately. This has no impact on actions sent during a
-  transaction, which are still held until commit. If no action is
-  occurring, does nothing. Returns the number of actions dispatched."
+(defn release-pending-sends
+  "Normally, actions sent directly or indirectly during another action
+  are held until the action completes (changes the agent's
+  state). This function can be used to dispatch any pending sent
+  actions immediately. This has no impact on actions sent during a
+  transaction, which are still held until commit. If no action is
+  occurring, does nothing. Returns the number of actions dispatched."
   {:added "1.0"
    :static true}
-  [] (clojure.lang.Agent/releasePendingSends))
-
+  [] (clojure.lang.Agent/releasePendingSends))
+
 (defn add-watch
   "Adds a watch function to an agent/atom/var/ref reference. The watch
   fn must be a fn of 4 args: a key, the reference, its old-state, its
@@ -2075,7 +2148,7 @@
    :static true}
   [^clojure.lang.IRef reference key]
   (.removeWatch reference key))
-
+
 (defn agent-error
   "Returns the exception thrown during an asynchronous action of the
   agent if the agent is failed.  Returns nil if the agent is not
@@ -2169,33 +2242,33 @@
    :static true}
   [] (. clojure.lang.Agent shutdown))
  
-(defn ref
-  "Creates and returns a Ref with an initial value of x and zero or
-  more options (in any order):
-
-  :meta metadata-map
-
-  :validator validate-fn
-
-  :min-history (default 0)
-  :max-history (default 10)
-  
-  If metadata-map is supplied, it will become the metadata on the
-  ref. validate-fn must be nil or a side-effect-free fn of one
-  argument, which will be passed the intended new state on any state
-  change. If the new state is unacceptable, the validate-fn should
-  return false or throw an exception. validate-fn will be called on
-  transaction commit, when all refs have their final values.
-  
-  Normally refs accumulate history dynamically as needed to deal with
-  read demands.  If you know in advance you will need a history you can
-  set :min-history to ensure that it will be available when first needed (instead
-  of after a read fault).   History is limited and the limit can be set
-  with :max-history."
+(defn ref
+  "Creates and returns a Ref with an initial value of x and zero or
+  more options (in any order):
+
+  :meta metadata-map
+
+  :validator validate-fn
+
+  :min-history (default 0)
+  :max-history (default 10)
+  
+  If metadata-map is supplied, it will become the metadata on the
+  ref. validate-fn must be nil or a side-effect-free fn of one
+  argument, which will be passed the intended new state on any state
+  change. If the new state is unacceptable, the validate-fn should
+  return false or throw an exception. validate-fn will be called on
+  transaction commit, when all refs have their final values.
+  
+  Normally refs accumulate history dynamically as needed to deal with
+  read demands.  If you know in advance you will need a history you can
+  set :min-history to ensure that it will be available when first needed (instead
+  of after a read fault).   History is limited and the limit can be set
+  with :max-history."
   {:added "1.0"
    :static true
   }
-  ([x] (new clojure.lang.Ref x))
+  ([x] (new clojure.lang.Ref x))
   ([x & options] 
    (let [ r ^clojure.lang.Ref (setup-reference (ref x) options)
           opts (apply hash-map options)]
@@ -2214,9 +2287,9 @@
             timeout-val))))
     
 (defn deref
-  "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,
-  returns the in-transaction-value of ref, else returns the
-  most-recently-committed value of ref. When applied to a var, agent
+  "Also reader macro: @ref/@agent/@var/@atom/@delay/@future/@promise. Within a transaction,
+  returns the in-transaction-value of ref, else returns the
+  most-recently-committed value of ref. When applied to a var, agent
   or atom, returns its current state. When applied to a delay, forces
   it if not already forced. When applied to a future, will block if
   computation not complete. When applied to a promise, will block
@@ -2280,18 +2353,18 @@
   [^clojure.lang.IAtom atom newval] (.reset atom newval))
 
 (defn set-validator
-  "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
-  side-effect-free fn of one argument, which will be passed the intended
-  new state on any state change. If the new state is unacceptable, the
-  validator-fn should return false or throw an exception. If the current state (root
-  value if var) is not acceptable to the new validator, an exception
-  will be thrown and the validator will not be changed."
+  "Sets the validator-fn for a var/ref/agent/atom. validator-fn must be nil or a
+  side-effect-free fn of one argument, which will be passed the intended
+  new state on any state change. If the new state is unacceptable, the
+  validator-fn should return false or throw an exception. If the current state (root
+  value if var) is not acceptable to the new validator, an exception
+  will be thrown and the validator will not be changed."
   {:added "1.0"
    :static true}
-  [^clojure.lang.IRef iref validator-fn] (. iref (setValidator validator-fn)))
+  [^clojure.lang.IRef iref validator-fn] (. iref (setValidator validator-fn)))
 
 (defn get-validator
-  "Gets the validator-fn for a var/ref/agent/atom."
+  "Gets the validator-fn for a var/ref/agent/atom."
   {:added "1.0"
    :static true}
  [^clojure.lang.IRef iref] (. iref (getValidator)))
@@ -2402,17 +2475,17 @@
       (runInTransaction (fn [] ~@body))))
 
 
-(defmacro io!
-  "If an io! block occurs in a transaction, throws an
-  IllegalStateException, else runs body in an implicit do. If the
-  first expression in body is a literal string, will use that as the
-  exception message."
+(defmacro io!
+  "If an io! block occurs in a transaction, throws an
+  IllegalStateException, else runs body in an implicit do. If the
+  first expression in body is a literal string, will use that as the
+  exception message."
   {:added "1.0"}
-  [& body]
-  (let [message (when (string? (first body)) (first body))
-        body (if message (next body) body)]
-    `(if (clojure.lang.LockingTransaction/isRunning)
-       (throw (new InvalidOperationException ~(or message "I/O in transaction")))   ;;; IllegalStateException
+  [& body]
+  (let [message (when (string? (first body)) (first body))
+        body (if message (next body) body)]
+    `(if (clojure.lang.LockingTransaction/isRunning)
+       (throw (new InvalidOperationException ~(or message "I/O in transaction")))   ;;; IllegalStateException
        (do ~@body))))
        
 (defn volatile!
@@ -2582,15 +2655,15 @@
    :added "1.0"}
  not-every? (comp not every?))
 
-(defn some
-  "Returns the first logical true value of (pred x) for any x in coll,
-  else nil.  One common idiom is to use a set as pred, for example
-  this will return :fred if :fred is in the sequence, otherwise nil:
-  (some #{:fred} coll)"
+(defn some
+  "Returns the first logical true value of (pred x) for any x in coll,
+  else nil.  One common idiom is to use a set as pred, for example
+  this will return :fred if :fred is in the sequence, otherwise nil:
+  (some #{:fred} coll)"
   {:added "1.0"
    :static true}
-  [pred coll]
-    (when (seq coll)
+  [pred coll]
+    (when (seq coll)
       (or (pred (first coll)) (recur pred (next coll)))))
 
 (def
@@ -3112,9 +3185,9 @@
   the head of the sequence. Returns nil."
   {:added "1.0"}
   [seq-exprs & body]
-  (assert-args
-     (vector? seq-exprs) "a vector for its binding"
-     (even? (count seq-exprs)) "an even number of forms in binding vector")
+  (assert-args
+     (vector? seq-exprs) "a vector for its binding"
+     (even? (count seq-exprs)) "an even number of forms in binding vector")
   (let [step (fn step [recform exprs]
                (if-not exprs
                  [true `(do ~@body)]
@@ -3162,7 +3235,7 @@
                                  (let [~k (first ~seq-)]
                                    ~subform
                                    ~@(when needrec [recform]))))))])))))]
-    (nth (step nil (seq seq-exprs)) 1)))
+    (nth (step nil (seq seq-exprs)) 1)))
 
 (defn await
   "Blocks the current thread (indefinitely!) until all actions
@@ -3172,13 +3245,13 @@
   {:added "1.0"
    :static true}
   [& agents]
-  (io! "await in transaction"
-    (when *agent*
-      (throw (new Exception "Can't await in agent action")))
-    (let [latch (new clojure.lang.CountDownLatch (count agents))  ;;; java.util.concurrent.CountDownLatch
-          count-down (fn [agent] (. latch (CountDown)) agent)]    ;;; countDown
-      (doseq [agent agents]
-        (send agent count-down))
+  (io! "await in transaction"
+    (when *agent*
+      (throw (new Exception "Can't await in agent action")))
+    (let [latch (new clojure.lang.CountDownLatch (count agents))  ;;; java.util.concurrent.CountDownLatch
+          count-down (fn [agent] (. latch (CountDown)) agent)]    ;;; countDown
+      (doseq [agent agents]
+        (send agent count-down))
       (. latch (Await)))))                                        ;;; await
 
 (defn ^:static await1 [^clojure.lang.Agent a]
@@ -3194,31 +3267,31 @@
   {:added "1.0"
    :static true}
   [timeout-ms & agents]
-    (io! "await-for in transaction"
-     (when *agent*
-       (throw (new Exception "Can't await in agent action")))
-     (let [latch (new clojure.lang.CountDownLatch (count agents))   ;;; java.util.concurrent.CountDownLatch
-           count-down (fn [agent] (. latch (CountDown)) agent)]     ;;; countDown
-       (doseq [agent agents]
-           (send agent count-down))
+    (io! "await-for in transaction"
+     (when *agent*
+       (throw (new Exception "Can't await in agent action")))
+     (let [latch (new clojure.lang.CountDownLatch (count agents))   ;;; java.util.concurrent.CountDownLatch
+           count-down (fn [agent] (. latch (CountDown)) agent)]     ;;; countDown
+       (doseq [agent agents]
+           (send agent count-down))
        (. latch (Await timeout-ms)))))   ;;;(await  timeout-ms (. java.util.concurrent.TimeUnit MILLISECONDS))))))
 
-(defmacro dotimes
-  "bindings => name n
-
-  Repeatedly executes body (presumably for side-effects) with name
-  bound to integers from 0 through n-1."
+(defmacro dotimes
+  "bindings => name n
+
+  Repeatedly executes body (presumably for side-effects) with name
+  bound to integers from 0 through n-1."
   {:added "1.0"}
-  [bindings & body]
-  (assert-args
-     (vector? bindings) "a vector for its binding"
-     (= 2 (count bindings)) "exactly 2 forms in binding vector")
-  (let [i (first bindings)
-        n (second bindings)]
-    `(let [n# (long ~n)]
-       (loop [~i 0]
-         (when (< ~i n#)
-           ~@body
+  [bindings & body]
+  (assert-args
+     (vector? bindings) "a vector for its binding"
+     (= 2 (count bindings)) "exactly 2 forms in binding vector")
+  (let [i (first bindings)
+        n (second bindings)]
+    `(let [n# (long ~n)]
+       (loop [~i 0]
+         (when (< ~i n#)
+           ~@body
            (recur (unchecked-inc ~i)))))))
   
 #_(defn into
@@ -3314,15 +3387,15 @@
   (if (instance? clojure.lang.IEditableCollection to)
     (persistent! (reduce1 conj! (transient to) from))
     (reduce1 conj to from)))
-
-(defmacro import 
-  "import-list => (package-symbol class-name-symbols*)
-
-  For each name in class-name-symbols, adds a mapping from name to the
-  class named by package.name to the current namespace. Use :import in the ns
-  macro in preference to calling this directly."
+
+(defmacro import 
+  "import-list => (package-symbol class-name-symbols*)
+
+  For each name in class-name-symbols, adds a mapping from name to the
+  class named by package.name to the current namespace. Use :import in the ns
+  macro in preference to calling this directly."
   {:added "1.0"}
-  [& import-symbols-or-lists]
+  [& import-symbols-or-lists]
   (let [specs (map #(if (and (seq? %) (= 'quote (first %))) (second %) %) 
                    import-symbols-or-lists)]
     `(do ~@(map #(list 'clojure.core/import* %)
@@ -3455,14 +3528,14 @@
    :added "1.3"}
   [x] (clojure.lang.RT/uncheckedDoubleCast x))                    ;;; ^Number 
 
-
-(defn number?
-  "Returns true if x is a Number"
+
+(defn number?
+  "Returns true if x is a Number"
   {:added "1.0"
    :static true}
-  [x]
-  (. clojure.lang.Util (IsNumeric x)))    ;;; (instance? Number x))
-
+  [x]
+  (. clojure.lang.Util (IsNumeric x)))    ;;; (instance? Number x))
+
 (defn mod
   "Modulus of num and div. Truncates toward negative infinity."
   {:added "1.0"
@@ -3473,12 +3546,12 @@
       m 
       (+ m div))))
 
-(defn ratio?
-  "Returns true if n is a Ratio"
+(defn ratio?
+  "Returns true if n is a Ratio"
   {:added "1.0"
    :static true}
-  [n] (instance? clojure.lang.Ratio n))
-
+  [n] (instance? clojure.lang.Ratio n))
+
 (defn numerator
  "Returns the numerator part of a Ratio."
  {:tag BigInteger
@@ -3494,29 +3567,29 @@
   :static true}
  [r]
   (.denominator ^clojure.lang.Ratio r))
-
-(defn decimal?
-  "Returns true if n is a BigDecimal"
+
+(defn decimal?
+  "Returns true if n is a BigDecimal"
   {:added "1.0"
    :static true}
-  [n] (instance? BigDecimal n))
-
-(defn float?
-  "Returns true if n is a floating point number"
+  [n] (instance? BigDecimal n))
+
+(defn float?
+  "Returns true if n is a floating point number"
   {:added "1.0"
    :static true}
-  [n]   
-  (or (instance? Double n)
-      (instance? Single n)))     ;;; Float
-
-(defn rational?
-  "Returns true if n is a rational number"
+  [n]   
+  (or (instance? Double n)
+      (instance? Single n)))     ;;; Float
+
+(defn rational?
+  "Returns true if n is a rational number"
   {:added "1.0"
    :static true}
   [n]
-  (or (integer? n) (ratio? n) (decimal? n)))
+  (or (integer? n) (ratio? n) (decimal? n)))
 
-(defn bigint
+(defn bigint
   "Coerce to BigInt"
   {:tag clojure.lang.BigInt
    :static true
@@ -3530,33 +3603,33 @@
        (number? x) (clojure.lang.BigInt/valueOf (long x))   (string? x) (bigint (BigInteger/Parse ^String x))   ;; DM: Added string clause
        :else (bigint (BigInteger. x))))
 
-(defn biginteger
-  "Coerce to BigInteger"
-  {:tag BigInteger
+(defn biginteger
+  "Coerce to BigInteger"
+  {:tag BigInteger
    :added "1.0"
    :static true}
-  [x] (cond
-       (instance? BigInteger x) x
-	   (instance? clojure.lang.BigInt x) (.toBigInteger ^clojure.lang.BigInt x)
-       (decimal? x) (.ToBigInteger ^BigDecimal x)                                ;;; toBigInteger
-	   (float? x) (.ToBigInteger (BigDecimal/Create (double x)))                 ;;; (.toBigInteger (. BigDecimal valueOf (double x)))
-       (ratio? x) (.BigIntegerValue ^clojure.lang.Ratio x)
-       (number? x) (BigInteger/Create (long x))      (string? x) (bigint (BigInteger/Parse ^String x))          ;;;(BigInteger/valueOf (long x))  DM: Added string clause
-       :else (BigInteger. x)))
-
-(defn bigdec
-  "Coerce to BigDecimal"
-  {:tag BigDecimal
+  [x] (cond
+       (instance? BigInteger x) x
+	   (instance? clojure.lang.BigInt x) (.toBigInteger ^clojure.lang.BigInt x)
+       (decimal? x) (.ToBigInteger ^BigDecimal x)                                ;;; toBigInteger
+	   (float? x) (.ToBigInteger (BigDecimal/Create (double x)))                 ;;; (.toBigInteger (. BigDecimal valueOf (double x)))
+       (ratio? x) (.BigIntegerValue ^clojure.lang.Ratio x)
+       (number? x) (BigInteger/Create (long x))      (string? x) (bigint (BigInteger/Parse ^String x))          ;;;(BigInteger/valueOf (long x))  DM: Added string clause
+       :else (BigInteger. x)))
+
+(defn bigdec
+  "Coerce to BigDecimal"
+  {:tag BigDecimal
    :added "1.0"
    :static true}
-  [x] (cond
-       (decimal? x) x
-       (float? x) (BigDecimal/Create (double x))                                          ;;; (. BigDecimal valueOf (double x))
+  [x] (cond
+       (decimal? x) x
+       (float? x) (BigDecimal/Create (double x))                                          ;;; (. BigDecimal valueOf (double x))
        (ratio? x) (/ (BigDecimal/Create (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))     ;;; (/ (BigDecimal. (.numerator ^clojure.lang.Ratio x)) (.denominator ^clojure.lang.Ratio x))
        (instance? clojure.lang.BigInt x) (.ToBigDecimal ^clojure.lang.BigInt x)           ;;; .ToBigDecimal
-       (instance? BigInteger x) (BigDecimal/Create ^BigInteger x)                         ;;; (BigDecimal. ^BigInteger x)
-       (number? x) (BigDecimal/Create (long x))                                           ;;; (BigDecimal/valueOf (long x))
-       :else  (BigDecimal/Create x)))                                                     ;;; (BigDecimal. x)))
+       (instance? BigInteger x) (BigDecimal/Create ^BigInteger x)                         ;;; (BigDecimal. ^BigInteger x)
+       (number? x) (BigDecimal/Create (long x))                                           ;;; (BigDecimal/valueOf (long x))
+       :else  (BigDecimal/Create x)))                                                     ;;; (BigDecimal. x)))
 	   
 (def ^:dynamic ^{:private true} print-initialized false)
 
@@ -3689,55 +3762,55 @@ Note that read can execute code (controlled by *read-eval*),
   ([s] (clojure.lang.RT/readString s))
   ([opts s] (clojure.lang.RT/readString s opts)))
 
-(defn subvec
-  "Returns a persistent vector of the items in vector from
-  start (inclusive) to end (exclusive).  If end is not supplied,
-  defaults to (count vector). This operation is O(1) and very fast, as
-  the resulting vector shares structure with the original and no
-  trimming is done."
+(defn subvec
+  "Returns a persistent vector of the items in vector from
+  start (inclusive) to end (exclusive).  If end is not supplied,
+  defaults to (count vector). This operation is O(1) and very fast, as
+  the resulting vector shares structure with the original and no
+  trimming is done."
   {:added "1.0"
    :static true}
-  ([v start]
-   (subvec v start (count v)))
-  ([v start end]
+  ([v start]
+   (subvec v start (count v)))
+  ([v start end]
    (. clojure.lang.RT (subvec v start end))))
    
 (defmacro with-open
   "bindings => name init
 
-  Evaluates body in a try expression with names bound to the values
-  of the inits, and a finally clause that calls (.close name) on each
-  name in reverse order."
+  Evaluates body in a try expression with names bound to the values
+  of the inits, and a finally clause that calls (.close name) on each
+  name in reverse order."
   {:added "1.0"}
-  [bindings & body]
-  (assert-args
-     (vector? bindings) "a vector for its binding"
-     (even? (count bindings)) "an even number of forms in binding vector")
-  (cond
-    (= (count bindings) 0) `(do ~@body)
-    (symbol? (bindings 0)) `(let ~(subvec bindings 0 2)
-                              (try
-                                (with-open ~(subvec bindings 2) ~@body)
-                                (finally
-                                  (. ~(with-meta (bindings 0) {:tag 'IDisposable}) Dispose))))      ;;; close => Dispose
-    :else (throw (ArgumentException.                              ;;;IllegalArgumentException.
-                   "with-open only allows Symbols in bindings"))))
+  [bindings & body]
+  (assert-args
+     (vector? bindings) "a vector for its binding"
+     (even? (count bindings)) "an even number of forms in binding vector")
+  (cond
+    (= (count bindings) 0) `(do ~@body)
+    (symbol? (bindings 0)) `(let ~(subvec bindings 0 2)
+                              (try
+                                (with-open ~(subvec bindings 2) ~@body)
+                                (finally
+                                  (. ~(with-meta (bindings 0) {:tag 'IDisposable}) Dispose))))      ;;; close => Dispose
+    :else (throw (ArgumentException.                              ;;;IllegalArgumentException.
+                   "with-open only allows Symbols in bindings"))))
 
 (defmacro doto
-  "Evaluates x then calls all of the methods and functions with the
-  value of x supplied at the front of the given arguments.  The forms
-  are evaluated in order.  Returns x.
-
-  (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))"
+  "Evaluates x then calls all of the methods and functions with the
+  value of x supplied at the front of the given arguments.  The forms
+  are evaluated in order.  Returns x.
+
+  (doto (new java.util.HashMap) (.put \"a\" 1) (.put \"b\" 2))"
   {:added "1.0"}
-  [x & forms]
-    (let [gx (gensym)]
-      `(let [~gx ~x]
-         ~@(map (fn [f]
-                  (if (seq? f)
-                    `(~(first f) ~gx ~@(next f))
-                    `(~f ~gx)))
-                forms)
+  [x & forms]
+    (let [gx (gensym)]
+      `(let [~gx ~x]
+         ~@(map (fn [f]
+                  (if (seq? f)
+                    `(~(first f) ~gx ~@(next f))
+                    `(~f ~gx)))
+                forms)
          ~gx)))
 
 (defmacro memfn
@@ -4023,8 +4096,8 @@ Note that read can execute code (controlled by *read-eval*),
   [] (clojure.lang.Namespace/all))
 
 (defn the-ns 
-  "If passed a namespace, returns it. Else, when passed a symbol,
-  returns the namespace named by it, throwing an exception if not
+  "If passed a namespace, returns it. Else, when passed a symbol,
+  returns the namespace named by it, throwing an exception if not
   found."
   {:added "1.0"
    :static true}
@@ -4217,15 +4290,15 @@ Note that read can execute code (controlled by *read-eval*),
   to the var objects themselves, and must be accessed with var-get and
   var-set"
   {:added "1.0"}
-  [name-vals-vec & body]
-  (assert-args
-     (vector? name-vals-vec) "a vector for its binding"
-     (even? (count name-vals-vec)) "an even number of forms in binding vector")
-  `(let [~@(interleave (take-nth 2 name-vals-vec)
-                       (repeat '(.. clojure.lang.Var create setDynamic)))]
-     (. clojure.lang.Var (pushThreadBindings (hash-map ~@name-vals-vec)))
-     (try
-      ~@body
+  [name-vals-vec & body]
+  (assert-args
+     (vector? name-vals-vec) "a vector for its binding"
+     (even? (count name-vals-vec)) "an even number of forms in binding vector")
+  `(let [~@(interleave (take-nth 2 name-vals-vec)
+                       (repeat '(.. clojure.lang.Var create setDynamic)))]
+     (. clojure.lang.Var (pushThreadBindings (hash-map ~@name-vals-vec)))
+     (try
+      ~@body
       (finally (. clojure.lang.Var (popThreadBindings))))))
 
 (defn ns-resolve
@@ -4324,17 +4397,17 @@ Note that read can execute code (controlled by *read-eval*),
       bindings
       (reduce1 process-entry [] bents))))
 
-(defmacro let
-  "binding => binding-form init-expr
-
-  Evaluates the exprs in a lexical context in which the symbols in
-  the binding-forms are bound to their respective init-exprs or parts
-  therein."
+(defmacro let
+  "binding => binding-form init-expr
+
+  Evaluates the exprs in a lexical context in which the symbols in
+  the binding-forms are bound to their respective init-exprs or parts
+  therein."
   {:added "1.0", :special-form true, :forms '[(let [bindings*] exprs*)]}
-  [bindings & body]
-  (assert-args
-     (vector? bindings) "a vector for its binding"
-     (even? (count bindings)) "an even number of forms in binding vector")
+  [bindings & body]
+  (assert-args
+     (vector? bindings) "a vector for its binding"
+     (even? (count bindings)) "an even number of forms in binding vector")
   `(let* ~(destructure bindings) ~@body))
 
 (defn ^{:private true}
@@ -4423,36 +4496,36 @@ Note that read can execute code (controlled by *read-eval*),
   the binding-forms are bound to their respective init-exprs or parts
   therein. Acts as a recur target."
   {:added "1.0", :special-form true, :forms '[(loop [bindings*] exprs*)]}
-  [bindings & body]
-    (assert-args
-      (vector? bindings) "a vector for its binding"
-      (even? (count bindings)) "an even number of forms in binding vector")
-    (let [db (destructure bindings)]
-      (if (= db bindings)
-        `(loop* ~bindings ~@body)
-        (let [vs (take-nth 2 (drop 1 bindings))
-              bs (take-nth 2 bindings)
-              gs (map (fn [b] (if (symbol? b) b (gensym))) bs)
-              bfs (reduce1 (fn [ret [b v g]]
-                            (if (symbol? b)
-                              (conj ret g v)
-                              (conj ret g v b g)))
-                          [] (map vector bs vs gs))]
-          `(let ~bfs
-             (loop* ~(vec (interleave gs gs))
-               (let ~(vec (interleave bs gs))
+  [bindings & body]
+    (assert-args
+      (vector? bindings) "a vector for its binding"
+      (even? (count bindings)) "an even number of forms in binding vector")
+    (let [db (destructure bindings)]
+      (if (= db bindings)
+        `(loop* ~bindings ~@body)
+        (let [vs (take-nth 2 (drop 1 bindings))
+              bs (take-nth 2 bindings)
+              gs (map (fn [b] (if (symbol? b) b (gensym))) bs)
+              bfs (reduce1 (fn [ret [b v g]]
+                            (if (symbol? b)
+                              (conj ret g v)
+                              (conj ret g v b g)))
+                          [] (map vector bs vs gs))]
+          `(let ~bfs
+             (loop* ~(vec (interleave gs gs))
+               (let ~(vec (interleave bs gs))
                  ~@body)))))))
 
-(defmacro when-first
-  "bindings => x xs
-
-  Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once"
+(defmacro when-first
+  "bindings => x xs
+
+  Roughly the same as (when (seq xs) (let [x (first xs)] body)) but xs is evaluated only once"
   {:added "1.0"}
-  [bindings & body]
-  (assert-args
-     (vector? bindings) "a vector for its binding"
-     (= 2 (count bindings)) "exactly 2 forms in binding vector")
-  (let [[x xs] bindings]
+  [bindings & body]
+  (assert-args
+     (vector? bindings) "a vector for its binding"
+     (= 2 (count bindings)) "exactly 2 forms in binding vector")
+  (let [[x xs] bindings]
     `(when-let [xs# (seq ~xs)]
        (let [~x (first xs#)]
            ~@body))))
@@ -4656,14 +4729,14 @@ Note that read can execute code (controlled by *read-eval*),
         (do (f) :ok)
         :no-test)))
 ;;; Had to add a bogus class clojure.lang.JReMatcher to make the re-* functions work.
-(defn re-pattern
-  "Returns an instance of java.util.regex.Pattern, for use, e.g. in
-  re-matcher."
-  {:tag System.Text.RegularExpressions.Regex                             ;;; {:tag java.util.regex.Pattern}
+(defn re-pattern
+  "Returns an instance of java.util.regex.Pattern, for use, e.g. in
+  re-matcher."
+  {:tag System.Text.RegularExpressions.Regex                             ;;; {:tag java.util.regex.Pattern}
    :added "1.0"
    :static true}
-  [s] (if (instance? System.Text.RegularExpressions.Regex s)             ;;; java.util.regex.Pattern
-        s
+  [s] (if (instance? System.Text.RegularExpressions.Regex s)             ;;; java.util.regex.Pattern
+        s
         (System.Text.RegularExpressions.Regex. s)))                      ;;; (. java.util.regex.Pattern (compile s))))
 
 (defn re-matcher
@@ -5421,33 +5494,33 @@ Note that read can execute code (controlled by *read-eval*),
   class. h must be a hierarchy obtained from make-hierarchy, if not
   supplied defaults to, and modifies, the global hierarchy."
   {:added "1.0"}
-  ([tag parent]
-   (assert (namespace parent))
-   (assert (or (class? tag) (and (instance? clojure.lang.Named tag) (namespace tag))))
-
-   (alter-var-root #'global-hierarchy derive tag parent) nil)
-  ([h tag parent]
-   (assert (not= tag parent))
-   (assert (or (class? tag) (instance? clojure.lang.Named tag)))
-   (assert (instance? clojure.lang.Named parent))
-
-   (let [tp (:parents h)
-         td (:descendants h)
-         ta (:ancestors h)
-         tf (fn [m source sources target targets]
-              (reduce1 (fn [ret k]
-                        (assoc ret k
-                               (reduce1 conj (get targets k #{}) (cons target (targets target)))))
-                      m (cons source (sources source))))]
-     (or
-      (when-not (contains? (tp tag) parent)
-        (when (contains? (ta tag) parent)
-          (throw (Exception. (print-str tag "already has" parent "as ancestor"))))
-        (when (contains? (ta parent) tag)
-          (throw (Exception. (print-str "Cyclic derivation:" parent "has" tag "as ancestor"))))
-        {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent))
-         :ancestors (tf (:ancestors h) tag td parent ta)
-         :descendants (tf (:descendants h) parent ta tag td)})
+  ([tag parent]
+   (assert (namespace parent))
+   (assert (or (class? tag) (and (instance? clojure.lang.Named tag) (namespace tag))))
+
+   (alter-var-root #'global-hierarchy derive tag parent) nil)
+  ([h tag parent]
+   (assert (not= tag parent))
+   (assert (or (class? tag) (instance? clojure.lang.Named tag)))
+   (assert (instance? clojure.lang.Named parent))
+
+   (let [tp (:parents h)
+         td (:descendants h)
+         ta (:ancestors h)
+         tf (fn [m source sources target targets]
+              (reduce1 (fn [ret k]
+                        (assoc ret k
+                               (reduce1 conj (get targets k #{}) (cons target (targets target)))))
+                      m (cons source (sources source))))]
+     (or
+      (when-not (contains? (tp tag) parent)
+        (when (contains? (ta tag) parent)
+          (throw (Exception. (print-str tag "already has" parent "as ancestor"))))
+        (when (contains? (ta parent) tag)
+          (throw (Exception. (print-str "Cyclic derivation:" parent "has" tag "as ancestor"))))
+        {:parents (assoc (:parents h) tag (conj (get tp tag #{}) parent))
+         :ancestors (tf (:ancestors h) tag td parent ta)
+         :descendants (tf (:descendants h) parent ta tag td)})
       h))))
 
 (declare flatten)
@@ -5541,8 +5614,8 @@ Note that read can execute code (controlled by *read-eval*),
   [fmt & args]
   (print (apply format fmt args)))
 
-(declare gen-class)
-;;; no clear equivalent for us
+(declare gen-class)
+;;; no clear equivalent for us
 (defmacro with-loading-context [& body]
   `((fn loading# [] 
         (. clojure.lang.Var (pushThreadBindings  {}))   ;;;{clojure.lang.Compiler/LOADER  
@@ -5551,35 +5624,35 @@ Note that read can execute code (controlled by *read-eval*),
          ~@body
          (finally
           (. clojure.lang.Var (popThreadBindings)))))))
-
-(defmacro ns
-  "Sets *ns* to the namespace named by name (unevaluated), creating it
-  if needed.  references can be zero or more of: (:refer-clojure ...)
-  (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)
-  with the syntax of refer-clojure/require/use/import/load/gen-class
-  respectively, except the arguments are unevaluated and need not be
-  quoted. (:gen-class ...), when supplied, defaults to :name
-  corresponding to the ns name, :main true, :impl-ns same as ns, and
-  :init-impl-ns true. All options of gen-class are
-  supported. The :gen-class directive is ignored when not
-  compiling. If :gen-class is not supplied, when compiled only an
-  nsname__init.class will be generated. If :refer-clojure is not used, a
-  default (refer 'clojure.core) is used.  Use of ns is preferred to
-  individual calls to in-ns/require/use/import:
-
-  (ns foo.bar
-    (:refer-clojure :exclude [ancestors printf])
-    (:require (clojure.contrib sql combinatorics))
-    (:use (my.lib this that))
-    (:import (java.util Date Timer Random)
-              (java.sql Connection Statement)))"
-  {:arglists '([name docstring? attr-map? references*])
+
+(defmacro ns
+  "Sets *ns* to the namespace named by name (unevaluated), creating it
+  if needed.  references can be zero or more of: (:refer-clojure ...)
+  (:require ...) (:use ...) (:import ...) (:load ...) (:gen-class)
+  with the syntax of refer-clojure/require/use/import/load/gen-class
+  respectively, except the arguments are unevaluated and need not be
+  quoted. (:gen-class ...), when supplied, defaults to :name
+  corresponding to the ns name, :main true, :impl-ns same as ns, and
+  :init-impl-ns true. All options of gen-class are
+  supported. The :gen-class directive is ignored when not
+  compiling. If :gen-class is not supplied, when compiled only an
+  nsname__init.class will be generated. If :refer-clojure is not used, a
+  default (refer 'clojure.core) is used.  Use of ns is preferred to
+  individual calls to in-ns/require/use/import:
+
+  (ns foo.bar
+    (:refer-clojure :exclude [ancestors printf])
+    (:require (clojure.contrib sql combinatorics))
+    (:use (my.lib this that))
+    (:import (java.util Date Timer Random)
+              (java.sql Connection Statement)))"
+  {:arglists '([name docstring? attr-map? references*])
    :added "1.0"}
-  [name & references]
-  (let [process-reference
-        (fn [[kname & args]]
-          `(~(symbol "clojure.core" (clojure.core/name kname))
-             ~@(map #(list 'quote %) args)))
+  [name & references]
+  (let [process-reference
+        (fn [[kname & args]]
+          `(~(symbol "clojure.core" (clojure.core/name kname))
+             ~@(map #(list 'quote %) args)))
         docstring  (when (string? (first references)) (first references))
         references (if docstring (next references) references)
         name (if docstring
@@ -5590,10 +5663,10 @@ Note that read can execute code (controlled by *read-eval*),
         name (if metadata
                (vary-meta name merge metadata)
                name)
-        gen-class-clause (first (filter #(= :gen-class (first %)) references))
-        gen-class-call
-          (when gen-class-clause
-            (list* `gen-class :name (.Replace (str name) \- \_) :impl-ns name :main true (next gen-class-clause)))   ;;; .replace
+        gen-class-clause (first (filter #(= :gen-class (first %)) references))
+        gen-class-call
+          (when gen-class-clause
+            (list* `gen-class :name (.Replace (str name) \- \_) :impl-ns name :main true (next gen-class-clause)))   ;;; .replace
         references (remove #(= :gen-class (first %)) references)
         ;ns-effect (clojure.core/in-ns name)
         name-metadata (meta name)]
@@ -5875,35 +5948,35 @@ Note that read can execute code (controlled by *read-eval*),
   {:added "1.0"}
   [] @*loaded-libs*)
 
-(defn load
-  "Loads Clojure code from resources in classpath. A path is interpreted as
-  classpath-relative if it begins with a slash or relative to the root
-  directory for the current namespace otherwise."
+(defn load
+  "Loads Clojure code from resources in classpath. A path is interpreted as
+  classpath-relative if it begins with a slash or relative to the root
+  directory for the current namespace otherwise."
   {:redef true
    :added "1.0"}
-  [& paths]
-  (doseq [^String path paths]
-    (let [^String path (if (.StartsWith path "/")   ;;; startsWith
-                          path
-                         (str (root-directory (ns-name *ns*)) \/ path))]
-      (when *loading-verbosely*
-        (printf "(clojure.core/load \"%s\")\n" path)
-        (flush))
+  [& paths]
+  (doseq [^String path paths]
+    (let [^String path (if (.StartsWith path "/")   ;;; startsWith
+                          path
+                         (str (root-directory (ns-name *ns*)) \/ path))]
+      (when *loading-verbosely*
+        (printf "(clojure.core/load \"%s\")\n" path)
+        (flush))
       (check-cyclic-dependency path)
-      (when-not (= path (first *pending-paths*))
-        (binding [*pending-paths* (conj *pending-paths* path)]
+      (when-not (= path (first *pending-paths*))
+        (binding [*pending-paths* (conj *pending-paths* path)]
           (clojure.lang.RT/load (.Substring path 1)))))))       ;;; .substring
 
-(defn compile
-  "Compiles the namespace named by the symbol lib into a set of
-  classfiles. The source for the lib must be in a proper
-  classpath-relative directory. The output files will go into the
-  directory specified by *compile-path*, and that directory too must
-  be in the classpath."
+(defn compile
+  "Compiles the namespace named by the symbol lib into a set of
+  classfiles. The source for the lib must be in a proper
+  classpath-relative directory. The output files will go into the
+  directory specified by *compile-path*, and that directory too must
+  be in the classpath."
   {:added "1.0"}
-  [lib]
-  (binding [*compile-files* true]
-    (load-one lib true true))
+  [lib]
+  (binding [*compile-files* true]
+    (load-one lib true true))
   lib)
 
 ;;;;;;;;;;;;; nested associative ops ;;;;;;;;;;;
@@ -5988,15 +6061,15 @@ Note that read can execute code (controlled by *read-eval*),
    :static true}
   [x] (instance? clojure.lang.IPersistentList x))
 
-(defn ifn?
-  "Returns true if x implements IFn. Note that many data structures
-  (e.g. sets and maps) implement IFn"
+(defn ifn?
+  "Returns true if x implements IFn. Note that many data structures
+  (e.g. sets and maps) implement IFn"
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.IFn x))
   
-(defn fn?
-  "Returns true if x implements Fn, i.e. is an object created via fn."
+(defn fn?
+  "Returns true if x implements Fn, i.e. is an object created via fn."
   {:added "1.0"
    :static true}
   [x] (instance? clojure.lang.Fn x))     
@@ -6032,6 +6105,11 @@ Note that read can execute code (controlled by *read-eval*),
    :static true}
   [coll] (instance? clojure.lang.Reversible coll))
 
+(defn indexed?
+  "Return true if coll implements Indexed, indicating efficient lookup by index"
+  {:added "1.9"}
+  [coll] (instance? clojure.lang.Indexed coll))
+
 (def ^:dynamic 
  ^{:doc "bound in a repl thread to the most recent value printed"
    :added "1.0"}
@@ -6052,105 +6130,105 @@ Note that read can execute code (controlled by *read-eval*),
    :added "1.0"}
  *e)
 
-(defn trampoline
-  "trampoline can be used to convert algorithms requiring mutual
-  recursion without stack consumption. Calls f with supplied args, if
-  any. If f returns a fn, calls that fn with no arguments, and
-  continues to repeat, until the return value is not a fn, then
-  returns that non-fn value. Note that if you want to return a fn as a
-  final value, you must wrap it in some data structure and unpack it
-  after trampoline returns."
-  {:added "1.0"
-   :static true}
-  ([f]
-     (let [ret (f)]
-       (if (fn? ret)
-         (recur ret)
-         ret)))
-  ([f & args]
-     (trampoline #(apply f args))))
-
-(defn intern
-  "Finds or creates a var named by the symbol name in the namespace
-  ns (which can be a symbol or a namespace), setting its root binding
-  to val if supplied. The namespace must exist. The var will adopt any
-  metadata from the name symbol.  Returns the var."
-  {:added "1.0"
-   :static true}
-  ([ns ^clojure.lang.Symbol name] 
-     (let [v (clojure.lang.Var/intern (the-ns ns) name)]
-       (when (meta name) (.setMeta v (meta name)))
-       v))
-  ([ns name val] 
-     (let [v (clojure.lang.Var/intern (the-ns ns) name val)]
-       (when (meta name) (.setMeta v (meta name)))
-       v)))
-
-(defmacro while
-  "Repeatedly executes body while test expression is true. Presumes
-  some side-effect will cause test to become false/nil. Returns nil"
+(defn trampoline
+  "trampoline can be used to convert algorithms requiring mutual
+  recursion without stack consumption. Calls f with supplied args, if
+  any. If f returns a fn, calls that fn with no arguments, and
+  continues to repeat, until the return value is not a fn, then
+  returns that non-fn value. Note that if you want to return a fn as a
+  final value, you must wrap it in some data structure and unpack it
+  after trampoline returns."
+  {:added "1.0"
+   :static true}
+  ([f]
+     (let [ret (f)]
+       (if (fn? ret)
+         (recur ret)
+         ret)))
+  ([f & args]
+     (trampoline #(apply f args))))
+
+(defn intern
+  "Finds or creates a var named by the symbol name in the namespace
+  ns (which can be a symbol or a namespace), setting its root binding
+  to val if supplied. The namespace must exist. The var will adopt any
+  metadata from the name symbol.  Returns the var."
+  {:added "1.0"
+   :static true}
+  ([ns ^clojure.lang.Symbol name] 
+     (let [v (clojure.lang.Var/intern (the-ns ns) name)]
+       (when (meta name) (.setMeta v (meta name)))
+       v))
+  ([ns name val] 
+     (let [v (clojure.lang.Var/intern (the-ns ns) name val)]
+       (when (meta name) (.setMeta v (meta name)))
+       v)))
+
+(defmacro while
+  "Repeatedly executes body while test expression is true. Presumes
+  some side-effect will cause test to become false/nil. Returns nil"
   {:added "1.0"}
-  [test & body]
-  `(loop []
-     (when ~test
-       ~@body
-       (recur))))
-
-(defn memoize
-  "Returns a memoized version of a referentially transparent function. The
-  memoized version of the function keeps a cache of the mapping from arguments
-  to results and, when calls with the same arguments are repeated often, has
-  higher performance at the expense of higher memory use."
-  {:added "1.0"
-   :static true}
-  [f]
-  (let [mem (atom {})]
-    (fn [& args]
-      (if-let [e (find @mem args)]
-        (val e)
-        (let [ret (apply f args)]
-          (swap! mem assoc args ret)
-          ret)))))
-
-(defmacro condp
-  "Takes a binary predicate, an expression, and a set of clauses.
-  Each clause can take the form of either:
-
-  test-expr result-expr
-
-  test-expr :>> result-fn
-
-  Note :>> is an ordinary keyword.
-
-  For each clause, (pred test-expr expr) is evaluated. If it returns
-  logical true, the clause is a match. If a binary clause matches, the
-  result-expr is returned, if a ternary clause matches, its result-fn,
-  which must be a unary function, is called with the result of the
-  predicate as its argument, the result of that call being the return
-  value of condp. A single default expression can follow the clauses,
-  and its value will be returned if no clause matches. If no default
-  expression is provided and no clause matches, an
-  IllegalArgumentException is thrown."
+  [test & body]
+  `(loop []
+     (when ~test
+       ~@body
+       (recur))))
+
+(defn memoize
+  "Returns a memoized version of a referentially transparent function. The
+  memoized version of the function keeps a cache of the mapping from arguments
+  to results and, when calls with the same arguments are repeated often, has
+  higher performance at the expense of higher memory use."
+  {:added "1.0"
+   :static true}
+  [f]
+  (let [mem (atom {})]
+    (fn [& args]
+      (if-let [e (find @mem args)]
+        (val e)
+        (let [ret (apply f args)]
+          (swap! mem assoc args ret)
+          ret)))))
+
+(defmacro condp
+  "Takes a binary predicate, an expression, and a set of clauses.
+  Each clause can take the form of either:
+
+  test-expr result-expr
+
+  test-expr :>> result-fn
+
+  Note :>> is an ordinary keyword.
+
+  For each clause, (pred test-expr expr) is evaluated. If it returns
+  logical true, the clause is a match. If a binary clause matches, the
+  result-expr is returned, if a ternary clause matches, its result-fn,
+  which must be a unary function, is called with the result of the
+  predicate as its argument, the result of that call being the return
+  value of condp. A single default expression can follow the clauses,
+  and its value will be returned if no clause matches. If no default
+  expression is provided and no clause matches, an
+  IllegalArgumentException is thrown."
   {:added "1.0"}
-
-  [pred expr & clauses]
-  (let [gpred (gensym "pred__")
-        gexpr (gensym "expr__")
-        emit (fn emit [pred expr args]
-               (let [[[a b c :as clause] more] 
-                       (split-at (if (= :>> (second args)) 3 2) args)
-                       n (count clause)]
-                 (cond
+
+  [pred expr & clauses]
+  (let [gpred (gensym "pred__")
+        gexpr (gensym "expr__")
+        emit (fn emit [pred expr args]
+               (let [[[a b c :as clause] more] 
+                       (split-at (if (= :>> (second args)) 3 2) args)
+                       n (count clause)]
+                 (cond
                   (= 0 n) `(throw (ArgumentException. (str "No matching clause: " ~expr)))  ;;;IllegalArgumentException
-                  (= 1 n) a
-                  (= 2 n) `(if (~pred ~a ~expr)
-                             ~b
-                             ~(emit pred expr more))
-                  :else `(if-let [p# (~pred ~a ~expr)]
-                           (~c p#)
-                           ~(emit pred expr more)))))]
-    `(let [~gpred ~pred
-           ~gexpr ~expr]
+                  (= 1 n) a
+                  (= 2 n) `(if (~pred ~a ~expr)
+                             ~b
+                             ~(emit pred expr more))
+                  :else `(if-let [p# (~pred ~a ~expr)]
+                           (~c p#)
+                           ~(emit pred expr more)))))]
+    `(let [~gpred ~pred
+           ~gexpr ~expr]
        ~(emit gpred gexpr clauses))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; var documentation ;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -6517,6 +6595,18 @@ Note that read can execute code (controlled by *read-eval*),
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; helper files ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (alter-meta! (find-ns 'clojure.core) assoc :doc "Fundamental library of the Clojure language") (load "core_clr")  ;;; Added
+
+(defn seqable? [x]
+  "Based on RT.cs, clojure.core/cast, clojure.core/instance. Uncertain whether it works in all cases"
+  (or
+    (nil? x)
+    (instance? clojure.lang.ASeq x)
+    (instance? clojure.lang.LazySeq x)
+    (instance? clojure.lang.Seqable x)
+    (array? x)
+    (string? x)
+    (instance? System.Collections.IEnumerable x)))
+
 (load "core_proxy")
 (load "core_print")
 (load "genclass")
@@ -6524,6 +6614,36 @@ Note that read can execute code (controlled by *read-eval*),
 (load "core/protocols")
 (load "gvec")
 (load "instant")
+
+(defprotocol Inst
+  (inst-ms* [inst]))
+
+(extend-protocol Inst
+  ;;java.util.Date
+  System.DateTime
+  ;;(inst-ms* [inst] (.getTime ^java.util.Date inst))
+  (inst-ms* [inst]
+    ;; from https://blogs.msdn.microsoft.com/brada/2004/03/20/seconds-since-the-unix-epoch-in-c/
+    (let [^System.TimeSpan t (System.DateTime/op_Subtraction
+                               System.DateTime/UtcNow
+                               (System.DateTime. 1970, 1, 1))]
+      (. t TotalMilliseconds))
+    ;;(.getTime ^System.DateTime inst)
+    )
+  )
+
+(defn inst-ms
+  "Return the number of milliseconds since January 1, 1970, 00:00:00 GMT"
+  {:added "1.9"}
+  [inst]
+  (inst-ms* inst))
+
+(defn inst?
+  "Return true if x satisfies Inst"
+  {:added "1.9"}
+  [x]
+  (satisfies? Inst x))
+
 (load "uuid")
 
 (defn reduce
@@ -7097,6 +7217,18 @@ clojure.lang.IKVReduce
                         (cons x (keepi (inc idx) (rest s)))))))))]
        (keepi 0 coll))))
 
+(defn bounded-count
+  "If coll is counted? returns its count, else will count at most the first n
+  elements of coll using its seq"
+  {:added "1.9"}
+  [n coll]
+  (if (counted? coll)
+    (count coll)
+    (loop [i 0 s (seq coll)]
+      (if (and s (< i n))
+        (recur (inc i) (next s))
+        i))))
+
 (defn every-pred
   "Takes a set of predicates and returns a function f that returns true if all of its
   composing predicates return a logical true value against all of its arguments, else it returns
diff --git a/Clojure/Clojure.Source/clojure/core_proxy.clj b/Clojure/Clojure.Source/clojure/core_proxy.clj
index a9217dd3f..3642c40fe 100644
--- a/Clojure/Clojure.Source/clojure/core_proxy.clj
+++ b/Clojure/Clojure.Source/clojure/core_proxy.clj
@@ -43,13 +43,13 @@
 (defn proxy-name
  {:tag String} 
  [^Type super interfaces]                                                  ;;; Class
-  (let [inames (into1 (sorted-set) (map #(.Name ^Type %) interfaces))]      ;;;  .getName ^Class
-    (apply str (.Replace (str *ns*) \- \_) ".proxy"                         ;;; .replace
-      (interleave (repeat "$")
-        (concat
-          [(.Name super)]                                              ;;; .getName
-          (map #(subs % (inc (.LastIndexOf ^String % "."))) inames)       ;;; .lastIndexOf
-          [(.ToString (hash inames) "X")] [(clojure.lang.Compiler/IsCompilingSuffix)])))))                             ;;;[(Integer/toHexString (hash inames))])))))                   
+  (let [inames (into1 (sorted-set) (map #(.Name ^Type %) interfaces))]      ;;;  .getName ^Class
+    (apply str (.Replace (str *ns*) \- \_) ".proxy"                         ;;; .replace
+      (interleave (repeat "$")
+        (concat
+          [(.Name super)]                                              ;;; .getName
+          (map #(subs % (inc (.LastIndexOf ^String % "."))) inames)       ;;; .lastIndexOf
+          [(.ToString (int (hash inames)) "X")] [(clojure.lang.Compiler/IsCompilingSuffix)])))))                             ;;;[(Integer/toHexString (hash inames))])))))                   
 
 (defn- generate-proxy [^Type super interfaces]     ;;; Class
   (clojure.lang.GenProxy/GenerateProxyClass super interfaces (proxy-name super interfaces)))  ;;;DM;;
@@ -264,7 +264,7 @@
   returns an instance of a proxy class derived from the supplied
   classes. The resulting value is cached and used for any subsequent
   requests for the same class set. Returns a Class object."  
-  {:added "1.0"}
+  {:added "1.0"}
   [& bases]
     (let [[super interfaces] (get-super-and-interfaces bases)
           pname (proxy-name super interfaces)]
@@ -275,7 +275,7 @@
 (defn construct-proxy
   "Takes a proxy class and any arguments for its superclass ctor and
   creates and returns an instance of the proxy."  
-  {:added "1.0"}
+  {:added "1.0"}
   [c & ctor-args]
     (. Reflector (InvokeConstructor c (to-array ctor-args))))                   ;;; invokeConstructor
 
@@ -285,7 +285,7 @@
   fns (which must take arguments matching the corresponding method,
   plus an additional (explicit) first arg corresponding to this, and
   sets the proxy's fn map. Returns the proxy."
-  {:added "1.0"}
+  {:added "1.0"}
   [^IProxy proxy mappings]
     (. proxy (__initClojureFnMappings mappings))
 	proxy)
@@ -300,14 +300,14 @@
   default behavior. Note that this function can be used to update the
   behavior of an existing instance without changing its identity.
   Returns the proxy."
-  {:added "1.0"}
+  {:added "1.0"}
   [^IProxy proxy mappings]
     (. proxy (__updateClojureFnMappings mappings))
 	proxy)
 
 (defn proxy-mappings
   "Takes a proxy instance and returns the proxy's fn map."
-  {:added "1.0"}
+  {:added "1.0"}
   [^IProxy proxy]
     (. proxy (__getClojureFnMappings)))
 
@@ -335,7 +335,7 @@
   be provided to override protected methods, they have no other access
   to protected members, nor to super, as these capabilities cannot be
   proxied."
-  {:added "1.0"}
+  {:added "1.0"}
   [class-and-interfaces args & fs]
    (let [bases (map #(or (resolve %) (throw (Exception. (str "Can't resolve: " %)))) 
                     class-and-interfaces)
@@ -345,7 +345,7 @@
 ;;;                            (clojure.lang.Compiler/writeClassFile cname bytecode)))
          pc-effect (apply get-proxy-class bases)
          pname (proxy-name super interfaces)]
-     ;remember the class to prevent it from disappearing before use
+     ;remember the class to prevent it from disappearing before use
      (intern *ns* (symbol pname) pc-effect)         
      `(let [;pc# (get-proxy-class ~@class-and-interfaces)
             p# (new ~(symbol pname) ~@args)] ;(construct-proxy pc# ~@args)]   
@@ -369,21 +369,21 @@
 (defn proxy-call-with-super [call this meth]
  (let [m (proxy-mappings this)]
     (update-proxy this (assoc m meth nil))
-    (try
-      (call)
+    (try
+      (call)
       (finally (update-proxy this m)))))
 
 (defmacro proxy-super 
   "Use to call a superclass method in the body of a proxy method. 
   Note, expansion captures 'this"
-  {:added "1.0"}
+  {:added "1.0"}
   [meth & args]
  `(proxy-call-with-super (fn [] (. ~'this ~meth ~@args))  ~'this ~(name meth)))
 
 ;;;(defn bean
 ;;;  "Takes a Java object and returns a read-only implementation of the
 ;;;  map abstraction based upon its JavaBean properties."
-;;;  {:added "1.0"}
+;;;  {:added "1.0"}
 ;;;  [^Object x]
 ;;;  (let [c (. x (getClass))
 ;;;	pmap (reduce (fn [m ^java.beans.PropertyDescriptor pd]
diff --git a/Clojure/Clojure.Source/clojure/reflect/clr.clj b/Clojure/Clojure.Source/clojure/reflect/clr.clj
index c0be29848..9492c82ec 100644
--- a/Clojure/Clojure.Source/clojure/reflect/clr.clj
+++ b/Clojure/Clojure.Source/clojure/reflect/clr.clj
@@ -146,10 +146,10 @@
 
 (defn- declared-constructors
   "Return a set of the declared constructors of class as a Clojure map."
-  [cls]
+  [^Type cls]
   (set (map
         constructor->map
-        (.GetConstructors (cast Type cls) basic-binding-flags)))) 
+        (.GetConstructors cls basic-binding-flags)))) 
 
 (defrecord Method
   [name return-type declaring-class parameter-types flags])
@@ -165,10 +165,10 @@
 
 (defn- declared-methods
   "Return a set of the declared constructors of class as a Clojure map."
-  [cls]
+  [^Type cls]
   (set (map
         method->map
-        (.GetMethods (cast Type cls) basic-binding-flags))))
+        (.GetMethods cls basic-binding-flags))))
 
 (defrecord Field
   [name type declaring-class flags])
@@ -183,10 +183,10 @@
 
 (defn- declared-fields
   "Return a set of the declared fields of class as a Clojure map."
-  [cls]
+  [^Type cls]
   (set (map
         field->map
-        (.GetFields (cast Type cls) basic-binding-flags))))
+        (.GetFields cls basic-binding-flags))))
 
 (defrecord Property
   [name type declaring-class flags])
@@ -201,10 +201,10 @@
 
 (defn- declared-properties
   "Return a set of the declared fields of class as a Clojure map."
-  [cls]
+  [^Type cls]
   (set (map
         property->map
-        (.GetProperties (cast Type cls) basic-binding-flags))))
+        (.GetProperties cls basic-binding-flags))))
 
 
 (deftype ClrReflector [a]
diff --git a/Clojure/Clojure.Source/clojure/spec.clj b/Clojure/Clojure.Source/clojure/spec.clj
new file mode 100644
index 000000000..301186468
--- /dev/null
+++ b/Clojure/Clojure.Source/clojure/spec.clj
@@ -0,0 +1,1726 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(ns clojure.spec
+  (:refer-clojure :exclude [+ * and assert or cat def keys merge])
+  (:require [clojure.walk :as walk]
+            [clojure.spec.gen :as gen]
+            [clojure.string :as str]))
+
+(alias 'c 'clojure.core)
+
+(set! *warn-on-reflection* true)
+
+(def ^:dynamic *recursion-limit*
+  "A soft limit on how many times a branching spec (or/alt/*/opt-keys/multi-spec)
+  can be recursed through during generation. After this a
+  non-recursive branch will be chosen."
+  4)
+
+(def ^:dynamic *fspec-iterations*
+  "The number of times an anonymous fn specified by fspec will be (generatively) tested during conform"
+  21)
+
+(def ^:dynamic *coll-check-limit*
+  "The number of elements validated in a collection spec'ed with 'every'"
+  101)
+
+(def ^:dynamic *coll-error-limit*
+  "The number of errors reported by explain in a collection spec'ed with 'every'"
+  20)
+
+(defprotocol Spec
+  (conform* [spec x])
+  (unform* [spec y])
+  (explain* [spec path via in x])
+  (gen* [spec overrides path rmap])
+  (with-gen* [spec gfn])
+  (describe* [spec]))
+
+(defonce ^:private registry-ref (atom {}))
+
+(defn- named? [x] (instance? clojure.lang.Named x))
+
+(defn- with-name [spec name]
+  (with-meta spec (assoc (meta spec) ::name name)))
+
+(defn- spec-name [spec]
+  (cond
+   (keyword? spec) spec
+
+   (instance? clojure.lang.IObj spec)
+   (-> (meta spec) ::name)))
+
+(defn- reg-resolve
+  "returns the spec/regex at end of alias chain starting with k, nil if not found, k if k not Named"
+  [k]
+  (if (named? k)
+    (let [reg @registry-ref]
+      (loop [spec k]
+        (if (named? spec)
+          (recur (get reg spec))
+          (when spec
+            (with-name spec k)))))
+    k))
+
+(defn- reg-resolve!
+  "returns the spec/regex at end of alias chain starting with k, throws if not found, k if k not ident"
+  [k]
+  (if (ident? k)
+    (c/or (reg-resolve k)
+          (throw (Exception. (str "Unable to resolve spec: " k))))
+    k))
+
+(defn spec?
+  "returns x if x is a spec object, else logical false"
+  [x]
+  (c/and (extends? Spec (class x)) x))
+
+(defn regex?
+  "returns x if x is a (clojure.spec) regex op, else logical false"
+  [x]
+  (c/and (::op x) x))
+
+(declare spec-impl)
+(declare regex-spec-impl)
+
+(defn- maybe-spec
+  "spec-or-k must be a spec, regex or resolvable kw/sym, else returns nil."
+  [spec-or-k]
+  (let [s (c/or (spec? spec-or-k)
+                (regex? spec-or-k)
+                (c/and (named? spec-or-k) (reg-resolve spec-or-k))
+                nil)]
+    (if (regex? s)
+      (with-name (regex-spec-impl s nil) (spec-name s))
+      s)))
+
+(defn- the-spec
+  "spec-or-k must be a spec, regex or kw/sym, else returns nil. Throws if unresolvable kw/sym"
+  [spec-or-k]
+  (c/or (maybe-spec spec-or-k)
+        (when (named? spec-or-k)
+          (throw (Exception. (str "Unable to resolve spec: " spec-or-k))))))
+
+(defn- specize [s]
+  (c/or (the-spec s) (spec-impl ::unknown s nil nil)))
+
+(defn conform
+  "Given a spec and a value, returns :clojure.spec/invalid if value does not match spec,
+  else the (possibly destructured) value."
+  [spec x]
+  (conform* (specize spec) x))
+
+(defn unform
+  "Given a spec and a value created by or compliant with a call to
+  'conform' with the same spec, returns a value with all conform
+  destructuring undone."
+  [spec x]
+  (unform* (specize spec) x))
+
+(defn form
+  "returns the spec as data"
+  [spec]
+  ;;TODO - incorporate gens
+  (describe* (specize spec)))
+
+(defn abbrev [form]
+  (cond
+   (seq? form)
+   (walk/postwalk (fn [form]
+                    (cond
+                     (c/and (symbol? form) (namespace form))
+                     (-> form name symbol)
+
+                     (c/and (seq? form) (= 'fn (first form)) (= '[%] (second form)))
+                     (last form)
+                     
+                     :else form))
+                  form)
+
+   (c/and (symbol? form) (namespace form))
+   (-> form name symbol)
+
+   :else form))
+
+(defn describe
+  "returns an abbreviated description of the spec as data"
+  [spec]
+  (abbrev (form spec)))
+
+(defn with-gen
+  "Takes a spec and a no-arg, generator-returning fn and returns a version of that spec that uses that generator"
+  [spec gen-fn]
+  (let [spec (reg-resolve spec)]
+    (if (regex? spec)
+      (assoc spec ::gfn gen-fn)
+      (with-gen* (specize spec) gen-fn))))
+
+(defn explain-data* [spec path via in x]
+  (let [probs (explain* (specize spec) path via in x)]
+    (when-not (empty? probs)
+      {::problems probs})))
+
+(defn explain-data
+  "Given a spec and a value x which ought to conform, returns nil if x
+  conforms, else a map with at least the key ::problems whose value is
+  a collection of problem-maps, where problem-map has at least :path :pred and :val
+  keys describing the predicate and the value that failed at that
+  path."
+  [spec x]
+  (explain-data* spec [] (if-let [name (spec-name spec)] [name] []) [] x))
+
+(defn explain-out
+  "prints explanation data (per 'explain-data') to *out*."
+  [ed]
+  (if ed
+    (do
+      ;;(prn {:ed ed})
+      (doseq [{:keys [path pred val reason via in] :as prob}  (::problems ed)]
+        (when-not (empty? in)
+          (print "In:" (pr-str in) ""))
+        (print "val: ")
+        (pr val)
+        (print " fails")
+        (when-not (empty? via)
+          (print " spec:" (pr-str (last via))))
+        (when-not (empty? path)
+          (print " at:" (pr-str path)))
+        (print " predicate: ")
+        (pr (abbrev pred))
+        (when reason (print ", " reason))
+        (doseq [[k v] prob]
+          (when-not (#{:path :pred :val :reason :via :in} k)
+            (print "\n\t" (pr-str k) " ")
+            (pr v)))
+        (newline))
+      (doseq [[k v] ed]
+        (when-not (#{::problems} k)
+          (print (pr-str k) " ")
+          (pr v)
+          (newline))))
+    (println "Success!")))
+
+(defn explain
+  "Given a spec and a value that fails to conform, prints an explanation to *out*."
+  [spec x]
+  (explain-out (explain-data spec x)))
+
+(defn explain-str
+  "Given a spec and a value that fails to conform, returns an explanation as a string."
+  [spec x]
+  (with-out-str (explain spec x)))
+
+(declare valid?)
+
+(defn- gensub
+  [spec overrides path rmap form]
+  ;;(prn {:spec spec :over overrides :path path :form form})
+  (let [spec (specize spec)]
+    (if-let [g (c/or (when-let [gfn (c/or (get overrides (c/or (spec-name spec) spec))
+                                          (get overrides path))]
+                       (gfn))
+                     (gen* spec overrides path rmap))]
+      (gen/such-that #(valid? spec %) g 100)
+      (let [abbr (abbrev form)]
+        (throw (ex-info (str "Unable to construct gen at: " path " for: " abbr)
+                        {::path path ::form form ::failure :no-gen}))))))
+
+(defn gen
+  "Given a spec, returns the generator for it, or throws if none can
+  be constructed. Optionally an overrides map can be provided which
+  should map spec names or paths (vectors of keywords) to no-arg
+  generator-creating fns. These will be used instead of the generators at those
+  names/paths. Note that parent generator (in the spec or overrides
+  map) will supersede those of any subtrees. A generator for a regex
+  op must always return a sequential collection (i.e. a generator for
+  s/? should return either an empty sequence/vector or a
+  sequence/vector with one item in it)"
+  ([spec] (gen spec nil))
+  ([spec overrides] (gensub spec overrides [] {::recursion-limit *recursion-limit*} spec)))
+
+(defn- ->sym
+  "Returns a symbol from a symbol or var"
+  [x]
+  (if (var? x)
+    (let [^clojure.lang.Var v x]
+      (symbol (str (.Name (.ns v)))
+              (str (.sym v))))
+    x))
+
+(defn- unfn [expr]
+  (if (c/and (seq? expr)
+             (symbol? (first expr))
+             (= "fn*" (name (first expr))))
+    (let [[[s] & form] (rest expr)]
+      (conj (walk/postwalk-replace {s '%} form) '[%] 'fn))
+    expr))
+
+(defn- res [form]
+  (cond
+   (keyword? form) form
+   (symbol? form) (c/or (-> form resolve ->sym) form)   
+   (sequential? form) (walk/postwalk #(if (symbol? %) (res %) %) (unfn form))
+   :else form))
+
+(defn ^:skip-wiki def-impl
+  "Do not call this directly, use 'def'"
+  [k form spec]
+  (c/assert (c/and (named? k) (namespace k)) "k must be namespaced keyword or resolvable symbol")
+  (let [spec (if (c/or (spec? spec) (regex? spec) (get @registry-ref spec))
+               spec
+               (spec-impl form spec nil nil))]
+    (swap! registry-ref assoc k spec)
+    k))
+
+(defn- ns-qualify
+  "Qualify symbol s by resolving it or using the current *ns*."
+  [s]
+  (if-let [ns-sym (some-> s namespace symbol)]
+    (c/or (some-> (get (ns-aliases *ns*) ns-sym) str (symbol (name s)))
+          s)
+    (symbol (str (.Name *ns*)) (str s))))
+
+(defmacro def
+  "Given a namespace-qualified keyword or resolvable symbol k, and a
+  spec, spec-name, predicate or regex-op makes an entry in the
+  registry mapping k to the spec"
+  [k spec-form]
+  (let [k (if (symbol? k) (ns-qualify k) k)]
+    `(def-impl '~k '~(res spec-form) ~spec-form)))
+
+(defn registry
+  "returns the registry map, prefer 'get-spec' to lookup a spec by name"
+  []
+  @registry-ref)
+
+(defn get-spec
+  "Returns spec registered for keyword/symbol/var k, or nil."
+  [k]
+  (get (registry) (if (keyword? k) k (->sym k))))
+
+(declare map-spec)
+
+(defmacro spec
+  "Takes a single predicate form, e.g. can be the name of a predicate,
+  like even?, or a fn literal like #(< % 42). Note that it is not
+  generally necessary to wrap predicates in spec when using the rest
+  of the spec macros, only to attach a unique generator
+
+  Can also be passed the result of one of the regex ops -
+  cat, alt, *, +, ?, in which case it will return a regex-conforming
+  spec, useful when nesting an independent regex.
+  ---
+
+  Optionally takes :gen generator-fn, which must be a fn of no args that
+  returns a test.check generator.
+
+  Returns a spec."
+  [form & {:keys [gen]}]
+  (when form
+    `(spec-impl '~(res form) ~form ~gen nil)))
+
+(defmacro multi-spec
+  "Takes the name of a spec/predicate-returning multimethod and a
+  tag-restoring keyword or fn (retag).  Returns a spec that when
+  conforming or explaining data will pass it to the multimethod to get
+  an appropriate spec. You can e.g. use multi-spec to dynamically and
+  extensibly associate specs with 'tagged' data (i.e. data where one
+  of the fields indicates the shape of the rest of the structure).
+
+  (defmulti mspec :tag)
+
+  The methods should ignore their argument and return a predicate/spec:
+  (defmethod mspec :int [_] (s/keys :req-un [::tag ::i]))
+
+  retag is used during generation to retag generated values with
+  matching tags. retag can either be a keyword, at which key the
+  dispatch-tag will be assoc'ed, or a fn of generated value and
+  dispatch-tag that should return an appropriately retagged value.
+
+  Note that because the tags themselves comprise an open set,
+  the tag key spec cannot enumerate the values, but can e.g.
+  test for keyword?.
+
+  Note also that the dispatch values of the multimethod will be
+  included in the path, i.e. in reporting and gen overrides, even
+  though those values are not evident in the spec.
+"
+  [mm retag]
+  `(multi-spec-impl '~(res mm) (var ~mm) ~retag))
+
+(defmacro keys
+  "Creates and returns a map validating spec. :req and :opt are both
+  vectors of namespaced-qualified keywords. The validator will ensure
+  the :req keys are present. The :opt keys serve as documentation and
+  may be used by the generator.
+
+  The :req key vector supports 'and' and 'or' for key groups:
+
+  (s/keys :req [::x ::y (or ::secret (and ::user ::pwd))] :opt [::z])
+
+  There are also -un versions of :req and :opt. These allow
+  you to connect unqualified keys to specs.  In each case, fully
+  qualfied keywords are passed, which name the specs, but unqualified
+  keys (with the same name component) are expected and checked at
+  conform-time, and generated during gen:
+
+  (s/keys :req-un [:my.ns/x :my.ns/y])
+
+  The above says keys :x and :y are required, and will be validated
+  and generated by specs (if they exist) named :my.ns/x :my.ns/y 
+  respectively.
+
+  In addition, the values of *all* namespace-qualified keys will be validated
+  (and possibly destructured) by any registered specs. Note: there is
+  no support for inline value specification, by design.
+
+  Optionally takes :gen generator-fn, which must be a fn of no args that
+  returns a test.check generator."
+  [& {:keys [req req-un opt opt-un gen]}]
+  (let [unk #(-> % name keyword)
+        req-keys (filterv keyword? (flatten req))
+        req-un-specs (filterv keyword? (flatten req-un))
+        _ (c/assert (every? #(c/and (keyword? %) (namespace %)) (concat req-keys req-un-specs opt opt-un))
+                    "all keys must be namespace-qualified keywords")
+        req-specs (into req-keys req-un-specs)
+        req-keys (into req-keys (map unk req-un-specs))
+        opt-keys (into (vec opt) (map unk opt-un))
+        opt-specs (into (vec opt) opt-un)
+        parse-req (fn [rk f]
+                    (map (fn [x]
+                           (if (keyword? x)
+                             `#(contains? % ~(f x))
+                             (let [gx (gensym)]
+                               `(fn* [~gx]
+                                     ~(walk/postwalk
+                                       (fn [y] (if (keyword? y) `(contains? ~gx ~(f y)) y))
+                                       x)))))
+                         rk))
+        pred-exprs [`map?]
+        pred-exprs (into pred-exprs (parse-req req identity))
+        pred-exprs (into pred-exprs (parse-req req-un unk))
+        pred-forms (walk/postwalk res pred-exprs)]
+   ;; `(map-spec-impl ~req-keys '~req ~opt '~pred-forms ~pred-exprs ~gen)
+    `(map-spec-impl {:req '~req :opt '~opt :req-un '~req-un :opt-un '~opt-un
+                     :req-keys '~req-keys :req-specs '~req-specs
+                     :opt-keys '~opt-keys :opt-specs '~opt-specs
+                     :pred-forms '~pred-forms
+                     :pred-exprs ~pred-exprs
+                     :gfn ~gen})))
+
+(defmacro or
+  "Takes key+pred pairs, e.g.
+
+  (s/or :even even? :small #(< % 42))
+
+  Returns a destructuring spec that returns a map entry containing the
+  key of the first matching pred and the corresponding value. Thus the
+  'key' and 'val' functions can be used to refer generically to the
+  components of the tagged return."
+  [& key-pred-forms]
+  (let [pairs (partition 2 key-pred-forms)
+        keys (mapv first pairs)
+        pred-forms (mapv second pairs)
+        pf (mapv res pred-forms)]
+    (c/assert (c/and (even? (count key-pred-forms)) (every? keyword? keys)) "spec/or expects k1 p1 k2 p2..., where ks are keywords")
+    `(or-spec-impl ~keys '~pf ~pred-forms nil)))
+
+(defmacro and
+  "Takes predicate/spec-forms, e.g.
+
+  (s/and even? #(< % 42))
+
+  Returns a spec that returns the conformed value. Successive
+  conformed values propagate through rest of predicates."
+  [& pred-forms]
+  `(and-spec-impl '~(mapv res pred-forms) ~(vec pred-forms) nil))
+
+(defmacro merge
+  "Takes map-validating specs (e.g. 'keys' specs) and
+  returns a spec that returns a conformed map satisfying all of the
+  specs.  Successive conformed values propagate through rest of
+  predicates. Unlike 'and', merge can generate maps satisfying the
+  union of the predicates."
+  [& pred-forms]
+  `(merge-spec-impl '~(mapv res pred-forms) ~(vec pred-forms) nil))
+
+(defmacro every
+  "takes a pred and validates collection elements against that pred.
+
+  Note that 'every' does not do exhaustive checking, rather it samples
+  *coll-check-limit* elements. Nor (as a result) does it do any
+  conforming of elements. 'explain' will report at most *coll-error-limit*
+  problems.  Thus 'every' should be suitable for potentially large
+  collections.
+
+  Takes several kwargs options that further constrain the collection:
+
+  :kind - a pred/spec that the collection type must satisfy, e.g. vector?
+        (default nil) Note that if :kind is specified and :into is
+        not, this pred must generate in order for every to generate.
+  :count - specifies coll has exactly this count (default nil)
+  :min-count, :max-count - coll has count (<= min-count count max-count) (defaults nil)
+  :distinct - all the elements are distinct (default nil)
+
+  And additional args that control gen
+
+  :gen-max - the maximum coll size to generate (default 20)
+  :into - one of [], (), {}, #{} - the default collection to generate into
+      (default: empty coll as generated by :kind pred if supplied, else [])
+  
+  Optionally takes :gen generator-fn, which must be a fn of no args that
+  returns a test.check generator
+
+  See also - coll-of, every-kv
+"
+  [pred & {:keys [into kind count max-count min-count distinct gen-max gen] :as opts}]
+  (let [nopts (-> opts (dissoc :gen) (assoc ::kind-form `'~(res (:kind opts))))]
+    `(every-impl '~pred ~pred ~nopts ~gen)))
+
+(defmacro every-kv
+  "like 'every' but takes separate key and val preds and works on associative collections.
+
+  Same options as 'every', :into defaults to {}
+
+  See also - map-of"
+
+  [kpred vpred & opts]
+  `(every (tuple ~kpred ~vpred) ::kfn (fn [i# v#] (nth v# 0)) :into {} ~@opts))
+
+(defmacro coll-of
+  "Returns a spec for a collection of items satisfying pred. Unlike
+  'every', coll-of will exhaustively conform every value.
+
+  Same options as 'every'. conform will produce a collection
+  corresponding to :into if supplied, else will match the input collection,
+  avoiding rebuilding when possible.
+
+  See also - every, map-of"
+  [pred & opts]
+  `(every ~pred ::conform-all true ~@opts))
+
+(defmacro map-of
+  "Returns a spec for a map whose keys satisfy kpred and vals satisfy
+  vpred. Unlike 'every-kv', map-of will exhaustively conform every
+  value.
+
+  Same options as 'every', :kind defaults to map?, with the addition of:
+
+  :conform-keys - conform keys as well as values (default false)
+
+  See also - every-kv"
+  [kpred vpred & opts]
+  `(every-kv ~kpred ~vpred ::conform-all true :kind map? ~@opts))
+
+
+(defmacro *
+  "Returns a regex op that matches zero or more values matching
+  pred. Produces a vector of matches iff there is at least one match"
+  [pred-form]
+  `(rep-impl '~(res pred-form) ~pred-form))
+
+(defmacro +
+  "Returns a regex op that matches one or more values matching
+  pred. Produces a vector of matches"
+  [pred-form]
+  `(rep+impl '~(res pred-form) ~pred-form))
+
+(defmacro ?
+  "Returns a regex op that matches zero or one value matching
+  pred. Produces a single value (not a collection) if matched."
+  [pred-form]
+  `(maybe-impl ~pred-form '~pred-form))
+
+(defmacro alt
+  "Takes key+pred pairs, e.g.
+
+  (s/alt :even even? :small #(< % 42))
+
+  Returns a regex op that returns a map entry containing the key of the
+  first matching pred and the corresponding value. Thus the
+  'key' and 'val' functions can be used to refer generically to the
+  components of the tagged return"
+  [& key-pred-forms]
+  (let [pairs (partition 2 key-pred-forms)
+        keys (mapv first pairs)
+        pred-forms (mapv second pairs)
+        pf (mapv res pred-forms)]
+    (c/assert (c/and (even? (count key-pred-forms)) (every? keyword? keys)) "alt expects k1 p1 k2 p2..., where ks are keywords")
+    `(alt-impl ~keys ~pred-forms '~pf)))
+
+(defmacro cat
+  "Takes key+pred pairs, e.g.
+
+  (s/cat :e even? :o odd?)
+
+  Returns a regex op that matches (all) values in sequence, returning a map
+  containing the keys of each pred and the corresponding value."
+  [& key-pred-forms]
+  (let [pairs (partition 2 key-pred-forms)
+        keys (mapv first pairs)
+        pred-forms (mapv second pairs)
+        pf (mapv res pred-forms)]
+    ;;(prn key-pred-forms)
+    (c/assert (c/and (even? (count key-pred-forms)) (every? keyword? keys)) "cat expects k1 p1 k2 p2..., where ks are keywords")
+    `(cat-impl ~keys ~pred-forms '~pf)))
+
+(defmacro &
+  "takes a regex op re, and predicates. Returns a regex-op that consumes
+  input as per re but subjects the resulting value to the
+  conjunction of the predicates, and any conforming they might perform."
+  [re & preds]
+  (let [pv (vec preds)]
+    `(amp-impl ~re ~pv '~(mapv res pv))))
+
+(defmacro conformer
+  "takes a predicate function with the semantics of conform i.e. it should return either a
+  (possibly converted) value or :clojure.spec/invalid, and returns a
+  spec that uses it as a predicate/conformer. Optionally takes a
+  second fn that does unform of result of first"
+  ([f] `(spec-impl '~f ~f nil true))
+  ([f unf] `(spec-impl '~f ~f nil true ~unf)))
+
+(defmacro fspec
+  "takes :args :ret and (optional) :fn kwargs whose values are preds
+  and returns a spec whose conform/explain take a fn and validates it
+  using generative testing. The conformed value is always the fn itself.
+
+  See 'fdef' for a single operation that creates an fspec and
+  registers it, as well as a full description of :args, :ret and :fn
+
+  fspecs can generate functions that validate the arguments and
+  fabricate a return value compliant with the :ret spec, ignoring
+  the :fn spec if present.
+
+  Optionally takes :gen generator-fn, which must be a fn of no args
+  that returns a test.check generator."
+  
+  [& {:keys [args ret fn gen]}]
+  `(fspec-impl (spec ~args) '~(res args)
+               (spec ~ret) '~(res ret)
+               (spec ~fn) '~(res fn) ~gen))
+
+(defmacro tuple
+  "takes one or more preds and returns a spec for a tuple, a vector
+  where each element conforms to the corresponding pred. Each element
+  will be referred to in paths using its ordinal."
+  [& preds]
+  (c/assert (not (empty? preds)))
+  `(tuple-impl '~(mapv res preds) ~(vec preds)))
+
+(defn- macroexpand-check
+  [v args]
+  (let [fn-spec (get-spec v)]
+    (when-let [arg-spec (:args fn-spec)]
+      (when (= ::invalid (conform arg-spec args))
+        (let [ed (assoc (explain-data* arg-spec [:args]
+                                       (if-let [name (spec-name arg-spec)] [name] []) [] args)
+                   ::args args)]
+          (throw (ArgumentException.
+                   (str
+                     "Call to " (->sym v) " did not conform to spec:\n"
+                     (with-out-str (explain-out ed))))))))))
+
+(defmacro fdef
+  "Takes a symbol naming a function, and one or more of the following:
+
+  :args A regex spec for the function arguments as they were a list to be
+    passed to apply - in this way, a single spec can handle functions with
+    multiple arities
+  :ret A spec for the function's return value
+  :fn A spec of the relationship between args and ret - the
+    value passed is {:args conformed-args :ret conformed-ret} and is
+    expected to contain predicates that relate those values
+
+  Qualifies fn-sym with resolve, or using *ns* if no resolution found.
+  Registers an fspec in the global registry, where it can be retrieved
+  by calling get-spec with the var or fully-qualified symbol.
+
+  Once registered, function specs are included in doc, checked by
+  instrument, tested by the runner clojure.spec.test/run-tests, and (if
+  a macro) used to explain errors during macroexpansion.
+
+  Note that :fn specs require the presence of :args and :ret specs to
+  conform values, and so :fn specs will be ignored if :args or :ret
+  are missing.
+
+  Returns the qualified fn-sym.
+
+  For example, to register function specs for the symbol function:
+
+  (s/fdef clojure.core/symbol
+    :args (s/alt :separate (s/cat :ns string? :n string?)
+                 :str string?
+                 :sym symbol?)
+    :ret symbol?)"
+  [fn-sym & specs]
+  `(clojure.spec/def ~fn-sym (clojure.spec/fspec ~@specs)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; impl ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defn- recur-limit? [rmap id path k]
+  (c/and (> (get rmap id) (::recursion-limit rmap))
+         (contains? (set path) k)))
+
+(defn- inck [m k]
+  (assoc m k (inc (c/or (get m k) 0))))
+
+(defn- dt
+  ([pred x form] (dt pred x form nil))
+  ([pred x form cpred?]
+     (if pred
+       (if-let [spec (the-spec pred)]
+         (conform spec x)
+         (if (ifn? pred)
+           (if cpred?
+             (pred x)
+             (if (pred x) x ::invalid))
+           (throw (Exception. (str (pr-str form) " is not a fn, expected predicate fn")))))
+       x)))
+
+(defn valid?
+  "Helper function that returns true when x is valid for spec."
+  ([spec x]
+     (not= ::invalid (dt spec x ::unknown)))
+  ([spec x form]
+     (not= ::invalid (dt spec x form))))
+
+(defn- explain-1 [form pred path via in v]
+  ;;(prn {:form form :pred pred :path path :in in :v v})
+  (let [pred (maybe-spec pred)]
+    (if (spec? pred)
+      (explain* pred path (if-let [name (spec-name pred)] (conj via name) via) in v)
+      [{:path path :pred (abbrev form) :val v :via via :in in}])))
+
+(defn ^:skip-wiki map-spec-impl
+  "Do not call this directly, use 'spec' with a map argument"
+  [{:keys [req-un opt-un pred-exprs opt-keys req-specs req req-keys opt-specs pred-forms opt gfn]
+    :as argm}]
+  (let [keys-pred (apply every-pred pred-exprs)
+        k->s (zipmap (concat req-keys opt-keys) (concat req-specs opt-specs))
+        keys->specs #(c/or (k->s %) %)
+        ;; id (java.util.UUID/randomUUID)
+        id (System.Guid.) ;; maaaaybe?
+        ]
+    (reify
+     clojure.lang.IFn
+     (invoke [this x] (valid? this x))
+     Spec
+     (conform* [_ m]
+               (if (keys-pred m)
+                 (let [reg (registry)]
+                   (loop [ret m, [k & ks :as keys] (c/keys m)]
+                     (if keys
+                       (if (contains? reg (keys->specs k))
+                         (let [v (get m k)
+                               cv (conform (keys->specs k) v)]
+                           (if (= cv ::invalid)
+                             ::invalid
+                             (recur (if (identical? cv v) ret (assoc ret k cv))
+                                    ks)))
+                         (recur ret ks))
+                       ret)))
+                 ::invalid))
+     (unform* [_ m]
+              (let [reg (registry)]
+                (loop [ret m, [k & ks :as keys] (c/keys m)]
+                  (if keys
+                    (if (contains? reg (keys->specs k))
+                      (let [cv (get m k)
+                            v (unform (keys->specs k) cv)]
+                        (recur (if (identical? cv v) ret (assoc ret k v))
+                               ks))
+                      (recur ret ks))
+                    ret))))
+     (explain* [_ path via in x]
+               (if-not (map? x)
+                 [{:path path :pred 'map? :val x :via via :in in}]
+                 (let [reg (registry)]
+                   (apply concat
+                          (when-let [probs (->> (map (fn [pred form] (when-not (pred x) (abbrev form)))
+                                                     pred-exprs pred-forms)
+                                                (keep identity)
+                                                seq)]
+                            (map
+                             #(identity {:path path :pred % :val x :via via :in in})
+                             probs))
+                          (map (fn [[k v]]
+                                 (when-not (c/or (not (contains? reg (keys->specs k)))
+                                                 (valid? (keys->specs k) v k))
+                                   (explain-1 (keys->specs k) (keys->specs k) (conj path k) via (conj in k) v)))
+                               (seq x))))))
+     (gen* [_ overrides path rmap]
+           (if gfn
+             (gfn)
+             (let [rmap (inck rmap id)
+                   gen (fn [k s] (gensub s overrides (conj path k) rmap k))
+                   ogen (fn [k s]
+                          (when-not (recur-limit? rmap id path k)
+                            [k (gen/delay (gensub s overrides (conj path k) rmap k))]))
+                   req-gens (map gen req-keys req-specs)
+                   opt-gens (remove nil? (map ogen opt-keys opt-specs))]
+               (when (every? identity (concat req-gens opt-gens))
+                 (let [reqs (zipmap req-keys req-gens)
+                       opts (into {} opt-gens)]
+                   (gen/bind (gen/choose 0 (count opts))
+                             #(let [args (concat (seq reqs) (when (seq opts) (shuffle (seq opts))))]
+                                (->> args
+                                     (take (c/+ % (count reqs)))
+                                     (apply concat)
+                                     (apply gen/hash-map)))))))))
+     (with-gen* [_ gfn] (map-spec-impl (assoc argm :gfn gfn)))
+     (describe* [_] (cons `keys
+                          (cond-> []
+                                  req (conj :req req)
+                                  opt (conj :opt opt)
+                                  req-un (conj :req-un req-un)
+                                  opt-un (conj :opt-un opt-un)))))))
+
+
+
+
+(defn ^:skip-wiki spec-impl
+  "Do not call this directly, use 'spec'"
+  ([form pred gfn cpred?] (spec-impl form pred gfn cpred? nil))
+  ([form pred gfn cpred? unc]
+     (cond
+      (spec? pred) (cond-> pred gfn (with-gen gfn))
+      (regex? pred) (regex-spec-impl pred gfn)
+      (named? pred) (cond-> (the-spec pred) gfn (with-gen gfn))
+      :else
+      (reify
+       Spec
+       (conform* [_ x] (dt pred x form cpred?))
+       (unform* [_ x] (if cpred?
+                        (if unc
+                          (unc x)
+                          (throw (InvalidOperationException. "no unform fn for conformer")))
+                        x))
+       (explain* [_ path via in x]
+                 (when (= ::invalid (dt pred x form cpred?))
+                   [{:path path :pred (abbrev form) :val x :via via :in in}]))
+       (gen* [_ _ _ _] (if gfn
+                         (gfn)
+                         (gen/gen-for-pred pred)))
+       (with-gen* [_ gfn] (spec-impl form pred gfn cpred?))
+       (describe* [_] form)))))
+
+(defn ^:skip-wiki multi-spec-impl
+  "Do not call this directly, use 'multi-spec'"
+  ([form mmvar retag] (multi-spec-impl form mmvar retag nil))
+  ([form mmvar retag gfn]
+     (let [id (System.Guid.)
+           predx #(let [^clojure.lang.MultiFn mm @mmvar]
+                    (c/and (contains? (methods mm)
+                                      ((.dispatchFn mm) %))
+                           (mm %)))
+           dval #((.dispatchFn ^clojure.lang.MultiFn @mmvar) %)
+           tag (if (keyword? retag)
+                 #(assoc %1 retag %2)
+                 retag)]
+       (reify
+        Spec
+        (conform* [_ x] (if-let [pred (predx x)]
+                          (dt pred x form)
+                          ::invalid))
+        (unform* [_ x] (if-let [pred (predx x)]
+                         (unform pred x)
+                         (throw (InvalidOperationException. (str "No method of: " form " for dispatch value: " (dval x))))))
+        (explain* [_ path via in x]
+                  (let [dv (dval x)
+                        path (conj path dv)]
+                    (if-let [pred (predx x)]
+                      (explain-1 form pred path via in x)
+                      [{:path path :pred (abbrev form) :val x :reason "no method" :via via :in in}])))
+        (gen* [_ overrides path rmap]
+              (if gfn
+                (gfn)
+                (let [gen (fn [[k f]]
+                            (let [p (f nil)]
+                              (let [rmap (inck rmap id)]
+                                (when-not (recur-limit? rmap id path k)
+                                  (gen/delay
+                                   (gen/fmap
+                                    #(tag % k)
+                                    (gensub p overrides (conj path k) rmap (list 'method form k))))))))
+                      gs (->> (methods @mmvar)
+                              (remove (fn [[k]] (= k ::invalid)))
+                              (map gen)
+                              (remove nil?))]
+                  (when (every? identity gs)
+                    (gen/one-of gs)))))
+        (with-gen* [_ gfn] (multi-spec-impl form mmvar retag gfn))
+        (describe* [_] `(multi-spec ~form))))))
+
+(defn ^:skip-wiki tuple-impl
+  "Do not call this directly, use 'tuple'"
+  ([forms preds] (tuple-impl forms preds nil))
+  ([forms preds gfn]
+     (reify
+      Spec
+      (conform* [_ x]
+                (if-not (c/and (vector? x)
+                               (= (count x) (count preds)))
+                  ::invalid
+                  (loop [ret x, i 0]
+                    (if (= i (count x))
+                      ret
+                      (let [v (x i)
+                            cv (dt (preds i) v (forms i))]
+                        (if (= ::invalid cv)
+                          ::invalid
+                          (recur (if (identical? cv v) ret (assoc ret i cv))
+                                 (inc i))))))))
+      (unform* [_ x]
+               (c/assert (c/and (vector? x)
+                              (= (count x) (count preds))))
+               (loop [ret x, i 0]
+                 (if (= i (count x))
+                   ret
+                   (let [cv (x i)
+                         v (unform (preds i) cv)]
+                     (recur (if (identical? cv v) ret (assoc ret i v))
+                            (inc i))))))
+      (explain* [_ path via in x]
+                (cond
+                 (not (vector? x))
+                 [{:path path :pred 'vector? :val x :via via :in in}]
+
+                 (not= (count x) (count preds))
+                 [{:path path :pred `(= (count ~'%) ~(count preds)) :val x :via via :in in}]
+
+                 :else
+                 (apply concat
+                        (map (fn [i form pred]
+                               (let [v (x i)]
+                                 (when-not (valid? pred v)
+                                   (explain-1 form pred (conj path i) via (conj in i) v))))
+                             (range (count preds)) forms preds))))
+      (gen* [_ overrides path rmap]
+            (if gfn
+              (gfn)
+              (let [gen (fn [i p f]
+                          (gensub p overrides (conj path i) rmap f))
+                    gs (map gen (range (count preds)) preds forms)]
+                (when (every? identity gs)
+                  (apply gen/tuple gs)))))
+      (with-gen* [_ gfn] (tuple-impl forms preds gfn))
+      (describe* [_] `(tuple ~@forms)))))
+
+(defn- tagged-ret [tag ret]
+  (clojure.lang.MapEntry. tag ret))
+
+(defn ^:skip-wiki or-spec-impl
+  "Do not call this directly, use 'or'"
+  [keys forms preds gfn]
+  (let [id (System.Guid.)
+        kps (zipmap keys preds)
+        cform (fn [x]
+                (loop [i 0]
+                  (if (< i (count preds))
+                    (let [pred (preds i)]
+                      (let [ret (dt pred x (nth forms i))]
+                        (if (= ::invalid ret)
+                          (recur (inc i))
+                          (tagged-ret (keys i) ret))))
+                    ::invalid)))]
+    (reify
+     Spec
+     (conform* [_ x] (cform x))
+     (unform* [_ [k x]] (unform (kps k) x))
+     (explain* [this path via in x]
+               (when-not (valid? this x)
+                 (apply concat
+                        (map (fn [k form pred]
+                               (when-not (valid? pred x)
+                                 (explain-1 form pred (conj path k) via in x)))
+                             keys forms preds))))
+     (gen* [_ overrides path rmap]
+           (if gfn
+             (gfn)
+             (let [gen (fn [k p f]
+                         (let [rmap (inck rmap id)]
+                           (when-not (recur-limit? rmap id path k)
+                             (gen/delay
+                              (gensub p overrides (conj path k) rmap f)))))
+                   gs (remove nil? (map gen keys preds forms))]
+               (when-not (empty? gs)
+                 (gen/one-of gs)))))
+     (with-gen* [_ gfn] (or-spec-impl keys forms preds gfn))
+     (describe* [_] `(or ~@(mapcat vector keys forms))))))
+
+(defn- and-preds [x preds forms]
+  (loop [ret x
+         [pred & preds] preds
+         [form & forms] forms]
+    (if pred
+      (let [nret (dt pred ret form)]
+        (if (= ::invalid nret)
+          ::invalid
+          ;;propagate conformed values
+          (recur nret preds forms)))
+      ret)))
+
+(defn- explain-pred-list
+  [forms preds path via in x]
+  (loop [ret x
+         [form & forms] forms
+         [pred & preds] preds]
+    (when pred
+      (let [nret (dt pred ret form)]
+        (if (not= ::invalid nret)
+          (recur nret forms preds)
+          (explain-1 form pred path via in ret))))))
+
+(defn ^:skip-wiki and-spec-impl
+  "Do not call this directly, use 'and'"
+  [forms preds gfn]
+  (reify
+   Spec
+   (conform* [_ x] (and-preds x preds forms))
+   (unform* [_ x] (reduce #(unform %2 %1) x (reverse preds)))
+   (explain* [_ path via in x] (explain-pred-list forms preds path via in x))
+   (gen* [_ overrides path rmap] (if gfn (gfn) (gensub (first preds) overrides path rmap (first forms))))
+   (with-gen* [_ gfn] (and-spec-impl forms preds gfn))
+   (describe* [_] `(and ~@forms))))
+
+(defn ^:skip-wiki merge-spec-impl
+  "Do not call this directly, use 'merge'"
+  [forms preds gfn]
+  (reify
+   Spec
+   (conform* [_ x] (let [ms (map #(dt %1 x %2) preds forms)]
+                     (if (some #{::invalid} ms)
+                       ::invalid
+                       (apply c/merge ms))))
+   (unform* [_ x] (apply c/merge (map #(unform % x) (reverse preds))))
+   (explain* [_ path via in x]
+             (apply concat
+                    (map #(explain-1 %1 %2 path via in x)
+                         forms preds)))
+   (gen* [_ overrides path rmap]
+         (if gfn
+           (gfn)
+           (gen/fmap
+            #(apply c/merge %)
+            (apply gen/tuple (map #(gensub %1 overrides path rmap %2)
+                                  preds forms)))))
+   (with-gen* [_ gfn] (merge-spec-impl forms preds gfn))
+   (describe* [_] `(merge ~@forms))))
+
+(defn- coll-prob [x kfn kform distinct count min-count max-count
+                  path via in]
+  (let [pred (c/or kfn coll?)
+        kform (c/or kform `coll?)]
+    (cond
+     (not (valid? pred x))
+     (explain-1 kform pred path via in x)
+
+     (c/and distinct (not (empty? x)) (not (apply distinct? x)))
+     [{:path path :pred 'distinct? :val x :via via :in in}]
+
+     (c/and count (not= count (bounded-count count x)))
+     [{:path path :pred `(= ~count (c/count ~'%)) :val x :via via :in in}]
+
+     (c/and (c/or min-count max-count)
+            (not (<= (c/or min-count 0)
+                     (bounded-count (if max-count (inc max-count) min-count) x)
+                     (c/or max-count System.Int32/MaxValue))))
+     [{:path path :pred `(<= ~(c/or min-count 0) (c/count ~'%) ~(c/or max-count 'System.Int32/MaxValue)) :val x :via via :in in}])))
+
+(defn ^:skip-wiki every-impl
+  "Do not call this directly, use 'every', 'every-kv', 'coll-of' or 'map-of'"
+  ([form pred opts] (every-impl form pred opts nil))
+  ([form pred {gen-into :into
+               :keys [kind ::kind-form count max-count min-count distinct gen-max ::kfn
+                      conform-keys ::conform-all]
+               :or {gen-max 20}
+               :as opts}
+    gfn]
+     (let [conform-into gen-into
+           check? #(valid? pred %)
+           kfn (c/or kfn (fn [i v] i))
+           addcv (fn [ret i v cv] (conj ret cv))
+           cfns (fn [x]
+                  ;;returns a tuple of [init add complete] fns
+                  (cond
+                   (c/and (vector? x) (c/or (not conform-into) (vector? conform-into)))
+                   [identity
+                    (fn [ret i v cv]
+                      (if (identical? v cv)
+                        ret
+                        (assoc ret i cv)))
+                    identity]
+
+                   (c/and (map? x) (c/or (c/and kind (not conform-into)) (map? conform-into)))
+                   [(if conform-keys empty identity)
+                    (fn [ret i v cv]
+                      (if (c/and (identical? v cv) (not conform-keys))
+                        ret
+                        (assoc ret (nth (if conform-keys cv v) 0) (nth cv 1))))
+                    identity]
+                  
+                   (c/or (list? conform-into) (c/and (not conform-into) (list? x)))
+                   [(constantly ()) addcv reverse]
+
+                   :else [#(empty (c/or conform-into %)) addcv identity]))]
+       (reify
+        Spec
+        (conform* [_ x]
+                  (cond
+                   (coll-prob x kind kind-form distinct count min-count max-count
+                              nil nil nil)
+                   ::invalid
+
+                   conform-all
+                   (let [[init add complete] (cfns x)]
+                     (loop [ret (init x), i 0, [v & vs :as vseq] (seq x)]
+                       (if vseq
+                         (let [cv (dt pred v nil)]
+                           (if (= ::invalid cv)
+                             ::invalid
+                             (recur (add ret i v cv) (inc i) vs)))
+                         (complete ret))))
+                   
+                   
+                   :else
+                   (if (indexed? x)
+                     (let [step (max 1 (long (/ (c/count x) *coll-check-limit*)))]
+                       (loop [i 0]
+                         (if (>= i (c/count x))
+                           x
+                           (if (check? (nth x i))
+                             (recur (c/+ i step))
+                             ::invalid))))
+                     (c/or (c/and (every? check? (take *coll-check-limit* x)) x)
+                           ::invalid))))
+        (unform* [_ x] x)
+        (explain* [_ path via in x]
+                  (c/or (coll-prob x kind kind-form distinct count min-count max-count
+                                   path via in)
+                        (apply concat
+                               ((if conform-all identity (partial take *coll-error-limit*))
+                                (keep identity
+                                      (map (fn [i v]
+                                             (let [k (kfn i v)]
+                                               (when-not (check? v)
+                                                 (let [prob (explain-1 form pred path via (conj in k) v)]
+                                                   prob))))
+                                           (range) x))))))
+        (gen* [_ overrides path rmap]
+              (if gfn
+                (gfn)
+                (let [pgen (gensub pred overrides path rmap form)]
+                  (gen/bind
+                   (cond
+                    gen-into (gen/return (empty gen-into))
+                    kind (gen/fmap #(if (empty? %) % (empty %))
+                                   (gensub kind overrides path rmap form))
+                    :else (gen/return []))
+                   (fn [init]
+                     (gen/fmap
+                      #(if (vector? init) % (into init %))
+                      (cond
+                       distinct
+                       (if count
+                         (gen/vector-distinct pgen {:num-elements count :max-tries 100})
+                         (gen/vector-distinct pgen {:min-elements (c/or min-count 0)
+                                                    :max-elements (c/or max-count (max gen-max (c/* 2 (c/or min-count 0))))
+                                                    :max-tries 100}))
+
+                       count
+                       (gen/vector pgen count)
+
+                       (c/or min-count max-count)
+                       (gen/vector pgen (c/or min-count 0) (c/or max-count (max gen-max (c/* 2 (c/or min-count 0)))))
+
+                       :else
+                       (gen/vector pgen 0 gen-max))))))))
+        
+        (with-gen* [_ gfn] (every-impl form pred opts gfn))
+        (describe* [_] `(every ~form ~@(mapcat identity opts)))))))
+
+;;;;;;;;;;;;;;;;;;;;;;; regex ;;;;;;;;;;;;;;;;;;;
+;;See:
+;; http://matt.might.net/articles/implementation-of-regular-expression-matching-in-scheme-with-derivatives/
+;; http://www.ccs.neu.edu/home/turon/re-deriv.pdf
+
+;;ctors
+(defn- accept [x] {::op ::accept :ret x})
+
+(defn- accept? [{:keys [::op]}]
+  (= ::accept op))
+
+(defn- pcat* [{[p1 & pr :as ps] :ps,  [k1 & kr :as ks] :ks, [f1 & fr :as forms] :forms, ret :ret, rep+ :rep+}]
+  (when (every? identity ps)
+    (if (accept? p1)
+      (let [rp (:ret p1)
+            ret (conj ret (if ks {k1 rp} rp))]
+        (if pr
+          (pcat* {:ps pr :ks kr :forms fr :ret ret})
+          (accept ret)))
+      {::op ::pcat, :ps ps, :ret ret, :ks ks, :forms forms :rep+ rep+})))
+
+(defn- pcat [& ps] (pcat* {:ps ps :ret []}))
+
+(defn ^:skip-wiki cat-impl
+  "Do not call this directly, use 'cat'"
+  [ks ps forms]
+  (pcat* {:ks ks, :ps ps, :forms forms, :ret {}}))
+
+(defn- rep* [p1 p2 ret splice form]
+  (when p1
+    (let [r {::op ::rep, :p2 p2, :splice splice, :forms form :id (System.Guid.)}]
+      (if (accept? p1)
+        (assoc r :p1 p2 :ret (conj ret (:ret p1)))
+        (assoc r :p1 p1, :ret ret)))))
+
+(defn ^:skip-wiki rep-impl
+  "Do not call this directly, use '*'"
+  [form p] (rep* p p [] false form))
+
+(defn ^:skip-wiki rep+impl
+  "Do not call this directly, use '+'"
+  [form p]
+  (pcat* {:ps [p (rep* p p [] true form)] :forms `[~form (* ~form)] :ret [] :rep+ form}))
+
+(defn ^:skip-wiki amp-impl
+  "Do not call this directly, use '&'"
+  [re preds pred-forms]
+  {::op ::amp :p1 re :ps preds :forms pred-forms})
+
+(defn- filter-alt [ps ks forms f]
+  (if (c/or ks forms)
+    (let [pks (->> (map vector ps
+                        (c/or (seq ks) (repeat nil))
+                        (c/or (seq forms) (repeat nil)))
+                   (filter #(-> % first f)))]
+      [(seq (map first pks)) (when ks (seq (map second pks))) (when forms (seq (map #(nth % 2) pks)))])
+    [(seq (filter f ps)) ks forms]))
+
+(defn- alt* [ps ks forms]
+  (let [[[p1 & pr :as ps] [k1 :as ks] forms] (filter-alt ps ks forms identity)]
+    (when ps
+      (let [ret {::op ::alt, :ps ps, :ks ks :forms forms}]
+        (if (nil? pr) 
+          (if k1
+            (if (accept? p1)
+              (accept (tagged-ret k1 (:ret p1)))
+              ret)
+            p1)
+          ret)))))
+
+(defn- alts [& ps] (alt* ps nil nil))
+(defn- alt2 [p1 p2] (if (c/and p1 p2) (alts p1 p2) (c/or p1 p2)))
+
+(defn ^:skip-wiki alt-impl
+  "Do not call this directly, use 'alt'"
+  [ks ps forms] (assoc (alt* ps ks forms) :id (System.Guid.)))
+
+(defn ^:skip-wiki maybe-impl
+  "Do not call this directly, use '?'"
+  [p form] (assoc (alt* [p (accept ::nil)] nil [form ::nil]) :maybe form))
+
+(defn- noret? [p1 pret]
+  (c/or (= pret ::nil)
+        (c/and (#{::rep ::pcat} (::op (reg-resolve! p1))) ;;hrm, shouldn't know these
+               (empty? pret))
+        nil))
+
+(declare preturn)
+
+(defn- accept-nil? [p]
+  (let [{:keys [::op ps p1 p2 forms] :as p} (reg-resolve! p)]
+    (case op
+          ::accept true
+          nil nil
+          ::amp (c/and (accept-nil? p1)
+                       (c/or (noret? p1 (preturn p1))
+                             (let [ret (-> (preturn p1) (and-preds ps (next forms)))]
+                               (not= ret ::invalid))))
+          ::rep (c/or (identical? p1 p2) (accept-nil? p1))
+          ::pcat (every? accept-nil? ps)
+          ::alt (c/some accept-nil? ps))))
+
+(declare add-ret)
+
+(defn- preturn [p]
+  (let [{[p0 & pr :as ps] :ps, [k :as ks] :ks, :keys [::op p1 ret forms] :as p} (reg-resolve! p)]
+    (case op
+          ::accept ret
+          nil nil
+          ::amp (let [pret (preturn p1)]
+                  (if (noret? p1 pret)
+                    ::nil
+                    (and-preds pret ps forms)))
+          ::rep (add-ret p1 ret k)
+          ::pcat (add-ret p0 ret k)
+          ::alt (let [[[p0] [k0]] (filter-alt ps ks forms accept-nil?)
+                      r (if (nil? p0) ::nil (preturn p0))]
+                  (if k0 (tagged-ret k0 r) r)))))
+
+(defn- op-unform [p x]
+  ;;(prn {:p p :x x})
+  (let [{[p0 & pr :as ps] :ps, [k :as ks] :ks, :keys [::op p1 ret forms rep+ maybe] :as p} (reg-resolve! p)
+        kps (zipmap ks ps)]
+    (case op
+          ::accept [ret]
+          nil [(unform p x)]
+          ::amp (let [px (reduce #(unform %2 %1) x (reverse ps))]
+                  (op-unform p1 px))
+          ::rep (mapcat #(op-unform p1 %) x)
+          ::pcat (if rep+
+                   (mapcat #(op-unform p0 %) x)
+                   (mapcat (fn [k]
+                             (when (contains? x k)
+                               (op-unform (kps k) (get x k))))
+                           ks))
+          ::alt (if maybe
+                  [(unform p0 x)]
+                  (let [[k v] x]
+                    (op-unform (kps k) v))))))
+
+(defn- add-ret [p r k]
+  (let [{:keys [::op ps splice] :as p} (reg-resolve! p)
+        prop #(let [ret (preturn p)]
+                (if (empty? ret) r ((if splice into conj) r (if k {k ret} ret))))]
+    (case op
+          nil r
+          (::alt ::accept ::amp)
+          (let [ret (preturn p)]
+            ;;(prn {:ret ret})
+            (if (= ret ::nil) r (conj r (if k {k ret} ret))))
+
+          (::rep ::pcat) (prop))))
+
+(defn- deriv
+  [p x]
+  (let [{[p0 & pr :as ps] :ps, [k0 & kr :as ks] :ks, :keys [::op p1 p2 ret splice forms] :as p} (reg-resolve! p)]
+    (when p
+      (case op
+            ::accept nil
+            nil (let [ret (dt p x p)]
+                  (when-not (= ::invalid ret) (accept ret)))
+            ::amp (when-let [p1 (deriv p1 x)]
+                    (if (= ::accept (::op p1))
+                      (let [ret (-> (preturn p1) (and-preds ps (next forms)))]
+                        (when-not (= ret ::invalid)
+                          (accept ret)))
+                      (amp-impl p1 ps forms)))
+            ::pcat (alt2 (pcat* {:ps (cons (deriv p0 x) pr), :ks ks, :forms forms, :ret ret})
+                         (when (accept-nil? p0) (deriv (pcat* {:ps pr, :ks kr, :forms (next forms), :ret (add-ret p0 ret k0)}) x)))
+            ::alt (alt* (map #(deriv % x) ps) ks forms)
+            ::rep (alt2 (rep* (deriv p1 x) p2 ret splice forms)
+                        (when (accept-nil? p1) (deriv (rep* p2 p2 (add-ret p1 ret nil) splice forms) x)))))))
+
+(defn- op-describe [p]  
+  (let [{:keys [::op ps ks forms splice p1 rep+ maybe] :as p} (reg-resolve! p)]
+    ;;(prn {:op op :ks ks :forms forms :p p})
+    (when p
+      (case op
+            ::accept nil
+            nil p
+            ::amp (list* 'clojure.spec/& (op-describe p1) forms)
+            ::pcat (if rep+
+                     (list `+ rep+)
+                     (cons `cat (mapcat vector (c/or (seq ks) (repeat :_)) forms)))
+            ::alt (if maybe
+                    (list `? maybe)
+                    (cons `alt (mapcat vector ks forms)))
+            ::rep (list (if splice `+ `*) forms)))))
+
+(defn- op-explain [form p path via in input]
+  ;;(prn {:form form :p p :path path :input input})
+  (let [[x :as input] input
+        {:keys [::op ps ks forms splice p1 p2] :as p} (reg-resolve! p)
+        via (if-let [name (spec-name p)] (conj via name) via)
+        insufficient (fn [path form]
+                       [{:path path
+                         :reason "Insufficient input"
+                         :pred (abbrev form)
+                         :val ()
+                         :via via
+                         :in in}])]
+    (when p
+      (case op
+            ::accept nil
+            nil (if (empty? input)
+                  (insufficient path form)
+                  (explain-1 form p path via in x))
+            ::amp (if (empty? input)
+                    (if (accept-nil? p1)
+                      (explain-pred-list forms ps path via in (preturn p1))
+                      (insufficient path (op-describe p1)))
+                    (if-let [p1 (deriv p1 x)]
+                      (explain-pred-list forms ps path via in (preturn p1))
+                      (op-explain (op-describe p1) p1 path via in input)))
+            ::pcat (let [pkfs (map vector
+                                   ps
+                                   (c/or (seq ks) (repeat nil))
+                                   (c/or (seq forms) (repeat nil)))
+                         [pred k form] (if (= 1 (count pkfs))
+                                         (first pkfs)
+                                         (first (remove (fn [[p]] (accept-nil? p)) pkfs)))
+                         path (if k (conj path k) path)
+                         form (c/or form (op-describe pred))]
+                     (if (c/and (empty? input) (not pred))
+                       (insufficient path form)
+                       (op-explain form pred path via in input)))
+            ::alt (if (empty? input)
+                    (insufficient path (op-describe p))
+                    (apply concat
+                           (map (fn [k form pred]
+                                  (op-explain (c/or form (op-describe pred))
+                                              pred
+                                              (if k (conj path k) path)
+                                              via
+                                              in
+                                              input))
+                                (c/or (seq ks) (repeat nil))
+                                (c/or (seq forms) (repeat nil))
+                                ps)))
+            ::rep (op-explain (if (identical? p1 p2)
+                                forms
+                                (op-describe p1))
+                              p1 path via in input)))))
+
+(defn- re-gen [p overrides path rmap f]
+  ;;(prn {:op op :ks ks :forms forms})
+  (let [{:keys [::op ps ks p1 p2 forms splice ret id ::gfn] :as p} (reg-resolve! p)
+        rmap (if id (inck rmap id) rmap)
+        ggens (fn [ps ks forms]
+                (let [gen (fn [p k f]
+                            ;;(prn {:k k :path path :rmap rmap :op op :id id})
+                            (when-not (c/and rmap id k (recur-limit? rmap id path k))
+                              (if id
+                                (gen/delay (re-gen p overrides (if k (conj path k) path) rmap (c/or f p)))
+                                (re-gen p overrides (if k (conj path k) path) rmap (c/or f p)))))]
+                  (map gen ps (c/or (seq ks) (repeat nil)) (c/or (seq forms) (repeat nil)))))]
+    (c/or (when-let [g (get overrides path)]
+            (case op
+                  (:accept nil) (gen/fmap vector g)
+                  g))
+          (when gfn
+            (gfn))
+          (when p
+            (case op
+                  ::accept (if (= ret ::nil)
+                             (gen/return [])
+                             (gen/return [ret]))
+                  nil (when-let [g (gensub p overrides path rmap f)]
+                        (gen/fmap vector g))
+                  ::amp (re-gen p1 overrides path rmap (op-describe p1))
+                  ::pcat (let [gens (ggens ps ks forms)]
+                           (when (every? identity gens)
+                             (apply gen/cat gens)))
+                  ::alt (let [gens (remove nil? (ggens ps ks forms))]
+                          (when-not (empty? gens)
+                            (gen/one-of gens)))
+                  ::rep (if (recur-limit? rmap id [id] id)
+                          (gen/return [])
+                          (when-let [g (re-gen p2 overrides path rmap forms)]
+                            (gen/fmap #(apply concat %)
+                                      (gen/vector g)))))))))
+
+(defn- re-conform [p [x & xs :as data]]
+  ;;(prn {:p p :x x :xs xs})
+  (if (empty? data)
+    (if (accept-nil? p)
+      (let [ret (preturn p)]
+        (if (= ret ::nil)
+          nil
+          ret))
+      ::invalid)
+    (if-let [dp (deriv p x)]
+      (recur dp xs)
+      ::invalid)))
+
+(defn- re-explain [path via in re input]
+  (loop [p re [x & xs :as data] input i 0]
+    ;;(prn {:p p :x x :xs xs :re re}) (prn)
+    (if (empty? data)
+      (if (accept-nil? p)
+        nil ;;success
+        (op-explain (op-describe p) p path via in nil))
+      (if-let [dp (deriv p x)]
+        (recur dp xs (inc i))
+        (if (accept? p)
+          (if (= (::op p) ::pcat)
+            (op-explain (op-describe p) p path via (conj in i) (seq data))
+            [{:path path
+              :reason "Extra input"
+              :pred (abbrev (op-describe re))
+              :val data
+              :via via
+              :in (conj in i)}])
+          (c/or (op-explain (op-describe p) p path via (conj in i) (seq data))
+                [{:path path
+                  :reason "Extra input"
+                  :pred (abbrev (op-describe p))
+                  :val data
+                  :via via
+                  :in (conj in i)}]))))))
+
+(defn ^:skip-wiki regex-spec-impl
+  "Do not call this directly, use 'spec' with a regex op argument"
+  [re gfn]
+  (reify
+   Spec
+   (conform* [_ x]
+             (if (c/or (nil? x) (coll? x))
+               (re-conform re (seq x))
+               ::invalid))
+   (unform* [_ x] (op-unform re x))
+   (explain* [_ path via in x]
+             (if (c/or (nil? x) (coll? x))
+               (re-explain path via in re (seq x))
+               [{:path path :pred (abbrev (op-describe re)) :val x :via via :in in}]))
+   (gen* [_ overrides path rmap]
+         (if gfn
+           (gfn)
+           (re-gen re overrides path rmap (op-describe re))))
+   (with-gen* [_ gfn] (regex-spec-impl re gfn))
+   (describe* [_] (op-describe re))))
+
+;;;;;;;;;;;;;;;;; HOFs ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- call-valid?
+  [f specs args]
+  (let [cargs (conform (:args specs) args)]
+    (when-not (= cargs ::invalid)
+      (let [ret (apply f args)
+            cret (conform (:ret specs) ret)]
+        (c/and (not= cret ::invalid) 
+               (if (:fn specs)
+                 (valid? (:fn specs) {:args cargs :ret cret})
+                 true))))))
+
+(defn- validate-fn
+  "returns f if valid, else smallest"
+  [f specs iters]
+  (let [g (gen (:args specs))
+        prop (gen/for-all* [g] #(call-valid? f specs %))]
+    (let [ret (gen/quick-check iters prop)]
+      (if-let [[smallest] (-> ret :shrunk :smallest)]
+        smallest
+        f))))
+
+(defn ^:skip-wiki fspec-impl
+  "Do not call this directly, use 'fspec'"
+  [argspec aform retspec rform fnspec fform gfn]
+  (let [specs {:args argspec :ret retspec :fn fnspec}]
+    (reify
+     clojure.lang.ILookup
+     (valAt [this k] (get specs k))
+     (valAt [_ k not-found] (get specs k not-found))
+
+     Spec
+     (conform* [_ f] (if (ifn? f)
+                       (if (identical? f (validate-fn f specs *fspec-iterations*)) f ::invalid)
+                       ::invalid))
+     (unform* [_ f] f)
+     (explain* [_ path via in f]
+               (if (ifn? f)
+                 (let [args (validate-fn f specs 100)]
+                   (if (identical? f args) ;;hrm, we might not be able to reproduce
+                     nil
+                     (let [ret (try (apply f args) (catch Exception ;;Throwable
+                                                       t t))]
+                       (if (instance? Exception ;;Throwable
+                             ret)
+                         ;;TODO add exception data
+                         {path {:pred '(apply fn) :val args :reason (.getMessage ^Exception ;;^Throwable
+                                                                      ret) :via via :in in}}
+
+                         (let [cret (dt retspec ret rform)]
+                           (if (= ::invalid cret)
+                             (explain-1 rform retspec (conj path :ret) via in ret)
+                             (when fnspec
+                               (let [cargs (conform argspec args)]
+                                 (explain-1 fform fnspec (conj path :fn) via in {:args cargs :ret cret})))))))))
+                 [{:path path :pred 'ifn? :val f :via via :in in}]))
+     (gen* [_ overrides _ _] (if gfn
+             (gfn)
+             (gen/return
+              (fn [& args]
+                (c/assert (valid? argspec args) (with-out-str (explain argspec args)))
+                (gen/generate (gen retspec overrides))))))
+     (with-gen* [_ gfn] (fspec-impl argspec aform retspec rform fnspec fform gfn))
+     (describe* [_] `(fspec :args ~aform :ret ~rform :fn ~fform)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; non-primitives ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(clojure.spec/def ::kvs->map (conformer #(zipmap (map ::k %) (map ::v %)) #(map (fn [[k v]] {::k k ::v v}) %)))
+
+(defmacro keys*
+  "takes the same arguments as spec/keys and returns a regex op that matches sequences of key/values,
+  converts them into a map, and conforms that map with a corresponding
+  spec/keys call:
+
+  user=> (s/conform (s/keys :req-un [::a ::c]) {:a 1 :c 2})
+  {:a 1, :c 2}
+  user=> (s/conform (s/keys* :req-un [::a ::c]) [:a 1 :c 2])
+  {:a 1, :c 2}
+
+  the resulting regex op can be composed into a larger regex:
+
+  user=> (s/conform (s/cat :i1 integer? :m (s/keys* :req-un [::a ::c]) :i2 integer?) [42 :a 1 :c 2 :d 4 99])
+  {:i1 42, :m {:a 1, :c 2, :d 4}, :i2 99}"
+  [& kspecs]
+  `(let [mspec# (keys ~@kspecs)]
+     (with-gen (clojure.spec/& (* (cat ::k keyword? ::v any?)) ::kvs->map mspec#)
+       (fn [] (gen/fmap (fn [m#] (apply concat m#)) (gen mspec#))))))
+
+(defmacro nilable
+  "returns a spec that accepts nil and values satisfiying pred"
+  [pred]
+  `(and (or ::nil nil? ::pred ~pred) (conformer second #(if (nil? %) [::nil nil] [::pred %]))))
+
+(defn exercise
+  "generates a number (default 10) of values compatible with spec and maps conform over them,
+  returning a sequence of [val conformed-val] tuples. Optionally takes
+  a generator overrides map as per gen"
+  ([spec] (exercise spec 10))
+  ([spec n] (exercise spec n nil))
+  ([spec n overrides]
+     (map #(vector % (conform spec %)) (gen/sample (gen spec overrides) n))))
+
+(defn exercise-fn
+  "exercises the fn named by sym (a symbol) by applying it to
+  n (default 10) generated samples of its args spec. When fspec is
+  supplied its arg spec is used, and sym-or-f can be a fn.  Returns a
+  sequence of tuples of [args ret]. "
+  ([sym] (exercise-fn sym 10))
+  ([sym n] (exercise-fn sym n (get-spec sym)))
+  ([sym-or-f n fspec]
+     (let [f (if (symbol? sym-or-f) (resolve sym-or-f) sym-or-f)]
+       (for [args (gen/sample (gen (:args fspec)) n)]
+         [args (apply f args)]))))
+
+(defn inst-in-range?
+  "Return true if inst at or after start and before end"
+  [start end inst]
+  (c/and (inst? inst)
+         (let [t (inst-ms inst)]
+           (c/and (<= (inst-ms start) t) (< t (inst-ms end))))))
+
+(defmacro inst-in
+  "Returns a spec that validates insts in the range from start
+(inclusive) to end (exclusive)."
+  [start end]
+  `(let [st# (inst-ms ~start)
+         et# (inst-ms ~end)
+         mkdate# (fn [d#] (java.util.Date. ^{:tag ~'long} d#))]
+     (spec (and inst? #(inst-in-range? ~start ~end %))
+       :gen (fn []
+              (gen/fmap mkdate#
+                (gen/large-integer* {:min st# :max et#}))))))
+
+(defn int-in-range?
+  "Return true if start <= val and val < end"
+  [start end val]
+  (c/and int? (<= start val) (< val end)))
+
+(defmacro int-in
+  "Returns a spec that validates ints in the range from start
+(inclusive) to end (exclusive)."
+  [start end]
+  `(spec (and int? #(int-in-range? ~start ~end %))
+     :gen #(gen/large-integer* {:min ~start :max (dec ~end)})))
+
+(defmacro double-in
+  "Specs a 64-bit floating point number. Options:
+
+    :infinite? - whether +/- infinity allowed (default true)
+    :NaN?      - whether NaN allowed (default true)
+    :min       - minimum value (inclusive, default none)
+    :max       - maximum value (inclusive, default none)"
+  [& {:keys [infinite? NaN? min max]
+    :or {infinite? true NaN? true}
+    :as m}]
+  `(spec (and c/double?
+              ~@(when-not infinite? '[#(not (Double/isInfinite %))])
+              ~@(when-not NaN? '[#(not (Double/isNaN %))])
+              ~@(when max `[#(<= % ~max)])
+              ~@(when min `[#(<= ~min %)]))
+         :gen #(gen/double* ~m)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; assert ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defonce
+  ^{:dynamic true
+    :doc "If true, compiler will enable spec asserts, which are then
+subject to runtime control via check-asserts? If false, compiler
+will eliminate all spec assert overhead. See 'assert'.
+
+Initially set to boolean value of clojure.spec.compile-asserts
+system property. Defaults to true."}
+  *compile-asserts*
+  (not= "false"
+        (System.Environment/GetEnvironmentVariable "CLOJURE_SPEC_COMPILE_ASSERTS")
+;;        (System/getProperty "clojure.spec.compile-asserts")
+        ))
+
+(def ^:private check-spec-asserts-ref
+  ;; janky hack in absence of easier way to modify RT
+  (atom
+    ;; ;; I guess? see https://docs.oracle.com/javase/7/docs/api/java/lang/Boolean.html
+    ;; ;; Without some more work won't "default to true", though
+    ;; (= "true" 
+    ;;    (System.Environment/GetEnvironmentVariable "CLOJURE_SPEC_COMPILE_ASSERTS"))
+    true ;; fify
+    ))
+
+(defn check-asserts?
+  "Returns the value set by check-asserts."
+  []  
+  @check-spec-asserts-ref
+  ;;clojure.lang.RT/checkSpecAsserts
+  )
+
+(defn check-asserts
+  "Enable or disable spec asserts that have been compiled
+with '*compile-asserts*' true.  See 'assert'.
+
+Initially set to boolean value of clojure.spec.check-asserts
+system property. Defaults to false."
+  [flag]
+  (reset! check-spec-asserts-ref flag)
+  ;;(set! (. clojure.lang.RT checkSpecAsserts) flag)
+  )
+
+(defn assert*
+  "Do not call this directly, use 'assert'."
+  [spec x]
+  (if (valid? spec x)
+    x
+    (let [ed (c/merge (assoc (explain-data* spec [] [] [] x)
+                        ::failure :assertion-failed))]
+      (throw (ex-info
+              (str "Spec assertion failed\n" (with-out-str (explain-out ed)))
+              ed)))))
+
+(defmacro assert
+  "spec-checking assert expression. Returns x if x is valid? according
+to spec, else throws an ex-info with explain-data plus ::failure of
+:assertion-failed.
+
+Can be disabled at either compile time or runtime:
+
+If *compile-asserts* is false at compile time, compiles to x. Defaults
+to value of 'clojure.spec.compile-asserts' system property, or true if
+not set.
+
+If (check-asserts?) is false at runtime, always returns x. Defaults to
+value of 'clojure.spec.check-asserts' system property, or false if not
+set. You can toggle check-asserts? with (check-asserts bool)."
+  [spec x]
+  (if *compile-asserts*
+    `(if clojure.lang.RT/checkSpecAsserts
+       (assert* ~spec ~x)
+       ~x)
+    x))
+
diff --git a/Clojure/Clojure.Source/clojure/spec/gen.clj b/Clojure/Clojure.Source/clojure/spec/gen.clj
new file mode 100644
index 000000000..650c66082
--- /dev/null
+++ b/Clojure/Clojure.Source/clojure/spec/gen.clj
@@ -0,0 +1,224 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(ns clojure.spec.gen
+    (:refer-clojure :exclude [boolean bytes cat hash-map list map not-empty set vector
+                              char double int keyword symbol string uuid delay]))
+
+(alias 'c 'clojure.core)
+
+(defn- dynaload
+  [s]
+  (let [ns (namespace s)]
+    (assert ns)
+    (require (c/symbol ns))
+    (let [v (resolve s)]
+      (if v
+        @v
+        (throw (Exception. (str "Var " s " is not on the classpath")))))))
+
+(def ^:private quick-check-ref
+     (c/delay (dynaload 'clojure.test.check/quick-check)))
+(defn quick-check
+  [& args]
+  (apply @quick-check-ref args))
+
+(def ^:private for-all*-ref
+     (c/delay (dynaload 'clojure.test.check.properties/for-all*)))
+(defn for-all*
+  "Dynamically loaded clojure.test.check.properties/for-all*."
+  [& args]
+  (apply @for-all*-ref args))
+
+(let [g? (c/delay (dynaload 'clojure.test.check.generators/generator?))
+      g (c/delay (dynaload 'clojure.test.check.generators/generate))
+      mkg (c/delay (dynaload 'clojure.test.check.generators/->Generator))]
+  (defn- generator?
+    [x]
+    (@g? x))
+  (defn- generator
+    [gfn]
+    (@mkg gfn))
+  (defn generate
+    "Generate a single value using generator."
+    [generator]
+    (@g generator)))
+
+(defn ^:skip-wiki delay-impl
+  [gfnd]
+  ;;N.B. depends on test.check impl details
+  (generator (fn [rnd size]
+               ((:gen @gfnd) rnd size))))
+
+(defmacro delay
+  "given body that returns a generator, returns a
+  generator that delegates to that, but delays
+  creation until used."
+  [& body]
+  `(delay-impl (c/delay ~@body)))
+
+(defn gen-for-name
+  "Dynamically loads test.check generator named s."
+  [s]
+  (let [g (dynaload s)]
+    (if (generator? g)
+      g
+      (throw (Exception. (str "Var " s " is not a generator"))))))
+
+(defmacro ^:skip-wiki lazy-combinator
+  "Implementation macro, do not call directly."
+  [s]
+  (let [fqn (c/symbol "clojure.test.check.generators" (name s))
+        doc (str "Lazy loaded version of " fqn)]
+    `(let [g# (c/delay (dynaload '~fqn))]
+       (defn ~s
+         ~doc
+         [& ~'args]
+         (apply @g# ~'args)))))
+
+(defmacro ^:skip-wiki lazy-combinators
+  "Implementation macro, do not call directly."
+  [& syms]
+  `(do
+     ~@(c/map
+        (fn [s] (c/list 'lazy-combinator s))
+        syms)))
+
+(lazy-combinators hash-map list map not-empty set vector vector-distinct fmap elements
+                  bind choose fmap one-of such-that tuple sample return
+                  large-integer* double*)
+
+(defmacro ^:skip-wiki lazy-prim
+  "Implementation macro, do not call directly."
+  [s]
+  (let [fqn (c/symbol "clojure.test.check.generators" (name s))
+        doc (str "Fn returning " fqn)]
+    `(let [g# (c/delay (dynaload '~fqn))]
+       (defn ~s
+         ~doc
+         [& ~'args]
+         @g#))))
+
+(defmacro ^:skip-wiki lazy-prims
+  "Implementation macro, do not call directly."
+  [& syms]
+  `(do
+     ~@(c/map
+        (fn [s] (c/list 'lazy-prim s))
+        syms)))
+
+(lazy-prims any any-printable boolean bytes char char-alpha char-alphanumeric char-ascii double
+            int keyword keyword-ns large-integer ratio simple-type simple-type-printable
+            string string-ascii string-alphanumeric symbol symbol-ns uuid)
+
+(defn cat
+  "Returns a generator of a sequence catenated from results of
+gens, each of which should generate something sequential."
+  [& gens]
+  (fmap #(apply concat %)
+        (apply tuple gens)))
+
+(defn- qualified? [ident] (not (nil? (namespace ident))))
+
+(def ^:private
+  gen-builtins
+  (c/delay
+   (let [simple (simple-type-printable)]
+     {any? (one-of [(return nil) (any-printable)])
+      some? (such-that some? (any-printable))
+      number? (one-of [(large-integer) (double)])
+      integer? (large-integer)
+      int? (large-integer)
+      pos-int? (large-integer* {:min 1})
+      neg-int? (large-integer* {:max -1})
+      nat-int? (large-integer* {:min 0})
+      float? (double)
+      double? (double)
+      boolean? (boolean)
+      string? (string-alphanumeric)
+      ident? (one-of [(keyword-ns) (symbol-ns)])
+      simple-ident? (one-of [(keyword) (symbol)])
+      qualified-ident? (such-that qualified? (one-of [(keyword-ns) (symbol-ns)]))
+      keyword? (keyword-ns)
+      simple-keyword? (keyword)
+      qualified-keyword? (such-that qualified? (keyword-ns))
+      symbol? (symbol-ns)
+      simple-symbol? (symbol)
+      qualified-symbol? (such-that qualified? (symbol-ns))
+      ;; uuid? (uuid)
+      ;; uri? (fmap #(java.net.URI/create (str "http://" % ".com")) (uuid))
+      ;; bigdec? (fmap #(BigDecimal/valueOf %)
+      ;;               (double* {:infinite? false :NaN? false}))
+      ;; inst? (fmap #(java.util.Date. %)
+      ;;             (large-integer))
+      seqable? (one-of [(return nil)
+                        (list simple)
+                        (vector simple)
+                        (map simple simple)
+                        (set simple)
+                        (string-alphanumeric)])
+      indexed? (vector simple)
+      map? (map simple simple)
+      vector? (vector simple)
+      list? (list simple)
+      seq? (list simple)
+      char? (char)
+      set? (set simple)
+      nil? (return nil)
+      false? (return false)
+      true? (return true)
+      zero? (return 0)
+      rational? (one-of [(large-integer) (ratio)])
+      coll? (one-of [(map simple simple)
+                     (list simple)
+                     (vector simple)
+                     (set simple)])
+      empty? (elements [nil '() [] {} #{}])
+      associative? (one-of [(map simple simple) (vector simple)])
+      sequential? (one-of [(list simple) (vector simple)])
+      ratio? (such-that ratio? (ratio))
+      ;; bytes? (bytes)
+      })))
+
+(defn gen-for-pred
+  "Given a predicate, returns a built-in generator if one exists."
+  [pred]
+  (if (set? pred)
+    (elements pred)
+    (get @gen-builtins pred)))
+
+(comment
+  (require :reload 'clojure.spec.gen)
+  (in-ns 'clojure.spec.gen)
+
+  ;; combinators, see call to lazy-combinators above for complete list
+  (generate (one-of [(gen-for-pred integer?) (gen-for-pred string?)]))
+  (generate (such-that #(< 10000 %) (gen-for-pred integer?)))
+  (let [reqs {:a (gen-for-pred number?)
+              :b (gen-for-pred ratio?)}
+        opts {:c (gen-for-pred string?)}]
+    (generate (bind (choose 0 (count opts))
+                    #(let [args (concat (seq reqs) (shuffle (seq opts)))]
+                       (->> args
+                            (take (+ % (count reqs)))
+                            (mapcat identity)
+                            (apply hash-map))))))
+  (generate (cat (list (gen-for-pred string?))
+                 (list (gen-for-pred ratio?))))
+  
+  ;; load your own generator
+  (gen-for-name 'clojure.test.check.generators/int)
+  
+  ;; failure modes
+  (gen-for-name 'unqualified)
+  (gen-for-name 'clojure.core/+)
+  (gen-for-name 'clojure.core/name-does-not-exist)
+  (gen-for-name 'ns.does.not.exist/f)
+  
+  )
+
diff --git a/Clojure/Clojure.Source/clojure/spec/test.clj b/Clojure/Clojure.Source/clojure/spec/test.clj
new file mode 100644
index 000000000..672efa9ab
--- /dev/null
+++ b/Clojure/Clojure.Source/clojure/spec/test.clj
@@ -0,0 +1,504 @@
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+
+(ns clojure.spec.test
+  (:refer-clojure :exclude [test])
+  (:require
+   [clojure.pprint :as pp]
+   [clojure.spec :as s]
+   [clojure.spec.gen :as gen]
+   [clojure.string :as str]))
+
+(in-ns 'clojure.spec.test.check)
+(in-ns 'clojure.spec.test)
+(alias 'stc 'clojure.spec.test.check)
+
+(defn- throwable?
+  [x]
+  (instance? Exception x))
+
+(defn ->sym
+  [x]
+  (@#'s/->sym x))
+
+(defn- ->var
+  [s-or-v]
+  (if (var? s-or-v)
+    s-or-v
+    (let [v (and (symbol? s-or-v) (resolve s-or-v))]
+      (if (var? v)
+        v
+        (throw (ArgumentException. (str (pr-str s-or-v) " does not name a var")))))))
+
+(defn- collectionize
+  [x]
+  (if (symbol? x)
+    (list x)
+    x))
+
+(defn enumerate-namespace
+  "Given a symbol naming an ns, or a collection of such symbols,
+returns the set of all symbols naming vars in those nses."
+  [ns-sym-or-syms]
+  (into
+   #{}
+   (mapcat (fn [ns-sym]
+             (map
+              (fn [name-sym]
+                (symbol (name ns-sym) (name name-sym)))
+              (keys (ns-interns ns-sym)))))
+   (collectionize ns-sym-or-syms)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; instrument ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(def ^:private ^:dynamic *instrument-enabled*
+  "if false, instrumented fns call straight through"
+  true)
+
+(defn- fn-spec?
+  "Fn-spec must include at least :args or :ret specs."
+  [m]
+  (or (:args m) (:ret m)))
+
+(defmacro with-instrument-disabled
+  "Disables instrument's checking of calls, within a scope."
+  [& body]
+  `(binding [*instrument-enabled* nil]
+     ~@body))
+
+(defn- interpret-stack-trace-element
+  "Given the vector-of-syms form of a stacktrace element produced
+by e.g. Throwable->map, returns a map form that adds some keys
+guessing the original Clojure names. Returns a map with
+
+  :class         class name symbol from stack trace
+  :method        method symbol from stack trace
+  :file          filename from stack trace
+  :line          line number from stack trace
+  :var-scope     optional Clojure var symbol scoping fn def
+  :local-fn      optional local Clojure symbol scoping fn def
+
+For non-Clojure fns, :scope and :local-fn will be absent."
+  [{:keys [method file line]
+    cls :class}]
+  (let [clojure? (contains? '#{invoke invokeStatic} method)
+        demunge #(clojure.lang.Compiler/demunge %)
+        degensym #(str/replace % #"--.*" "")
+        [ns-sym name-sym local] (when clojure?
+                                  (-> (->> (str/split (str cls) #"\$" 3)
+                                           (mapv demunge))
+                                      (update 0 #(str/replace % #"/" "."))))
+        ;; (when clojure?
+        ;;   (->> (str/split (str cls) #"\$" 3)
+        ;;        (map demunge)))
+        ]
+    (merge {:file file
+            :line line
+            :method method
+            :class cls}
+           (when (and ns-sym name-sym)
+             {:var-scope (symbol ns-sym name-sym)})
+           (when local
+             {:local-fn (symbol (degensym local))}))))
+
+(def ^:private stack-frame-regex
+  (re-pattern
+    (clojure.string/join
+      (flatten
+        ["^\\s*at"
+         "\\s+(\\S+)\\.(\\S+)" ;; class & method
+         ".*(\\(.*\\))"        ;; params
+         "(?:\\s+(\\[.*\\]))?" ;; weirdness
+         "(?:\\s+in\\s+)?"
+         ["(?:"
+          "(\\S+?)"            ;; file
+          "\\:"
+          "(?:line\\D+)?"      ;; line
+          "(\\d+)"             ;; line number
+          ")?"]
+         ".*$"]))))
+
+(defn- parse-stack-trace [stack-trace]
+  (for [frame (clojure.string/split-lines stack-trace)]
+    (when-let [[_ class method args _ file line] (first
+                                                   (re-seq stack-frame-regex
+                                                     frame))]
+      {:class (symbol class)
+       :method (symbol method)
+       :args args
+       :file file
+       :line line})))
+
+(defn- stacktrace-relevant-to-instrument
+  "Takes a coll of stack trace elements (as returned by
+StackTraceElement->vec) and returns a coll of maps as per
+interpret-stack-trace-element that are relevant to a
+failure in instrument."
+  [stack-trace]
+  (let [plumbing? (fn [{:keys [var-scope]}]
+                    (contains? '#{clojure.spec.test/spec-checking-fn} var-scope))]
+    (sequence (comp ;;(map StackTraceElement->vec)
+                    (map interpret-stack-trace-element)
+                    (filter :var-scope)
+                    (drop-while plumbing?))
+      (parse-stack-trace stack-trace))))
+
+;; wish we had System.Diagnostics
+
+(defn- spec-checking-fn
+  [v f fn-spec]
+  (let [fn-spec (@#'s/maybe-spec fn-spec)
+        conform! (fn [v role spec data args]
+                   (let [conformed (s/conform spec data)]
+                     (if (= ::s/invalid conformed)
+                       (let [caller (->> Environment/StackTrace ;;(.StackTrace (Thread/currentThread))
+                                         stacktrace-relevant-to-instrument
+                                         first)
+                             ed (merge (assoc (s/explain-data* spec [role] [] [] data)
+                                         ::s/args args
+                                         ::s/failure :instrument)
+                                       (when caller
+                                         {::caller (dissoc caller :class :method)}))]
+                         (throw (ex-info
+                                  (str "Call to " v " did not conform to spec:\n"
+                                       (with-out-str (s/explain-out ed)))
+                                 ed)))
+                       conformed)))]
+    (fn
+     [& args]
+     (if *instrument-enabled*
+       (with-instrument-disabled
+         (when (:args fn-spec) (conform! v :args (:args fn-spec) args args))
+         (binding [*instrument-enabled* true]
+           (.applyTo ^clojure.lang.IFn f args)))
+       (.applyTo ^clojure.lang.IFn f args)))))
+
+(defn- no-fspec
+  [v spec]
+  (ex-info (str "Fn at " v " is not spec'ed.")
+           {:var v :spec spec ::s/failure :no-fspec}))
+
+(defonce ^:private instrumented-vars (atom {}))
+
+(defn- instrument-choose-fn
+  "Helper for instrument."
+  [f spec sym {over :gen :keys [stub replace]}]
+  (if (some #{sym} stub)
+    (-> spec (s/gen over) gen/generate)
+    (get replace sym f)))
+
+(defn- instrument-choose-spec
+  "Helper for instrument"
+  [spec sym {overrides :spec}]
+  (get overrides sym spec))
+
+(def instrument-1-log (atom []))
+
+(defn- instrument-1
+  [s opts]
+  (swap! instrument-1-log conj
+    {:s s :opts opts})
+  (when-let [v (resolve s)]
+    (when-not (-> v meta :macro)
+      (let [spec (s/get-spec v)
+            {:keys [raw wrapped]} (get @instrumented-vars v)
+            current @v
+            to-wrap (if (= wrapped current) raw current)
+            ospec (or (instrument-choose-spec spec s opts)
+                      (throw (no-fspec v spec)))
+            ofn (instrument-choose-fn to-wrap ospec s opts)
+            checked (spec-checking-fn v ofn ospec)]
+        (alter-var-root v (constantly checked))
+        (swap! instrumented-vars assoc v {:raw to-wrap :wrapped checked})
+        (->sym v)))))
+
+(defn- unstrument-1
+  [s]
+  (when-let [v (resolve s)]
+    (when-let [{:keys [raw wrapped]} (get @instrumented-vars v)]
+      (swap! instrumented-vars dissoc v)
+      (let [current @v]
+        (when (= wrapped current)
+          (alter-var-root v (constantly raw))
+          (->sym v))))))
+
+(defn- opt-syms
+  "Returns set of symbols referenced by 'instrument' opts map"
+  [opts]
+  (reduce into #{} [(:stub opts) (keys (:replace opts)) (keys (:spec opts))]))
+
+(defn- fn-spec-name?
+  [s]
+  (symbol? s))
+
+(defn instrumentable-syms
+  "Given an opts map as per instrument, returns the set of syms
+that can be instrumented."
+  ([] (instrumentable-syms nil))
+  ([opts]
+     (assert (every? ident? (keys (:gen opts))) "instrument :gen expects ident keys")
+     (reduce into #{} [(filter fn-spec-name? (keys (s/registry)))
+                       (keys (:spec opts))
+                       (:stub opts)
+                       (keys (:replace opts))])))
+
+(defn instrument
+  "Instruments the vars named by sym-or-syms, a symbol or collection
+of symbols, or all instrumentable vars if sym-or-syms is not
+specified.
+
+If a var has an :args fn-spec, sets the var's root binding to a
+fn that checks arg conformance (throwing an exception on failure)
+before delegating to the original fn.
+
+The opts map can be used to override registered specs, and/or to
+replace fn implementations entirely. Opts for symbols not included
+in sym-or-syms are ignored. This facilitates sharing a common
+options map across many different calls to instrument.
+
+The opts map may have the following keys:
+
+  :spec     a map from var-name symbols to override specs
+  :stub     a set of var-name symbols to be replaced by stubs
+  :gen      a map from spec names to generator overrides
+  :replace  a map from var-name symbols to replacement fns
+
+:spec overrides registered fn-specs with specs your provide. Use
+:spec overrides to provide specs for libraries that do not have
+them, or to constrain your own use of a fn to a subset of its
+spec'ed contract.
+
+:stub replaces a fn with a stub that checks :args, then uses the
+:ret spec to generate a return value.
+
+:gen overrides are used only for :stub generation.
+
+:replace replaces a fn with a fn that checks args conformance, then
+invokes the fn you provide, enabling arbitrary stubbing and mocking.
+
+:spec can be used in combination with :stub or :replace.
+
+Returns a collection of syms naming the vars instrumented."
+  ([] (instrument (instrumentable-syms)))
+  ([sym-or-syms] (instrument sym-or-syms nil))
+  ([sym-or-syms opts]
+     (locking instrumented-vars
+       (into
+        []
+        (comp (filter (instrumentable-syms opts))
+              (distinct)
+              (map #(instrument-1 % opts))
+              (remove nil?))
+        (collectionize sym-or-syms)))))
+
+(defn unstrument
+  "Undoes instrument on the vars named by sym-or-syms, specified
+as in instrument. With no args, unstruments all instrumented vars.
+Returns a collection of syms naming the vars unstrumented."
+  ([] (unstrument (map ->sym (keys @instrumented-vars))))
+  ([sym-or-syms]
+     (locking instrumented-vars
+       (into
+        []
+        (comp (filter symbol?)
+              (map unstrument-1)
+              (remove nil?))
+        (collectionize sym-or-syms)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; testing  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- explain-check
+  [args spec v role]
+  (ex-info
+   "Specification-based check failed"
+   (when-not (s/valid? spec v nil)
+     (assoc (s/explain-data* spec [role] [] [] v)
+       ::args args
+       ::val v
+       ::s/failure :check-failed))))
+
+(defn- check-call
+  "Returns true if call passes specs, otherwise *returns* an exception
+with explain-data + ::s/failure."
+  [f specs args]
+  (let [cargs (when (:args specs) (s/conform (:args specs) args))]
+    (if (= cargs ::s/invalid)
+      (explain-check args (:args specs) args :args)
+      (let [ret (apply f args)
+            cret (when (:ret specs) (s/conform (:ret specs) ret))]
+        (if (= cret ::s/invalid)
+          (explain-check args (:ret specs) ret :ret)
+          (if (and (:args specs) (:ret specs) (:fn specs))
+            (if (s/valid? (:fn specs) {:args cargs :ret cret})
+              true
+              (explain-check args (:fn specs) {:args cargs :ret cret} :fn))
+            true))))))
+
+(defn- quick-check
+  [f specs {gen :gen opts ::stc/opts}]
+  (let [{:keys [num-tests] :or {num-tests 1000}} opts
+        g (try (s/gen (:args specs) gen) (catch Exception t t))]
+    (if (throwable? g)
+      {:result g}
+      (let [prop (gen/for-all* [g] #(check-call f specs %))]
+        (apply gen/quick-check num-tests prop (mapcat identity opts))))))
+
+(defn- make-check-result
+  "Builds spec result map."
+  [check-sym spec test-check-ret]
+  (merge {:spec spec
+          ::stc/ret test-check-ret}
+         (when check-sym
+           {:sym check-sym})
+         (when-let [result (-> test-check-ret :result)]
+           (when-not (true? result) {:failure result}))
+         (when-let [shrunk (-> test-check-ret :shrunk)]
+           {:failure (:result shrunk)})))
+
+(defn- check-1
+  [{:keys [s f v spec]} opts]
+  (let [re-inst? (and v (seq (unstrument s)) true)
+        f (or f (when v @v))]
+    (try
+     (cond
+      (nil? f)
+      {:failure (ex-info "No fn to spec" {::s/failure :no-fn})
+       :sym s :spec spec}
+    
+      (:args spec)
+      (let [tcret (quick-check f spec opts)]
+        (make-check-result s spec tcret))
+    
+      :default
+      {:failure (ex-info "No :args spec" {::s/failure :no-args-spec})
+       :sym s :spec spec})
+     (finally
+      (when re-inst? (instrument s))))))
+
+(defn- sym->check-map
+  [s]
+  (let [v (resolve s)]
+    {:s s
+     :v v
+     :spec (when v (s/get-spec v))}))
+
+(defn- validate-check-opts
+  [opts]
+  (assert (every? ident? (keys (:gen opts))) "check :gen expects ident keys"))
+
+(defn check-fn
+  "Runs generative tests for fn f using spec and opts. See
+'check' for options and return."
+  ([f spec] (check-fn f spec nil))
+  ([f spec opts]
+     (validate-check-opts opts)
+     (check-1 {:f f :spec spec} opts)))
+
+(defn checkable-syms
+  "Given an opts map as per check, returns the set of syms that
+can be checked."
+  ([] (checkable-syms nil))
+  ([opts]
+     (validate-check-opts opts)
+     (reduce into #{} [(filter fn-spec-name? (keys (s/registry)))
+                       (keys (:spec opts))])))
+
+(defn check
+  "Run generative tests for spec conformance on vars named by
+sym-or-syms, a symbol or collection of symbols. If sym-or-syms
+is not specified, check all checkable vars.
+
+The opts map includes the following optional keys, where stc
+aliases clojure.spec.test.check: 
+
+::stc/opts  opts to flow through test.check/quick-check
+:gen        map from spec names to generator overrides
+
+The ::stc/opts include :num-tests in addition to the keys
+documented by test.check. Generator overrides are passed to
+spec/gen when generating function args.
+
+Returns a lazy sequence of check result maps with the following
+keys
+
+:spec       the spec tested
+:sym        optional symbol naming the var tested
+:failure    optional test failure
+::stc/ret   optional value returned by test.check/quick-check
+
+The value for :failure can be any exception. Exceptions thrown by
+spec itself will have an ::s/failure value in ex-data:
+
+:check-failed   at least one checked return did not conform
+:no-args-spec   no :args spec provided
+:no-fn          no fn provided
+:no-fspec       no fspec provided
+:no-gen         unable to generate :args
+:instrument     invalid args detected by instrument
+"
+  ([] (check (checkable-syms)))
+  ([sym-or-syms] (check sym-or-syms nil))
+  ([sym-or-syms opts]
+     (->> (collectionize sym-or-syms)
+          (filter (checkable-syms opts))
+          (pmap
+           #(check-1 (sym->check-map %) opts)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; check reporting  ;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defn- failure-type
+  [x]
+  (::s/failure (ex-data x)))
+
+(defn- unwrap-failure
+  [x]
+  (if (failure-type x)
+    (ex-data x)
+    x))
+
+(defn- result-type
+  "Returns the type of the check result. This can be any of the
+::s/failure keywords documented in 'check', or:
+
+  :check-passed   all checked fn returns conformed
+  :check-threw    checked fn threw an exception"
+  [ret]
+  (let [failure (:failure ret)]
+    (cond
+     (nil? failure) :check-passed
+     (failure-type failure) (failure-type failure)
+     :default :check-threw)))
+
+(defn abbrev-result
+  "Given a check result, returns an abbreviated version
+suitable for summary use."
+  [x]
+  (if (:failure x)
+    (-> (dissoc x ::stc/ret)
+        (update :spec s/describe)
+        (update :failure unwrap-failure))
+    (dissoc x :spec ::stc/ret)))
+
+(defn summarize-results
+  "Given a collection of check-results, e.g. from 'check', pretty
+prints the summary-result (default abbrev-result) of each.
+
+Returns a map with :total, the total number of results, plus a
+key with a count for each different :type of result."
+  ([check-results] (summarize-results check-results abbrev-result))
+  ([check-results summary-result]
+     (reduce
+      (fn [summary result]
+        (pp/pprint (summary-result result))
+        (-> summary
+            (update :total inc)
+            (update (result-type result) (fnil inc 0))))
+      {:total 0}
+       check-results)))
+
+
diff --git a/Clojure/Clojure.Source/clojure/stacktrace.clj b/Clojure/Clojure.Source/clojure/stacktrace.clj
index 6f4adb4a9..3fdcaa48e 100644
--- a/Clojure/Clojure.Source/clojure/stacktrace.clj
+++ b/Clojure/Clojure.Source/clojure/stacktrace.clj
@@ -11,7 +11,7 @@
 ;; by Stuart Sierra
 ;; January 6, 2009
 
-(ns ^{:doc "Print stack traces oriented towards Clojure, not Java."
+(ns ^{:doc "Print stack traces oriented towards Clojure, not Java."
        :author "Stuart Sierra"}
   clojure.stacktrace)
 
@@ -26,7 +26,7 @@
 (defn print-trace-element
   "Prints a Clojure-oriented view of one element in a stack trace."
   {:added "1.1"} 
-  [e]                   ;;; in CLR, e will be a StackFrame
+  [^System.Diagnostics.StackFrame e]                   ;;; in CLR, e will be a StackFrame
   (let [class   (if-let [t (.. e  (GetMethod) ReflectedType)] (.FullName t) "")         ;;;  (.getClassName e)
 	method      (.. e (GetMethod)  Name)]                             ;;;  (.getMethodName e)] 
     (let [match (re-matches #"^([A-Za-z0-9_.-]+)\$(\w+)__\d+$" (str class))]
@@ -52,8 +52,8 @@
        (print-throwable1 tr)
        (newline)
        (print " at ") 
-       (if-let [e (first st)]
-         (print-trace-element e)
+       (if-let [e (first st)]
+         (print-trace-element e)
          (print "[empty stack trace]"))
        (newline)
        (doseq [e (if (nil? n)
diff --git a/Clojure/Clojure.Source/clojure/test/junit.clj b/Clojure/Clojure.Source/clojure/test/junit.clj
index 412a01d5e..7b769d5b5 100644
--- a/Clojure/Clojure.Source/clojure/test/junit.clj
+++ b/Clojure/Clojure.Source/clojure/test/junit.clj
@@ -80,7 +80,7 @@
                         (reverse (map #(:name (meta %)) vars)))))
 
 (defn package-class
-  [name]
+  [^System.String name]
   (let [i (.LastIndexOf name ".")]                            ;;; lastIndexOf
     (if (< i 0)
       [nil name]
@@ -182,7 +182,7 @@
 (defmacro with-junit-output
   "Execute body with modified test-is reporting functions that write
   JUnit-compatible XML output."
-  {:added "1.1"} 
+  {:added "1.1"} 
   [& body]
   `(binding [t/report junit-report
              *var-context* (list)
diff --git a/Clojure/Clojure.Source/clojure/test/tap.clj b/Clojure/Clojure.Source/clojure/test/tap.clj
index e958c5074..545926927 100644
--- a/Clojure/Clojure.Source/clojure/test/tap.clj
+++ b/Clojure/Clojure.Source/clojure/test/tap.clj
@@ -20,25 +20,25 @@
 
 
 
-(ns ^{:doc "clojure.test extensions for the Test Anything Protocol (TAP)
-
-  TAP is a simple text-based syntax for reporting test results.  TAP
-  was originally developed for Perl, and now has implementations in
-  several languages.  For more information on TAP, see
-  http://testanything.org/ and
-  http://search.cpan.org/~petdance/TAP-1.0.0/TAP.pm
-
-  To use this library, wrap any calls to
-  clojure.test/run-tests in the with-tap-output macro,
-  like this:
-
-    (use 'clojure.test)
-    (use 'clojure.test.tap)
-
-    (with-tap-output
-     (run-tests 'my.cool.library))"
-       :author "Stuart Sierra"}
-  clojure.test.tap
+(ns ^{:doc "clojure.test extensions for the Test Anything Protocol (TAP)
+
+  TAP is a simple text-based syntax for reporting test results.  TAP
+  was originally developed for Perl, and now has implementations in
+  several languages.  For more information on TAP, see
+  http://testanything.org/ and
+  http://search.cpan.org/~petdance/TAP-1.0.0/TAP.pm
+
+  To use this library, wrap any calls to
+  clojure.test/run-tests in the with-tap-output macro,
+  like this:
+
+    (use 'clojure.test)
+    (use 'clojure.test.tap)
+
+    (with-tap-output
+     (run-tests 'my.cool.library))"
+       :author "Stuart Sierra"}
+  clojure.test.tap
   (:require [clojure.test :as t]
             [clojure.stacktrace :as stack]))
 
@@ -53,7 +53,7 @@
   string."
   {:added "1.1"} 
   [data]
-  (doseq [line (.split ^String data "\n")]
+  (doseq [line (.Split ^String data "\n")]
     (println "#" line)))
 
 (defn print-tap-pass
@@ -75,21 +75,21 @@
   (t/with-test-out
    (print-tap-diagnostic (pr-str data))))
 
-(defn print-diagnostics [data]
-  (when (seq t/*testing-contexts*)
-    (print-tap-diagnostic (t/testing-contexts-str)))
-  (when (:message data)
-    (print-tap-diagnostic (:message data)))
-  (print-tap-diagnostic (str "expected:" (pr-str (:expected data))))
-  (if (= :pass (:type data))
-    (print-tap-diagnostic (str "  actual:" (pr-str (:actual data))))
-    (do
-      (print-tap-diagnostic
-       (str "  actual:"
-        (with-out-str
-          (if (instance? Exception (:actual data))                                   ;;; Throwable
-            (stack/print-cause-trace (:actual data) t/*stack-trace-depth*)
-            (prn (:actual data)))))))))
+(defn print-diagnostics [data]
+  (when (seq t/*testing-contexts*)
+    (print-tap-diagnostic (t/testing-contexts-str)))
+  (when (:message data)
+    (print-tap-diagnostic (:message data)))
+  (print-tap-diagnostic (str "expected:" (pr-str (:expected data))))
+  (if (= :pass (:type data))
+    (print-tap-diagnostic (str "  actual:" (pr-str (:actual data))))
+    (do
+      (print-tap-diagnostic
+       (str "  actual:"
+        (with-out-str
+          (if (instance? Exception (:actual data))                                   ;;; Throwable
+            (stack/print-cause-trace (:actual data) t/*stack-trace-depth*)
+            (prn (:actual data)))))))))
 
 (defmethod tap-report :pass [data]
   (t/with-test-out
@@ -101,12 +101,12 @@
   (t/with-test-out
    (t/inc-report-counter :error)
    (print-tap-fail (t/testing-vars-str data))
-   (print-diagnostics data)))
-
-(defmethod tap-report :fail [data]
-  (t/with-test-out
-   (t/inc-report-counter :fail)
-   (print-tap-fail (t/testing-vars-str data))
+   (print-diagnostics data)))
+
+(defmethod tap-report :fail [data]
+  (t/with-test-out
+   (t/inc-report-counter :fail)
+   (print-tap-fail (t/testing-vars-str data))
    (print-diagnostics data)))
 
 (defmethod tap-report :summary [data]
diff --git a/Clojure/Clojure.Tests/Clojure.Tests.csproj b/Clojure/Clojure.Tests/Clojure.Tests.csproj
index 8b0e05b7e..6fe4a5217 100644
--- a/Clojure/Clojure.Tests/Clojure.Tests.csproj
+++ b/Clojure/Clojure.Tests/Clojure.Tests.csproj
@@ -31,7 +31,7 @@
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
-    <RestorePackages>true</RestorePackages>
+    <RestorePackages Condition="'$(RestorePackages)' == ''">true</RestorePackages>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 3.5|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
diff --git a/Clojure/Clojure/CljCompiler/Ast/AssignExpr.cs b/Clojure/Clojure/CljCompiler/Ast/AssignExpr.cs
index 89aaa4a30..9a1f9fd34 100644
--- a/Clojure/Clojure/CljCompiler/Ast/AssignExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/AssignExpr.cs
@@ -18,6 +18,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class AssignExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly AssignableExpr _target;
diff --git a/Clojure/Clojure/CljCompiler/Ast/BodyExpr.cs b/Clojure/Clojure/CljCompiler/Ast/BodyExpr.cs
index 5eaf9fc88..35a066bbb 100644
--- a/Clojure/Clojure/CljCompiler/Ast/BodyExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/BodyExpr.cs
@@ -18,6 +18,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class BodyExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _exprs;
diff --git a/Clojure/Clojure/CljCompiler/Ast/CaseExpr.cs b/Clojure/Clojure/CljCompiler/Ast/CaseExpr.cs
index 8027d0759..0fc031d3c 100644
--- a/Clojure/Clojure/CljCompiler/Ast/CaseExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/CaseExpr.cs
@@ -21,6 +21,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class CaseExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly LocalBindingExpr _expr;
diff --git a/Clojure/Clojure/CljCompiler/Ast/DefExpr.cs b/Clojure/Clojure/CljCompiler/Ast/DefExpr.cs
index 8816495eb..db3fa54d3 100644
--- a/Clojure/Clojure/CljCompiler/Ast/DefExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/DefExpr.cs
@@ -21,6 +21,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class DefExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Var _var;
diff --git a/Clojure/Clojure/CljCompiler/Ast/EmptyExpr.cs b/Clojure/Clojure/CljCompiler/Ast/EmptyExpr.cs
index 4ba13f2f6..cded002ab 100644
--- a/Clojure/Clojure/CljCompiler/Ast/EmptyExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/EmptyExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class EmptyExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly object _coll;
diff --git a/Clojure/Clojure/CljCompiler/Ast/GenContext.cs b/Clojure/Clojure/CljCompiler/Ast/GenContext.cs
index 07c6cec6e..73895011f 100644
--- a/Clojure/Clojure/CljCompiler/Ast/GenContext.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/GenContext.cs
@@ -150,18 +150,13 @@ private static GenContext CreateGenContext(string sourceName, string assyName, s
             }
 
             AssemblyName aname = new AssemblyName(assyName);
-            return new GenContext(directory, aname, extension, createDynInitHelper, sourceName);
-        }
-
-        private GenContext(string directory, AssemblyName aname, string extension, bool createDynInitHelper, string sourceName)
-        {
-            // TODO: Make this settable from a *debug* flag
-#if DEBUG
-            _isDebuggable = true;
-#else
-            _isDebuggable = false;
-#endif
-
+            return new GenContext(directory, aname, extension, createDynInitHelper, sourceName);
+        }
+
+        private GenContext(string directory, AssemblyName aname, string extension, bool createDynInitHelper, string sourceName)
+        {
+            _isDebuggable = (bool)Compiler.DebugVar.deref();
+            
             _assyGen = new AssemblyGen(aname, directory, extension, _isDebuggable);
             if ( createDynInitHelper )
                 _dynInitHelper = new DynInitHelper(_assyGen, GenerateName());
diff --git a/Clojure/Clojure/CljCompiler/Ast/IfExpr.cs b/Clojure/Clojure/CljCompiler/Ast/IfExpr.cs
index 17255b17c..e463ebd96 100644
--- a/Clojure/Clojure/CljCompiler/Ast/IfExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/IfExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class IfExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentMap _sourceSpan;
diff --git a/Clojure/Clojure/CljCompiler/Ast/InstanceOfExpr.cs b/Clojure/Clojure/CljCompiler/Ast/InstanceOfExpr.cs
index bf95ae64f..7454fac39 100644
--- a/Clojure/Clojure/CljCompiler/Ast/InstanceOfExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/InstanceOfExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public sealed class InstanceOfExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Expr _expr;
diff --git a/Clojure/Clojure/CljCompiler/Ast/InstanceZeroArityCallExpr.cs b/Clojure/Clojure/CljCompiler/Ast/InstanceZeroArityCallExpr.cs
index d7d9333ba..be17d8aad 100644
--- a/Clojure/Clojure/CljCompiler/Ast/InstanceZeroArityCallExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/InstanceZeroArityCallExpr.cs
@@ -83,7 +83,12 @@ public override bool HasClrType
 
         public override Type ClrType
         {
-            get { return HostExpr.TagToType(_tag); }
+            get
+            {
+                return _tag != null
+                ? HostExpr.TagToType(_tag)
+                : typeof(object);
+            }
         }
 
         #endregion
diff --git a/Clojure/Clojure/CljCompiler/Ast/InvokeExpr.cs b/Clojure/Clojure/CljCompiler/Ast/InvokeExpr.cs
index 56159d830..5dbd96c9d 100644
--- a/Clojure/Clojure/CljCompiler/Ast/InvokeExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/InvokeExpr.cs
@@ -21,6 +21,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class InvokeExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Expr _fexpr;
diff --git a/Clojure/Clojure/CljCompiler/Ast/KeywordInvokeExpr.cs b/Clojure/Clojure/CljCompiler/Ast/KeywordInvokeExpr.cs
index 716a62d8b..5e0c7762f 100644
--- a/Clojure/Clojure/CljCompiler/Ast/KeywordInvokeExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/KeywordInvokeExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public sealed class KeywordInvokeExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly KeywordExpr _kw;
diff --git a/Clojure/Clojure/CljCompiler/Ast/LetExpr.cs b/Clojure/Clojure/CljCompiler/Ast/LetExpr.cs
index eedd13431..2e6c6adef 100644
--- a/Clojure/Clojure/CljCompiler/Ast/LetExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/LetExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class LetExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _bindingInits;
diff --git a/Clojure/Clojure/CljCompiler/Ast/LetFnExpr.cs b/Clojure/Clojure/CljCompiler/Ast/LetFnExpr.cs
index 8d6c6e4b6..f14e1f8e9 100644
--- a/Clojure/Clojure/CljCompiler/Ast/LetFnExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/LetFnExpr.cs
@@ -21,6 +21,8 @@ namespace clojure.lang.CljCompiler.Ast
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Fn")]
     public class LetFnExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _bindingInits;
diff --git a/Clojure/Clojure/CljCompiler/Ast/LiteralExpr.cs b/Clojure/Clojure/CljCompiler/Ast/LiteralExpr.cs
index 9eb93cdb9..3a889bf0f 100644
--- a/Clojure/Clojure/CljCompiler/Ast/LiteralExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/LiteralExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public abstract class LiteralExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         public abstract object Val { get; }
 
         #region Expr Members
diff --git a/Clojure/Clojure/CljCompiler/Ast/LocalBinding.cs b/Clojure/Clojure/CljCompiler/Ast/LocalBinding.cs
index de8f298e3..7d0a1282f 100644
--- a/Clojure/Clojure/CljCompiler/Ast/LocalBinding.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/LocalBinding.cs
@@ -55,8 +55,8 @@ public sealed class LocalBinding
 
         public LocalBinding(int index, Symbol sym, Symbol tag, Expr init, Type declaredType, bool isThis, bool isArg, bool isByRef)
         {
-            if (Compiler.MaybePrimitiveType(init) != null && tag != null)
-                throw new InvalidOperationException("Can't type hint a local with a primitive initializer");
+            // if (Compiler.MaybePrimitiveType(init) != null && tag != null)
+            //     throw new InvalidOperationException("Can't type hint a local with a primitive initializer");
 
             Index = index;
             _sym = sym;
diff --git a/Clojure/Clojure/CljCompiler/Ast/LocalBindingExpr.cs b/Clojure/Clojure/CljCompiler/Ast/LocalBindingExpr.cs
index bb1c377ec..df40251b6 100644
--- a/Clojure/Clojure/CljCompiler/Ast/LocalBindingExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/LocalBindingExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class LocalBindingExpr : Expr, MaybePrimitiveExpr, AssignableExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly LocalBinding _b;
diff --git a/Clojure/Clojure/CljCompiler/Ast/MapExpr.cs b/Clojure/Clojure/CljCompiler/Ast/MapExpr.cs
index f67519ee7..ed36963fe 100644
--- a/Clojure/Clojure/CljCompiler/Ast/MapExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/MapExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class MapExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _keyvals;
diff --git a/Clojure/Clojure/CljCompiler/Ast/MetaExpr.cs b/Clojure/Clojure/CljCompiler/Ast/MetaExpr.cs
index 763da9a19..5cf3670c6 100644
--- a/Clojure/Clojure/CljCompiler/Ast/MetaExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/MetaExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class MetaExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Expr _expr;
diff --git a/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs b/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs
index 0d41a27d6..bdc2e1442 100644
--- a/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/MethodExpr.cs
@@ -199,7 +199,7 @@ private void EmitComplexCall(ObjExpr objx, CljILGen ilg)
             //       emit the args
             //       emit the call (slightly different for light compile vs full)
             //
-
+            
             //  Build the parameter list
 
             List<ParameterExpression> paramExprs = new List<ParameterExpression>(_args.Count + 1);
diff --git a/Clojure/Clojure/CljCompiler/Ast/MethodParamExpr.cs b/Clojure/Clojure/CljCompiler/Ast/MethodParamExpr.cs
index 18b9fca46..cbfa330e6 100644
--- a/Clojure/Clojure/CljCompiler/Ast/MethodParamExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/MethodParamExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public sealed class MethodParamExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Type _t;
diff --git a/Clojure/Clojure/CljCompiler/Ast/NewExpr.cs b/Clojure/Clojure/CljCompiler/Ast/NewExpr.cs
index 5a858a2e6..a09c3cadc 100644
--- a/Clojure/Clojure/CljCompiler/Ast/NewExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/NewExpr.cs
@@ -29,6 +29,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class NewExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IList<HostArg> _args;
diff --git a/Clojure/Clojure/CljCompiler/Ast/ObjExpr.cs b/Clojure/Clojure/CljCompiler/Ast/ObjExpr.cs
index 4f9f5c46c..116053de9 100644
--- a/Clojure/Clojure/CljCompiler/Ast/ObjExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/ObjExpr.cs
@@ -26,6 +26,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class ObjExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         public const string ConstPrefix = "const__";
@@ -398,17 +400,17 @@ void EmitKeywordCallsiteDefs(TypeBuilder baseTB)
             }
         }
 
-        private void DefineStaticConstructor(TypeBuilder fnTB)
+        protected virtual void DefineStaticConstructor(TypeBuilder fnTB)
         {
             ConstructorBuilder cb = fnTB.DefineConstructor(MethodAttributes.Static, CallingConventions.Standard, Type.EmptyTypes);
             EmitStaticConstructorBody(new CljILGen(cb.GetILGenerator()));
 
         }
-
-        private void EmitStaticConstructorBody(CljILGen ilg)
+        
+        protected void EmitStaticConstructorBody(CljILGen ilg)
         {
             GenContext.EmitDebugInfo(ilg, SpanMap);
-
+            
             if (Constants.count() > 0)
                 EmitConstantFieldInits(ilg);
 
@@ -420,7 +422,7 @@ private void EmitStaticConstructorBody(CljILGen ilg)
 
             ilg.Emit(OpCodes.Ret);
         }
-
+        
         private void EmitLoadNsInitForDeftype(CljILGen ilg)
         {
             string nsname = ((Symbol)RT.second(Src)).Namespace;
@@ -500,7 +502,7 @@ protected void EmitClosedOverFields(TypeBuilder tb)
                         attributes |= FieldAttributes.InitOnly;
                 }
 
-                Type type = lb.PrimitiveType ?? typeof(object);
+                Type type = (lb.HasClrType && lb.ClrType != null) ? lb.ClrType : (lb.PrimitiveType ?? typeof(object));
 
                 FieldBuilder fb = markVolatile
                     ? tb.DefineField(lb.Name, type, new Type[] { typeof(IsVolatile) }, Type.EmptyTypes, attributes)
@@ -527,7 +529,7 @@ private void EmitProtocolCallsites(TypeBuilder tb)
             }
         }
 
-        private ConstructorBuilder EmitConstructor(TypeBuilder fnTB, Type baseType)
+        protected virtual ConstructorBuilder EmitConstructor(TypeBuilder fnTB, Type baseType)
         {
             if (IsDefType)
                 return EmitConstructorForDefType(fnTB, baseType);
diff --git a/Clojure/Clojure/CljCompiler/Ast/RecurExpr.cs b/Clojure/Clojure/CljCompiler/Ast/RecurExpr.cs
index 0b0148b42..fe6ef9dc4 100644
--- a/Clojure/Clojure/CljCompiler/Ast/RecurExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/RecurExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class RecurExpr : Expr, MaybePrimitiveExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _args;
diff --git a/Clojure/Clojure/CljCompiler/Ast/SetExpr.cs b/Clojure/Clojure/CljCompiler/Ast/SetExpr.cs
index 4be7b4b3e..39fecf0e8 100644
--- a/Clojure/Clojure/CljCompiler/Ast/SetExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/SetExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class SetExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _keys;
diff --git a/Clojure/Clojure/CljCompiler/Ast/TheVarExpr.cs b/Clojure/Clojure/CljCompiler/Ast/TheVarExpr.cs
index 8bb4aa558..2875d691d 100644
--- a/Clojure/Clojure/CljCompiler/Ast/TheVarExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/TheVarExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class TheVarExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Var _var;
diff --git a/Clojure/Clojure/CljCompiler/Ast/TryExpr.cs b/Clojure/Clojure/CljCompiler/Ast/TryExpr.cs
index de59d828e..900528eae 100644
--- a/Clojure/Clojure/CljCompiler/Ast/TryExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/TryExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class TryExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Nested classes
 
         public sealed class CatchClause
diff --git a/Clojure/Clojure/CljCompiler/Ast/UnresolvedVarExpr.cs b/Clojure/Clojure/CljCompiler/Ast/UnresolvedVarExpr.cs
index d64c09a96..e3b2bb1d2 100644
--- a/Clojure/Clojure/CljCompiler/Ast/UnresolvedVarExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/UnresolvedVarExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class UnresolvedVarExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Symbol _symbol;
diff --git a/Clojure/Clojure/CljCompiler/Ast/UntypedExpr.cs b/Clojure/Clojure/CljCompiler/Ast/UntypedExpr.cs
index 0f89bdd1e..640d10e2e 100644
--- a/Clojure/Clojure/CljCompiler/Ast/UntypedExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/UntypedExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public abstract class UntypedExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Expr Members
 
         public bool HasClrType { get { return false; } }
diff --git a/Clojure/Clojure/CljCompiler/Ast/VarExpr.cs b/Clojure/Clojure/CljCompiler/Ast/VarExpr.cs
index b892a8e28..6c8d4befd 100644
--- a/Clojure/Clojure/CljCompiler/Ast/VarExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/VarExpr.cs
@@ -20,6 +20,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class VarExpr : Expr, AssignableExpr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly Var _var;
diff --git a/Clojure/Clojure/CljCompiler/Ast/VectorExpr.cs b/Clojure/Clojure/CljCompiler/Ast/VectorExpr.cs
index ae7740285..b400b9305 100644
--- a/Clojure/Clojure/CljCompiler/Ast/VectorExpr.cs
+++ b/Clojure/Clojure/CljCompiler/Ast/VectorExpr.cs
@@ -19,6 +19,8 @@ namespace clojure.lang.CljCompiler.Ast
 {
     public class VectorExpr : Expr
     {
+        public ParserContext ParsedContext { get; set; }
+        
         #region Data
 
         readonly IPersistentVector _args;
diff --git a/Clojure/Clojure/CljCompiler/Compiler.cs b/Clojure/Clojure/CljCompiler/Compiler.cs
index 861e49a12..83073f0fc 100644
--- a/Clojure/Clojure/CljCompiler/Compiler.cs
+++ b/Clojure/Clojure/CljCompiler/Compiler.cs
@@ -129,6 +129,9 @@ internal static Type FindDuplicateType(string typename)
         #region Vars
 
         //boolean
+        internal static readonly Var DebugVar = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
+                                                         Symbol.intern("*debug*"), false).setDynamic();  
+        
         internal static readonly Var CompileFilesVar = Var.intern(Namespace.findOrCreate(Symbol.intern("clojure.core")),
                                                          Symbol.intern("*compile-files*"), false).setDynamic();  
 
@@ -212,21 +215,28 @@ static void InitializeCompilerOptions()
         {
             Object compilerOptions = null;
 
+			string nixPrefix = "CLOJURE_COMPILER_";
+			string winPrefix = "clojure.compiler.";
+
             IDictionary envVars = Environment.GetEnvironmentVariables();
             foreach (DictionaryEntry de in envVars)
             {
                 string name = (string)de.Key;
                 string v = (string)de.Value;
-                if (name.StartsWith("CLOJURE_COMPILER_"))
+				if (name.StartsWith(nixPrefix))
                 {
+					// compiler options on *nix need to be of the form
+					// CLOJURE_COMPILER_DIRECT_LINKING because most shells do not
+					// support hyphens in variable names
+					string optionName = name.Substring(1 + nixPrefix.Length).Replace("_", "-").ToLower();
                     compilerOptions = RT.assoc(compilerOptions,
-                        RT.keyword(null, name.Substring(1 + name.LastIndexOf("_"))),
+                        RT.keyword(null, optionName),
                         RT.readString(v));
                 }
-                if ( name.StartsWith("clojure.compiler."))
+				if ( name.StartsWith(winPrefix))
                 {
                     compilerOptions = RT.assoc(compilerOptions,
-                        RT.keyword(null, name.Substring(1 + name.LastIndexOf("."))),
+                        RT.keyword(null, name.Substring(1 + winPrefix.Length)),
                         RT.readString(v));
                 }
 
@@ -1422,7 +1432,8 @@ public static string IsCompilingSuffix()
 
         internal static string InitClassName(string sourcePath)
         {
-            return "__Init__$" + sourcePath.Replace(".", "/");
+			// munge slashes to $ to avoid mono lookup bug -nasser
+			return "__Init__$" + sourcePath.Replace(".", "/").Replace("/", "$");
         }
         
         public static void PushNS()
@@ -1635,20 +1646,7 @@ internal static void LoadAssembly(byte[] assyData, string relativePath)
 
         private static Type GetTypeFromAssy(Assembly assy, string typeName)
         {
-            if (RT.IsRunningOnMono)
-            {
-                // I have no idea why Mono can't find our initializer types using Assembly.GetType(string).
-                // This is roll-your-own.
-                Type[] types = assy.GetExportedTypes();
-                foreach (Type t in types)
-                {
-                    if (t.Name.Equals(typeName))
-                        return t;
-                }
-                return null;
-            }
-            else
-                return assy.GetType(typeName);
+            return assy.GetType(typeName);
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes")]
@@ -1703,7 +1701,8 @@ internal static bool TryLoadInitType(string relativePath)
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "load")]
         public static object loadFile(string fileName)
-        {
            FileInfo finfo = new FileInfo(fileName);
+        {
+            FileInfo finfo = new FileInfo(fileName);
             if (!finfo.Exists)
                 throw new FileNotFoundException("Cannot find file to load", fileName);
 
diff --git a/Clojure/Clojure/Clojure.csproj b/Clojure/Clojure/Clojure.csproj
index 2468f250e..97c20fdd7 100644
--- a/Clojure/Clojure/Clojure.csproj
+++ b/Clojure/Clojure/Clojure.csproj
@@ -32,7 +32,7 @@
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
-    <RestorePackages>true</RestorePackages>
+    <RestorePackages Condition="'$(RestorePackages)' == ''">true</RestorePackages>
     <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 3.5|AnyCPU' ">
diff --git a/Clojure/Clojure/Lib/MultiFn.cs b/Clojure/Clojure/Lib/MultiFn.cs
index ec8881973..d65c34505 100644
--- a/Clojure/Clojure/Lib/MultiFn.cs
+++ b/Clojure/Clojure/Lib/MultiFn.cs
@@ -83,7 +83,7 @@ public IPersistentMap PreferTable
         /// </summary>
         volatile object _cachedHierarchy;
 
-        ReaderWriterLockSlim _rw;
+        ReaderWriterLock _rw;
         bool _disposed = false;
 
         //static readonly Var _assoc = RT.var("clojure.core", "assoc");
@@ -114,7 +114,7 @@ public MultiFn(string name, IFn dispatchFn, object defaultDispatchVal, IRef hier
             _preferTable = PersistentHashMap.EMPTY;
             _hierarchy = hierarchy;
             _cachedHierarchy = null;
-            _rw = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+            _rw = new ReaderWriterLock();
         }
 
         #endregion
@@ -130,7 +130,7 @@ public MultiFn(string name, IFn dispatchFn, object defaultDispatchVal, IRef hier
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "add")]
         public MultiFn addMethod(object dispatchVal, IFn method)
         {
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             try
             {
                 _methodTable = MethodTable.assoc(dispatchVal, method);
@@ -139,7 +139,7 @@ public MultiFn addMethod(object dispatchVal, IFn method)
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
         }
 
@@ -152,7 +152,7 @@ public MultiFn addMethod(object dispatchVal, IFn method)
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "remove")]
         public MultiFn removeMethod(object dispatchVal)
         {
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             try
             {
                 _methodTable = MethodTable.without(dispatchVal);
@@ -161,7 +161,7 @@ public MultiFn removeMethod(object dispatchVal)
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
         }
 
@@ -174,7 +174,7 @@ public MultiFn removeMethod(object dispatchVal)
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "prefer")]
         public MultiFn preferMethod(object dispatchValX, object dispatchValY)
         {
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             try
             {
                 if (Prefers(dispatchValY, dispatchValX))
@@ -187,7 +187,7 @@ public MultiFn preferMethod(object dispatchValX, object dispatchValY)
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
         }
 
@@ -244,7 +244,7 @@ private bool Dominates(object x, object y)
         /// <returns></returns>
         private IPersistentMap ResetCache()
         {
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             try
             {
                 _methodCache = MethodTable;
@@ -253,7 +253,7 @@ private IPersistentMap ResetCache()
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
         }
 
@@ -291,7 +291,7 @@ private IFn GetFn(object dispatchVal)
         /// <returns>The mest method.</returns>
         private IFn FindAndCacheBestMethod(object dispatchVal)
         {
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             object bestValue;
             IPersistentMap mt = _methodTable;
             IPersistentMap pt = _preferTable;
@@ -322,11 +322,11 @@ private IFn FindAndCacheBestMethod(object dispatchVal)
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
 
             // ensure basis has stayed stable throughout, else redo
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             try
             {
                 if (mt == _methodTable
@@ -346,7 +346,7 @@ private IFn FindAndCacheBestMethod(object dispatchVal)
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
         }
 
@@ -378,7 +378,7 @@ public IPersistentMap getPreferTable()
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "reset")]
         public MultiFn reset()
         {
-            _rw.EnterWriteLock();
+            _rw.AcquireWriterLock(-1);
             try
             {
                 _methodTable = _methodCache = _preferTable = PersistentHashMap.EMPTY;
@@ -387,7 +387,7 @@ public MultiFn reset()
             }
             finally
             {
-                _rw.ExitWriteLock();
+                _rw.ReleaseWriterLock();
             }
         }
 
@@ -788,11 +788,6 @@ private void Dispose(bool disposing)
         {
             if (!_disposed)
             {
-                if (disposing)
-                {
-                    ((IDisposable)_rw).Dispose();
-                }
-
                 _disposed = true;
             }
         }
diff --git a/Clojure/Clojure/Lib/Numbers.cs b/Clojure/Clojure/Lib/Numbers.cs
index 5868a4b39..27d47418a 100644
--- a/Clojure/Clojure/Lib/Numbers.cs
+++ b/Clojure/Clojure/Lib/Numbers.cs
@@ -567,19 +567,19 @@ public static int unsignedShiftRightInt(int x, int n)
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly")]
-        static long unsignedShiftRight(Object x, Object y)
+        public static long unsignedShiftRight(object x, object y)
         {
             return unsignedShiftRight(bitOpsCast(x), bitOpsCast(y));
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly")]
-        public static long unsignedShiftRight(Object x, long y)
+        public static long unsignedShiftRight(object x, long y)
         {
             return unsignedShiftRight(bitOpsCast(x), y);
         }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly")]
-        public static long unsignedShiftRight(long x, Object y)
+        public static long unsignedShiftRight(long x, object y)
         {
             return unsignedShiftRight(x, bitOpsCast(y));
         }
@@ -2650,6 +2650,22 @@ public static long xor(long x, long y)
 
         #endregion
 
+        #region not
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "and")]
+        public static long not(object x)
+        {
+            return not(bitOpsCast(x));
+        }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "and")]
+        public static long not(long x)
+        {
+            return ~x;
+        }
+        
+        #endregion
+        
         #region andNot
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "and")]
diff --git a/Clojure/Clojure/Lib/RT.cs b/Clojure/Clojure/Lib/RT.cs
index d1b97b606..8fc2eef67 100644
--- a/Clojure/Clojure/Lib/RT.cs
+++ b/Clojure/Clojure/Lib/RT.cs
@@ -414,6 +414,9 @@ public static readonly Var AllowSymbolEscapeVar
         #endregion
 
         #region Vars (miscellaneous)
+        
+        public static readonly Var RequireVar
+            = Var.intern(ClojureNamespace, Symbol.intern("require"));
 
         public static readonly Var AllowUnresolvedVarsVar
             //= Var.intern(CLOJURE_NS, Symbol.intern("*allow-unresolved-vars*"), RT.F);
@@ -600,11 +603,11 @@ static RT()
 
         static void DoInit()
         {
-            //Stopwatch sw = new Stopwatch();
-            //sw.Start();
+            // Stopwatch sw = new Stopwatch();
+            // sw.Start();
             load("clojure/core");
-            //sw.Stop();
-            //Console.WriteLine("Initial clojure/core load: {0} milliseconds.", sw.ElapsedMilliseconds);
+            // sw.Stop();
+            // Console.WriteLine("Initial clojure/core load: {0} milliseconds.", sw.ElapsedMilliseconds);
 
             PostBootstrapInit();
         }
@@ -2922,53 +2925,6 @@ public static Type classForName(string p)
                         return t1;
             }
 
-            // slow path, will succeed for display names (returned by Type.Name)
-            // e.g. "Transform"
-            foreach (Assembly assy1 in assys)
-            {
-                Type t1 = assy1.GetType(p, false);
-
-                if (IsRunningOnMono)
-                {
-                    // I do not know why Assembly.GetType fails to find types in our assemblies in Mono
-                    if (t1 == null)
-                    {
-#if CLR2
-					if (!(assy1 is AssemblyBuilder))
-#else
-                        if (!assy1.IsDynamic)
-#endif
-                        {
-                            try
-                            {
-
-                                foreach (Type tt in assy1.GetTypes())
-                                {
-                                    if (tt.Name.Equals(p))
-                                    {
-                                        t1 = tt;
-                                        break;
-                                    }
-                                }
-                            }
-                            catch (System.Reflection.ReflectionTypeLoadException)
-                            {
-                            }
-                        }
-                    }
-                }
-
-                if (t1 != null && !candidateTypes.Contains(t1))
-                    candidateTypes.Add(t1);
-            }
-
-            if (candidateTypes.Count == 0)
-                t = null;
-            else if (candidateTypes.Count == 1)
-                t = candidateTypes[0];
-            else // multiple, ambiguous
-                t = null;
-
             if (t == null && p.IndexOfAny(_triggerTypeChars) != -1)
                 t = ClrTypeSpec.GetTypeFromName(p);
 
@@ -3398,9 +3354,15 @@ public static void load(String relativePath)
             load(relativePath, true);
         }
 
+        private static int loadNesting = -1;
+
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly")]
         public static void load(String relativePath, Boolean failIfNotFound)
         {
+            ++loadNesting;
+            Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "--> RT.load({0})", relativePath);
+            Stopwatch sw = new Stopwatch();
+            sw.Start();
             string cljname = relativePath + ".clj";
             string assemblyname = relativePath.Replace('/', '.') + ".clj.dll";
 
@@ -3434,19 +3396,30 @@ public static void load(String relativePath, Boolean failIfNotFound)
                     finally
                     {
                         Var.popThreadBindings();
+                        sw.Stop();
+                        Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "<-- RT.load({0}) LoadAssembly - {1} milliseconds.", relativePath, sw.ElapsedMilliseconds);
+                        --loadNesting;
                     }
                 }
 
                 if (cljInfo != null)
                 {
-                    if (booleanCast(Compiler.CompileFilesVar.deref()))
+                    if (booleanCast(Compiler.CompileFilesVar.deref())) {
                         Compile(cljInfo, cljname);
-                    else
+                        sw.Stop();
+                        Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "<-- RT.load({0} Compile - {1} milliseconds.", relativePath, sw.ElapsedMilliseconds);
+                    } else {
                         LoadScript(cljInfo, cljname);
+                        sw.Stop();
+                        Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "<-- RT.load({0} LoadScript - {1} milliseconds.", relativePath, sw.ElapsedMilliseconds);
+                    }
+                    --loadNesting;
                     return;
                 }
             }
 
+            var swit = new Stopwatch();
+            swit.Start();
             try
             {
                 Var.pushThreadBindings(RT.map(CurrentNSVar, CurrentNSVar.deref(),
@@ -3458,17 +3431,29 @@ public static void load(String relativePath, Boolean failIfNotFound)
             finally
             {
                 Var.popThreadBindings();
+                swit.Stop();
+                Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "    RT.load({0} TryLoadInitType - {1} milliseconds.", relativePath, swit.ElapsedMilliseconds);
             }
 
 
+            var swer = new Stopwatch();
+            swer.Start();
             bool loaded = TryLoadFromEmbeddedResource(relativePath, assemblyname);
+            Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "    RT.load({0} TryLoadFromEmbeddedResource - {1} milliseconds.", relativePath, swer.ElapsedMilliseconds);
 
 
-            if (!loaded && failIfNotFound)
+            if (!loaded && failIfNotFound) {
+                --loadNesting;
+                sw.Stop();
+                Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "<-- RT.load({0} ERROR - {1} milliseconds.", relativePath, sw.ElapsedMilliseconds);
                 throw new FileNotFoundException(String.Format("Could not locate {0} or {1} on load path.{2}", 
                     assemblyname, 
                     cljname,
                     relativePath.Contains("_") ? " Please check that namespaces with dashes use underscores in the Clojure file name." : ""));
+            }
+            sw.Stop();
+            Console.WriteLine(string.Concat(Enumerable.Repeat("  ", loadNesting).ToArray()) + "<-- RT.load({0} - {1} milliseconds.", relativePath, sw.ElapsedMilliseconds);
+            --loadNesting;
         }
 
         private static bool TryLoadFromEmbeddedResource(string relativePath, string assemblyname)
@@ -3512,12 +3497,12 @@ private static void MaybeLoadCljScript(string cljname)
             LoadCljScript(cljname, false);
         }
 
-        static void LoadCljScript(string cljname)
+        public static void LoadCljScript(string cljname)
         {
             LoadCljScript(cljname, true);
         }
 
-        static void LoadCljScript(string cljname, bool failIfNotFound)
+        public static void LoadCljScript(string cljname, bool failIfNotFound)
         {
             FileInfo cljInfo = FindFile(cljname);
             if (cljInfo != null)
@@ -3564,8 +3549,8 @@ public static IEnumerable<string> GetFindFilePaths()
 
         static IEnumerable<string> GetFindFilePathsRaw()
         {
-            yield return System.AppDomain.CurrentDomain.BaseDirectory;
-            yield return Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, "bin");
+            yield return System.Environment.CurrentDirectory;
+            yield return Path.Combine(System.Environment.CurrentDirectory, "bin");
             yield return Directory.GetCurrentDirectory();
             yield return Path.GetDirectoryName(typeof(RT).Assembly.Location);
 
diff --git a/Clojure/Clojure/Lib/Ref.cs b/Clojure/Clojure/Lib/Ref.cs
index 20c4f5239..5cc0f200b 100644
--- a/Clojure/Clojure/Lib/Ref.cs
+++ b/Clojure/Clojure/Lib/Ref.cs
@@ -96,7 +96,7 @@ public TVal Next
 
             /// <summary>
             /// Construct a TVal, linked to a previous TVal.
-            /// </summary>
+            /// </summary>
             public TVal(object val, long point, TVal prior)
             {
                 _val = val;
@@ -109,7 +109,7 @@ public TVal(object val, long point, TVal prior)
 
             /// <summary>
             /// Construct a TVal, linked to itself.
-            /// </summary>
+            /// </summary>
             public TVal(object val, long point)
             {
                 _val = val;
@@ -126,7 +126,7 @@ public TVal(object val, long point)
             /// Set the value/point.
             /// </summary>
             /// <param name="val"></param>
-            /// <param name="point"></param>
+            /// <param name="point"></param>
             public void SetValue(object val, long point)
             {
                 _val = val;
@@ -141,19 +141,19 @@ public void SetValue(object val, long point)
         #region Data
 
         /// <summary>
-        /// Values at points in time for this reference.
+        /// Values at points in time for this reference.
         /// </summary>
         TVal _tvals;
 
         /// <summary>
-        /// Values at points in time for this reference.
-        /// </summary>
-        internal TVal TVals
-        {
-            get { return _tvals; }
-        }
-
-        /// <summary>
+        /// Values at points in time for this reference.
+        /// </summary>
+        internal TVal TVals
+        {
+            get { return _tvals; }
+        }
+
+        /// <summary>
         /// Number of faults for the reference.
         /// </summary>
         readonly AtomicInteger _faults;
@@ -161,7 +161,7 @@ internal TVal TVals
         /// <summary>
         /// Reader/writer lock for the reference.
         /// </summary>
-        readonly ReaderWriterLockSlim _lock;
+        readonly ReaderWriterLock _lock;
 
         /// <summary>
         /// Info on the transaction locking this ref.
@@ -196,8 +196,8 @@ public int MinHistory
         {
             get { return _minHistory; }
             set { _minHistory = value; }
-        }
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "set")]
+        }
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "set")]
         public Ref setMinHistory(int minHistory)
         {
             _minHistory = minHistory;
@@ -210,8 +210,8 @@ public int MaxHistory
         {
             get { return _maxHistory; }
             set { _maxHistory = value; }
-        }
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "set")]
+        }
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "set")]
         public Ref setMaxHistory(int maxHistory)
         {
             _maxHistory = maxHistory;
@@ -222,8 +222,8 @@ public Ref setMaxHistory(int maxHistory)
         /// <summary>
         /// Used to generate unique ids.
         /// </summary>
-        static readonly AtomicLong _ids = new AtomicLong();
-
+        static readonly AtomicLong _ids = new AtomicLong();
+
         bool _disposed = false;
 
         #endregion
@@ -250,7 +250,7 @@ public Ref(object initval, IPersistentMap meta)
         {
             _id = _ids.getAndIncrement();
             _faults = new AtomicInteger();
-            _lock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
+            _lock = new ReaderWriterLock();
             _tvals = new TVal(initval, 0);
         }
 
@@ -291,9 +291,9 @@ public Ref(object initval, IPersistentMap meta)
 
         #endregion
 
-        #region History counts
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "get")]
+        #region History counts
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "get")]
         public int getHistoryCount()
         {
             try
@@ -337,21 +337,21 @@ public override object deref()
                 //Console.WriteLine("Thr {0}, {1}: No-trans get => {2}", Thread.CurrentThread.ManagedThreadId,DebugStr(), ret);
                 return ret;
             }
-            return t.DoGet(this);
+            return t.DoGet(this);
         }
 
         object currentVal()
         {
             try
             {
-                _lock.EnterReadLock();
+                _lock.AcquireReaderLock(-1);
                 if (_tvals != null)
                     return _tvals.Val;
                 throw new InvalidOperationException(String.Format("{0} is unbound.", ToString()));
             }
             finally
             {
-                _lock.ExitReadLock();
+                _lock.ReleaseReaderLock();
             }
         }
 
@@ -364,7 +364,7 @@ object currentVal()
         /// </summary>
         internal void EnterReadLock()
         {
-            _lock.EnterReadLock();
+            _lock.AcquireReaderLock(-1);
         }
 
         /// <summary>
@@ -372,7 +372,7 @@ internal void EnterReadLock()
         /// </summary>
         internal void ExitReadLock()
         {
-            _lock.ExitReadLock();
+            _lock.ReleaseReaderLock();
         }
 
         /// <summary>
@@ -380,7 +380,7 @@ internal void ExitReadLock()
         /// </summary>
         internal void EnterWriteLock()
         {
-            _lock.EnterWriteLock();
+            _lock.AcquireWriterLock(-1);
         }
 
 
@@ -389,7 +389,13 @@ internal void EnterWriteLock()
         /// </summary>
         internal bool TryEnterWriteLock(int msecTimeout)
         {
-            return _lock.TryEnterWriteLock(msecTimeout);
+            try {
+                _lock.AcquireWriterLock(msecTimeout);
+                return true;
+                
+            } catch(ApplicationException) {
+                return false;
+            }
         }
 
         /// <summary>
@@ -397,7 +403,7 @@ internal bool TryEnterWriteLock(int msecTimeout)
         /// </summary>
         internal void ExitWriteLock()
         {
-            _lock.ExitWriteLock();
+            _lock.ReleaseWriterLock();
         }
 
         /// <summary>
@@ -457,8 +463,8 @@ internal void SetValue(object val, long commitPoint)
         /// Set the value (must be in a transaction).
         /// </summary>
         /// <param name="val">The new value.</param>
-        /// <returns>The new value.</returns>
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "set")]
+        /// <returns>The new value.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "set")]
         public object set(object val)
         {
             return LockingTransaction.GetEx().DoSet(this, val);
@@ -469,8 +475,8 @@ public object set(object val)
         /// </summary>
         /// <param name="fn">The function to apply to the current state and additional arguments.</param>
         /// <param name="args">Additional arguments.</param>
-        /// <returns>The computed value.</returns>
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "commute")]
+        /// <returns>The computed value.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "commute")]
         public object commute(IFn fn, ISeq args)
         {
             return LockingTransaction.GetEx().DoCommute(this, fn, args);
@@ -481,18 +487,18 @@ public object commute(IFn fn, ISeq args)
         /// </summary>
         /// <param name="fn">The function to apply to the current state and additional arguments.</param>
         /// <param name="args">Additional arguments.</param>
-        /// <returns>The computed value.</returns>
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "alter")]
+        /// <returns>The computed value.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "alter")]
         public object alter(IFn fn, ISeq args)
         {
             LockingTransaction t = LockingTransaction.GetEx();
-            return t.DoSet(this, fn.applyTo(RT.cons(t.DoGet(this), args)));
+            return t.DoSet(this, fn.applyTo(RT.cons(t.DoGet(this), args)));
         }
 
         /// <summary>
         /// Touch the reference.  (Add to the tracking list in the current transaction.)
-        /// </summary>
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "touch")]
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "touch")]
         public void touch()
         {
             LockingTransaction.GetEx().DoEnsure(this);
@@ -500,10 +506,10 @@ public void touch()
 
         #endregion
 
-        #region IFn Members
-
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "fn")]
+        #region IFn Members
+
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "fn")]
         public IFn fn()
         {
             return (IFn)deref();
@@ -669,92 +675,86 @@ public int CompareTo(Ref other)
             return _id.CompareTo(other._id);
         }
 
-        #endregion
-
-        #region object overrides
-
-        public override bool Equals(object obj)
-        {
-            if (ReferenceEquals(this, obj))
-                return true;
-
-            Ref r = obj as Ref;
-            if (ReferenceEquals(r,null))
-                return false;
-
-            return _id == r._id;
-        }
-
-        public override int GetHashCode()
-        {
-            return _id.GetHashCode();
-        }
-        #endregion
-
-        #region operator overrides
-
-        public static bool operator ==(Ref x, Ref y)
-        {
-            if (ReferenceEquals(x, y))
-                return true;
-
-            if (ReferenceEquals(x,null))
-                return false;
-
-            return x.CompareTo(y) == 0;
-        }
-
-        public static bool operator !=(Ref x, Ref y)
-        {
-            return !(x == y);
-        }
-
-        public static bool operator <(Ref x, Ref y)
-        {
-            if (ReferenceEquals(x, y))
-                return false;
-
-            if ( ReferenceEquals(x,null) )
-                throw new ArgumentException("Cannot compare null","x");
-
-            return x.CompareTo(y) < 0;
-        }
-
-        public static bool operator >(Ref x, Ref y)
-        {
-            if (ReferenceEquals(x, y))
-                return false;
-
-            if ( ReferenceEquals(x,null) )
-                throw new ArgumentException("Cannot compare null","x");
-
-            return x.CompareTo(y) > 0;
-        }
-
-        #endregion
-
-        #region IDisposable
-
-        public void Dispose()
-        {
-            Dispose(true);
-            GC.SuppressFinalize(this);
-        }
-
-        private void Dispose(bool disposing)
-        {
-            if (!_disposed)
-            {
-                if (disposing)
-                {
-                    if ( _lock != null )
-                        _lock.Dispose();
-                }
-
-                _disposed = true;
-            }
-        }
-
-        #endregion
+        #endregion
+
+        #region object overrides
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(this, obj))
+                return true;
+
+            Ref r = obj as Ref;
+            if (ReferenceEquals(r,null))
+                return false;
+
+            return _id == r._id;
+        }
+
+        public override int GetHashCode()
+        {
+            return _id.GetHashCode();
+        }
+        #endregion
+
+        #region operator overrides
+
+        public static bool operator ==(Ref x, Ref y)
+        {
+            if (ReferenceEquals(x, y))
+                return true;
+
+            if (ReferenceEquals(x,null))
+                return false;
+
+            return x.CompareTo(y) == 0;
+        }
+
+        public static bool operator !=(Ref x, Ref y)
+        {
+            return !(x == y);
+        }
+
+        public static bool operator <(Ref x, Ref y)
+        {
+            if (ReferenceEquals(x, y))
+                return false;
+
+            if ( ReferenceEquals(x,null) )
+                throw new ArgumentException("Cannot compare null","x");
+
+            return x.CompareTo(y) < 0;
+        }
+
+        public static bool operator >(Ref x, Ref y)
+        {
+            if (ReferenceEquals(x, y))
+                return false;
+
+            if ( ReferenceEquals(x,null) )
+                throw new ArgumentException("Cannot compare null","x");
+
+            return x.CompareTo(y) > 0;
+        }
+
+        #endregion
+
+        #region IDisposable
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                _disposed = true;
+            }
+        }
+
+        #endregion
     }
 }
diff --git a/Clojure/Clojure/Runtime/Reflector.cs b/Clojure/Clojure/Runtime/Reflector.cs
index cfa3d83e4..0b0c70f55 100644
--- a/Clojure/Clojure/Runtime/Reflector.cs
+++ b/Clojure/Clojure/Runtime/Reflector.cs
@@ -177,6 +177,13 @@ public static MethodInfo GetMatchingMethod(IPersistentMap spanMap, Expr target,
                 method = GetMatchingMethodAux(targetType, args, methods, methodName, false);
                 hasMethods = methods.Count > 0;
             }
+            else
+            {
+                Type targetType = typeof(object);
+                IList<MethodBase> methods = GetMethods(targetType, methodName, typeArgs, args.Count, false);
+                method = GetMatchingMethodAux(targetType, args, methods, methodName, false);
+                hasMethods = methods.Count > 0;
+            }
 
             MaybeReflectionWarn(spanMap, (target.HasClrType ? target.ClrType : null), false, hasMethods, method, methodName, args);
             return (MethodInfo)method;
@@ -286,7 +293,7 @@ private static MethodBase GetMatchingMethodAux(Type targetType, IList<HostArg> a
             foreach (HostArg ha in args)
             {
                 Expr e = ha.ArgExpr;
-                Type argType = e.HasClrType ? (e.ClrType ?? typeof(object)) : typeof(Object);
+                Type argType = e.HasClrType ? (e.ClrType ?? typeof(object)) : typeof(object);
 
                 Type t;
 
diff --git a/Clojure/Csharp.Tests/Csharp.Tests.csproj b/Clojure/Csharp.Tests/Csharp.Tests.csproj
index 197fb5592..67c799d24 100644
--- a/Clojure/Csharp.Tests/Csharp.Tests.csproj
+++ b/Clojure/Csharp.Tests/Csharp.Tests.csproj
@@ -12,7 +12,7 @@
     <AssemblyName>Csharp.Tests</AssemblyName>
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
-    <RestorePackages>true</RestorePackages>
+    <RestorePackages Condition="'$(RestorePackages)' == ''">true</RestorePackages>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.0|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -153,11 +153,11 @@
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
   -->
 </Project>
\ No newline at end of file
diff --git a/Clojure/DlrConsole/DlrConsole.csproj b/Clojure/DlrConsole/DlrConsole.csproj
index fb1610b54..fb6173656 100644
--- a/Clojure/DlrConsole/DlrConsole.csproj
+++ b/Clojure/DlrConsole/DlrConsole.csproj
@@ -15,7 +15,7 @@
     </TargetFrameworkProfile>
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
-    <RestorePackages>true</RestorePackages>
+    <RestorePackages Condition="'$(RestorePackages)' == ''">true</RestorePackages>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug 4.0|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -98,11 +98,11 @@
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
   -->
 </Project>
\ No newline at end of file
diff --git a/Clojure/build.proj b/Clojure/build.proj
index 29cef78b6..b5fbcc328 100644
--- a/Clojure/build.proj
+++ b/Clojure/build.proj
@@ -36,7 +36,7 @@
   
   <Target Name="Build">
     <MSBuild Projects="ClojureCLR.sln"
-             Properties="Runtime=$(Runtime);PlatformSym=$(PlatformSym);DirectLinking=$(DirectLinking)"/>
+             Properties="RestorePackages=$(RestorePackages);Runtime=$(Runtime);PlatformSym=$(PlatformSym);DirectLinking=$(DirectLinking)"/>
   </Target>
   
   <Target Name="CompileTest" DependsOnTargets="Build">
diff --git a/unity-build.sh b/unity-build.sh
new file mode 100755
index 000000000..8272c6304
--- /dev/null
+++ b/unity-build.sh
@@ -0,0 +1,2 @@
+rm -fr dist bin
+RestorePackages=false xbuild Clojure/build.proj /target:"Dist" /p:Runtime="Mono" /p:Configuration="Release 3.5" /p:Platform="Any CPU"
diff --git a/unity-install.sh b/unity-install.sh
new file mode 100755
index 000000000..21f150982
--- /dev/null
+++ b/unity-install.sh
@@ -0,0 +1,10 @@
+echo "copy infrastructure"
+cp bin/3.5/Release/{Clojure,Microsoft.{Dynamic,Scripting,Scripting.{Core,Metadata}}}.dll $1/Infrastructure
+
+echo "copy clojure source"
+rm -fr $1/Source/clojure
+cp -r bin/3.5/Release/clojure $1/Source
+rm -fr $1/Source/clojure/*samples*
+rm -fr $1/Source/clojure/*run_test*
+rm -fr $1/Source/clojure/*dm-test*
+rm -fr $1/Source/clojure/*test_*