From 6d56982abe6574aad709dc85d670389756c0662f Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 09:13:14 -0400
Subject: [PATCH 01/14] Auto-resolve ::keywords; honor clojure.edn reader opts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The reader dropped the namespace on ::kw (read ::foo as :foo), so auto-resolved
keywords never matched their qualified form — code that round-trips them (spec
keys, aero's :aero.core/* expansion keys) silently broke. Resolve ::name against
the current ns and ::alias/name through the alias table, as Clojure does. The
runtime loader reads form-by-form with the ns set after the ns form; the
cross-compile reads all forms up front, so ei-emit-ns*/ei-emit-ns-records set the
ns before reading.

clojure.edn/read over a reader discarded its opts map — :readers/:default/:eof
were ignored, so a custom :default never saw the tag. Route the reader arity
through read-string so opts apply, and pass the tag to :default as a symbol (not
the internal :#name keyword), matching Clojure.

Seed re-minted (the ::halt transducer key in clojure.core now reads as
:clojure.core/halt). Corpus gains ::-keyword rows; the unit case that asserted the
old ns-dropping behavior now asserts the qualified result.
---
 host/chez/emit-image.ss   |  5 +++++
 host/chez/post-prelude.ss |  8 +++++---
 host/chez/reader.ss       | 18 +++++++++++++-----
 host/chez/seed/prelude.ss |  4 ++--
 stdlib/clojure/edn.clj    |  3 ++-
 test/chez/corpus.edn      |  3 +++
 test/chez/unit.edn        |  2 +-
 7 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/host/chez/emit-image.ss b/host/chez/emit-image.ss
index 7bc6ea0..adb6329 100644
--- a/host/chez/emit-image.ss
+++ b/host/chez/emit-image.ss
@@ -59,6 +59,10 @@
 ;; that fails to emit) and `jolt build` (bld-emit-ns: optimize? #t, guard? #f —
 ;; strict, a failing form errors the build).
 (define (ei-emit-ns* ns-name src optimize? guard?)
+  ;; set the ns before reading so ::kw auto-resolves against this ns (the runtime
+  ;; loader reads form-by-form after the ns form sets it; the cross-compile reads
+  ;; all forms up front, so set it here).
+  (set-chez-ns! ns-name)
   (let loop ((forms (ei-read-all src)) (acc '()))
     (if (null? forms)
         (reverse acc)
@@ -92,6 +96,7 @@
 ;; record whose refs are roots. A macro is prunable — its expander isn't called at
 ;; runtime in an AOT build.
 (define (ei-emit-ns-records ns-name src)
+  (set-chez-ns! ns-name)               ; ::kw resolves against this ns (see ei-emit-ns*)
   (let loop ((forms (ei-read-all src)) (acc '()))
     (if (null? forms)
         (reverse acc)
diff --git a/host/chez/post-prelude.ss b/host/chez/post-prelude.ss
index 7a47e03..9a6ee38 100644
--- a/host/chez/post-prelude.ss
+++ b/host/chez/post-prelude.ss
@@ -64,12 +64,14 @@
         ;; realized? reads :jolt/type and throws on a jolt-lazyseq record.
         ((jolt-lazyseq? x) (jolt-lazyseq-realized? x))
         (else (jolt-invoke overlay-realized? x))))))
-;; clojure.edn/read over a reader: the overlay edn.clj drain-reader reads
-;; :jolt/type; the native version (io.ss) drains the jhost reader instead.
+;; clojure.edn/read over a reader: drain the jhost reader, then read through the
+;; overlay read-string so the opts map (:readers/:default/:eof) is honored.
 (def-var! "clojure.edn" "read"
   (case-lambda
     ((reader) (chez-edn-read reader))
-    ((opts reader) (chez-edn-read reader))))
+    ((opts reader)
+     (jolt-invoke (var-deref "clojure.edn" "read-string") opts
+                  (if (reader-jhost? reader) (drain-reader reader) (jolt-str-render-one reader))))))
 ;; line-seq: a jhost reader (io/reader result) -> drain+split; a map-reader (the
 ;; overlay's :read-line-fn model, e.g. with-in-str) -> the overlay version.
 (let ((overlay-line-seq (var-deref "clojure.core" "line-seq")))
diff --git a/host/chez/reader.ss b/host/chez/reader.ss
index 2e0966c..eadd4c9 100644
--- a/host/chez/reader.ss
+++ b/host/chez/reader.ss
@@ -451,11 +451,19 @@
 
 ;; --- keyword ----------------------------------------------------------------
 (define (rdr-read-keyword s i end)       ; i points just past the leading ':'
-  ;; ::kw auto-resolves; drop the ns, so skip a second ':'
-  (let ((i (if (and (< i end) (char=? (string-ref s i) #\:)) (+ i 1) i)))
-    (let-values (((tok j) (rdr-read-token s i end)))
-      (let-values (((ns name) (rdr-sym-parts tok)))
-        (values (keyword ns name) j)))))
+  ;; ::kw is auto-resolved against the current ns: ::name -> current-ns/name,
+  ;; ::alias/name -> the alias's target ns / name (Clojure's reader semantics).
+  (let ((auto? (and (< i end) (char=? (string-ref s i) #\:))))
+    (let ((i (if auto? (+ i 1) i)))
+      (let-values (((tok j) (rdr-read-token s i end)))
+        (let-values (((ns name) (rdr-sym-parts tok)))
+          (if auto?
+              (let* ((cur (chez-current-ns))
+                     (rns (if (string? ns)
+                              (let ((a (chez-resolve-alias cur ns))) (if a a ns))
+                              cur)))
+                (values (keyword rns name) j))
+              (values (keyword ns name) j)))))))
 
 ;; --- the main dispatch ------------------------------------------------------
 ;; Returns (values form j). form is rdr-eof at end-of-input or at an unconsumed
diff --git a/host/chez/seed/prelude.ss b/host/chez/seed/prelude.ss
index 8441f3d..50b3168 100644
--- a/host/chez/seed/prelude.ss
+++ b/host/chez/seed/prelude.ss
@@ -543,7 +543,7 @@
 (guard (e (#t #f))
   (def-var! "clojure.core" "ensure-reduced" (letrec ((ensure-reduced (lambda (x) (let fnrec1989 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) x (jolt-invoke (var-deref "clojure.core" "reduced") x)))))) ensure-reduced)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "halt-when" (letrec ((halt-when (case-lambda ((pred) (let fnrec1990 ((pred pred)) (jolt-invoke halt-when pred jolt-nil))) ((pred retf) (let fnrec1991 ((pred pred) (retf retf)) (lambda (rf) (let fnrec1992 ((rf rf)) (case-lambda (() (let fnrec1993 () (jolt-invoke rf))) ((result) (let fnrec1994 ((result result)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__13__auto) (jolt-contains? result (keyword #f "halt")) and__13__auto))) (jolt-get result (keyword #f "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec1995 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword #f "halt") (if (jolt-truthy? retf) (jolt-invoke retf (jolt-invoke rf result) input) input))) (jolt-invoke rf result input)))))))))))) halt-when)))
+  (def-var! "clojure.core" "halt-when" (letrec ((halt-when (case-lambda ((pred) (let fnrec1990 ((pred pred)) (jolt-invoke halt-when pred jolt-nil))) ((pred retf) (let fnrec1991 ((pred pred) (retf retf)) (lambda (rf) (let fnrec1992 ((rf rf)) (case-lambda (() (let fnrec1993 () (jolt-invoke rf))) ((result) (let fnrec1994 ((result result)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__13__auto) (jolt-contains? result (keyword "clojure.core" "halt")) and__13__auto))) (jolt-get result (keyword "clojure.core" "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec1995 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword "clojure.core" "halt") (if (jolt-truthy? retf) (jolt-invoke retf (jolt-invoke rf result) input) input))) (jolt-invoke rf result input)))))))))))) halt-when)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "parse-boolean" (letrec ((parse-boolean (lambda (s) (let fnrec1996 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt= s "true") #t (if (jolt= s "false") #f (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-boolean requires a string, got: " s))))))) parse-boolean)))
 (guard (e (#t #f))
@@ -1057,7 +1057,7 @@
     (lambda (argv expr . _values) (let fnrec74 ((argv argv) (expr expr) (_values (list->cseq _values))) (let* ((c (jolt-count argv))) (let* ((_a$78 (var-deref "clojure.core" "__sqcat")) (_a$79 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$80 (let* ((_a$76 (lambda (a) (let fnrec75 ((a a)) (jolt-invoke (var-deref "clojure.template" "apply-template") argv expr a)))) (_a$77 (jolt-invoke (var-deref "clojure.core" "partition") c _values))) (jolt-map _a$76 _a$77)))) (jolt-invoke _a$78 _a$79 _a$80))))))
   (mark-macro! "clojure.template" "do-template"))
 (guard (e (#t #f))
-  (def-var! "clojure.edn" "edn->value" (letrec ((edn->value (lambda (opts x) (let fnrec81 ((opts opts) (x x)) (if (jolt= (keyword "jolt" "set") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "set") (let* ((_a$83 (lambda (v) (let fnrec82 ((v v)) (jolt-invoke edn->value opts v)))) (_a$84 (jolt-get x (keyword #f "value")))) (jolt-map _a$83 _a$84))) (if (jolt= (keyword "jolt" "tagged") (jolt-get x (keyword "jolt" "type"))) (let* ((tag (jolt-get x (keyword #f "tag"))) (v (jolt-invoke edn->value opts (jolt-get x (keyword #f "form")))) (tag-sym (let* ((n (jolt-invoke (var-deref "clojure.core" "name") tag))) (jolt-invoke (var-deref "clojure.core" "symbol") (if (jolt= "#" (jolt-invoke (var-deref "clojure.core" "subs") n 0 1)) (jolt-invoke (var-deref "clojure.core" "subs") n 1) n)))) (custom (jolt-get (jolt-get opts (keyword #f "readers")) tag-sym))) (if (jolt-truthy? custom) (jolt-invoke custom v) (if (jolt-truthy? (jolt-get opts (keyword #f "default"))) (jolt-invoke (jolt-get opts (keyword #f "default")) tag v) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "__read-tagged") tag v) jolt-nil)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$88 (jolt-hash-map)) (_a$89 (jolt-map (lambda (e) (let fnrec85 ((e e)) (let* ((_o$86 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "key") e))) (_o$87 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "val") e)))) (jolt-vector _o$86 _o$87)))) x))) (jolt-into _a$88 _a$89)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") x)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (v) (let fnrec90 ((v v)) (jolt-invoke edn->value opts v))) x) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") x)) (jolt-map (lambda (v) (let fnrec91 ((v v)) (jolt-invoke edn->value opts v))) x) (if (jolt-truthy? (keyword #f "else")) x jolt-nil)))))))))) edn->value)))
+  (def-var! "clojure.edn" "edn->value" (letrec ((edn->value (lambda (opts x) (let fnrec81 ((opts opts) (x x)) (if (jolt= (keyword "jolt" "set") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "set") (let* ((_a$83 (lambda (v) (let fnrec82 ((v v)) (jolt-invoke edn->value opts v)))) (_a$84 (jolt-get x (keyword #f "value")))) (jolt-map _a$83 _a$84))) (if (jolt= (keyword "jolt" "tagged") (jolt-get x (keyword "jolt" "type"))) (let* ((tag (jolt-get x (keyword #f "tag"))) (v (jolt-invoke edn->value opts (jolt-get x (keyword #f "form")))) (tag-sym (let* ((n (jolt-invoke (var-deref "clojure.core" "name") tag))) (jolt-invoke (var-deref "clojure.core" "symbol") (if (jolt= "#" (jolt-invoke (var-deref "clojure.core" "subs") n 0 1)) (jolt-invoke (var-deref "clojure.core" "subs") n 1) n)))) (custom (jolt-get (jolt-get opts (keyword #f "readers")) tag-sym))) (if (jolt-truthy? custom) (jolt-invoke custom v) (if (jolt-truthy? (jolt-get opts (keyword #f "default"))) (jolt-invoke (jolt-get opts (keyword #f "default")) tag-sym v) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "__read-tagged") tag v) jolt-nil)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$88 (jolt-hash-map)) (_a$89 (jolt-map (lambda (e) (let fnrec85 ((e e)) (let* ((_o$86 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "key") e))) (_o$87 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "val") e)))) (jolt-vector _o$86 _o$87)))) x))) (jolt-into _a$88 _a$89)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") x)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (v) (let fnrec90 ((v v)) (jolt-invoke edn->value opts v))) x) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") x)) (jolt-map (lambda (v) (let fnrec91 ((v v)) (jolt-invoke edn->value opts v))) x) (if (jolt-truthy? (keyword #f "else")) x jolt-nil)))))))))) edn->value)))
 (guard (e (#t #f))
   (def-var! "clojure.edn" "read-edn" (letrec ((read-edn (lambda (opts s) (let fnrec92 ((opts opts) (s s)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") s))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.string" "blank?") s)))) (jolt-get opts (keyword #f "eof") jolt-nil) (jolt-invoke (var-deref "clojure.edn" "edn->value") opts (jolt-invoke (var-deref "clojure.core" "read-string") s))))))) read-edn)))
 (guard (e (#t #f))
diff --git a/stdlib/clojure/edn.clj b/stdlib/clojure/edn.clj
index b67268e..66c4f9c 100644
--- a/stdlib/clojure/edn.clj
+++ b/stdlib/clojure/edn.clj
@@ -27,7 +27,8 @@
             custom (get (get opts :readers) tag-sym)]
         (cond
           custom (custom v)
-          (get opts :default) ((get opts :default) tag v)
+          ;; Clojure calls :default with the tag as a SYMBOL and the value.
+          (get opts :default) ((get opts :default) tag-sym v)
           :else (__read-tagged tag v)))
     (map? x)
       (into {} (map (fn [e] [(edn->value opts (key e)) (edn->value opts (val e))]) x))
diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn
index 672ca14..f67b72f 100644
--- a/test/chez/corpus.edn
+++ b/test/chez/corpus.edn
@@ -2645,6 +2645,9 @@
   {:suite "clojure.walk / records keep their type" :label "instance? survives a walk" :expected "true" :actual "(do (require (quote [clojure.walk :as w])) (defrecord R [a]) (instance? R (w/postwalk identity (->R 1))))"}
   {:suite "clojure.walk / records keep their type" :label "a record nested in a map keeps its type" :expected "true" :actual "(do (require (quote [clojure.walk :as w])) (defrecord R [a]) (record? (:r (w/postwalk identity {:r (->R 1)}))))"}
   {:suite "clojure.walk / records keep their type" :label "prewalk preserves record type" :expected "true" :actual "(do (require (quote [clojure.walk :as w])) (defrecord R [a]) (record? (w/prewalk identity (->R 1))))"}
+  {:suite "reader / auto-resolved keywords" :label "::kw is namespace-qualified" :expected "true" :actual "(some? (namespace ::foo))"}
+  {:suite "reader / auto-resolved keywords" :label "::kw keeps its name" :expected "\"foo\"" :actual "(name ::foo)"}
+  {:suite "reader / auto-resolved keywords" :label "::kw resolves to the current ns" :expected "true" :actual "(= ::a ::a)"}
   {:suite "conformance / CRITICAL: lazy sequences" :label "self-ref lazy-cat fib" :expected "[0 1 1 2 3 5 8 13 21 34]" :actual "(do (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq))) (take 10 fib-seq))"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map two colls" :expected "[11 22 33]" :actual "(map + [1 2 3] [10 20 30])"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map three colls" :expected "[12 24 36]" :actual "(map + [1 2 3] [10 20 30] [1 2 3])"}
diff --git a/test/chez/unit.edn b/test/chez/unit.edn
index 53cb5bb..a8b49fa 100644
--- a/test/chez/unit.edn
+++ b/test/chez/unit.edn
@@ -303,7 +303,7 @@
   {:suite "reader" :expr "(integer? (read-string \"7\"))" :expected "true"}
   {:suite "reader" :expr "(= :foo (read-string \":foo\"))" :expected "true"}
   {:suite "reader" :expr "(= :a/b (read-string \":a/b\"))" :expected "true"}
-  {:suite "reader" :expr "(= :foo (read-string \"::foo\"))" :expected "true"}
+  {:suite "reader" :expr "(= [true \"foo\"] [(some? (namespace (read-string \"::foo\"))) (name (read-string \"::foo\"))])" :expected "true"}
   {:suite "reader" :expr "(= (quote sym) (read-string \"sym\"))" :expected "true"}
   {:suite "reader" :expr "(= (quote ns/sym) (read-string \"ns/sym\"))" :expected "true"}
   {:suite "reader" :expr "(nil? (read-string \"nil\"))" :expected "true"}

From 2c5b7fc27ab80d3539264a375849ae27b7f84e79 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 09:13:28 -0400
Subject: [PATCH 02/14] Support metadata on lazy seqs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

with-meta/meta only recognized the eager collections, so (with-meta (map-indexed
…) m) — a lazy seq — threw "value does not support metadata". A lazy seq is IObj
on the JVM; add it to the metadatable set (keyed in the side-table by identity,
like cseq/procedure).
---
 host/chez/natives-meta.ss | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/host/chez/natives-meta.ss b/host/chez/natives-meta.ss
index 2c98ac3..36ab7fa 100644
--- a/host/chez/natives-meta.ss
+++ b/host/chez/natives-meta.ss
@@ -19,7 +19,7 @@
        (jolt-assoc (if user user (jolt-hash-map))
                    jolt-kw-var-ns (var-cell-ns x)
                    jolt-kw-var-name (var-cell-name x))))
-    ((or (pvec? x) (pmap? x) (pset? x) (cseq? x) (empty-list-t? x) (jrec? x) (procedure? x))
+    ((or (pvec? x) (pmap? x) (pset? x) (cseq? x) (empty-list-t? x) (jolt-lazyseq? x) (jrec? x) (procedure? x))
      (hashtable-ref meta-table x jolt-nil))
     (else jolt-nil)))
 
@@ -36,7 +36,7 @@
 (define (jolt-with-meta x m)
   (cond
     ((symbol-t? x) (make-symbol-t (symbol-t-ns x) (symbol-t-name x) m))
-    ((or (pvec? x) (pmap? x) (pset? x) (cseq? x) (empty-list-t? x) (jrec? x) (procedure? x))
+    ((or (pvec? x) (pmap? x) (pset? x) (cseq? x) (empty-list-t? x) (jolt-lazyseq? x) (jrec? x) (procedure? x))
      (let ((c (meta-copy x)))
        (if (jolt-nil? m) (hashtable-delete! meta-table c) (hashtable-set! meta-table c m))
        c))

From 44b7f39562b6d0944be7ff67aa79c610c0f1c6a0 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 09:13:28 -0400
Subject: [PATCH 03/14] defmethod on a referred multifn resolves to its home ns
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A (defmethod m …) where m is :refer'd from another ns passed the bare symbol to
defmethod-setup, which resolved it in the current ns and created a shadow multifn
— the method never reached the real one. Resolve an unqualified name through the
refer table (then current ns) so it lands on the referred multifn.

The AOT build strips the ns form, so the refer table is empty in a binary; emit
chez-register-refer!/-refer-all! per app ns alongside the existing alias
registrations. build-app's fixture gains a defmethod on a referred multifn.
---
 host/chez/build-smoke.sh             |  3 ++-
 host/chez/build.ss                   | 24 ++++++++++++++++++++----
 host/chez/multimethods.ss            | 10 ++++++++--
 test/chez/build-app/src/app/core.clj |  9 +++++++--
 4 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/host/chez/build-smoke.sh b/host/chez/build-smoke.sh
index b2a61ea..95ae1f2 100755
--- a/host/chez/build-smoke.sh
+++ b/host/chez/build-smoke.sh
@@ -46,7 +46,8 @@ HELLO FROM A BUILT BINARY!
 args: [alpha bb ccc]
 sum: 10
 greet-default: greet:default
-greet-loud: greet:loud'
+greet-loud: greet:loud
+greet-soft: greet:soft'
 if [ "$got" != "$want" ]; then
   echo "  FAIL: binary output mismatch"
   echo "--- want ---"; echo "$want"
diff --git a/host/chez/build.ss b/host/chez/build.ss
index 1dc401e..bb36752 100644
--- a/host/chez/build.ss
+++ b/host/chez/build.ss
@@ -185,10 +185,26 @@
         (let loop ((xs (cdr items)))
           (when (and (pair? xs) (pair? (cdr xs)))
             (let ((k (car xs)) (v (cadr xs)))
-              (when (and (keyword? k) (string=? (keyword-t-name k) "as") (symbol-t? v))
-                (emit! (string-append "(chez-register-alias! " (ei-str-lit ns-name)
-                                      " " (ei-str-lit (symbol-t-name v))
-                                      " " (ei-str-lit target) ")"))))
+              (when (keyword? k)
+                (cond
+                  ((and (string=? (keyword-t-name k) "as") (symbol-t? v))
+                   (emit! (string-append "(chez-register-alias! " (ei-str-lit ns-name)
+                                         " " (ei-str-lit (symbol-t-name v))
+                                         " " (ei-str-lit target) ")")))
+                  ;; :refer [a b] / :refer :all — a defmethod on a referred multifn
+                  ;; resolves the bare name through the refer table at runtime.
+                  ((or (string=? (keyword-t-name k) "refer") (string=? (keyword-t-name k) "only"))
+                   (cond
+                     ((and (keyword? v) (string=? (keyword-t-name v) "all"))
+                      (emit! (string-append "(chez-register-refer-all! " (ei-str-lit ns-name)
+                                            " " (ei-str-lit target) ")")))
+                     ((or (pvec? v) (and (cseq? v) (cseq-list? v)))
+                      (for-each (lambda (n)
+                                  (when (symbol-t? n)
+                                    (emit! (string-append "(chez-register-refer! " (ei-str-lit ns-name)
+                                                          " " (ei-str-lit (symbol-t-name n))
+                                                          " " (ei-str-lit target) ")"))))
+                                (seq->list v))))))))
             (loop (cddr xs))))))))
 
 (define (bld-ns-prelude ns-name src)
diff --git a/host/chez/multimethods.ss b/host/chez/multimethods.ss
index 3233e26..f97c25d 100644
--- a/host/chez/multimethods.ss
+++ b/host/chez/multimethods.ss
@@ -73,8 +73,14 @@
          (sns (symbol-t-ns mm-sym))
          (qns (and sns (not (jolt-nil? sns)) (not (null? sns)) sns))
          ;; qualified (cf.mm/ext) resolves in its own ns (cross-ns defmethod);
-         ;; unqualified stays in the current ns (a shadow, as before).
-         (mns (if qns (or (chez-resolve-alias (chez-current-ns) qns) qns) (chez-current-ns)))
+         ;; unqualified resolves in the current ns, else a :refer's home ns (so a
+         ;; defmethod on a referred multifn lands on the real one), else stays in
+         ;; the current ns (a shadow, as before).
+         (mns (cond
+                (qns (or (chez-resolve-alias (chez-current-ns) qns) qns))
+                ((var-cell-lookup (chez-current-ns) nm) (chez-current-ns))
+                ((chez-resolve-refer (chez-current-ns) nm) => values)
+                (else (chez-current-ns))))
          (cur (var-deref mns nm))
          (mf (if (jolt-multifn? cur) cur
                  ;; auto-create: copy the dispatch fn + default from a same-named
diff --git a/test/chez/build-app/src/app/core.clj b/test/chez/build-app/src/app/core.clj
index c47c1fb..4914552 100644
--- a/test/chez/build-app/src/app/core.clj
+++ b/test/chez/build-app/src/app/core.clj
@@ -1,5 +1,5 @@
 (ns app.core
-  (:require [app.util :as util]
+  (:require [app.util :as util :refer [greet]]
             [clojure.java.io :as io]))
 
 ;; An aliased cross-ns defmethod: 'util/greet is passed quoted to defmethod-setup,
@@ -7,6 +7,10 @@
 ;; ns "util" and never reaches app.util/greet (the dispatch falls to :default).
 (defmethod util/greet :loud [_] "greet:loud")
 
+;; A defmethod on a REFERRED multifn (bare `greet`): the AOT build must register
+;; the :refer so the bare name resolves to app.util/greet, not a shadow.
+(defmethod greet :soft [_] "greet:soft")
+
 (defn -main [& args]
   ;; the resource is baked into the binary (deps.edn :jolt/build :embed), so this
   ;; resolves with no resources/ dir on disk, run from any cwd.
@@ -15,4 +19,5 @@
   (println "args:" (vec args))
   (println "sum:" (reduce + (map count args)))
   (println "greet-default:" (util/greet :unknown))
-  (println "greet-loud:" (util/greet :loud)))
+  (println "greet-loud:" (util/greet :loud))
+  (println "greet-soft:" (util/greet :soft)))

From 289e41943ec8281f033c0472ede25d5d2950466b Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 09:13:28 -0400
Subject: [PATCH 04/14] Shim clojure.lang.LineNumberingPushbackReader

A pushback-reader (drainable, so clojure.edn/read over it works); getLineNumber
is a stub since jolt doesn't track line numbers. Config readers (aero) wrap their
input in one.
---
 host/chez/host-static-classes.ss | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/host/chez/host-static-classes.ss b/host/chez/host-static-classes.ss
index b6de1a4..1aecc9c 100644
--- a/host/chez/host-static-classes.ss
+++ b/host/chez/host-static-classes.ss
@@ -218,6 +218,12 @@
 ;; state: a vector #(wrapped-reader pushed-list)
 (register-class-ctor! "PushbackReader"
   (lambda (rdr . _) (make-jhost "pushback-reader" (vector rdr '()))))
+;; LineNumberingPushbackReader: a pushback-reader (jolt doesn't track line
+;; numbers; getLineNumber is a stub for error-reporting paths that read it).
+(register-class-ctor! "LineNumberingPushbackReader"
+  (lambda (rdr . _) (make-jhost "pushback-reader" (vector rdr '()))))
+(register-class-ctor! "clojure.lang.LineNumberingPushbackReader"
+  (lambda (rdr . _) (make-jhost "pushback-reader" (vector rdr '()))))
 (define (read-unit r)        ; read one code unit (flonum) from any reader, -1 at EOF
   (record-method-dispatch r "read" jolt-nil))
 (register-host-methods! "pushback-reader"
@@ -230,7 +236,8 @@
                          (vector-set! (jhost-state self) 1
                            (cons (if (char? ch) (->num (char->integer ch)) ch) (vector-ref (jhost-state self) 1)))
                          jolt-nil))
-        (cons "close" (lambda (self) jolt-nil))))
+        (cons "close" (lambda (self) jolt-nil))
+        (cons "getLineNumber" (lambda (self) 0))))
 
 ;; ---- StringTokenizer --------------------------------------------------------
 ;; state: a vector #(tokens-list pos)

From 54a72498ced48e23d6e9f86dca8be588827a9d6a Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 09:33:45 -0400
Subject: [PATCH 05/14] spec: note jolt's unknown-alias behavior; corpus rows
 for the reader/edn fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The EBNF and reader S7 already specified ::kw auto-resolution — the
implementation was out of spec, now aligned. S7 noted unknown ::alias/k MUST be a
read error; jolt is lenient (reads :alias/k), so record that as a deviation.
Corpus gains JVM-certified rows for ::kw resolution, clojure.edn :default
receiving a symbol tag, and with-meta on a lazy seq.
---
 docs/spec/02-reader.md | 5 +++--
 test/chez/corpus.edn   | 2 ++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/docs/spec/02-reader.md b/docs/spec/02-reader.md
index 88e782b..9b7c31a 100644
--- a/docs/spec/02-reader.md
+++ b/docs/spec/02-reader.md
@@ -59,8 +59,9 @@ keyword  := ':' name | ':' ns '/' name | '::' name | '::' alias '/' name
   . $ & %` (with `%` and `&` further constrained inside `#()`); a symbol
   MUST NOT begin with a digit; `.` and `/` have positional restrictions.
 - S7. `::kw` MUST resolve to the current namespace at *read* time
-  (`::k` in ns `user` reads as `:user/k`); `::alias/k` resolves the alias or
-  MUST be a read error if the alias does not exist.
+  (`::k` in ns `user` reads as `:user/k`); `::alias/k` resolves `alias` through
+  the current namespace's aliases. (Clojure raises a read error for an unknown
+  alias; jolt reads it as `:alias/k`.)
 
 ### Strings and characters
 
diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn
index f67b72f..95516a2 100644
--- a/test/chez/corpus.edn
+++ b/test/chez/corpus.edn
@@ -2648,6 +2648,8 @@
   {:suite "reader / auto-resolved keywords" :label "::kw is namespace-qualified" :expected "true" :actual "(some? (namespace ::foo))"}
   {:suite "reader / auto-resolved keywords" :label "::kw keeps its name" :expected "\"foo\"" :actual "(name ::foo)"}
   {:suite "reader / auto-resolved keywords" :label "::kw resolves to the current ns" :expected "true" :actual "(= ::a ::a)"}
+  {:suite "clojure.edn / reader opts" :label ":default receives the tag as a symbol" :expected "[true \"foo\" 5]" :actual "(do (require (quote [clojure.edn :as edn])) (let [r (edn/read-string {:default (fn [t v] [t v])} \"#foo 5\")] [(symbol? (first r)) (name (first r)) (second r)]))"}
+  {:suite "metadata / lazy seqs carry meta" :label "with-meta on a lazy seq" :expected "{:k 1}" :actual "(meta (with-meta (map inc [1 2 3]) {:k 1}))"}
   {:suite "conformance / CRITICAL: lazy sequences" :label "self-ref lazy-cat fib" :expected "[0 1 1 2 3 5 8 13 21 34]" :actual "(do (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq))) (take 10 fib-seq))"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map two colls" :expected "[11 22 33]" :actual "(map + [1 2 3] [10 20 30])"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map three colls" :expected "[12 24 36]" :actual "(map + [1 2 3] [10 20 30] [1 2 3])"}

From d5deba2df877855289fcc320681cacd687e3429b Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 10:22:10 -0400
Subject: [PATCH 06/14] Define *print-meta* as a bindable dynamic var
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

clojure.core/*print-meta* was missing, so (binding [*print-meta* true] …) failed
to compile ("var of non-var"). Add it (default false, like the JVM); corpus
covers binding it.
---
 host/chez/dynamic-var-defaults.ss | 3 +++
 test/chez/corpus.edn              | 1 +
 2 files changed, 4 insertions(+)

diff --git a/host/chez/dynamic-var-defaults.ss b/host/chez/dynamic-var-defaults.ss
index 8fc26ac..387e048 100644
--- a/host/chez/dynamic-var-defaults.ss
+++ b/host/chez/dynamic-var-defaults.ss
@@ -25,3 +25,6 @@
 
 ;; *print-readably* — bound by pr-family / with-out-str-style code; default true.
 (def-var! "clojure.core" "*print-readably*" #t)
+
+;; *print-meta* — when true, pr prints metadata with a ^ prefix; default false.
+(def-var! "clojure.core" "*print-meta*" #f)
diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn
index 95516a2..76c54ee 100644
--- a/test/chez/corpus.edn
+++ b/test/chez/corpus.edn
@@ -2650,6 +2650,7 @@
   {:suite "reader / auto-resolved keywords" :label "::kw resolves to the current ns" :expected "true" :actual "(= ::a ::a)"}
   {:suite "clojure.edn / reader opts" :label ":default receives the tag as a symbol" :expected "[true \"foo\" 5]" :actual "(do (require (quote [clojure.edn :as edn])) (let [r (edn/read-string {:default (fn [t v] [t v])} \"#foo 5\")] [(symbol? (first r)) (name (first r)) (second r)]))"}
   {:suite "metadata / lazy seqs carry meta" :label "with-meta on a lazy seq" :expected "{:k 1}" :actual "(meta (with-meta (map inc [1 2 3]) {:k 1}))"}
+  {:suite "dynamic vars / *print-meta*" :label "*print-meta* is a bindable dynamic var" :expected "true" :actual "(binding [*print-meta* true] (true? *print-meta*))"}
   {:suite "conformance / CRITICAL: lazy sequences" :label "self-ref lazy-cat fib" :expected "[0 1 1 2 3 5 8 13 21 34]" :actual "(do (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq))) (take 10 fib-seq))"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map two colls" :expected "[11 22 33]" :actual "(map + [1 2 3] [10 20 30])"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map three colls" :expected "[12 24 36]" :actual "(map + [1 2 3] [10 20 30] [1 2 3])"}

From b2bc52935d74786366922bef2fa4ea7ec2f8d2e8 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 10:22:10 -0400
Subject: [PATCH 07/14] Resolve relative slurp/io-reader paths against JOLT_PWD
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

io/file already resolved a relative path against JOLT_PWD (the user's cwd before
the launcher cd's to the repo root), but slurp and io/reader on a relative string
path opened it against the process cwd — so a program run from its own directory
couldn't read its own relative files (e.g. aero's (read-config "config.edn")).
Route the string branches through project-relative, matching io/file. Internal
callers pass already-resolved paths through read-file-string and are unaffected.
---
 host/chez/io.ss | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/host/chez/io.ss b/host/chez/io.ss
index ab9287b..0805bf8 100644
--- a/host/chez/io.ss
+++ b/host/chez/io.ss
@@ -211,7 +211,7 @@
     ;; a byte input-stream shim (e.g. clj-http-lite's :as :stream body): drain it.
     ((and (htable? src) (jolt-truthy? (jolt-ref-get src (keyword "jolt" "input-stream"))))
      (decode-bytevector (drain-byte-stream src) (slurp-encoding opts)))
-    ((string? src) (read-file-string src))
+    ((string? src) (read-file-string (project-relative src)))
     (else (error #f "slurp: unsupported source" src))))
 
 (define (spit-append? opts)
@@ -300,7 +300,7 @@
     ((embedded-res? x) (host-new "StringReader" (embedded-res-content x)))
     ((and (jhost? x) (string=? (jhost-tag x) "url"))
      (host-new "StringReader" (read-file-string (url-strip-scheme (url-spec x)))))
-    ((string? x) (host-new "StringReader" (read-file-string x)))
+    ((string? x) (host-new "StringReader" (read-file-string (project-relative x))))
     ((or (cseq? x) (empty-list-t? x) (pvec? x))
      (host-new "StringReader" (seq-source->string x)))
     (else (host-new "StringReader" (jolt-str-render-one x)))))

From 3412563a79f4b49a371437834d7f2b34e30962f3 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 11:03:33 -0400
Subject: [PATCH 08/14] Tagged literals are value-equal

(tagged-literal t f) compared by identity, so two equal tagged literals were not
= and didn't dedup as map keys / set members; JVM's TaggedLiteral is value-equal.
Add a register-eq-arm! for jtagged (tag + recursive form); hash is already
structural. Fixes an infinite loop in any fixpoint that dedups structures
containing tagged literals (e.g. aero's #ref expansion).
---
 host/chez/natives-misc.ss | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/host/chez/natives-misc.ss b/host/chez/natives-misc.ss
index 1768ab6..ff66458 100644
--- a/host/chez/natives-misc.ss
+++ b/host/chez/natives-misc.ss
@@ -82,6 +82,13 @@
           (else d))))
 (define (jtagged-pr t) (string-append "#" (jolt-pr-str (jtagged-tag t)) " " (jolt-pr-readable (jtagged-form t))))
 (register-pr-arm! jtagged? jtagged-pr)
+;; two tagged literals are = iff same tag and (recursively) = form, like the JVM's
+;; TaggedLiteral — so they work as map keys / set members. (jolt-hash already
+;; hashes the fields structurally, so eq/hash stay consistent.)
+(register-eq-arm! (lambda (a b) (or (jtagged? a) (jtagged? b)))
+                  (lambda (a b) (and (jtagged? a) (jtagged? b)
+                                     (jolt=2 (jtagged-tag a) (jtagged-tag b))
+                                     (jolt=2 (jtagged-form a) (jtagged-form b)))))
 (def-var! "clojure.core" "tagged-literal" jolt-tagged-literal)
 ;; tagged-literal? is OVERLAY (reads :jolt/type) — asserted in post-prelude.ss.
 

From b2394325d43770173b03451bcd3225927eeee491 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 11:03:34 -0400
Subject: [PATCH 09/14] Recognize core clojure.lang interfaces in instance?

(instance? clojure.lang.IObj/IMapEntry/IRecord/IPersistentMap/... x) all returned
false, so libraries branching on these interfaces (e.g. a metadata-preserving
walk guarded by IObj) silently misbehaved. Register an instance-check arm mapping
the interface tokens to jolt predicates, matched by last dotted segment.
---
 host/chez/host-static-classes.ss | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/host/chez/host-static-classes.ss b/host/chez/host-static-classes.ss
index 1aecc9c..eb35534 100644
--- a/host/chez/host-static-classes.ss
+++ b/host/chez/host-static-classes.ss
@@ -506,5 +506,37 @@
 (def-var! "clojure.core" "__register-instance-check!"
   (lambda (f) (set! user-instance-checks (append user-instance-checks (list f))) jolt-nil))
 
+;; (instance? clojure.lang.IFoo x) for the core clojure.lang interfaces libraries
+;; branch on — jolt's value model satisfies them, so report it. Matched by the
+;; interface's last dotted segment, so "clojure.lang.IObj" and "IObj" both hit.
+(define (hsc-last-segment s)
+  (let loop ((i (- (string-length s) 1)))
+    (cond ((< i 0) s)
+          ((char=? (string-ref s i) #\.) (substring s (+ i 1) (string-length s)))
+          (else (loop (- i 1))))))
+;; values that carry metadata (mirrors jolt-with-meta's set in natives-meta.ss).
+(define (hsc-imeta? x)
+  (or (pvec? x) (pmap? x) (pset? x) (cseq? x) (empty-list-t? x)
+      (jolt-lazyseq? x) (jrec? x) (procedure? x) (symbol-t? x)))
+(register-instance-check-arm!
+  (lambda (type-sym val)
+    (let ((iface (hsc-last-segment (symbol-t-name type-sym))))
+      (let ((hit (cond
+                   ((or (string=? iface "IObj") (string=? iface "IMeta")) (hsc-imeta? val))
+                   ((or (string=? iface "IMapEntry") (string=? iface "MapEntry")) (jolt-map-entry? val))
+                   ((string=? iface "IRecord") (jrec? val))
+                   ((string=? iface "IPersistentMap") (or (pmap? val) (htable-sorted-map? val)))
+                   ((string=? iface "IPersistentVector") (and (pvec? val) (not (jolt-map-entry? val))))
+                   ((string=? iface "IPersistentSet") (or (pset? val) (htable-sorted-set? val)))
+                   ((or (string=? iface "ISeq") (string=? iface "Seqable"))
+                    (or (cseq? val) (empty-list-t? val) (jolt-lazyseq? val)))
+                   ((string=? iface "Sequential")
+                    (or (pvec? val) (cseq? val) (empty-list-t? val) (jolt-lazyseq? val)))
+                   ((string=? iface "IFn")
+                    (or (procedure? val) (keyword? val) (symbol-t? val)
+                        (pmap? val) (pset? val) (pvec? val)))
+                   (else 'none))))
+        (if (eq? hit 'none) 'pass (if hit #t #f))))))
+
 ;; (jolt.host/table? x) — is x a host tagged-table?
 (def-var! "jolt.host" "table?" (lambda (x) (if (htable? x) #t #f)))

From 7947918919b123437935f59dc0734b2f45a66932 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 11:03:34 -0400
Subject: [PATCH 10/14] Add File .isAbsolute and the default #inst/#uuid data
 readers

jfile lacked .isAbsolute (path starts with /). clojure.core/default-data-readers
and *data-readers* were nil, so a library merging them (aero's reader opts)
couldn't resolve #inst. Define them keyed by symbol, like Clojure.
---
 host/chez/inst-time.ss | 8 ++++++++
 host/chez/io.ss        | 1 +
 2 files changed, 9 insertions(+)

diff --git a/host/chez/inst-time.ss b/host/chez/inst-time.ss
index 61c310c..f05b726 100644
--- a/host/chez/inst-time.ss
+++ b/host/chez/inst-time.ss
@@ -388,3 +388,11 @@
              ((string=? method-name "after") (> (jinst-ms obj) (ms-of (car (seq->list rest-args)))))
              (else (error #f (string-append "No method " method-name " on Date")))))
       (else (%it-rmd obj method-name rest-args)))))
+
+;; Clojure's built-in data readers, so a library that merges default-data-readers
+;; or binds *data-readers* (e.g. aero's reader opts) resolves #inst / #uuid.
+;; Keyed by symbol, like Clojure. *data-readers* is the bindable user table.
+(def-var! "clojure.core" "default-data-readers"
+  (jolt-hash-map (jolt-symbol #f "inst") jolt-inst-from-string
+                 (jolt-symbol #f "uuid") jolt-uuid-from-string))
+(def-var! "clojure.core" "*data-readers*" empty-pmap)
diff --git a/host/chez/io.ss b/host/chez/io.ss
index 0805bf8..8d0e38b 100644
--- a/host/chez/io.ss
+++ b/host/chez/io.ss
@@ -100,6 +100,7 @@
       ((string=? name "exists")         (list (if (file-exists? p) #t #f)))
       ((string=? name "isDirectory")    (list (if (file-directory? p) #t #f)))
       ((string=? name "isFile")         (list (if (and (file-exists? p) (not (file-directory? p))) #t #f)))
+      ((string=? name "isAbsolute")     (list (if (and (> (string-length p) 0) (char=? (string-ref p 0) #\/)) #t #f)))
       ((string=? name "listFiles")      (list (list->cseq (map make-jfile (jolt-list-dir p)))))
       ((string=? name "getParent")
        (let loop ((i (- (string-length p) 1)))

From 79d00841632a4e6a4d7d385eaeb607cbfcde0f24 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 11:03:34 -0400
Subject: [PATCH 11/14] Readable messages for host conditions

clojure.test reported a host-condition crash with a blank message (ex-message is
nil for non-ex-info conditions); fall back to jolt.host/condition-message.
condition-message itself left a Chez format-template message (open-input-file's
'failed for ~a: ~(~a~)') unformatted; apply its irritants.
---
 host/chez/records.ss    | 19 +++++++++++++++----
 stdlib/clojure/test.clj | 12 ++++++++++--
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/host/chez/records.ss b/host/chez/records.ss
index eb21e91..3a3d880 100644
--- a/host/chez/records.ss
+++ b/host/chez/records.ss
@@ -255,10 +255,21 @@
 ;; &message text plus any &irritants, or display-condition output as a fallback.
 (define (condition->message-string c)
   (if (message-condition? c)
-      (let ((m (condition-message c))
-            (irr (if (irritants-condition? c) (condition-irritants c) '())))
-        (let loop ((xs irr) (acc m))
-          (if (null? xs) acc (loop (cdr xs) (string-append acc " " (jolt-pr-str (car xs)))))))
+      (let* ((m (condition-message c))
+             (irr (if (irritants-condition? c) (condition-irritants c) '()))
+             (append-irr (lambda ()
+                           (let loop ((xs irr) (acc m))
+                             (if (null? xs) acc
+                                 (loop (cdr xs) (string-append acc " " (jolt-pr-str (car xs)))))))))
+        ;; some Chez conditions (open-input-file etc.) carry a format-template
+        ;; message ("failed for ~a: ~(~a~)") whose irritants fill the directives;
+        ;; format it in. Fall back to appending the irritants if that fails.
+        (if (and (string? m) (let scan ((i 0))
+                               (cond ((>= i (string-length m)) #f)
+                                     ((char=? (string-ref m i) #\~) #t)
+                                     (else (scan (+ i 1))))))
+            (guard (e (#t (append-irr))) (apply format m irr))
+            (append-irr)))
       (with-output-to-string (lambda () (display-condition c)))))
 ;; expose a Chez condition's message to Clojure (ex-message returns nil for raw
 ;; host conditions): the nREPL eval handler surfaces it instead of an opaque
diff --git a/stdlib/clojure/test.clj b/stdlib/clojure/test.clj
index 46d722e..789c350 100644
--- a/stdlib/clojure/test.clj
+++ b/stdlib/clojure/test.clj
@@ -46,6 +46,14 @@
 (defn n-error [] (:error @counters))
 (defn failures [] (:fails @counters))
 
+;; Message of a thrown value: ex-info's message, else a raw host condition's text
+;; (ex-message is nil for those), else its printed form — so a crash is never
+;; reported with a blank message.
+(defn err-text [e]
+  (or (ex-message e)
+      (jolt.host/condition-message e)
+      (str e)))
+
 ;; clojure.test/report multimethod — present so suites that add reporting
 ;; methods (defmethod clojure.test/report :begin-test-var ...) load. The runner
 ;; below does its own console output and doesn't dispatch through it.
@@ -110,7 +118,7 @@
           (clojure.test/inc-pass!)
           (clojure.test/fail! (str (pr-str '~form) (when ~msg (str " — " ~msg)))))
         (catch Throwable e#
-          (clojure.test/err! (str (pr-str '~form) " threw: " (clojure.core/ex-message e#))))))))
+          (clojure.test/err! (str (pr-str '~form) " threw: " (clojure.test/err-text e#))))))))
 
 (defmacro testing [s & body]
   `(do
@@ -152,7 +160,7 @@
       (try
         ((:fn t))
         (catch Throwable e
-          (err! (str (:name t) " crashed: " (clojure.core/ex-message e))))))))
+          (err! (str (:name t) " crashed: " (err-text e))))))))
 
 (defn run-registered []
   (doseq [t @registry] (run-one t))

From 091d2c4b620b43b3e2a6544f5813745f476d7ebd Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 11:03:34 -0400
Subject: [PATCH 12/14] corpus: rows for the tagged-literal / interface /
 data-reader fixes

---
 test/chez/corpus.edn | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn
index 76c54ee..888dc01 100644
--- a/test/chez/corpus.edn
+++ b/test/chez/corpus.edn
@@ -2651,6 +2651,14 @@
   {:suite "clojure.edn / reader opts" :label ":default receives the tag as a symbol" :expected "[true \"foo\" 5]" :actual "(do (require (quote [clojure.edn :as edn])) (let [r (edn/read-string {:default (fn [t v] [t v])} \"#foo 5\")] [(symbol? (first r)) (name (first r)) (second r)]))"}
   {:suite "metadata / lazy seqs carry meta" :label "with-meta on a lazy seq" :expected "{:k 1}" :actual "(meta (with-meta (map inc [1 2 3]) {:k 1}))"}
   {:suite "dynamic vars / *print-meta*" :label "*print-meta* is a bindable dynamic var" :expected "true" :actual "(binding [*print-meta* true] (true? *print-meta*))"}
+  {:suite "tagged literals / value equality" :label "equal tag+form are =" :expected "true" :actual "(= (tagged-literal (quote x) [1 2]) (tagged-literal (quote x) [1 2]))"}
+  {:suite "tagged literals / value equality" :label "different tag is not =" :expected "false" :actual "(= (tagged-literal (quote x) [1]) (tagged-literal (quote y) [1]))"}
+  {:suite "tagged literals / value equality" :label "dedup as map keys" :expected "1" :actual "(count {(tagged-literal (quote x) [1]) :a (tagged-literal (quote x) [1]) :b})"}
+  {:suite "interop / clojure.lang interfaces" :label "vector is IObj" :expected "true" :actual "(instance? clojure.lang.IObj [1])"}
+  {:suite "interop / clojure.lang interfaces" :label "map entry is IMapEntry" :expected "true" :actual "(instance? clojure.lang.IMapEntry (first {:a 1}))"}
+  {:suite "interop / clojure.lang interfaces" :label "record is IRecord" :expected "true" :actual "(do (defrecord R [a]) (instance? clojure.lang.IRecord (->R 1)))"}
+  {:suite "interop / clojure.lang interfaces" :label "number is not IObj" :expected "false" :actual "(instance? clojure.lang.IObj 5)"}
+  {:suite "reader / default data readers" :label "#inst is in default-data-readers" :expected "true" :actual "(boolean (get default-data-readers (quote inst)))"}
   {:suite "conformance / CRITICAL: lazy sequences" :label "self-ref lazy-cat fib" :expected "[0 1 1 2 3 5 8 13 21 34]" :actual "(do (def fib-seq (lazy-cat [0 1] (map + (rest fib-seq) fib-seq))) (take 10 fib-seq))"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map two colls" :expected "[11 22 33]" :actual "(map + [1 2 3] [10 20 30])"}
   {:suite "conformance / CRITICAL: multi-collection map" :label "map three colls" :expected "[12 24 36]" :actual "(map + [1 2 3] [10 20 30] [1 2 3])"}

From 473d1002b7052a4f1f5c5972b3895dcb8cb38b1f Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 12:04:36 -0400
Subject: [PATCH 13/14] Reader attaches collection metadata to data, not a
 with-meta form

The reader lowered ^meta on a vector/map/set literal to a runtime
(with-meta form meta) list, so read-string/edn of data with metadata
returned the form and lost the metadata. Attach it to the value instead,
as Clojure does; the analyzer re-emits (with-meta coll meta) for a
meta-carrying collection literal in code, so a literal still carries its
metadata at runtime and ^Type/^long arglist hints (consumed by
analyze-arity directly) are unaffected.

Also: pr honors *print-meta*, and clojure.walk/clojure.edn re-attach
metadata to the collections they rebuild (matches Clojure; a
metadata-driven config lib like aero relies on it).
---
 host/chez/host-contract.ss  |   5 +
 host/chez/printing.ss       |  21 +-
 host/chez/reader.ss         |  28 +-
 host/chez/seed/image.ss     | 488 ++++++++++----------
 host/chez/seed/prelude.ss   | 888 ++++++++++++++++++------------------
 jolt-core/jolt/analyzer.clj |  26 +-
 stdlib/clojure/edn.clj      |  11 +-
 stdlib/clojure/walk.clj     |  12 +-
 8 files changed, 763 insertions(+), 716 deletions(-)

diff --git a/host/chez/host-contract.ss b/host/chez/host-contract.ss
index 9a42d80..08bde45 100644
--- a/host/chez/host-contract.ss
+++ b/host/chez/host-contract.ss
@@ -86,6 +86,10 @@
 (define (hc-sym-meta x)
   (let ((m (symbol-t-meta x)))
     (if (and m (not (jolt-nil? m)) (not (null? m))) m jolt-nil)))
+;; Metadata the reader attached to a collection literal (vec/map/set/list), or
+;; jolt-nil. The analyzer re-emits a runtime (with-meta ..) for a meta-carrying
+;; vector/map/set so the value keeps its metadata.
+(define (hc-coll-meta x) (jolt-meta x))
 
 ;; list items -> jolt vector (pvec); the analyzer mapv's over the result.
 (define (hc-elements x)
@@ -327,6 +331,7 @@
   (def-var! "jolt.host" "form-sym-name" hc-sym-name)
   (def-var! "jolt.host" "form-sym-ns" hc-sym-ns)
   (def-var! "jolt.host" "form-sym-meta" hc-sym-meta)
+  (def-var! "jolt.host" "form-coll-meta" hc-coll-meta)
   (def-var! "jolt.host" "form-list?" hc-list?)
   (def-var! "jolt.host" "form-vec?" hc-vec?)
   (def-var! "jolt.host" "form-map?" hc-map?)
diff --git a/host/chez/printing.ss b/host/chez/printing.ss
index 520485e..1c09e61 100644
--- a/host/chez/printing.ss
+++ b/host/chez/printing.ss
@@ -67,12 +67,31 @@
          (if (jolt-nil? s) (reverse acc)
              (loop (jolt-seq (seq-more s)) (cons (jolt-pr-readable (seq-first s)) acc))))) ")"))
     (else (jolt-pr-str x))))
-(define (jolt-pr-readable x)
+(define (jolt-pr-readable-dispatch x)
   (let loop ((as jolt-pr-readable-arms))
     (cond ((null? as) (jolt-pr-readable-base x))
           (((caar as) x) ((cdar as) x))
           (else (loop (cdr as))))))
 
+;; *print-meta* support. The var is def'd after this file loads, so capture its
+;; cell lazily; jolt-var-get (patched by dyn-binding.ss) honors a `binding`.
+(define pr-meta-cell #f)
+(define (pr-print-meta?)
+  (unless pr-meta-cell (set! pr-meta-cell (jolt-var "clojure.core" "*print-meta*")))
+  (jolt-truthy? (jolt-var-get pr-meta-cell)))
+;; The metadata to print before x, or jolt-nil. A var prints as #'ns/name (its
+;; {:ns :name} is derived, not user metadata) and a procedure is opaque — skip both.
+(define (pr-user-meta x)
+  (if (or (var-cell? x) (procedure? x)) jolt-nil (jolt-meta x)))
+
+(define (jolt-pr-readable x)
+  (if (pr-print-meta?)
+      (let ((m (pr-user-meta x)))
+        (if (jolt-nil? m)
+            (jolt-pr-readable-dispatch x)
+            (string-append "^" (jolt-pr-readable-dispatch m) " " (jolt-pr-readable-dispatch x))))
+      (jolt-pr-readable-dispatch x)))
+
 ;; __pr-str1: render ONE value readably (the overlay's pr-str joins these).
 (define (jolt-pr-str1 x) (jolt-pr-readable x))
 
diff --git a/host/chez/reader.ss b/host/chez/reader.ss
index eadd4c9..92f74ce 100644
--- a/host/chez/reader.ss
+++ b/host/chez/reader.ss
@@ -290,20 +290,22 @@
     ((symbol-t? target)
      (make-symbol-t (symbol-t-ns target) (symbol-t-name target)
                     (rdr-merge-meta (symbol-t-meta target) meta)))
-    ;; A LIST form is code: ^Type (expr) is a compile-time hint on the FORM, not a
-    ;; runtime operation. Attach the metadata to the form itself (so a quoted list
-    ;; keeps it and the analyzer can read :tag) — never lower to a runtime
-    ;; (with-meta (expr) meta), which would mis-apply the hint to the call's RESULT
-    ;; and throw when that result is a string/number (e.g. ^String (to-str x)).
-    ;; Matches Clojure: a tag hint on an evaluated form is discarded at runtime.
-    ((cseq? target) (jolt-with-meta target meta))
     ((empty-list-t? target) target)
-    ;; A vector/map/set LITERAL: Clojure attaches the metadata to the runtime value
-    ;; ((meta ^{:tag :int} [1 2]) / ^:foo {}), so lower to a runtime (with-meta form
-    ;; meta). Use the BARE `with-meta` symbol (ns #f) — the fn/defn macros unwrap a
-    ;; (with-meta <arglist-vec> _) return-hint by matching the unqualified head, so a
-    ;; qualified clojure.core/with-meta would slip past them (^bytes [b]).
-    (else (jolt-list (jolt-symbol #f "with-meta") target meta))))
+    ;; Lists/vectors/maps/sets attach metadata to the value itself, as Clojure's
+    ;; reader does. Reading DATA (read-string, edn) then preserves it. A list form
+    ;; is code: ^Type (expr) is a compile-time hint on the FORM, read off the form
+    ;; for :tag and discarded at runtime (a hint on an evaluated form is dropped).
+    ;; A vector/map/set LITERAL keeps it as a runtime value: the analyzer re-emits a
+    ;; (with-meta form meta) for a meta-carrying collection literal in code, so
+    ;; (meta ^{:tag :int} [1 2]) / ^:foo {} still works.
+    (else
+     (let ((c (jolt-with-meta target meta)))
+       ;; jolt-with-meta copies a pmap, giving it a fresh identity the rdr-map-order
+       ;; side-table (source key order for left-to-right map-literal eval) loses —
+       ;; carry the order entry over to the copy.
+       (let ((order (and (pmap? target) (hashtable-ref rdr-map-order target #f))))
+         (when order (hashtable-set! rdr-map-order c order)))
+       c))))
 
 ;; --- # dispatch -------------------------------------------------------------
 ;; #(...) anonymous fn shorthand: % -> p1, %N -> pN, %& -> rest. The
diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss
index a6c681a..cc46814 100644
--- a/host/chez/seed/image.ss
+++ b/host/chez/seed/image.ss
@@ -1,163 +1,165 @@
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec4801 ((v v)) (let* ((_o$4802 (keyword #f "op")) (_o$4803 (keyword #f "const")) (_o$4804 (keyword #f "val")) (_o$4805 v)) (jolt-hash-map _o$4802 _o$4803 _o$4804 _o$4805)))))) const)))
+  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec4825 ((v v)) (let* ((_o$4826 (keyword #f "op")) (_o$4827 (keyword #f "const")) (_o$4828 (keyword #f "val")) (_o$4829 v)) (jolt-hash-map _o$4826 _o$4827 _o$4828 _o$4829)))))) const)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec4806 ((name name)) (let* ((_o$4807 (keyword #f "op")) (_o$4808 (keyword #f "local")) (_o$4809 (keyword #f "name")) (_o$4810 name)) (jolt-hash-map _o$4807 _o$4808 _o$4809 _o$4810)))))) local)))
+  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec4830 ((name name)) (let* ((_o$4831 (keyword #f "op")) (_o$4832 (keyword #f "local")) (_o$4833 (keyword #f "name")) (_o$4834 name)) (jolt-hash-map _o$4831 _o$4832 _o$4833 _o$4834)))))) local)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec4811 ((ns ns) (name name)) (let* ((_o$4812 (keyword #f "op")) (_o$4813 (keyword #f "var")) (_o$4814 (keyword #f "ns")) (_o$4815 ns) (_o$4816 (keyword #f "name")) (_o$4817 name)) (jolt-hash-map _o$4812 _o$4813 _o$4814 _o$4815 _o$4816 _o$4817)))))) var-ref)))
+  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec4835 ((ns ns) (name name)) (let* ((_o$4836 (keyword #f "op")) (_o$4837 (keyword #f "var")) (_o$4838 (keyword #f "ns")) (_o$4839 ns) (_o$4840 (keyword #f "name")) (_o$4841 name)) (jolt-hash-map _o$4836 _o$4837 _o$4838 _o$4839 _o$4840 _o$4841)))))) var-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec4818 ((ns ns) (name name)) (let* ((_o$4819 (keyword #f "op")) (_o$4820 (keyword #f "the-var")) (_o$4821 (keyword #f "ns")) (_o$4822 ns) (_o$4823 (keyword #f "name")) (_o$4824 name)) (jolt-hash-map _o$4819 _o$4820 _o$4821 _o$4822 _o$4823 _o$4824)))))) the-var)))
+  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec4842 ((ns ns) (name name)) (let* ((_o$4843 (keyword #f "op")) (_o$4844 (keyword #f "the-var")) (_o$4845 (keyword #f "ns")) (_o$4846 ns) (_o$4847 (keyword #f "name")) (_o$4848 name)) (jolt-hash-map _o$4843 _o$4844 _o$4845 _o$4846 _o$4847 _o$4848)))))) the-var)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec4825 ((name name)) (let* ((_o$4826 (keyword #f "op")) (_o$4827 (keyword #f "host")) (_o$4828 (keyword #f "name")) (_o$4829 name)) (jolt-hash-map _o$4826 _o$4827 _o$4828 _o$4829)))))) host-ref)))
+  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec4849 ((name name)) (let* ((_o$4850 (keyword #f "op")) (_o$4851 (keyword #f "host")) (_o$4852 (keyword #f "name")) (_o$4853 name)) (jolt-hash-map _o$4850 _o$4851 _o$4852 _o$4853)))))) host-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec4830 ((class class) (member member)) (let* ((_o$4831 (keyword #f "op")) (_o$4832 (keyword #f "host-static")) (_o$4833 (keyword #f "class")) (_o$4834 class) (_o$4835 (keyword #f "member")) (_o$4836 member)) (jolt-hash-map _o$4831 _o$4832 _o$4833 _o$4834 _o$4835 _o$4836)))))) host-static)))
+  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec4854 ((class class) (member member)) (let* ((_o$4855 (keyword #f "op")) (_o$4856 (keyword #f "host-static")) (_o$4857 (keyword #f "class")) (_o$4858 class) (_o$4859 (keyword #f "member")) (_o$4860 member)) (jolt-hash-map _o$4855 _o$4856 _o$4857 _o$4858 _o$4859 _o$4860)))))) host-static)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec4837 ((class class) (args args)) (let* ((_o$4838 (keyword #f "op")) (_o$4839 (keyword #f "host-new")) (_o$4840 (keyword #f "class")) (_o$4841 class) (_o$4842 (keyword #f "args")) (_o$4843 args)) (jolt-hash-map _o$4838 _o$4839 _o$4840 _o$4841 _o$4842 _o$4843)))))) host-new)))
+  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec4861 ((class class) (args args)) (let* ((_o$4862 (keyword #f "op")) (_o$4863 (keyword #f "host-new")) (_o$4864 (keyword #f "class")) (_o$4865 class) (_o$4866 (keyword #f "args")) (_o$4867 args)) (jolt-hash-map _o$4862 _o$4863 _o$4864 _o$4865 _o$4866 _o$4867)))))) host-new)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec4844 ((test test) (then then) (_else _else)) (let* ((_o$4845 (keyword #f "op")) (_o$4846 (keyword #f "if")) (_o$4847 (keyword #f "test")) (_o$4848 test) (_o$4849 (keyword #f "then")) (_o$4850 then) (_o$4851 (keyword #f "else")) (_o$4852 _else)) (jolt-hash-map _o$4845 _o$4846 _o$4847 _o$4848 _o$4849 _o$4850 _o$4851 _o$4852)))))) if-node)))
+  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec4868 ((test test) (then then) (_else _else)) (let* ((_o$4869 (keyword #f "op")) (_o$4870 (keyword #f "if")) (_o$4871 (keyword #f "test")) (_o$4872 test) (_o$4873 (keyword #f "then")) (_o$4874 then) (_o$4875 (keyword #f "else")) (_o$4876 _else)) (jolt-hash-map _o$4869 _o$4870 _o$4871 _o$4872 _o$4873 _o$4874 _o$4875 _o$4876)))))) if-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec4853 ((statements statements) (ret ret)) (let* ((_o$4854 (keyword #f "op")) (_o$4855 (keyword #f "do")) (_o$4856 (keyword #f "statements")) (_o$4857 statements) (_o$4858 (keyword #f "ret")) (_o$4859 ret)) (jolt-hash-map _o$4854 _o$4855 _o$4856 _o$4857 _o$4858 _o$4859)))))) do-node)))
+  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec4877 ((statements statements) (ret ret)) (let* ((_o$4878 (keyword #f "op")) (_o$4879 (keyword #f "do")) (_o$4880 (keyword #f "statements")) (_o$4881 statements) (_o$4882 (keyword #f "ret")) (_o$4883 ret)) (jolt-hash-map _o$4878 _o$4879 _o$4880 _o$4881 _o$4882 _o$4883)))))) do-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec4860 ((f f) (args args)) (let* ((_o$4861 (keyword #f "op")) (_o$4862 (keyword #f "invoke")) (_o$4863 (keyword #f "fn")) (_o$4864 f) (_o$4865 (keyword #f "args")) (_o$4866 args)) (jolt-hash-map _o$4861 _o$4862 _o$4863 _o$4864 _o$4865 _o$4866)))))) invoke)))
+  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec4884 ((f f) (args args)) (let* ((_o$4885 (keyword #f "op")) (_o$4886 (keyword #f "invoke")) (_o$4887 (keyword #f "fn")) (_o$4888 f) (_o$4889 (keyword #f "args")) (_o$4890 args)) (jolt-hash-map _o$4885 _o$4886 _o$4887 _o$4888 _o$4889 _o$4890)))))) invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec4867 ((ns ns) (name name) (init init)) (let* ((_o$4868 (keyword #f "op")) (_o$4869 (keyword #f "def")) (_o$4870 (keyword #f "ns")) (_o$4871 ns) (_o$4872 (keyword #f "name")) (_o$4873 name) (_o$4874 (keyword #f "init")) (_o$4875 init)) (jolt-hash-map _o$4868 _o$4869 _o$4870 _o$4871 _o$4872 _o$4873 _o$4874 _o$4875)))) ((ns name init meta) (let fnrec4876 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$4877 (keyword #f "op")) (_o$4878 (keyword #f "def")) (_o$4879 (keyword #f "ns")) (_o$4880 ns) (_o$4881 (keyword #f "name")) (_o$4882 name) (_o$4883 (keyword #f "init")) (_o$4884 init) (_o$4885 (keyword #f "meta")) (_o$4886 meta)) (jolt-hash-map _o$4877 _o$4878 _o$4879 _o$4880 _o$4881 _o$4882 _o$4883 _o$4884 _o$4885 _o$4886)) (let* ((_o$4887 (keyword #f "op")) (_o$4888 (keyword #f "def")) (_o$4889 (keyword #f "ns")) (_o$4890 ns) (_o$4891 (keyword #f "name")) (_o$4892 name) (_o$4893 (keyword #f "init")) (_o$4894 init)) (jolt-hash-map _o$4887 _o$4888 _o$4889 _o$4890 _o$4891 _o$4892 _o$4893 _o$4894)))))))) def-node)))
+  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec4891 ((ns ns) (name name) (init init)) (let* ((_o$4892 (keyword #f "op")) (_o$4893 (keyword #f "def")) (_o$4894 (keyword #f "ns")) (_o$4895 ns) (_o$4896 (keyword #f "name")) (_o$4897 name) (_o$4898 (keyword #f "init")) (_o$4899 init)) (jolt-hash-map _o$4892 _o$4893 _o$4894 _o$4895 _o$4896 _o$4897 _o$4898 _o$4899)))) ((ns name init meta) (let fnrec4900 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$4901 (keyword #f "op")) (_o$4902 (keyword #f "def")) (_o$4903 (keyword #f "ns")) (_o$4904 ns) (_o$4905 (keyword #f "name")) (_o$4906 name) (_o$4907 (keyword #f "init")) (_o$4908 init) (_o$4909 (keyword #f "meta")) (_o$4910 meta)) (jolt-hash-map _o$4901 _o$4902 _o$4903 _o$4904 _o$4905 _o$4906 _o$4907 _o$4908 _o$4909 _o$4910)) (let* ((_o$4911 (keyword #f "op")) (_o$4912 (keyword #f "def")) (_o$4913 (keyword #f "ns")) (_o$4914 ns) (_o$4915 (keyword #f "name")) (_o$4916 name) (_o$4917 (keyword #f "init")) (_o$4918 init)) (jolt-hash-map _o$4911 _o$4912 _o$4913 _o$4914 _o$4915 _o$4916 _o$4917 _o$4918)))))))) def-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec4895 ((bindings bindings) (body body)) (let* ((_o$4896 (keyword #f "op")) (_o$4897 (keyword #f "let")) (_o$4898 (keyword #f "bindings")) (_o$4899 bindings) (_o$4900 (keyword #f "body")) (_o$4901 body)) (jolt-hash-map _o$4896 _o$4897 _o$4898 _o$4899 _o$4900 _o$4901)))))) let-node)))
+  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec4919 ((bindings bindings) (body body)) (let* ((_o$4920 (keyword #f "op")) (_o$4921 (keyword #f "let")) (_o$4922 (keyword #f "bindings")) (_o$4923 bindings) (_o$4924 (keyword #f "body")) (_o$4925 body)) (jolt-hash-map _o$4920 _o$4921 _o$4922 _o$4923 _o$4924 _o$4925)))))) let-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec4902 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$4903 (keyword #f "op")) (_o$4904 (keyword #f "fn")) (_o$4905 (keyword #f "name")) (_o$4906 name) (_o$4907 (keyword #f "arities")) (_o$4908 arities)) (jolt-hash-map _o$4903 _o$4904 _o$4905 _o$4906 _o$4907 _o$4908)) (let* ((_o$4909 (keyword #f "op")) (_o$4910 (keyword #f "fn")) (_o$4911 (keyword #f "arities")) (_o$4912 arities)) (jolt-hash-map _o$4909 _o$4910 _o$4911 _o$4912))))))) fn-node)))
+  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec4926 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$4927 (keyword #f "op")) (_o$4928 (keyword #f "fn")) (_o$4929 (keyword #f "name")) (_o$4930 name) (_o$4931 (keyword #f "arities")) (_o$4932 arities)) (jolt-hash-map _o$4927 _o$4928 _o$4929 _o$4930 _o$4931 _o$4932)) (let* ((_o$4933 (keyword #f "op")) (_o$4934 (keyword #f "fn")) (_o$4935 (keyword #f "arities")) (_o$4936 arities)) (jolt-hash-map _o$4933 _o$4934 _o$4935 _o$4936))))))) fn-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec4913 ((items items)) (let* ((_o$4914 (keyword #f "op")) (_o$4915 (keyword #f "vector")) (_o$4916 (keyword #f "items")) (_o$4917 items)) (jolt-hash-map _o$4914 _o$4915 _o$4916 _o$4917)))))) vector-node)))
+  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec4937 ((items items)) (let* ((_o$4938 (keyword #f "op")) (_o$4939 (keyword #f "vector")) (_o$4940 (keyword #f "items")) (_o$4941 items)) (jolt-hash-map _o$4938 _o$4939 _o$4940 _o$4941)))))) vector-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec4918 ((pairs pairs)) (let* ((_o$4919 (keyword #f "op")) (_o$4920 (keyword #f "map")) (_o$4921 (keyword #f "pairs")) (_o$4922 pairs)) (jolt-hash-map _o$4919 _o$4920 _o$4921 _o$4922)))))) map-node)))
+  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec4942 ((pairs pairs)) (let* ((_o$4943 (keyword #f "op")) (_o$4944 (keyword #f "map")) (_o$4945 (keyword #f "pairs")) (_o$4946 pairs)) (jolt-hash-map _o$4943 _o$4944 _o$4945 _o$4946)))))) map-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec4923 ((items items)) (let* ((_o$4924 (keyword #f "op")) (_o$4925 (keyword #f "set")) (_o$4926 (keyword #f "items")) (_o$4927 items)) (jolt-hash-map _o$4924 _o$4925 _o$4926 _o$4927)))))) set-node)))
+  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec4947 ((items items)) (let* ((_o$4948 (keyword #f "op")) (_o$4949 (keyword #f "set")) (_o$4950 (keyword #f "items")) (_o$4951 items)) (jolt-hash-map _o$4948 _o$4949 _o$4950 _o$4951)))))) set-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec4928 ((form form)) (let* ((_o$4929 (keyword #f "op")) (_o$4930 (keyword #f "quote")) (_o$4931 (keyword #f "form")) (_o$4932 form)) (jolt-hash-map _o$4929 _o$4930 _o$4931 _o$4932)))))) quote-node)))
+  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec4952 ((form form)) (let* ((_o$4953 (keyword #f "op")) (_o$4954 (keyword #f "quote")) (_o$4955 (keyword #f "form")) (_o$4956 form)) (jolt-hash-map _o$4953 _o$4954 _o$4955 _o$4956)))))) quote-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec4933 ((expr expr)) (let* ((_o$4934 (keyword #f "op")) (_o$4935 (keyword #f "throw")) (_o$4936 (keyword #f "expr")) (_o$4937 expr)) (jolt-hash-map _o$4934 _o$4935 _o$4936 _o$4937)))))) throw-node)))
+  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec4957 ((expr expr)) (let* ((_o$4958 (keyword #f "op")) (_o$4959 (keyword #f "throw")) (_o$4960 (keyword #f "expr")) (_o$4961 expr)) (jolt-hash-map _o$4958 _o$4959 _o$4960 _o$4961)))))) throw-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec4938 ((kind kind) (expr expr)) (let* ((_o$4939 (keyword #f "op")) (_o$4940 (keyword #f "coerce")) (_o$4941 (keyword #f "kind")) (_o$4942 kind) (_o$4943 (keyword #f "expr")) (_o$4944 expr)) (jolt-hash-map _o$4939 _o$4940 _o$4941 _o$4942 _o$4943 _o$4944)))))) coerce-node)))
+  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec4962 ((kind kind) (expr expr)) (let* ((_o$4963 (keyword #f "op")) (_o$4964 (keyword #f "coerce")) (_o$4965 (keyword #f "kind")) (_o$4966 kind) (_o$4967 (keyword #f "expr")) (_o$4968 expr)) (jolt-hash-map _o$4963 _o$4964 _o$4965 _o$4966 _o$4967 _o$4968)))))) coerce-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec4945 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$4946 node) (_a$4947 (keyword #f "test")) (_a$4948 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$4949 (keyword #f "then")) (_a$4950 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$4951 (keyword #f "else")) (_a$4952 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$4946 _a$4947 _a$4948 _a$4949 _a$4950 _a$4951 _a$4952)) (if (jolt= op (keyword #f "do")) (let* ((_a$4953 node) (_a$4954 (keyword #f "statements")) (_a$4955 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$4956 (keyword #f "ret")) (_a$4957 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$4953 _a$4954 _a$4955 _a$4956 _a$4957)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$4958 node) (_a$4959 (keyword #f "obj")) (_a$4960 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$4961 (keyword #f "val")) (_a$4962 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$4958 _a$4959 _a$4960 _a$4961 _a$4962)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$4963 node) (_a$4964 (keyword #f "fn")) (_a$4965 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$4966 (keyword #f "args")) (_a$4967 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$4963 _a$4964 _a$4965 _a$4966 _a$4967)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$4971 (var-deref "clojure.core" "mapv")) (_a$4972 (lambda (pr) (let fnrec4968 ((pr pr)) (let* ((_o$4969 (jolt-invoke f (jolt-nth pr 0))) (_o$4970 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$4969 _o$4970))))) (_a$4973 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$4971 _a$4972 _a$4973))) (if (jolt= op (keyword #f "let")) (let* ((_a$4980 node) (_a$4981 (keyword #f "bindings")) (_a$4982 (let* ((_a$4977 (var-deref "clojure.core" "mapv")) (_a$4978 (lambda (b) (let fnrec4974 ((b b)) (let* ((_o$4975 (jolt-nth b 0)) (_o$4976 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$4975 _o$4976))))) (_a$4979 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$4977 _a$4978 _a$4979))) (_a$4983 (keyword #f "body")) (_a$4984 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$4980 _a$4981 _a$4982 _a$4983 _a$4984)) (if (jolt= op (keyword #f "loop")) (let* ((_a$4991 node) (_a$4992 (keyword #f "bindings")) (_a$4993 (let* ((_a$4988 (var-deref "clojure.core" "mapv")) (_a$4989 (lambda (b) (let fnrec4985 ((b b)) (let* ((_o$4986 (jolt-nth b 0)) (_o$4987 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$4986 _o$4987))))) (_a$4990 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$4988 _a$4989 _a$4990))) (_a$4994 (keyword #f "body")) (_a$4995 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$4991 _a$4992 _a$4993 _a$4994 _a$4995)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$4997 (var-deref "clojure.core" "mapv")) (_a$4998 (lambda (a) (let fnrec4996 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$4999 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$4997 _a$4998 _a$4999))) (if (jolt= op (keyword #f "def")) (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))) (if (jolt= op (keyword #f "host-call")) (let* ((_a$5000 node) (_a$5001 (keyword #f "target")) (_a$5002 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$5003 (keyword #f "args")) (_a$5004 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$5000 _a$5001 _a$5002 _a$5003 _a$5004)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children)))
+  (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec4969 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$4970 node) (_a$4971 (keyword #f "test")) (_a$4972 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$4973 (keyword #f "then")) (_a$4974 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$4975 (keyword #f "else")) (_a$4976 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$4970 _a$4971 _a$4972 _a$4973 _a$4974 _a$4975 _a$4976)) (if (jolt= op (keyword #f "do")) (let* ((_a$4977 node) (_a$4978 (keyword #f "statements")) (_a$4979 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$4980 (keyword #f "ret")) (_a$4981 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$4977 _a$4978 _a$4979 _a$4980 _a$4981)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$4982 node) (_a$4983 (keyword #f "obj")) (_a$4984 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$4985 (keyword #f "val")) (_a$4986 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$4982 _a$4983 _a$4984 _a$4985 _a$4986)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$4987 node) (_a$4988 (keyword #f "fn")) (_a$4989 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$4990 (keyword #f "args")) (_a$4991 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$4987 _a$4988 _a$4989 _a$4990 _a$4991)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$4995 (var-deref "clojure.core" "mapv")) (_a$4996 (lambda (pr) (let fnrec4992 ((pr pr)) (let* ((_o$4993 (jolt-invoke f (jolt-nth pr 0))) (_o$4994 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$4993 _o$4994))))) (_a$4997 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$4995 _a$4996 _a$4997))) (if (jolt= op (keyword #f "let")) (let* ((_a$5004 node) (_a$5005 (keyword #f "bindings")) (_a$5006 (let* ((_a$5001 (var-deref "clojure.core" "mapv")) (_a$5002 (lambda (b) (let fnrec4998 ((b b)) (let* ((_o$4999 (jolt-nth b 0)) (_o$5000 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$4999 _o$5000))))) (_a$5003 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$5001 _a$5002 _a$5003))) (_a$5007 (keyword #f "body")) (_a$5008 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$5004 _a$5005 _a$5006 _a$5007 _a$5008)) (if (jolt= op (keyword #f "loop")) (let* ((_a$5015 node) (_a$5016 (keyword #f "bindings")) (_a$5017 (let* ((_a$5012 (var-deref "clojure.core" "mapv")) (_a$5013 (lambda (b) (let fnrec5009 ((b b)) (let* ((_o$5010 (jolt-nth b 0)) (_o$5011 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$5010 _o$5011))))) (_a$5014 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$5012 _a$5013 _a$5014))) (_a$5018 (keyword #f "body")) (_a$5019 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$5015 _a$5016 _a$5017 _a$5018 _a$5019)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$5021 (var-deref "clojure.core" "mapv")) (_a$5022 (lambda (a) (let fnrec5020 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$5023 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5021 _a$5022 _a$5023))) (if (jolt= op (keyword #f "def")) (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))) (if (jolt= op (keyword #f "host-call")) (let* ((_a$5024 node) (_a$5025 (keyword #f "target")) (_a$5026 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$5027 (keyword #f "args")) (_a$5028 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$5024 _a$5025 _a$5026 _a$5027 _a$5028)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec5005 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$5009 f) (_a$5010 (let* ((_a$5006 f) (_a$5007 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$5008 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$5006 _a$5007 _a$5008))) (_a$5011 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$5009 _a$5010 _a$5011)) (if (jolt= op (keyword #f "do")) (let* ((_a$5012 f) (_a$5013 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$5014 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$5012 _a$5013 _a$5014)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$5015 f) (_a$5016 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$5017 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$5015 _a$5016 _a$5017)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$5018 f) (_a$5019 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$5020 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$5018 _a$5019 _a$5020)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$5025 (lambda (a pr) (let fnrec5021 ((a a) (pr pr)) (let* ((_a$5022 f) (_a$5023 (jolt-invoke f a (jolt-nth pr 0))) (_a$5024 (jolt-nth pr 1))) (jolt-invoke _a$5022 _a$5023 _a$5024))))) (_a$5026 acc) (_a$5027 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$5025 _a$5026 _a$5027)) (if (jolt= op (keyword #f "let")) (let* ((_a$5032 f) (_a$5033 (let* ((_a$5029 (lambda (a b) (let fnrec5028 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$5030 acc) (_a$5031 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5029 _a$5030 _a$5031))) (_a$5034 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$5032 _a$5033 _a$5034)) (if (jolt= op (keyword #f "loop")) (let* ((_a$5039 f) (_a$5040 (let* ((_a$5036 (lambda (a b) (let fnrec5035 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$5037 acc) (_a$5038 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5036 _a$5037 _a$5038))) (_a$5041 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$5039 _a$5040 _a$5041)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$5043 (lambda (a ar) (let fnrec5042 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$5044 acc) (_a$5045 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$5043 _a$5044 _a$5045)) (if (jolt= op (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc) (if (jolt= op (keyword #f "host-call")) (let* ((_a$5046 f) (_a$5047 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$5048 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$5046 _a$5047 _a$5048)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children)))
+  (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec5029 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$5033 f) (_a$5034 (let* ((_a$5030 f) (_a$5031 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$5032 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$5030 _a$5031 _a$5032))) (_a$5035 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$5033 _a$5034 _a$5035)) (if (jolt= op (keyword #f "do")) (let* ((_a$5036 f) (_a$5037 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$5038 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$5036 _a$5037 _a$5038)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$5039 f) (_a$5040 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$5041 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$5039 _a$5040 _a$5041)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$5042 f) (_a$5043 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$5044 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$5042 _a$5043 _a$5044)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$5049 (lambda (a pr) (let fnrec5045 ((a a) (pr pr)) (let* ((_a$5046 f) (_a$5047 (jolt-invoke f a (jolt-nth pr 0))) (_a$5048 (jolt-nth pr 1))) (jolt-invoke _a$5046 _a$5047 _a$5048))))) (_a$5050 acc) (_a$5051 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$5049 _a$5050 _a$5051)) (if (jolt= op (keyword #f "let")) (let* ((_a$5056 f) (_a$5057 (let* ((_a$5053 (lambda (a b) (let fnrec5052 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$5054 acc) (_a$5055 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5053 _a$5054 _a$5055))) (_a$5058 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$5056 _a$5057 _a$5058)) (if (jolt= op (keyword #f "loop")) (let* ((_a$5063 f) (_a$5064 (let* ((_a$5060 (lambda (a b) (let fnrec5059 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$5061 acc) (_a$5062 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5060 _a$5061 _a$5062))) (_a$5065 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$5063 _a$5064 _a$5065)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$5067 (lambda (a ar) (let fnrec5066 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$5068 acc) (_a$5069 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$5067 _a$5068 _a$5069)) (if (jolt= op (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc) (if (jolt= op (keyword #f "host-call")) (let* ((_a$5070 f) (_a$5071 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$5072 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$5070 _a$5071 _a$5072)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children)))
 (guard (e (#t #f))
   (declare-var! "jolt.analyzer" "analyze"))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$5049 "quote") (_o$5050 "if") (_o$5051 "do") (_o$5052 "def") (_o$5053 "fn*") (_o$5054 "let*") (_o$5055 "loop*") (_o$5056 "recur") (_o$5057 "throw") (_o$5058 "try") (_o$5059 "syntax-quote") (_o$5060 "var") (_o$5061 "letfn") (_o$5062 "set!") (_o$5063 "defmacro")) (jolt-hash-set _o$5049 _o$5050 _o$5051 _o$5052 _o$5053 _o$5054 _o$5055 _o$5056 _o$5057 _o$5058 _o$5059 _o$5060 _o$5061 _o$5062 _o$5063)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$5073 "quote") (_o$5074 "if") (_o$5075 "do") (_o$5076 "def") (_o$5077 "fn*") (_o$5078 "let*") (_o$5079 "loop*") (_o$5080 "recur") (_o$5081 "throw") (_o$5082 "try") (_o$5083 "syntax-quote") (_o$5084 "var") (_o$5085 "letfn") (_o$5086 "set!") (_o$5087 "defmacro")) (jolt-hash-set _o$5073 _o$5074 _o$5075 _o$5076 _o$5077 _o$5078 _o$5079 _o$5080 _o$5081 _o$5082 _o$5083 _o$5084 _o$5085 _o$5086 _o$5087)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec5064 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable)))
+  (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec5088 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec5065 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name)))
+  (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec5089 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec5066 () (let* ((_o$5067 (keyword #f "locals")) (_o$5068 (jolt-hash-set)) (_o$5069 (keyword #f "hints")) (_o$5070 (jolt-hash-map))) (jolt-hash-map _o$5067 _o$5068 _o$5069 _o$5070)))))) empty-env)))
+  (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec5090 () (let* ((_o$5091 (keyword #f "locals")) (_o$5092 (jolt-hash-set)) (_o$5093 (keyword #f "hints")) (_o$5094 (jolt-hash-map))) (jolt-hash-map _o$5091 _o$5092 _o$5093 _o$5094)))))) empty-env)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec5071 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?)))
+  (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec5095 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec5072 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__47_) (let fnrec5073 ((p__47_ p__47_)) (jolt-reduce jolt-conj p__47_ names)))))))) add-locals)))
+  (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec5096 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__47_) (let fnrec5097 ((p__47_ p__47_)) (jolt-reduce jolt-conj p__47_ names)))))))) add-locals)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec5074 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur)))
+  (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec5098 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec5075 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__13__auto t)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__13__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of)))
+  (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec5099 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__13__auto t)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__13__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec5076 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint)))
+  (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec5100 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec5077 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of)))
+  (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec5101 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec5078 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind)))
+  (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec5102 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec5079 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of)))
+  (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec5103 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec5080 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__13__auto kind)) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__13__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$5082 (var-deref "clojure.core" "mapv")) (_a$5083 (lambda (a) (let fnrec5081 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$5084 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5082 _a$5083 _a$5084))) node))))) with-ret-nhint)))
+  (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec5104 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__13__auto kind)) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__13__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$5106 (var-deref "clojure.core" "mapv")) (_a$5107 (lambda (a) (let fnrec5105 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$5108 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5106 _a$5107 _a$5108))) node))))) with-ret-nhint)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec5085 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__48_) (let fnrec5086 ((p__48_ p__48_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__48_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$5087 (var-deref "jolt.ir" "do-node")) (_a$5088 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$5089 (jolt-peek v))) (jolt-invoke _a$5087 _a$5088 _a$5089)) jolt-nil)))))))) analyze-seq)))
+  (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec5109 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__48_) (let fnrec5110 ((p__48_ p__48_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__48_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$5111 (var-deref "jolt.ir" "do-node")) (_a$5112 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$5113 (jolt-peek v))) (jolt-invoke _a$5111 _a$5112 _a$5113)) jolt-nil)))))))) analyze-seq)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec5090 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop5091 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$5098 (+ i 2)) (_a$5099 (let* ((_a$5092 (var-deref "jolt.analyzer" "add-hint")) (_a$5093 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$5094 nm) (_a$5095 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$5092 _a$5093 _a$5094 _a$5095))) (_a$5100 (jolt-conj pairs (let* ((_o$5096 nm) (_o$5097 init)) (jolt-vector _o$5096 _o$5097))))) (loop5091 _a$5098 _a$5099 _a$5100))))) (let* ((_o$5101 pairs) (_o$5102 env)) (jolt-vector _o$5101 _o$5102))))))))) analyze-bindings)))
+  (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec5114 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop5115 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$5122 (+ i 2)) (_a$5123 (let* ((_a$5116 (var-deref "jolt.analyzer" "add-hint")) (_a$5117 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$5118 nm) (_a$5119 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$5116 _a$5117 _a$5118 _a$5119))) (_a$5124 (jolt-conj pairs (let* ((_o$5120 nm) (_o$5121 init)) (jolt-vector _o$5120 _o$5121))))) (loop5115 _a$5122 _a$5123 _a$5124))))) (let* ((_o$5125 pairs) (_o$5126 env)) (jolt-vector _o$5125 _o$5126))))))))) analyze-bindings)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec5103 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop5104 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$5105 (+ i 2)) (_a$5106 fixed) (_a$5107 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$5108 hints) (_a$5109 phints) (_a$5110 nhints)) (loop5104 _a$5105 _a$5106 _a$5107 _a$5108 _a$5109 _a$5110)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$5117 (jolt-inc i)) (_a$5118 (jolt-conj fixed nm)) (_a$5119 rest-name) (_a$5120 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$5111 nm) (_o$5112 h)) (jolt-vector _o$5111 _o$5112))) hints)) (_a$5121 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$5113 nm) (_o$5114 ph)) (jolt-vector _o$5113 _o$5114))) phints)) (_a$5122 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$5115 nm) (_o$5116 nh)) (jolt-vector _o$5115 _o$5116))) nhints))) (loop5104 _a$5117 _a$5118 _a$5119 _a$5120 _a$5121 _a$5122)))))) (let* ((_o$5123 (keyword #f "fixed")) (_o$5124 fixed) (_o$5125 (keyword #f "rest")) (_o$5126 rest-name) (_o$5127 (keyword #f "hints")) (_o$5128 hints) (_o$5129 (keyword #f "phints")) (_o$5130 phints) (_o$5131 (keyword #f "nhints")) (_o$5132 nhints)) (jolt-hash-map _o$5123 _o$5124 _o$5125 _o$5126 _o$5127 _o$5128 _o$5129 _o$5130 _o$5131 _o$5132))))))))) parse-params)))
+  (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec5127 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop5128 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$5129 (+ i 2)) (_a$5130 fixed) (_a$5131 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$5132 hints) (_a$5133 phints) (_a$5134 nhints)) (loop5128 _a$5129 _a$5130 _a$5131 _a$5132 _a$5133 _a$5134)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$5141 (jolt-inc i)) (_a$5142 (jolt-conj fixed nm)) (_a$5143 rest-name) (_a$5144 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$5135 nm) (_o$5136 h)) (jolt-vector _o$5135 _o$5136))) hints)) (_a$5145 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$5137 nm) (_o$5138 ph)) (jolt-vector _o$5137 _o$5138))) phints)) (_a$5146 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$5139 nm) (_o$5140 nh)) (jolt-vector _o$5139 _o$5140))) nhints))) (loop5128 _a$5141 _a$5142 _a$5143 _a$5144 _a$5145 _a$5146)))))) (let* ((_o$5147 (keyword #f "fixed")) (_o$5148 fixed) (_o$5149 (keyword #f "rest")) (_o$5150 rest-name) (_o$5151 (keyword #f "hints")) (_o$5152 hints) (_o$5153 (keyword #f "phints")) (_o$5154 phints) (_o$5155 (keyword #f "nhints")) (_o$5156 nhints)) (jolt-hash-map _o$5147 _o$5148 _o$5149 _o$5150 _o$5151 _o$5152 _o$5153 _o$5154 _o$5155 _o$5156))))))))) parse-params)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec5133 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop5134 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop5135 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop5135 (jolt-inc j)) jolt-nil))))))) (let* ((_a$5136 (jolt-inc i)) (_a$5137 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop5134 _a$5136 _a$5137))) out)))))))) uniquify-params)))
+  (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec5157 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop5158 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop5159 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop5159 (jolt-inc j)) jolt-nil))))))) (let* ((_a$5160 (jolt-inc i)) (_a$5161 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop5158 _a$5160 _a$5161))) out)))))))) uniquify-params)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec5138 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$5139 (var-deref "clojure.core" "str")) (_a$5140 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$5141 "/") (_a$5142 (let* ((or__14__auto fn-name)) (if (jolt-truthy? or__14__auto) or__14__auto "fn"))) (_a$5143 "--")) (jolt-invoke _a$5139 _a$5140 _a$5141 _a$5142 _a$5143)))) (names (let* ((G__41 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__42 (if (jolt-truthy? rst) (jolt-conj G__41 rst) G__41))) (let* ((G__43 (if (jolt-truthy? fn-name) (jolt-conj G__42 fn-name) G__42))) G__43)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$5149 (lambda (e pr) (let fnrec5144 ((e e) (pr pr)) (let* ((_a$5145 (var-deref "jolt.analyzer" "add-hint")) (_a$5146 e) (_a$5147 (jolt-nth pr 0)) (_a$5148 (jolt-nth pr 1))) (jolt-invoke _a$5145 _a$5146 _a$5147 _a$5148))))) (_a$5150 env0) (_a$5151 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$5149 _a$5150 _a$5151))) (arity (let* ((_o$5152 (keyword #f "params")) (_o$5153 fixed) (_o$5154 (keyword #f "recur-name")) (_o$5155 rname) (_o$5156 (keyword #f "body")) (_o$5157 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$5152 _o$5153 _o$5154 _o$5155 _o$5156 _o$5157))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity)))
+  (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec5162 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$5163 (var-deref "clojure.core" "str")) (_a$5164 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$5165 "/") (_a$5166 (let* ((or__14__auto fn-name)) (if (jolt-truthy? or__14__auto) or__14__auto "fn"))) (_a$5167 "--")) (jolt-invoke _a$5163 _a$5164 _a$5165 _a$5166 _a$5167)))) (names (let* ((G__41 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__42 (if (jolt-truthy? rst) (jolt-conj G__41 rst) G__41))) (let* ((G__43 (if (jolt-truthy? fn-name) (jolt-conj G__42 fn-name) G__42))) G__43)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$5173 (lambda (e pr) (let fnrec5168 ((e e) (pr pr)) (let* ((_a$5169 (var-deref "jolt.analyzer" "add-hint")) (_a$5170 e) (_a$5171 (jolt-nth pr 0)) (_a$5172 (jolt-nth pr 1))) (jolt-invoke _a$5169 _a$5170 _a$5171 _a$5172))))) (_a$5174 env0) (_a$5175 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$5173 _a$5174 _a$5175))) (arity (let* ((_o$5176 (keyword #f "params")) (_o$5177 fixed) (_o$5178 (keyword #f "recur-name")) (_o$5179 rname) (_o$5180 (keyword #f "body")) (_o$5181 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$5176 _o$5177 _o$5178 _o$5179 _o$5180 _o$5181))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec5158 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__13__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta)))
+  (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec5182 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__13__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec5159 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec5160 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$5161 (var-deref "jolt.analyzer" "analyze-arity")) (_a$5162 ctx) (_a$5163 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$5164 (jolt-rest cl)) (_a$5165 env) (_a$5166 fn-name)) (jolt-invoke _a$5161 _a$5162 _a$5163 _a$5164 _a$5165 _a$5166))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn)))
+  (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec5183 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec5184 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$5185 (var-deref "jolt.analyzer" "analyze-arity")) (_a$5186 ctx) (_a$5187 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$5188 (jolt-rest cl)) (_a$5189 env) (_a$5190 fn-name)) (jolt-invoke _a$5185 _a$5186 _a$5187 _a$5188 _a$5189 _a$5190))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec5167 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catch-sym (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil)) (catch-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil)) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec5168 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__13__auto head)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__13__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (jolt-truthy? (let* ((or__14__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2)))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "reset!") catch-sym (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth cl 2))) (jolt-invoke (var-deref "clojure.core" "reset!") catch-body (jolt-drop 3 cl)))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$5169 (keyword #f "op")) (_o$5170 (keyword #f "try")) (_o$5171 (keyword #f "body")) (_o$5172 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$5169 _o$5170 _o$5171 _o$5172))) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") catch-body)) (let* ((_a$5177 n) (_a$5178 (keyword #f "catch-sym")) (_a$5179 (jolt-invoke (var-deref "clojure.core" "deref") catch-sym)) (_a$5180 (keyword #f "catch-body")) (_a$5181 (let* ((_a$5173 (var-deref "jolt.analyzer" "analyze-seq")) (_a$5174 ctx) (_a$5175 (jolt-invoke (var-deref "clojure.core" "deref") catch-body)) (_a$5176 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector (jolt-invoke (var-deref "clojure.core" "deref") catch-sym))))) (jolt-invoke _a$5173 _a$5174 _a$5175 _a$5176)))) (jolt-assoc _a$5177 _a$5178 _a$5179 _a$5180 _a$5181)) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try)))
+  (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec5191 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catch-sym (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil)) (catch-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil)) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec5192 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__13__auto head)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__13__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (jolt-truthy? (let* ((or__14__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2)))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "reset!") catch-sym (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth cl 2))) (jolt-invoke (var-deref "clojure.core" "reset!") catch-body (jolt-drop 3 cl)))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$5193 (keyword #f "op")) (_o$5194 (keyword #f "try")) (_o$5195 (keyword #f "body")) (_o$5196 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$5193 _o$5194 _o$5195 _o$5196))) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") catch-body)) (let* ((_a$5201 n) (_a$5202 (keyword #f "catch-sym")) (_a$5203 (jolt-invoke (var-deref "clojure.core" "deref") catch-sym)) (_a$5204 (keyword #f "catch-body")) (_a$5205 (let* ((_a$5197 (var-deref "jolt.analyzer" "analyze-seq")) (_a$5198 ctx) (_a$5199 (jolt-invoke (var-deref "clojure.core" "deref") catch-body)) (_a$5200 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector (jolt-invoke (var-deref "clojure.core" "deref") catch-sym))))) (jolt-invoke _a$5197 _a$5198 _a$5199 _a$5200)))) (jolt-assoc _a$5201 _a$5202 _a$5203 _a$5204 _a$5205)) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec5182 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__49_) (let fnrec5183 ((p__49_ p__49_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__49_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec5184 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$5185 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$5186 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$5185 _o$5186))))) specs))) (let* ((_o$5187 (keyword #f "op")) (_o$5188 (keyword #f "let")) (_o$5189 (keyword #f "letrec")) (_o$5190 #t) (_o$5191 (keyword #f "bindings")) (_o$5192 binds) (_o$5193 (keyword #f "body")) (_o$5194 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$5187 _o$5188 _o$5189 _o$5190 _o$5191 _o$5192 _o$5193 _o$5194))))))) analyze-letfn)))
+  (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec5206 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__49_) (let fnrec5207 ((p__49_ p__49_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__49_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec5208 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$5209 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$5210 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$5209 _o$5210))))) specs))) (let* ((_o$5211 (keyword #f "op")) (_o$5212 (keyword #f "let")) (_o$5213 (keyword #f "letrec")) (_o$5214 #t) (_o$5215 (keyword #f "bindings")) (_o$5216 binds) (_o$5217 (keyword #f "body")) (_o$5218 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$5211 _o$5212 _o$5213 _o$5214 _o$5215 _o$5216 _o$5217 _o$5218))))))) analyze-letfn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec5195 ((nm nm)) (let* ((and__13__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__13__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__13__auto)))))) field-head?)))
+  (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec5219 ((nm nm)) (let* ((and__13__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__13__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__13__auto)))))) field-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec5196 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$5197 (keyword #f "op")) (_o$5198 (keyword #f "def")) (_o$5199 (keyword #f "ns")) (_o$5200 cur) (_o$5201 (keyword #f "name")) (_o$5202 nm) (_o$5203 (keyword #f "no-init")) (_o$5204 #t)) (jolt-hash-map _o$5197 _o$5198 _o$5199 _o$5200 _o$5201 _o$5202 _o$5203 _o$5204)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__13__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__13__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__14__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$5205 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$5206 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$5207 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$5205 _a$5206 _a$5207)) node-meta)))))))))) analyze-def)))
+  (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec5220 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$5221 (keyword #f "op")) (_o$5222 (keyword #f "def")) (_o$5223 (keyword #f "ns")) (_o$5224 cur) (_o$5225 (keyword #f "name")) (_o$5226 nm) (_o$5227 (keyword #f "no-init")) (_o$5228 #t)) (jolt-hash-map _o$5221 _o$5222 _o$5223 _o$5224 _o$5225 _o$5226 _o$5227 _o$5228)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__13__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__13__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__14__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$5229 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$5230 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$5231 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$5229 _a$5230 _a$5231)) node-meta)))))))))) analyze-def)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec5208 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__13__auto ti)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__13__auto thead)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__13__auto))) (let* ((_o$5209 (keyword #f "op")) (_o$5210 (keyword #f "set-field")) (_o$5211 (keyword #f "obj")) (_o$5212 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$5213 (keyword #f "field")) (_o$5214 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$5215 (keyword #f "val")) (_o$5216 val-node)) (jolt-hash-map _o$5209 _o$5210 _o$5211 _o$5212 _o$5213 _o$5214 _o$5215 _o$5216)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$5220 (keyword #f "op")) (_o$5221 (keyword #f "set-var")) (_o$5222 (keyword #f "the-var")) (_o$5223 (let* ((_a$5217 (var-deref "jolt.ir" "the-var")) (_a$5218 (jolt-get r (keyword #f "ns"))) (_a$5219 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5217 _a$5218 _a$5219))) (_o$5224 (keyword #f "val")) (_o$5225 val-node)) (jolt-hash-map _o$5220 _o$5221 _o$5222 _o$5223 _o$5224 _o$5225))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil)))))))) analyze-set!)))
+  (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec5232 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__13__auto ti)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__13__auto thead)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__13__auto))) (let* ((_o$5233 (keyword #f "op")) (_o$5234 (keyword #f "set-field")) (_o$5235 (keyword #f "obj")) (_o$5236 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$5237 (keyword #f "field")) (_o$5238 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$5239 (keyword #f "val")) (_o$5240 val-node)) (jolt-hash-map _o$5233 _o$5234 _o$5235 _o$5236 _o$5237 _o$5238 _o$5239 _o$5240)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$5244 (keyword #f "op")) (_o$5245 (keyword #f "set-var")) (_o$5246 (keyword #f "the-var")) (_o$5247 (let* ((_a$5241 (var-deref "jolt.ir" "the-var")) (_a$5242 (jolt-get r (keyword #f "ns"))) (_a$5243 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5241 _a$5242 _a$5243))) (_o$5248 (keyword #f "val")) (_o$5249 val-node)) (jolt-hash-map _o$5244 _o$5245 _o$5246 _o$5247 _o$5248 _o$5249))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil)))))))) analyze-set!)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec5226 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__44 op)) (if (jolt= G__44 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__44 "if") (begin (if (jolt-truthy? (let* ((or__14__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__14__auto) or__14__auto (> (jolt-count items) 4)))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$5227 (var-deref "jolt.ir" "if-node")) (_a$5228 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$5229 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$5230 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$5227 _a$5228 _a$5229 _a$5230))) (if (jolt= G__44 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__44 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__44 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__44 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$5235 (var-deref "jolt.ir" "let-node")) (_a$5236 (jolt-first r)) (_a$5237 (let* ((_a$5231 (var-deref "jolt.analyzer" "analyze-seq")) (_a$5232 ctx) (_a$5233 (jolt-drop 2 items)) (_a$5234 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$5231 _a$5232 _a$5233 _a$5234)))) (jolt-invoke _a$5235 _a$5236 _a$5237))) (if (jolt= G__44 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$5238 (keyword #f "op")) (_o$5239 (keyword #f "loop")) (_o$5240 (keyword #f "recur-name")) (_o$5241 rname) (_o$5242 (keyword #f "bindings")) (_o$5243 (jolt-first r)) (_o$5244 (keyword #f "body")) (_o$5245 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$5238 _o$5239 _o$5240 _o$5241 _o$5242 _o$5243 _o$5244 _o$5245))) (if (jolt= G__44 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$5250 (keyword #f "op")) (_o$5251 (keyword #f "recur")) (_o$5252 (keyword #f "recur-name")) (_o$5253 rt) (_o$5254 (keyword #f "args")) (_o$5255 (let* ((_a$5247 (var-deref "clojure.core" "mapv")) (_a$5248 (lambda (p__50_) (let fnrec5246 ((p__50_ p__50_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__50_ env)))) (_a$5249 (jolt-rest items))) (jolt-invoke _a$5247 _a$5248 _a$5249)))) (jolt-hash-map _o$5250 _o$5251 _o$5252 _o$5253 _o$5254 _o$5255)))) (if (jolt= G__44 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__44 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__44 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__44 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__44 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$5256 (var-deref "jolt.ir" "the-var")) (_a$5257 (jolt-get r (keyword #f "ns"))) (_a$5258 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5256 _a$5257 _a$5258)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__44 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$5259 (keyword #f "op")) (_o$5260 (keyword #f "defmacro")) (_o$5261 (keyword #f "ns")) (_o$5262 cur) (_o$5263 (keyword #f "name")) (_o$5264 nm) (_o$5265 (keyword #f "fn")) (_o$5266 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$5259 _o$5260 _o$5261 _o$5262 _o$5263 _o$5264 _o$5265 _o$5266)))) (if (jolt= G__44 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special)))
+  (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec5250 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__44 op)) (if (jolt= G__44 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__44 "if") (begin (if (jolt-truthy? (let* ((or__14__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__14__auto) or__14__auto (> (jolt-count items) 4)))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$5251 (var-deref "jolt.ir" "if-node")) (_a$5252 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$5253 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$5254 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$5251 _a$5252 _a$5253 _a$5254))) (if (jolt= G__44 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__44 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__44 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__44 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$5259 (var-deref "jolt.ir" "let-node")) (_a$5260 (jolt-first r)) (_a$5261 (let* ((_a$5255 (var-deref "jolt.analyzer" "analyze-seq")) (_a$5256 ctx) (_a$5257 (jolt-drop 2 items)) (_a$5258 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$5255 _a$5256 _a$5257 _a$5258)))) (jolt-invoke _a$5259 _a$5260 _a$5261))) (if (jolt= G__44 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$5262 (keyword #f "op")) (_o$5263 (keyword #f "loop")) (_o$5264 (keyword #f "recur-name")) (_o$5265 rname) (_o$5266 (keyword #f "bindings")) (_o$5267 (jolt-first r)) (_o$5268 (keyword #f "body")) (_o$5269 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$5262 _o$5263 _o$5264 _o$5265 _o$5266 _o$5267 _o$5268 _o$5269))) (if (jolt= G__44 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$5274 (keyword #f "op")) (_o$5275 (keyword #f "recur")) (_o$5276 (keyword #f "recur-name")) (_o$5277 rt) (_o$5278 (keyword #f "args")) (_o$5279 (let* ((_a$5271 (var-deref "clojure.core" "mapv")) (_a$5272 (lambda (p__50_) (let fnrec5270 ((p__50_ p__50_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__50_ env)))) (_a$5273 (jolt-rest items))) (jolt-invoke _a$5271 _a$5272 _a$5273)))) (jolt-hash-map _o$5274 _o$5275 _o$5276 _o$5277 _o$5278 _o$5279)))) (if (jolt= G__44 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__44 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__44 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__44 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__44 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$5280 (var-deref "jolt.ir" "the-var")) (_a$5281 (jolt-get r (keyword #f "ns"))) (_a$5282 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5280 _a$5281 _a$5282)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__44 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$5283 (keyword #f "op")) (_o$5284 (keyword #f "defmacro")) (_o$5285 (keyword #f "ns")) (_o$5286 cur) (_o$5287 (keyword #f "name")) (_o$5288 nm) (_o$5289 (keyword #f "fn")) (_o$5290 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$5283 _o$5284 _o$5285 _o$5286 _o$5287 _o$5288 _o$5289 _o$5290)))) (if (jolt= G__44 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec5267 ((nm nm)) (let* ((and__13__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__13__auto)) and__13__auto)) and__13__auto)))))) method-head?)))
+  (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec5291 ((nm nm)) (let* ((and__13__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__13__auto)) and__13__auto)) and__13__auto)))))) method-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec5268 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$5273 (keyword #f "op")) (_o$5274 (keyword #f "host-call")) (_o$5275 (keyword #f "method")) (_o$5276 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$5277 (keyword #f "target")) (_o$5278 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5279 (keyword #f "args")) (_o$5280 (let* ((_a$5270 (var-deref "clojure.core" "mapv")) (_a$5271 (lambda (p__51_) (let fnrec5269 ((p__51_ p__51_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__51_ env)))) (_a$5272 (jolt-drop 2 items))) (jolt-invoke _a$5270 _a$5271 _a$5272)))) (jolt-hash-map _o$5273 _o$5274 _o$5275 _o$5276 _o$5277 _o$5278 _o$5279 _o$5280))))))) analyze-host-call)))
+  (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec5292 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$5297 (keyword #f "op")) (_o$5298 (keyword #f "host-call")) (_o$5299 (keyword #f "method")) (_o$5300 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$5301 (keyword #f "target")) (_o$5302 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5303 (keyword #f "args")) (_o$5304 (let* ((_a$5294 (var-deref "clojure.core" "mapv")) (_a$5295 (lambda (p__51_) (let fnrec5293 ((p__51_ p__51_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__51_ env)))) (_a$5296 (jolt-drop 2 items))) (jolt-invoke _a$5294 _a$5295 _a$5296)))) (jolt-hash-map _o$5297 _o$5298 _o$5299 _o$5300 _o$5301 _o$5302 _o$5303 _o$5304))))))) analyze-host-call)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec5281 ((nm nm)) (let* ((and__13__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "." (let* ((_a$5282 (var-deref "clojure.core" "subs")) (_a$5283 nm) (_a$5284 (jolt-dec (jolt-count nm))) (_a$5285 (jolt-count nm))) (jolt-invoke _a$5282 _a$5283 _a$5284 _a$5285))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__13__auto)) and__13__auto)))))) ctor-head?)))
+  (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec5305 ((nm nm)) (let* ((and__13__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "." (let* ((_a$5306 (var-deref "clojure.core" "subs")) (_a$5307 nm) (_a$5308 (jolt-dec (jolt-count nm))) (_a$5309 (jolt-count nm))) (jolt-invoke _a$5306 _a$5307 _a$5308 _a$5309))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__13__auto)) and__13__auto)))))) ctor-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec5286 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__52_) (let fnrec5287 ((p__52_ p__52_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__52_ env))) args)))))) analyze-ctor)))
+  (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec5310 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__52_) (let fnrec5311 ((p__52_ p__52_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__52_ env))) args)))))) analyze-ctor)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec5288 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$5289 (keyword #f "op")) (_o$5290 (keyword #f "ffi-fn")) (_o$5291 (keyword #f "csym")) (_o$5292 (jolt-nth items 1)) (_o$5293 (keyword #f "argtypes")) (_o$5294 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$5295 (keyword #f "rettype")) (_o$5296 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$5297 (keyword #f "blocking")) (_o$5298 (let* ((and__13__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__13__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__13__auto)))) (jolt-hash-map _o$5289 _o$5290 _o$5291 _o$5292 _o$5293 _o$5294 _o$5295 _o$5296 _o$5297 _o$5298))))))) analyze-ffi-fn)))
+  (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec5312 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$5313 (keyword #f "op")) (_o$5314 (keyword #f "ffi-fn")) (_o$5315 (keyword #f "csym")) (_o$5316 (jolt-nth items 1)) (_o$5317 (keyword #f "argtypes")) (_o$5318 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$5319 (keyword #f "rettype")) (_o$5320 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$5321 (keyword #f "blocking")) (_o$5322 (let* ((and__13__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__13__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__13__auto)))) (jolt-hash-map _o$5313 _o$5314 _o$5315 _o$5316 _o$5317 _o$5318 _o$5319 _o$5320 _o$5321 _o$5322))))))) analyze-ffi-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec5299 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$5300 (keyword #f "op")) (_o$5301 (keyword #f "ffi-callable")) (_o$5302 (keyword #f "fn")) (_o$5303 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5304 (keyword #f "argtypes")) (_o$5305 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$5306 (keyword #f "rettype")) (_o$5307 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$5308 (keyword #f "collect-safe")) (_o$5309 (let* ((and__13__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__13__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__13__auto)))) (jolt-hash-map _o$5300 _o$5301 _o$5302 _o$5303 _o$5304 _o$5305 _o$5306 _o$5307 _o$5308 _o$5309))))))) analyze-ffi-callable)))
+  (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec5323 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$5324 (keyword #f "op")) (_o$5325 (keyword #f "ffi-callable")) (_o$5326 (keyword #f "fn")) (_o$5327 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5328 (keyword #f "argtypes")) (_o$5329 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$5330 (keyword #f "rettype")) (_o$5331 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$5332 (keyword #f "collect-safe")) (_o$5333 (let* ((and__13__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__13__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__13__auto)))) (jolt-hash-map _o$5324 _o$5325 _o$5326 _o$5327 _o$5328 _o$5329 _o$5330 _o$5331 _o$5332 _o$5333))))))) analyze-ffi-callable)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec5310 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member (jolt-nth items 2))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$5315 (keyword #f "op")) (_o$5316 (keyword #f "host-call")) (_o$5317 (keyword #f "method")) (_o$5318 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$5319 (keyword #f "target")) (_o$5320 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5321 (keyword #f "args")) (_o$5322 (let* ((_a$5312 (var-deref "clojure.core" "mapv")) (_a$5313 (lambda (p__53_) (let fnrec5311 ((p__53_ p__53_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__53_ env)))) (_a$5314 (jolt-drop 3 items))) (jolt-invoke _a$5312 _a$5313 _a$5314)))) (jolt-hash-map _o$5315 _o$5316 _o$5317 _o$5318 _o$5319 _o$5320 _o$5321 _o$5322)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$5323 (var-deref "jolt.ir" "invoke")) (_a$5324 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$5325 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$5323 _a$5324 _a$5325)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil))))))))) analyze-dot)))
+  (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec5334 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member (jolt-nth items 2))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$5339 (keyword #f "op")) (_o$5340 (keyword #f "host-call")) (_o$5341 (keyword #f "method")) (_o$5342 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$5343 (keyword #f "target")) (_o$5344 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5345 (keyword #f "args")) (_o$5346 (let* ((_a$5336 (var-deref "clojure.core" "mapv")) (_a$5337 (lambda (p__53_) (let fnrec5335 ((p__53_ p__53_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__53_ env)))) (_a$5338 (jolt-drop 3 items))) (jolt-invoke _a$5336 _a$5337 _a$5338)))) (jolt-hash-map _o$5339 _o$5340 _o$5341 _o$5342 _o$5343 _o$5344 _o$5345 _o$5346)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$5347 (var-deref "jolt.ir" "invoke")) (_a$5348 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$5349 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$5347 _a$5348 _a$5349)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil))))))))) analyze-dot)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec5326 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$5327 (keyword #f "op")) (_o$5328 (keyword #f "host-call")) (_o$5329 (keyword #f "method")) (_o$5330 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$5331 (keyword #f "target")) (_o$5332 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5333 (keyword #f "args")) (_o$5334 (jolt-vector))) (jolt-hash-map _o$5327 _o$5328 _o$5329 _o$5330 _o$5331 _o$5332 _o$5333 _o$5334))))))) analyze-field)))
+  (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec5350 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$5351 (keyword #f "op")) (_o$5352 (keyword #f "host-call")) (_o$5353 (keyword #f "method")) (_o$5354 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$5355 (keyword #f "target")) (_o$5356 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$5357 (keyword #f "args")) (_o$5358 (jolt-vector))) (jolt-hash-map _o$5351 _o$5352 _o$5353 _o$5354 _o$5355 _o$5356 _o$5357 _o$5358))))))) analyze-field)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec5335 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "nil?") ns))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__13__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__45 (let* ((_a$5336 (var-deref "jolt.ir" "var-ref")) (_a$5337 (jolt-get r (keyword #f "ns"))) (_a$5338 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5336 _a$5337 _a$5338)))) (let* ((G__46 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__45 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__45))) G__46)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__47 (jolt-get r (keyword #f "kind")))) (if (jolt= G__47 (keyword #f "var")) (let* ((G__48 (let* ((_a$5339 (var-deref "jolt.ir" "var-ref")) (_a$5340 (jolt-get r (keyword #f "ns"))) (_a$5341 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5339 _a$5340 _a$5341)))) (let* ((G__49 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__48 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__48))) G__49)) (if (jolt= G__47 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context"))))))) jolt-nil)))))))) analyze-symbol)))
+  (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec5359 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "nil?") ns))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__13__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__45 (let* ((_a$5360 (var-deref "jolt.ir" "var-ref")) (_a$5361 (jolt-get r (keyword #f "ns"))) (_a$5362 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5360 _a$5361 _a$5362)))) (let* ((G__46 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__45 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__45))) G__46)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__47 (jolt-get r (keyword #f "kind")))) (if (jolt= G__47 (keyword #f "var")) (let* ((G__48 (let* ((_a$5363 (var-deref "jolt.ir" "var-ref")) (_a$5364 (jolt-get r (keyword #f "ns"))) (_a$5365 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$5363 _a$5364 _a$5365)))) (let* ((G__49 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__48 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__48))) G__49)) (if (jolt= G__47 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context"))))))) jolt-nil)))))))) analyze-symbol)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec5342 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__13__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__13__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__13__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__13__auto)) and__13__auto))) (let* ((_a$5343 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$5344 ctx) (_a$5345 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$5346 (jolt-rest items)) (_a$5347 env)) (jolt-invoke _a$5343 _a$5344 _a$5345 _a$5346 _a$5347)) (if (jolt-truthy? (let* ((and__13__auto (jolt= hname "new"))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__13__auto)) and__13__auto)) and__13__auto))) (let* ((_a$5348 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$5349 ctx) (_a$5350 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$5351 (jolt-drop 2 items)) (_a$5352 env)) (jolt-invoke _a$5348 _a$5349 _a$5350 _a$5351 _a$5352)) (if (jolt-truthy? (let* ((and__13__auto (jolt= hname "."))) (if (jolt-truthy? and__13__auto) (jolt-not shadowed) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$5357 (var-deref "jolt.ir" "invoke")) (_a$5358 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$5359 (let* ((_a$5354 (var-deref "clojure.core" "mapv")) (_a$5355 (lambda (p__54_) (let fnrec5353 ((p__54_ p__54_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__54_ env)))) (_a$5356 (jolt-rest items))) (jolt-invoke _a$5354 _a$5355 _a$5356)))) (jolt-invoke _a$5357 _a$5358 _a$5359))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil)))))))))))))))))) analyze-list)))
+  (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec5366 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__13__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__13__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__13__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__13__auto)) and__13__auto))) (let* ((_a$5367 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$5368 ctx) (_a$5369 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$5370 (jolt-rest items)) (_a$5371 env)) (jolt-invoke _a$5367 _a$5368 _a$5369 _a$5370 _a$5371)) (if (jolt-truthy? (let* ((and__13__auto (jolt= hname "new"))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__13__auto)) and__13__auto)) and__13__auto))) (let* ((_a$5372 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$5373 ctx) (_a$5374 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$5375 (jolt-drop 2 items)) (_a$5376 env)) (jolt-invoke _a$5372 _a$5373 _a$5374 _a$5375 _a$5376)) (if (jolt-truthy? (let* ((and__13__auto (jolt= hname "."))) (if (jolt-truthy? and__13__auto) (jolt-not shadowed) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__13__auto hname)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not shadowed))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$5381 (var-deref "jolt.ir" "invoke")) (_a$5382 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$5383 (let* ((_a$5378 (var-deref "clojure.core" "mapv")) (_a$5379 (lambda (p__54_) (let fnrec5377 ((p__54_ p__54_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__54_ env)))) (_a$5380 (jolt-rest items))) (jolt-invoke _a$5378 _a$5379 _a$5380)))) (jolt-invoke _a$5381 _a$5382 _a$5383))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil)))))))))))))))))) analyze-list)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec5360 ((ctx ctx) (form form)) (jolt-invoke analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec5361 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$5363 (var-deref "clojure.core" "mapv")) (_a$5364 (lambda (p__55_) (let fnrec5362 ((p__55_ p__55_)) (jolt-invoke analyze ctx p__55_ env)))) (_a$5365 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$5363 _a$5364 _a$5365))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$5369 (var-deref "clojure.core" "mapv")) (_a$5370 (lambda (p) (let fnrec5366 ((p p)) (let* ((_o$5367 (jolt-invoke analyze ctx (jolt-first p) env)) (_o$5368 (jolt-invoke analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$5367 _o$5368))))) (_a$5371 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$5369 _a$5370 _a$5371))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$5373 (var-deref "clojure.core" "mapv")) (_a$5374 (lambda (p__56_) (let fnrec5372 ((p__56_ p__56_)) (jolt-invoke analyze ctx p__56_ env)))) (_a$5375 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$5373 _a$5374 _a$5375))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$5376 (keyword #f "op")) (_o$5377 (keyword #f "regex")) (_o$5378 (keyword #f "source")) (_o$5379 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$5376 _o$5377 _o$5378 _o$5379)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$5380 (keyword #f "op")) (_o$5381 (keyword #f "inst")) (_o$5382 (keyword #f "source")) (_o$5383 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$5380 _o$5381 _o$5382 _o$5383)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$5384 (keyword #f "op")) (_o$5385 (keyword #f "uuid")) (_o$5386 (keyword #f "source")) (_o$5387 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$5384 _o$5385 _o$5386 _o$5387)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$5388 (keyword #f "op")) (_o$5389 (keyword #f "bigdec")) (_o$5390 (keyword #f "source")) (_o$5391 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$5388 _o$5389 _o$5390 _o$5391)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$5392 (keyword #f "op")) (_o$5393 (keyword #f "the-ns")) (_o$5394 (keyword #f "name")) (_o$5395 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$5392 _o$5393 _o$5394 _o$5395)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil))))))))))))))))) analyze)))
+  (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec5384 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) node (let* ((_a$5387 (var-deref "jolt.ir" "invoke")) (_a$5388 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$5389 (let* ((_o$5385 node) (_o$5386 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$5385 _o$5386)))) (jolt-invoke _a$5387 _a$5388 _a$5389)))))))) with-coll-meta)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$3974 "+") (_o$3975 "+") (_o$3976 "-") (_o$3977 "-") (_o$3978 "*") (_o$3979 "*") (_o$3980 "/") (_o$3981 "/") (_o$3982 "<") (_o$3983 "<") (_o$3984 ">") (_o$3985 ">") (_o$3986 "<=") (_o$3987 "<=") (_o$3988 ">=") (_o$3989 ">=") (_o$3990 "=") (_o$3991 "jolt=") (_o$3992 "inc") (_o$3993 "jolt-inc") (_o$3994 "dec") (_o$3995 "jolt-dec") (_o$3996 "not") (_o$3997 "jolt-not") (_o$3998 "min") (_o$3999 "min") (_o$4000 "max") (_o$4001 "max") (_o$4002 "mod") (_o$4003 "modulo") (_o$4004 "rem") (_o$4005 "remainder") (_o$4006 "quot") (_o$4007 "quotient") (_o$4008 "vector") (_o$4009 "jolt-vector") (_o$4010 "hash-map") (_o$4011 "jolt-hash-map") (_o$4012 "hash-set") (_o$4013 "jolt-hash-set") (_o$4014 "conj") (_o$4015 "jolt-conj") (_o$4016 "get") (_o$4017 "jolt-get") (_o$4018 "nth") (_o$4019 "jolt-nth") (_o$4020 "count") (_o$4021 "jolt-count") (_o$4022 "assoc") (_o$4023 "jolt-assoc") (_o$4024 "dissoc") (_o$4025 "jolt-dissoc") (_o$4026 "contains?") (_o$4027 "jolt-contains?") (_o$4028 "empty?") (_o$4029 "jolt-empty?") (_o$4030 "peek") (_o$4031 "jolt-peek") (_o$4032 "pop") (_o$4033 "jolt-pop") (_o$4034 "first") (_o$4035 "jolt-first") (_o$4036 "rest") (_o$4037 "jolt-rest") (_o$4038 "next") (_o$4039 "jolt-next") (_o$4040 "seq") (_o$4041 "jolt-seq") (_o$4042 "cons") (_o$4043 "jolt-cons") (_o$4044 "list") (_o$4045 "jolt-list") (_o$4046 "reverse") (_o$4047 "jolt-reverse") (_o$4048 "last") (_o$4049 "jolt-last") (_o$4050 "map") (_o$4051 "jolt-map") (_o$4052 "filter") (_o$4053 "jolt-filter") (_o$4054 "remove") (_o$4055 "jolt-remove") (_o$4056 "reduce") (_o$4057 "jolt-reduce") (_o$4058 "into") (_o$4059 "jolt-into") (_o$4060 "concat") (_o$4061 "jolt-concat") (_o$4062 "apply") (_o$4063 "jolt-apply") (_o$4064 "range") (_o$4065 "jolt-range") (_o$4066 "take") (_o$4067 "jolt-take") (_o$4068 "drop") (_o$4069 "jolt-drop") (_o$4070 "keys") (_o$4071 "jolt-keys") (_o$4072 "vals") (_o$4073 "jolt-vals") (_o$4074 "even?") (_o$4075 "jolt-even?") (_o$4076 "odd?") (_o$4077 "jolt-odd?") (_o$4078 "pos?") (_o$4079 "jolt-pos?") (_o$4080 "neg?") (_o$4081 "jolt-neg?") (_o$4082 "zero?") (_o$4083 "jolt-zero?") (_o$4084 "identity") (_o$4085 "jolt-identity") (_o$4086 "ex-info") (_o$4087 "jolt-ex-info")) (jolt-hash-map _o$3974 _o$3975 _o$3976 _o$3977 _o$3978 _o$3979 _o$3980 _o$3981 _o$3982 _o$3983 _o$3984 _o$3985 _o$3986 _o$3987 _o$3988 _o$3989 _o$3990 _o$3991 _o$3992 _o$3993 _o$3994 _o$3995 _o$3996 _o$3997 _o$3998 _o$3999 _o$4000 _o$4001 _o$4002 _o$4003 _o$4004 _o$4005 _o$4006 _o$4007 _o$4008 _o$4009 _o$4010 _o$4011 _o$4012 _o$4013 _o$4014 _o$4015 _o$4016 _o$4017 _o$4018 _o$4019 _o$4020 _o$4021 _o$4022 _o$4023 _o$4024 _o$4025 _o$4026 _o$4027 _o$4028 _o$4029 _o$4030 _o$4031 _o$4032 _o$4033 _o$4034 _o$4035 _o$4036 _o$4037 _o$4038 _o$4039 _o$4040 _o$4041 _o$4042 _o$4043 _o$4044 _o$4045 _o$4046 _o$4047 _o$4048 _o$4049 _o$4050 _o$4051 _o$4052 _o$4053 _o$4054 _o$4055 _o$4056 _o$4057 _o$4058 _o$4059 _o$4060 _o$4061 _o$4062 _o$4063 _o$4064 _o$4065 _o$4066 _o$4067 _o$4068 _o$4069 _o$4070 _o$4071 _o$4072 _o$4073 _o$4074 _o$4075 _o$4076 _o$4077 _o$4078 _o$4079 _o$4080 _o$4081 _o$4082 _o$4083 _o$4084 _o$4085 _o$4086 _o$4087)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec5390 ((ctx ctx) (form form)) (jolt-invoke analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec5391 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$5393 (var-deref "clojure.core" "mapv")) (_a$5394 (lambda (p__55_) (let fnrec5392 ((p__55_ p__55_)) (jolt-invoke analyze ctx p__55_ env)))) (_a$5395 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$5393 _a$5394 _a$5395)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$5399 (var-deref "clojure.core" "mapv")) (_a$5400 (lambda (p) (let fnrec5396 ((p p)) (let* ((_o$5397 (jolt-invoke analyze ctx (jolt-first p) env)) (_o$5398 (jolt-invoke analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$5397 _o$5398))))) (_a$5401 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$5399 _a$5400 _a$5401)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$5403 (var-deref "clojure.core" "mapv")) (_a$5404 (lambda (p__56_) (let fnrec5402 ((p__56_ p__56_)) (jolt-invoke analyze ctx p__56_ env)))) (_a$5405 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$5403 _a$5404 _a$5405)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$5406 (keyword #f "op")) (_o$5407 (keyword #f "regex")) (_o$5408 (keyword #f "source")) (_o$5409 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$5406 _o$5407 _o$5408 _o$5409)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$5410 (keyword #f "op")) (_o$5411 (keyword #f "inst")) (_o$5412 (keyword #f "source")) (_o$5413 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$5410 _o$5411 _o$5412 _o$5413)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$5414 (keyword #f "op")) (_o$5415 (keyword #f "uuid")) (_o$5416 (keyword #f "source")) (_o$5417 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$5414 _o$5415 _o$5416 _o$5417)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$5418 (keyword #f "op")) (_o$5419 (keyword #f "bigdec")) (_o$5420 (keyword #f "source")) (_o$5421 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$5418 _o$5419 _o$5420 _o$5421)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$5422 (keyword #f "op")) (_o$5423 (keyword #f "the-ns")) (_o$5424 (keyword #f "name")) (_o$5425 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$5422 _o$5423 _o$5424 _o$5425)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil))))))))))))))))) analyze)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "core-value-procs" (jolt-invoke (var-deref "clojure.core" "merge") (var-deref "jolt.backend-scheme" "native-ops") (let* ((_o$4088 "+") (_o$4089 "jolt-add") (_o$4090 "-") (_o$4091 "jolt-sub") (_o$4092 "*") (_o$4093 "jolt-mul") (_o$4094 "/") (_o$4095 "jolt-div")) (jolt-hash-map _o$4088 _o$4089 _o$4090 _o$4091 _o$4092 _o$4093 _o$4094 _o$4095))) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$3998 "+") (_o$3999 "+") (_o$4000 "-") (_o$4001 "-") (_o$4002 "*") (_o$4003 "*") (_o$4004 "/") (_o$4005 "/") (_o$4006 "<") (_o$4007 "<") (_o$4008 ">") (_o$4009 ">") (_o$4010 "<=") (_o$4011 "<=") (_o$4012 ">=") (_o$4013 ">=") (_o$4014 "=") (_o$4015 "jolt=") (_o$4016 "inc") (_o$4017 "jolt-inc") (_o$4018 "dec") (_o$4019 "jolt-dec") (_o$4020 "not") (_o$4021 "jolt-not") (_o$4022 "min") (_o$4023 "min") (_o$4024 "max") (_o$4025 "max") (_o$4026 "mod") (_o$4027 "modulo") (_o$4028 "rem") (_o$4029 "remainder") (_o$4030 "quot") (_o$4031 "quotient") (_o$4032 "vector") (_o$4033 "jolt-vector") (_o$4034 "hash-map") (_o$4035 "jolt-hash-map") (_o$4036 "hash-set") (_o$4037 "jolt-hash-set") (_o$4038 "conj") (_o$4039 "jolt-conj") (_o$4040 "get") (_o$4041 "jolt-get") (_o$4042 "nth") (_o$4043 "jolt-nth") (_o$4044 "count") (_o$4045 "jolt-count") (_o$4046 "assoc") (_o$4047 "jolt-assoc") (_o$4048 "dissoc") (_o$4049 "jolt-dissoc") (_o$4050 "contains?") (_o$4051 "jolt-contains?") (_o$4052 "empty?") (_o$4053 "jolt-empty?") (_o$4054 "peek") (_o$4055 "jolt-peek") (_o$4056 "pop") (_o$4057 "jolt-pop") (_o$4058 "first") (_o$4059 "jolt-first") (_o$4060 "rest") (_o$4061 "jolt-rest") (_o$4062 "next") (_o$4063 "jolt-next") (_o$4064 "seq") (_o$4065 "jolt-seq") (_o$4066 "cons") (_o$4067 "jolt-cons") (_o$4068 "list") (_o$4069 "jolt-list") (_o$4070 "reverse") (_o$4071 "jolt-reverse") (_o$4072 "last") (_o$4073 "jolt-last") (_o$4074 "map") (_o$4075 "jolt-map") (_o$4076 "filter") (_o$4077 "jolt-filter") (_o$4078 "remove") (_o$4079 "jolt-remove") (_o$4080 "reduce") (_o$4081 "jolt-reduce") (_o$4082 "into") (_o$4083 "jolt-into") (_o$4084 "concat") (_o$4085 "jolt-concat") (_o$4086 "apply") (_o$4087 "jolt-apply") (_o$4088 "range") (_o$4089 "jolt-range") (_o$4090 "take") (_o$4091 "jolt-take") (_o$4092 "drop") (_o$4093 "jolt-drop") (_o$4094 "keys") (_o$4095 "jolt-keys") (_o$4096 "vals") (_o$4097 "jolt-vals") (_o$4098 "even?") (_o$4099 "jolt-even?") (_o$4100 "odd?") (_o$4101 "jolt-odd?") (_o$4102 "pos?") (_o$4103 "jolt-pos?") (_o$4104 "neg?") (_o$4105 "jolt-neg?") (_o$4106 "zero?") (_o$4107 "jolt-zero?") (_o$4108 "identity") (_o$4109 "jolt-identity") (_o$4110 "ex-info") (_o$4111 "jolt-ex-info")) (jolt-hash-map _o$3998 _o$3999 _o$4000 _o$4001 _o$4002 _o$4003 _o$4004 _o$4005 _o$4006 _o$4007 _o$4008 _o$4009 _o$4010 _o$4011 _o$4012 _o$4013 _o$4014 _o$4015 _o$4016 _o$4017 _o$4018 _o$4019 _o$4020 _o$4021 _o$4022 _o$4023 _o$4024 _o$4025 _o$4026 _o$4027 _o$4028 _o$4029 _o$4030 _o$4031 _o$4032 _o$4033 _o$4034 _o$4035 _o$4036 _o$4037 _o$4038 _o$4039 _o$4040 _o$4041 _o$4042 _o$4043 _o$4044 _o$4045 _o$4046 _o$4047 _o$4048 _o$4049 _o$4050 _o$4051 _o$4052 _o$4053 _o$4054 _o$4055 _o$4056 _o$4057 _o$4058 _o$4059 _o$4060 _o$4061 _o$4062 _o$4063 _o$4064 _o$4065 _o$4066 _o$4067 _o$4068 _o$4069 _o$4070 _o$4071 _o$4072 _o$4073 _o$4074 _o$4075 _o$4076 _o$4077 _o$4078 _o$4079 _o$4080 _o$4081 _o$4082 _o$4083 _o$4084 _o$4085 _o$4086 _o$4087 _o$4088 _o$4089 _o$4090 _o$4091 _o$4092 _o$4093 _o$4094 _o$4095 _o$4096 _o$4097 _o$4098 _o$4099 _o$4100 _o$4101 _o$4102 _o$4103 _o$4104 _o$4105 _o$4106 _o$4107 _o$4108 _o$4109 _o$4110 _o$4111)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$4137 "inc") (_o$4138 (lambda (p__4_) (let fnrec4096 ((p__4_ p__4_)) (jolt= p__4_ 1)))) (_o$4139 "dec") (_o$4140 (lambda (p__5_) (let fnrec4097 ((p__5_ p__5_)) (jolt= p__5_ 1)))) (_o$4141 "not") (_o$4142 (lambda (p__6_) (let fnrec4098 ((p__6_ p__6_)) (jolt= p__6_ 1)))) (_o$4143 "count") (_o$4144 (lambda (p__7_) (let fnrec4099 ((p__7_ p__7_)) (jolt= p__7_ 1)))) (_o$4145 "empty?") (_o$4146 (lambda (p__8_) (let fnrec4100 ((p__8_ p__8_)) (jolt= p__8_ 1)))) (_o$4147 "peek") (_o$4148 (lambda (p__9_) (let fnrec4101 ((p__9_ p__9_)) (jolt= p__9_ 1)))) (_o$4149 "pop") (_o$4150 (lambda (p__10_) (let fnrec4102 ((p__10_ p__10_)) (jolt= p__10_ 1)))) (_o$4151 "mod") (_o$4152 (lambda (p__11_) (let fnrec4103 ((p__11_ p__11_)) (jolt= p__11_ 2)))) (_o$4153 "rem") (_o$4154 (lambda (p__12_) (let fnrec4104 ((p__12_ p__12_)) (jolt= p__12_ 2)))) (_o$4155 "quot") (_o$4156 (lambda (p__13_) (let fnrec4105 ((p__13_ p__13_)) (jolt= p__13_ 2)))) (_o$4157 "contains?") (_o$4158 (lambda (p__14_) (let fnrec4106 ((p__14_ p__14_)) (jolt= p__14_ 2)))) (_o$4159 "get") (_o$4160 (lambda (p__15_) (let fnrec4107 ((p__15_ p__15_)) (let* ((or__14__auto (jolt= p__15_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__15_ 3)))))) (_o$4161 "nth") (_o$4162 (lambda (p__16_) (let fnrec4108 ((p__16_ p__16_)) (let* ((or__14__auto (jolt= p__16_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__16_ 3)))))) (_o$4163 "assoc") (_o$4164 (lambda (p__17_) (let fnrec4109 ((p__17_ p__17_)) (let* ((and__13__auto (>= p__17_ 3))) (if (jolt-truthy? and__13__auto) (jolt-odd? p__17_) and__13__auto))))) (_o$4165 "dissoc") (_o$4166 (lambda (p__18_) (let fnrec4110 ((p__18_ p__18_)) (>= p__18_ 1)))) (_o$4167 "conj") (_o$4168 (lambda (p__19_) (let fnrec4111 ((p__19_ p__19_)) (>= p__19_ 1)))) (_o$4169 "first") (_o$4170 (lambda (p__20_) (let fnrec4112 ((p__20_ p__20_)) (jolt= p__20_ 1)))) (_o$4171 "rest") (_o$4172 (lambda (p__21_) (let fnrec4113 ((p__21_ p__21_)) (jolt= p__21_ 1)))) (_o$4173 "next") (_o$4174 (lambda (p__22_) (let fnrec4114 ((p__22_ p__22_)) (jolt= p__22_ 1)))) (_o$4175 "seq") (_o$4176 (lambda (p__23_) (let fnrec4115 ((p__23_ p__23_)) (jolt= p__23_ 1)))) (_o$4177 "reverse") (_o$4178 (lambda (p__24_) (let fnrec4116 ((p__24_ p__24_)) (jolt= p__24_ 1)))) (_o$4179 "last") (_o$4180 (lambda (p__25_) (let fnrec4117 ((p__25_ p__25_)) (jolt= p__25_ 1)))) (_o$4181 "keys") (_o$4182 (lambda (p__26_) (let fnrec4118 ((p__26_ p__26_)) (jolt= p__26_ 1)))) (_o$4183 "vals") (_o$4184 (lambda (p__27_) (let fnrec4119 ((p__27_ p__27_)) (jolt= p__27_ 1)))) (_o$4185 "even?") (_o$4186 (lambda (p__28_) (let fnrec4120 ((p__28_ p__28_)) (jolt= p__28_ 1)))) (_o$4187 "odd?") (_o$4188 (lambda (p__29_) (let fnrec4121 ((p__29_ p__29_)) (jolt= p__29_ 1)))) (_o$4189 "pos?") (_o$4190 (lambda (p__30_) (let fnrec4122 ((p__30_ p__30_)) (jolt= p__30_ 1)))) (_o$4191 "neg?") (_o$4192 (lambda (p__31_) (let fnrec4123 ((p__31_ p__31_)) (jolt= p__31_ 1)))) (_o$4193 "zero?") (_o$4194 (lambda (p__32_) (let fnrec4124 ((p__32_ p__32_)) (jolt= p__32_ 1)))) (_o$4195 "identity") (_o$4196 (lambda (p__33_) (let fnrec4125 ((p__33_ p__33_)) (jolt= p__33_ 1)))) (_o$4197 "cons") (_o$4198 (lambda (p__34_) (let fnrec4126 ((p__34_ p__34_)) (jolt= p__34_ 2)))) (_o$4199 "filter") (_o$4200 (lambda (p__35_) (let fnrec4127 ((p__35_ p__35_)) (jolt= p__35_ 2)))) (_o$4201 "remove") (_o$4202 (lambda (p__36_) (let fnrec4128 ((p__36_ p__36_)) (jolt= p__36_ 2)))) (_o$4203 "into") (_o$4204 (lambda (p__37_) (let fnrec4129 ((p__37_ p__37_)) (jolt= p__37_ 2)))) (_o$4205 "take") (_o$4206 (lambda (p__38_) (let fnrec4130 ((p__38_ p__38_)) (jolt= p__38_ 2)))) (_o$4207 "drop") (_o$4208 (lambda (p__39_) (let fnrec4131 ((p__39_ p__39_)) (jolt= p__39_ 2)))) (_o$4209 "map") (_o$4210 (lambda (p__40_) (let fnrec4132 ((p__40_ p__40_)) (>= p__40_ 2)))) (_o$4211 "apply") (_o$4212 (lambda (p__41_) (let fnrec4133 ((p__41_ p__41_)) (>= p__41_ 2)))) (_o$4213 "reduce") (_o$4214 (lambda (p__42_) (let fnrec4134 ((p__42_ p__42_)) (let* ((or__14__auto (jolt= p__42_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__42_ 3)))))) (_o$4215 "range") (_o$4216 (lambda (p__43_) (let fnrec4135 ((p__43_ p__43_)) (let* ((and__13__auto (>= p__43_ 0))) (if (jolt-truthy? and__13__auto) (<= p__43_ 3) and__13__auto))))) (_o$4217 "ex-info") (_o$4218 (lambda (p__44_) (let fnrec4136 ((p__44_ p__44_)) (let* ((or__14__auto (jolt= p__44_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__44_ 3))))))) (jolt-hash-map _o$4137 _o$4138 _o$4139 _o$4140 _o$4141 _o$4142 _o$4143 _o$4144 _o$4145 _o$4146 _o$4147 _o$4148 _o$4149 _o$4150 _o$4151 _o$4152 _o$4153 _o$4154 _o$4155 _o$4156 _o$4157 _o$4158 _o$4159 _o$4160 _o$4161 _o$4162 _o$4163 _o$4164 _o$4165 _o$4166 _o$4167 _o$4168 _o$4169 _o$4170 _o$4171 _o$4172 _o$4173 _o$4174 _o$4175 _o$4176 _o$4177 _o$4178 _o$4179 _o$4180 _o$4181 _o$4182 _o$4183 _o$4184 _o$4185 _o$4186 _o$4187 _o$4188 _o$4189 _o$4190 _o$4191 _o$4192 _o$4193 _o$4194 _o$4195 _o$4196 _o$4197 _o$4198 _o$4199 _o$4200 _o$4201 _o$4202 _o$4203 _o$4204 _o$4205 _o$4206 _o$4207 _o$4208 _o$4209 _o$4210 _o$4211 _o$4212 _o$4213 _o$4214 _o$4215 _o$4216 _o$4217 _o$4218)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "core-value-procs" (jolt-invoke (var-deref "clojure.core" "merge") (var-deref "jolt.backend-scheme" "native-ops") (let* ((_o$4112 "+") (_o$4113 "jolt-add") (_o$4114 "-") (_o$4115 "jolt-sub") (_o$4116 "*") (_o$4117 "jolt-mul") (_o$4118 "/") (_o$4119 "jolt-div")) (jolt-hash-map _o$4112 _o$4113 _o$4114 _o$4115 _o$4116 _o$4117 _o$4118 _o$4119))) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$4219 "<") (_o$4220 ">") (_o$4221 "<=") (_o$4222 ">=")) (jolt-hash-set _o$4219 _o$4220 _o$4221 _o$4222)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$4161 "inc") (_o$4162 (lambda (p__4_) (let fnrec4120 ((p__4_ p__4_)) (jolt= p__4_ 1)))) (_o$4163 "dec") (_o$4164 (lambda (p__5_) (let fnrec4121 ((p__5_ p__5_)) (jolt= p__5_ 1)))) (_o$4165 "not") (_o$4166 (lambda (p__6_) (let fnrec4122 ((p__6_ p__6_)) (jolt= p__6_ 1)))) (_o$4167 "count") (_o$4168 (lambda (p__7_) (let fnrec4123 ((p__7_ p__7_)) (jolt= p__7_ 1)))) (_o$4169 "empty?") (_o$4170 (lambda (p__8_) (let fnrec4124 ((p__8_ p__8_)) (jolt= p__8_ 1)))) (_o$4171 "peek") (_o$4172 (lambda (p__9_) (let fnrec4125 ((p__9_ p__9_)) (jolt= p__9_ 1)))) (_o$4173 "pop") (_o$4174 (lambda (p__10_) (let fnrec4126 ((p__10_ p__10_)) (jolt= p__10_ 1)))) (_o$4175 "mod") (_o$4176 (lambda (p__11_) (let fnrec4127 ((p__11_ p__11_)) (jolt= p__11_ 2)))) (_o$4177 "rem") (_o$4178 (lambda (p__12_) (let fnrec4128 ((p__12_ p__12_)) (jolt= p__12_ 2)))) (_o$4179 "quot") (_o$4180 (lambda (p__13_) (let fnrec4129 ((p__13_ p__13_)) (jolt= p__13_ 2)))) (_o$4181 "contains?") (_o$4182 (lambda (p__14_) (let fnrec4130 ((p__14_ p__14_)) (jolt= p__14_ 2)))) (_o$4183 "get") (_o$4184 (lambda (p__15_) (let fnrec4131 ((p__15_ p__15_)) (let* ((or__14__auto (jolt= p__15_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__15_ 3)))))) (_o$4185 "nth") (_o$4186 (lambda (p__16_) (let fnrec4132 ((p__16_ p__16_)) (let* ((or__14__auto (jolt= p__16_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__16_ 3)))))) (_o$4187 "assoc") (_o$4188 (lambda (p__17_) (let fnrec4133 ((p__17_ p__17_)) (let* ((and__13__auto (>= p__17_ 3))) (if (jolt-truthy? and__13__auto) (jolt-odd? p__17_) and__13__auto))))) (_o$4189 "dissoc") (_o$4190 (lambda (p__18_) (let fnrec4134 ((p__18_ p__18_)) (>= p__18_ 1)))) (_o$4191 "conj") (_o$4192 (lambda (p__19_) (let fnrec4135 ((p__19_ p__19_)) (>= p__19_ 1)))) (_o$4193 "first") (_o$4194 (lambda (p__20_) (let fnrec4136 ((p__20_ p__20_)) (jolt= p__20_ 1)))) (_o$4195 "rest") (_o$4196 (lambda (p__21_) (let fnrec4137 ((p__21_ p__21_)) (jolt= p__21_ 1)))) (_o$4197 "next") (_o$4198 (lambda (p__22_) (let fnrec4138 ((p__22_ p__22_)) (jolt= p__22_ 1)))) (_o$4199 "seq") (_o$4200 (lambda (p__23_) (let fnrec4139 ((p__23_ p__23_)) (jolt= p__23_ 1)))) (_o$4201 "reverse") (_o$4202 (lambda (p__24_) (let fnrec4140 ((p__24_ p__24_)) (jolt= p__24_ 1)))) (_o$4203 "last") (_o$4204 (lambda (p__25_) (let fnrec4141 ((p__25_ p__25_)) (jolt= p__25_ 1)))) (_o$4205 "keys") (_o$4206 (lambda (p__26_) (let fnrec4142 ((p__26_ p__26_)) (jolt= p__26_ 1)))) (_o$4207 "vals") (_o$4208 (lambda (p__27_) (let fnrec4143 ((p__27_ p__27_)) (jolt= p__27_ 1)))) (_o$4209 "even?") (_o$4210 (lambda (p__28_) (let fnrec4144 ((p__28_ p__28_)) (jolt= p__28_ 1)))) (_o$4211 "odd?") (_o$4212 (lambda (p__29_) (let fnrec4145 ((p__29_ p__29_)) (jolt= p__29_ 1)))) (_o$4213 "pos?") (_o$4214 (lambda (p__30_) (let fnrec4146 ((p__30_ p__30_)) (jolt= p__30_ 1)))) (_o$4215 "neg?") (_o$4216 (lambda (p__31_) (let fnrec4147 ((p__31_ p__31_)) (jolt= p__31_ 1)))) (_o$4217 "zero?") (_o$4218 (lambda (p__32_) (let fnrec4148 ((p__32_ p__32_)) (jolt= p__32_ 1)))) (_o$4219 "identity") (_o$4220 (lambda (p__33_) (let fnrec4149 ((p__33_ p__33_)) (jolt= p__33_ 1)))) (_o$4221 "cons") (_o$4222 (lambda (p__34_) (let fnrec4150 ((p__34_ p__34_)) (jolt= p__34_ 2)))) (_o$4223 "filter") (_o$4224 (lambda (p__35_) (let fnrec4151 ((p__35_ p__35_)) (jolt= p__35_ 2)))) (_o$4225 "remove") (_o$4226 (lambda (p__36_) (let fnrec4152 ((p__36_ p__36_)) (jolt= p__36_ 2)))) (_o$4227 "into") (_o$4228 (lambda (p__37_) (let fnrec4153 ((p__37_ p__37_)) (jolt= p__37_ 2)))) (_o$4229 "take") (_o$4230 (lambda (p__38_) (let fnrec4154 ((p__38_ p__38_)) (jolt= p__38_ 2)))) (_o$4231 "drop") (_o$4232 (lambda (p__39_) (let fnrec4155 ((p__39_ p__39_)) (jolt= p__39_ 2)))) (_o$4233 "map") (_o$4234 (lambda (p__40_) (let fnrec4156 ((p__40_ p__40_)) (>= p__40_ 2)))) (_o$4235 "apply") (_o$4236 (lambda (p__41_) (let fnrec4157 ((p__41_ p__41_)) (>= p__41_ 2)))) (_o$4237 "reduce") (_o$4238 (lambda (p__42_) (let fnrec4158 ((p__42_ p__42_)) (let* ((or__14__auto (jolt= p__42_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__42_ 3)))))) (_o$4239 "range") (_o$4240 (lambda (p__43_) (let fnrec4159 ((p__43_ p__43_)) (let* ((and__13__auto (>= p__43_ 0))) (if (jolt-truthy? and__13__auto) (<= p__43_ 3) and__13__auto))))) (_o$4241 "ex-info") (_o$4242 (lambda (p__44_) (let fnrec4160 ((p__44_ p__44_)) (let* ((or__14__auto (jolt= p__44_ 2))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= p__44_ 3))))))) (jolt-hash-map _o$4161 _o$4162 _o$4163 _o$4164 _o$4165 _o$4166 _o$4167 _o$4168 _o$4169 _o$4170 _o$4171 _o$4172 _o$4173 _o$4174 _o$4175 _o$4176 _o$4177 _o$4178 _o$4179 _o$4180 _o$4181 _o$4182 _o$4183 _o$4184 _o$4185 _o$4186 _o$4187 _o$4188 _o$4189 _o$4190 _o$4191 _o$4192 _o$4193 _o$4194 _o$4195 _o$4196 _o$4197 _o$4198 _o$4199 _o$4200 _o$4201 _o$4202 _o$4203 _o$4204 _o$4205 _o$4206 _o$4207 _o$4208 _o$4209 _o$4210 _o$4211 _o$4212 _o$4213 _o$4214 _o$4215 _o$4216 _o$4217 _o$4218 _o$4219 _o$4220 _o$4221 _o$4222 _o$4223 _o$4224 _o$4225 _o$4226 _o$4227 _o$4228 _o$4229 _o$4230 _o$4231 _o$4232 _o$4233 _o$4234 _o$4235 _o$4236 _o$4237 _o$4238 _o$4239 _o$4240 _o$4241 _o$4242)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$4223 "isDirectory") (_o$4224 "listFiles")) (jolt-hash-set _o$4223 _o$4224)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$4243 "<") (_o$4244 ">") (_o$4245 "<=") (_o$4246 ">=")) (jolt-hash-set _o$4243 _o$4244 _o$4245 _o$4246)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$4225 "<") (_o$4226 "<=") (_o$4227 ">") (_o$4228 ">=") (_o$4229 "jolt=") (_o$4230 "jolt-not") (_o$4231 "jolt-even?") (_o$4232 "jolt-odd?") (_o$4233 "jolt-pos?") (_o$4234 "jolt-neg?") (_o$4235 "jolt-zero?") (_o$4236 "jolt-empty?") (_o$4237 "jolt-contains?")) (jolt-hash-set _o$4225 _o$4226 _o$4227 _o$4228 _o$4229 _o$4230 _o$4231 _o$4232 _o$4233 _o$4234 _o$4235 _o$4236 _o$4237)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$4247 "isDirectory") (_o$4248 "listFiles")) (jolt-hash-set _o$4247 _o$4248)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$4238 "+") (_o$4239 "fl+") (_o$4240 "-") (_o$4241 "fl-") (_o$4242 "*") (_o$4243 "fl*") (_o$4244 "/") (_o$4245 "fl/") (_o$4246 "min") (_o$4247 "flmin") (_o$4248 "max") (_o$4249 "flmax") (_o$4250 "<") (_o$4251 "fl<?") (_o$4252 ">") (_o$4253 "fl>?") (_o$4254 "<=") (_o$4255 "fl<=?") (_o$4256 ">=") (_o$4257 "fl>=?") (_o$4258 "=") (_o$4259 "fl=?") (_o$4260 "==") (_o$4261 "fl=?")) (jolt-hash-map _o$4238 _o$4239 _o$4240 _o$4241 _o$4242 _o$4243 _o$4244 _o$4245 _o$4246 _o$4247 _o$4248 _o$4249 _o$4250 _o$4251 _o$4252 _o$4253 _o$4254 _o$4255 _o$4256 _o$4257 _o$4258 _o$4259 _o$4260 _o$4261)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$4249 "<") (_o$4250 "<=") (_o$4251 ">") (_o$4252 ">=") (_o$4253 "jolt=") (_o$4254 "jolt-not") (_o$4255 "jolt-even?") (_o$4256 "jolt-odd?") (_o$4257 "jolt-pos?") (_o$4258 "jolt-neg?") (_o$4259 "jolt-zero?") (_o$4260 "jolt-empty?") (_o$4261 "jolt-contains?")) (jolt-hash-set _o$4249 _o$4250 _o$4251 _o$4252 _o$4253 _o$4254 _o$4255 _o$4256 _o$4257 _o$4258 _o$4259 _o$4260 _o$4261)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$4262 "+") (_o$4263 "fx+") (_o$4264 "-") (_o$4265 "fx-") (_o$4266 "*") (_o$4267 "fx*") (_o$4268 "min") (_o$4269 "fxmin") (_o$4270 "max") (_o$4271 "fxmax") (_o$4272 "unchecked-add") (_o$4273 "fx+") (_o$4274 "unchecked-subtract") (_o$4275 "fx-") (_o$4276 "unchecked-multiply") (_o$4277 "fx*") (_o$4278 "quot") (_o$4279 "fxquotient") (_o$4280 "rem") (_o$4281 "fxremainder") (_o$4282 "mod") (_o$4283 "fxmodulo") (_o$4284 "<") (_o$4285 "fx<?") (_o$4286 ">") (_o$4287 "fx>?") (_o$4288 "<=") (_o$4289 "fx<=?") (_o$4290 ">=") (_o$4291 "fx>=?") (_o$4292 "=") (_o$4293 "fx=?") (_o$4294 "==") (_o$4295 "fx=?")) (jolt-hash-map _o$4262 _o$4263 _o$4264 _o$4265 _o$4266 _o$4267 _o$4268 _o$4269 _o$4270 _o$4271 _o$4272 _o$4273 _o$4274 _o$4275 _o$4276 _o$4277 _o$4278 _o$4279 _o$4280 _o$4281 _o$4282 _o$4283 _o$4284 _o$4285 _o$4286 _o$4287 _o$4288 _o$4289 _o$4290 _o$4291 _o$4292 _o$4293 _o$4294 _o$4295)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$4262 "+") (_o$4263 "fl+") (_o$4264 "-") (_o$4265 "fl-") (_o$4266 "*") (_o$4267 "fl*") (_o$4268 "/") (_o$4269 "fl/") (_o$4270 "min") (_o$4271 "flmin") (_o$4272 "max") (_o$4273 "flmax") (_o$4274 "<") (_o$4275 "fl<?") (_o$4276 ">") (_o$4277 "fl>?") (_o$4278 "<=") (_o$4279 "fl<=?") (_o$4280 ">=") (_o$4281 "fl>=?") (_o$4282 "=") (_o$4283 "fl=?") (_o$4284 "==") (_o$4285 "fl=?")) (jolt-hash-map _o$4262 _o$4263 _o$4264 _o$4265 _o$4266 _o$4267 _o$4268 _o$4269 _o$4270 _o$4271 _o$4272 _o$4273 _o$4274 _o$4275 _o$4276 _o$4277 _o$4278 _o$4279 _o$4280 _o$4281 _o$4282 _o$4283 _o$4284 _o$4285)) (jolt-hash-map (keyword #f "private") #t)))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$4286 "+") (_o$4287 "fx+") (_o$4288 "-") (_o$4289 "fx-") (_o$4290 "*") (_o$4291 "fx*") (_o$4292 "min") (_o$4293 "fxmin") (_o$4294 "max") (_o$4295 "fxmax") (_o$4296 "unchecked-add") (_o$4297 "fx+") (_o$4298 "unchecked-subtract") (_o$4299 "fx-") (_o$4300 "unchecked-multiply") (_o$4301 "fx*") (_o$4302 "quot") (_o$4303 "fxquotient") (_o$4304 "rem") (_o$4305 "fxremainder") (_o$4306 "mod") (_o$4307 "fxmodulo") (_o$4308 "<") (_o$4309 "fx<?") (_o$4310 ">") (_o$4311 "fx>?") (_o$4312 "<=") (_o$4313 "fx<=?") (_o$4314 ">=") (_o$4315 "fx>=?") (_o$4316 "=") (_o$4317 "fx=?") (_o$4318 "==") (_o$4319 "fx=?")) (jolt-hash-map _o$4286 _o$4287 _o$4288 _o$4289 _o$4290 _o$4291 _o$4292 _o$4293 _o$4294 _o$4295 _o$4296 _o$4297 _o$4298 _o$4299 _o$4300 _o$4301 _o$4302 _o$4303 _o$4304 _o$4305 _o$4306 _o$4307 _o$4308 _o$4309 _o$4310 _o$4311 _o$4312 _o$4313 _o$4314 _o$4315 _o$4316 _o$4317 _o$4318 _o$4319)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
   (def-var! "jolt.backend-scheme" "prelude-mode?" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "set-prelude-mode!" (letrec ((set-prelude-mode! (lambda (on) (let fnrec4296 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "prelude-mode?") on))))) set-prelude-mode!)))
+  (def-var! "jolt.backend-scheme" "set-prelude-mode!" (letrec ((set-prelude-mode! (lambda (on) (let fnrec4320 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "prelude-mode?") on))))) set-prelude-mode!)))
 (guard (e (#t #f))
   (def-var! "jolt.backend-scheme" "direct-link?" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "set-direct-link!" (letrec ((set-direct-link! (lambda (on) (let fnrec4297 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link?") on))))) set-direct-link!)))
+  (def-var! "jolt.backend-scheme" "set-direct-link!" (letrec ((set-direct-link! (lambda (on) (let fnrec4321 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link?") on))))) set-direct-link!)))
 (guard (e (#t #f))
   (def-var! "jolt.backend-scheme" "direct-link-defined" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))))
 (guard (e (#t #f))
   (def-var! "jolt.backend-scheme" "direct-link-fns" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec4298 () (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-defined") (jolt-hash-set)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-fns") (jolt-hash-set))))))) direct-link-reset!)))
+  (def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec4322 () (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-defined") (jolt-hash-set)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-fns") (jolt-hash-set))))))) direct-link-reset!)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec4299 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge)))
+  (def-var! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec4323 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec4300 ((ns ns) (nm nm)) (let* ((_a$4301 (var-deref "clojure.core" "str")) (_a$4302 "jv$") (_a$4303 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$4304 "$") (_a$4305 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$4301 _a$4302 _a$4303 _a$4304 _a$4305)))))) dl-name)))
+  (def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec4324 ((ns ns) (nm nm)) (let* ((_a$4325 (var-deref "clojure.core" "str")) (_a$4326 "jv$") (_a$4327 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$4328 "$") (_a$4329 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$4325 _a$4326 _a$4327 _a$4328 _a$4329)))))) dl-name)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec4306 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn)))
+  (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec4330 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec4307 ((ns ns) (nm nm)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__13__auto) (let* ((_a$4308 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$4309 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$4308 _a$4309)) and__13__auto)))))) direct-linkable?)))
+  (def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec4331 ((ns ns) (nm nm)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__13__auto) (let* ((_a$4332 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$4333 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$4332 _a$4333)) and__13__auto)))))) direct-linkable?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec4310 ((ns ns) (nm nm)) (let* ((_a$4311 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$4312 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$4311 _a$4312)))))) direct-link-fn?)))
+  (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec4334 ((ns ns) (nm nm)) (let* ((_a$4335 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$4336 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$4335 _a$4336)))))) direct-link-fn?)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (jolt-hash-map (keyword #f "dynamic") #t)))
 (guard (e (#t #f))
@@ -165,273 +167,273 @@
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec4313 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label)))
+  (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec4337 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$4314 "if") (_o$4315 "begin") (_o$4316 "lambda") (_o$4317 "let") (_o$4318 "let*") (_o$4319 "letrec") (_o$4320 "letrec*") (_o$4321 "quote") (_o$4322 "quasiquote") (_o$4323 "unquote") (_o$4324 "set!") (_o$4325 "define") (_o$4326 "define-syntax") (_o$4327 "cond") (_o$4328 "case") (_o$4329 "when") (_o$4330 "unless") (_o$4331 "and") (_o$4332 "or") (_o$4333 "do") (_o$4334 "else") (_o$4335 "guard") (_o$4336 "parameterize") (_o$4337 "delay") (_o$4338 "values")) (jolt-hash-set _o$4314 _o$4315 _o$4316 _o$4317 _o$4318 _o$4319 _o$4320 _o$4321 _o$4322 _o$4323 _o$4324 _o$4325 _o$4326 _o$4327 _o$4328 _o$4329 _o$4330 _o$4331 _o$4332 _o$4333 _o$4334 _o$4335 _o$4336 _o$4337 _o$4338)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$4338 "if") (_o$4339 "begin") (_o$4340 "lambda") (_o$4341 "let") (_o$4342 "let*") (_o$4343 "letrec") (_o$4344 "letrec*") (_o$4345 "quote") (_o$4346 "quasiquote") (_o$4347 "unquote") (_o$4348 "set!") (_o$4349 "define") (_o$4350 "define-syntax") (_o$4351 "cond") (_o$4352 "case") (_o$4353 "when") (_o$4354 "unless") (_o$4355 "and") (_o$4356 "or") (_o$4357 "do") (_o$4358 "else") (_o$4359 "guard") (_o$4360 "parameterize") (_o$4361 "delay") (_o$4362 "values")) (jolt-hash-set _o$4338 _o$4339 _o$4340 _o$4341 _o$4342 _o$4343 _o$4344 _o$4345 _o$4346 _o$4347 _o$4348 _o$4349 _o$4350 _o$4351 _o$4352 _o$4353 _o$4354 _o$4355 _o$4356 _o$4357 _o$4358 _o$4359 _o$4360 _o$4361 _o$4362)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec4339 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name)))
+  (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec4363 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name)))
 (guard (e (#t #f))
   (declare-var! "jolt.backend-scheme" "emit"))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec4340 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (jolt-truthy? (let* ((and__13__auto (>= cp 32))) (if (jolt-truthy? and__13__auto) (< cp 127) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape)))
+  (def-var! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec4364 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (jolt-truthy? (let* ((and__13__auto (>= cp 32))) (if (jolt-truthy? and__13__auto) (< cp 127) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec4341 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec4342 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit)))
+  (def-var! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec4365 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec4366 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec4343 ((v v)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__4__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__4__auto) (let* ((kns temp__4__auto)) (let* ((_a$4344 (var-deref "clojure.core" "str")) (_a$4345 "(keyword ") (_a$4346 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$4347 " ") (_a$4348 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$4349 ")")) (jolt-invoke _a$4344 _a$4345 _a$4346 _a$4347 _a$4348 _a$4349))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$4350 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$4351 (jolt-hash-map))) (jolt-ex-info _a$4350 _a$4351))) jolt-nil))))))))))) emit-const)))
+  (def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec4367 ((v v)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__4__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__4__auto) (let* ((kns temp__4__auto)) (let* ((_a$4368 (var-deref "clojure.core" "str")) (_a$4369 "(keyword ") (_a$4370 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$4371 " ") (_a$4372 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$4373 ")")) (jolt-invoke _a$4368 _a$4369 _a$4370 _a$4371 _a$4372 _a$4373))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$4374 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$4375 (jolt-hash-map))) (jolt-ex-info _a$4374 _a$4375))) jolt-nil))))))))))) emit-const)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec4352 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec4353 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec4354 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered)))
+  (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec4376 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec4377 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec4378 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec4355 ((n n)) (let* ((_a$4361 (let* ((_o$4356 (keyword #f "const")) (_o$4357 (keyword #f "local")) (_o$4358 (keyword #f "var")) (_o$4359 (keyword #f "the-var")) (_o$4360 (keyword #f "quote"))) (jolt-hash-set _o$4356 _o$4357 _o$4358 _o$4359 _o$4360))) (_a$4362 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$4361 _a$4362)))))) side-effect-free?)))
+  (def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec4379 ((n n)) (let* ((_a$4385 (let* ((_o$4380 (keyword #f "const")) (_o$4381 (keyword #f "local")) (_o$4382 (keyword #f "var")) (_o$4383 (keyword #f "the-var")) (_o$4384 (keyword #f "quote"))) (jolt-hash-set _o$4380 _o$4381 _o$4382 _o$4383 _o$4384))) (_a$4386 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$4385 _a$4386)))))) side-effect-free?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec4363 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?)))
+  (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec4387 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec4364 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec4365 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec4366 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call)))
+  (def-var! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec4388 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec4389 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec4390 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call)))
 (guard (e (#t #f))
   (declare-var! "jolt.backend-scheme" "emit-quoted"))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec4367 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec4368 ((p p)) (let* ((_o$4369 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$4370 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$4369 _o$4370)))) pairs)) ")"))))) emit-quoted-map)))
+  (def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec4391 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec4392 ((p p)) (let* ((_o$4393 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$4394 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$4393 _o$4394)))) pairs)) ")"))))) emit-quoted-map)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec4371 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$4377 (lambda (k) (let fnrec4372 ((k k)) (let* ((_a$4373 (var-deref "clojure.core" "str")) (_a$4374 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$4375 " ") (_a$4376 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$4373 _a$4374 _a$4375 _a$4376))))) (_a$4378 (jolt-keys m))) (jolt-map _a$4377 _a$4378))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value)))
+  (def-var! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec4395 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$4401 (lambda (k) (let fnrec4396 ((k k)) (let* ((_a$4397 (var-deref "clojure.core" "str")) (_a$4398 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$4399 " ") (_a$4400 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$4397 _a$4398 _a$4399 _a$4400))))) (_a$4402 (jolt-keys m))) (jolt-map _a$4401 _a$4402))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec4379 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__13__auto m)) (if (jolt-truthy? and__13__auto) (jolt-pos? (jolt-count m)) and__13__auto))) (let* ((_a$4380 (var-deref "clojure.core" "str")) (_a$4381 "(jolt-symbol/meta ") (_a$4382 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$4383 " ") (_a$4384 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4385 " ") (_a$4386 (jolt-invoke emit-quoted m)) (_a$4387 ")")) (jolt-invoke _a$4380 _a$4381 _a$4382 _a$4383 _a$4384 _a$4385 _a$4386 _a$4387)) (let* ((_a$4388 (var-deref "clojure.core" "str")) (_a$4389 "(jolt-symbol ") (_a$4390 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$4391 " ") (_a$4392 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4393 ")")) (jolt-invoke _a$4388 _a$4389 _a$4390 _a$4391 _a$4392 _a$4393)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$4394 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$4395 (jolt-hash-map))) (jolt-ex-info _a$4394 _a$4395))) jolt-nil)))))))))))))))) emit-quoted)))
+  (def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec4403 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__13__auto m)) (if (jolt-truthy? and__13__auto) (jolt-pos? (jolt-count m)) and__13__auto))) (let* ((_a$4404 (var-deref "clojure.core" "str")) (_a$4405 "(jolt-symbol/meta ") (_a$4406 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$4407 " ") (_a$4408 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4409 " ") (_a$4410 (jolt-invoke emit-quoted m)) (_a$4411 ")")) (jolt-invoke _a$4404 _a$4405 _a$4406 _a$4407 _a$4408 _a$4409 _a$4410 _a$4411)) (let* ((_a$4412 (var-deref "clojure.core" "str")) (_a$4413 "(jolt-symbol ") (_a$4414 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$4415 " ") (_a$4416 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4417 ")")) (jolt-invoke _a$4412 _a$4413 _a$4414 _a$4415 _a$4416 _a$4417)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$4418 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$4419 (jolt-hash-map))) (jolt-ex-info _a$4418 _a$4419))) jolt-nil)))))))))))))))) emit-quoted)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec4396 ((m m)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__13__auto) (jolt-pos? (jolt-count m)) and__13__auto)))))) jmeta-nonempty?)))
+  (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec4420 ((m m)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__13__auto) (jolt-pos? (jolt-count m)) and__13__auto)))))) jmeta-nonempty?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec4397 ((b b)) (let* ((_a$4398 (var-deref "clojure.core" "str")) (_a$4399 "(") (_a$4400 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$4401 " ") (_a$4402 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$4403 ")")) (jolt-invoke _a$4398 _a$4399 _a$4400 _a$4401 _a$4402 _a$4403)))))) emit-binding)))
+  (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec4421 ((b b)) (let* ((_a$4422 (var-deref "clojure.core" "str")) (_a$4423 "(") (_a$4424 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$4425 " ") (_a$4426 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$4427 ")")) (jolt-invoke _a$4422 _a$4423 _a$4424 _a$4425 _a$4426 _a$4427)))))) emit-binding)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec4404 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$4405 (var-deref "clojure.core" "str")) (_a$4406 "(") (_a$4407 kw) (_a$4408 " (") (_a$4409 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$4410 ") ") (_a$4411 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$4412 ")")) (jolt-invoke _a$4405 _a$4406 _a$4407 _a$4408 _a$4409 _a$4410 _a$4411 _a$4412))))))) emit-let)))
+  (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec4428 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$4429 (var-deref "clojure.core" "str")) (_a$4430 "(") (_a$4431 kw) (_a$4432 " (") (_a$4433 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$4434 ") ") (_a$4435 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$4436 ")")) (jolt-invoke _a$4429 _a$4430 _a$4431 _a$4432 _a$4433 _a$4434 _a$4435 _a$4436))))))) emit-let)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec4413 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__45_) (let fnrec4414 ((p__45_ p__45_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__45_ 0)))) pairs)) (inits (jolt-map (lambda (p__46_) (let fnrec4415 ((p__46_ p__46_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__46_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec4416 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec4417 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__8__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__8__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop)))
+  (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec4437 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__45_) (let fnrec4438 ((p__45_ p__45_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__45_ 0)))) pairs)) (inits (jolt-map (lambda (p__46_) (let fnrec4439 ((p__46_ p__46_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__46_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec4440 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec4441 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__8__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__8__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$4418 "int") (_o$4419 "int") (_o$4420 "uint") (_o$4421 "unsigned-int") (_o$4422 "long") (_o$4423 "long") (_o$4424 "ulong") (_o$4425 "unsigned-long") (_o$4426 "int64") (_o$4427 "integer-64") (_o$4428 "uint64") (_o$4429 "unsigned-64") (_o$4430 "size_t") (_o$4431 "size_t") (_o$4432 "ssize_t") (_o$4433 "ssize_t") (_o$4434 "iptr") (_o$4435 "iptr") (_o$4436 "uptr") (_o$4437 "uptr") (_o$4438 "double") (_o$4439 "double") (_o$4440 "float") (_o$4441 "float") (_o$4442 "pointer") (_o$4443 "void*") (_o$4444 "void*") (_o$4445 "void*") (_o$4446 "string") (_o$4447 "string") (_o$4448 "void") (_o$4449 "void") (_o$4450 "uint8") (_o$4451 "unsigned-8") (_o$4452 "u8") (_o$4453 "unsigned-8") (_o$4454 "byte") (_o$4455 "unsigned-8") (_o$4456 "char") (_o$4457 "char")) (jolt-hash-map _o$4418 _o$4419 _o$4420 _o$4421 _o$4422 _o$4423 _o$4424 _o$4425 _o$4426 _o$4427 _o$4428 _o$4429 _o$4430 _o$4431 _o$4432 _o$4433 _o$4434 _o$4435 _o$4436 _o$4437 _o$4438 _o$4439 _o$4440 _o$4441 _o$4442 _o$4443 _o$4444 _o$4445 _o$4446 _o$4447 _o$4448 _o$4449 _o$4450 _o$4451 _o$4452 _o$4453 _o$4454 _o$4455 _o$4456 _o$4457)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$4442 "int") (_o$4443 "int") (_o$4444 "uint") (_o$4445 "unsigned-int") (_o$4446 "long") (_o$4447 "long") (_o$4448 "ulong") (_o$4449 "unsigned-long") (_o$4450 "int64") (_o$4451 "integer-64") (_o$4452 "uint64") (_o$4453 "unsigned-64") (_o$4454 "size_t") (_o$4455 "size_t") (_o$4456 "ssize_t") (_o$4457 "ssize_t") (_o$4458 "iptr") (_o$4459 "iptr") (_o$4460 "uptr") (_o$4461 "uptr") (_o$4462 "double") (_o$4463 "double") (_o$4464 "float") (_o$4465 "float") (_o$4466 "pointer") (_o$4467 "void*") (_o$4468 "void*") (_o$4469 "void*") (_o$4470 "string") (_o$4471 "string") (_o$4472 "void") (_o$4473 "void") (_o$4474 "uint8") (_o$4475 "unsigned-8") (_o$4476 "u8") (_o$4477 "unsigned-8") (_o$4478 "byte") (_o$4479 "unsigned-8") (_o$4480 "char") (_o$4481 "char")) (jolt-hash-map _o$4442 _o$4443 _o$4444 _o$4445 _o$4446 _o$4447 _o$4448 _o$4449 _o$4450 _o$4451 _o$4452 _o$4453 _o$4454 _o$4455 _o$4456 _o$4457 _o$4458 _o$4459 _o$4460 _o$4461 _o$4462 _o$4463 _o$4464 _o$4465 _o$4466 _o$4467 _o$4468 _o$4469 _o$4470 _o$4471 _o$4472 _o$4473 _o$4474 _o$4475 _o$4476 _o$4477 _o$4478 _o$4479 _o$4480 _o$4481)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec4458 ((t t)) (let* ((or__14__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-throw (let* ((_a$4459 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$4460 (jolt-hash-map))) (jolt-ex-info _a$4459 _a$4460))))))))) ffi-type->chez)))
+  (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec4482 ((t t)) (let* ((or__14__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-throw (let* ((_a$4483 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$4484 (jolt-hash-map))) (jolt-ex-info _a$4483 _a$4484))))))))) ffi-type->chez)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec4461 ((node node)) (let* ((_a$4462 (var-deref "clojure.core" "str")) (_a$4463 "(foreign-procedure ") (_a$4464 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$4465 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$4466 " (") (_a$4467 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$4468 ") ") (_a$4469 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$4470 ")")) (jolt-invoke _a$4462 _a$4463 _a$4464 _a$4465 _a$4466 _a$4467 _a$4468 _a$4469 _a$4470)))))) emit-ffi-fn)))
+  (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec4485 ((node node)) (let* ((_a$4486 (var-deref "clojure.core" "str")) (_a$4487 "(foreign-procedure ") (_a$4488 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$4489 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$4490 " (") (_a$4491 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$4492 ") ") (_a$4493 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$4494 ")")) (jolt-invoke _a$4486 _a$4487 _a$4488 _a$4489 _a$4490 _a$4491 _a$4492 _a$4493 _a$4494)))))) emit-ffi-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec4471 ((node node)) (let* ((_a$4472 (var-deref "clojure.core" "str")) (_a$4473 "(jolt-ffi-register-callable! (foreign-callable ") (_a$4474 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$4475 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$4476 " (") (_a$4477 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$4478 ") ") (_a$4479 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$4480 "))")) (jolt-invoke _a$4472 _a$4473 _a$4474 _a$4475 _a$4476 _a$4477 _a$4478 _a$4479 _a$4480)))))) emit-ffi-callable)))
+  (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec4495 ((node node)) (let* ((_a$4496 (var-deref "clojure.core" "str")) (_a$4497 "(jolt-ffi-register-callable! (foreign-callable ") (_a$4498 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$4499 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$4500 " (") (_a$4501 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$4502 ") ") (_a$4503 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$4504 "))")) (jolt-invoke _a$4496 _a$4497 _a$4498 _a$4499 _a$4500 _a$4501 _a$4502 _a$4503 _a$4504)))))) emit-ffi-callable)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec4481 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$4483 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$4484 arg-nodes) (_a$4485 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$4486 (lambda (as) (let fnrec4482 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$4483 _a$4484 _a$4485 _a$4486)))))))) emit-recur)))
+  (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec4505 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$4507 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$4508 arg-nodes) (_a$4509 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$4510 (lambda (as) (let fnrec4506 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$4507 _a$4508 _a$4509 _a$4510)))))))) emit-recur)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec4487 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init)))
+  (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec4511 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec4488 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$4489 (jolt-hash-map)) (_a$4490 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$4489 _a$4490))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__15__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__15__auto) (let* ((r temp__15__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__8__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__8__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__13__auto restp)) (if (jolt-truthy? and__13__auto) (jolt-empty? params) and__13__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec4491 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$4492 paramlist) (_o$4493 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$4492 _o$4493))))))) emit-arity-clause)))
+  (def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec4512 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$4513 (jolt-hash-map)) (_a$4514 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$4513 _a$4514))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__15__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__15__auto) (let* ((r temp__15__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__8__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__8__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__13__auto restp)) (if (jolt-truthy? and__13__auto) (jolt-empty? params) and__13__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec4515 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$4516 paramlist) (_o$4517 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$4516 _o$4517))))))) emit-arity-clause)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec4494 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__15__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__15__auto) (let* ((nm temp__15__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__8__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__8__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$4495 (var-deref "clojure.core" "str")) (_a$4496 "(lambda ") (_a$4497 (jolt-nth c 0)) (_a$4498 " ") (_a$4499 (jolt-nth c 1)) (_a$4500 ")")) (jolt-invoke _a$4495 _a$4496 _a$4497 _a$4498 _a$4499 _a$4500))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec4501 ((c c)) (let* ((_a$4502 (var-deref "clojure.core" "str")) (_a$4503 "(") (_a$4504 (jolt-nth c 0)) (_a$4505 " ") (_a$4506 (jolt-nth c 1)) (_a$4507 ")")) (jolt-invoke _a$4502 _a$4503 _a$4504 _a$4505 _a$4506 _a$4507)))) clauses)) ")")))) (let* ((temp__4__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__4__auto) (let* ((nm temp__4__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn)))
+  (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec4518 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__15__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__15__auto) (let* ((nm temp__15__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__8__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__8__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$4519 (var-deref "clojure.core" "str")) (_a$4520 "(lambda ") (_a$4521 (jolt-nth c 0)) (_a$4522 " ") (_a$4523 (jolt-nth c 1)) (_a$4524 ")")) (jolt-invoke _a$4519 _a$4520 _a$4521 _a$4522 _a$4523 _a$4524))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec4525 ((c c)) (let* ((_a$4526 (var-deref "clojure.core" "str")) (_a$4527 "(") (_a$4528 (jolt-nth c 0)) (_a$4529 " ") (_a$4530 (jolt-nth c 1)) (_a$4531 ")")) (jolt-invoke _a$4526 _a$4527 _a$4528 _a$4529 _a$4530 _a$4531)))) clauses)) ")")))) (let* ((temp__4__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__4__auto) (let* ((nm temp__4__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec4508 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__34 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__34 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__34 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") op)) jolt-nil (if (jolt-truthy? (let* ((and__13__auto arity-ok)) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__13__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op)))
+  (def-var! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec4532 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__34 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__34 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__34 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") op)) jolt-nil (if (jolt-truthy? (let* ((and__13__auto arity-ok)) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__13__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec4509 ((fnode fnode)) (let* ((G__35 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__35 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (jolt-truthy? (let* ((or__14__auto (jolt= G__35 (keyword #f "map")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= G__35 (keyword #f "set")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= G__35 (keyword #f "vector"))))))) (keyword #f "coll") jolt-nil))))))) ifn-kind)))
+  (def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec4533 ((fnode fnode)) (let* ((G__35 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__35 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (jolt-truthy? (let* ((or__14__auto (jolt= G__35 (keyword #f "map")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= G__35 (keyword #f "set")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= G__35 (keyword #f "vector"))))))) (keyword #f "coll") jolt-nil))))))) ifn-kind)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec4510 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__14__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__14__auto) or__14__auto "")) "clojure.") and__13__auto)))))) stdlib-var?)))
+  (def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec4534 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__14__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__14__auto) or__14__auto "")) "clojure.") and__13__auto)))))) stdlib-var?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec4511 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__13__auto) (jolt= nm "inc") and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__13__auto) (jolt= nm "dec") and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= nm "inc"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= nm "unchecked-inc"))) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= nm "dec"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= nm "unchecked-dec"))) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (if (jolt= kind (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm)))) (jolt-invoke order-args (lambda (as) (let fnrec4512 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric)))
+  (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec4535 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__13__auto) (jolt= nm "inc") and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__13__auto) (jolt= nm "dec") and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= nm "inc"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= nm "unchecked-inc"))) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (jolt-truthy? (let* ((and__13__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= nm "dec"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= nm "unchecked-dec"))) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (if (jolt= kind (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm)))) (jolt-invoke order-args (lambda (as) (let fnrec4536 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec4513 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec4514 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec4515 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec4516 () (let* ((_a$4518 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$4519 (jolt-cons fnode arg-nodes)) (_a$4520 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$4521 (lambda (G__36) (let fnrec4517 ((G__36 G__36)) (let* ((G__37 G__36) (f (jolt-nth G__37 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__37 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$4518 _a$4519 _a$4520 _a$4521)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$4522 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$4523 (jolt-get node (keyword #f "num-kind"))) (_a$4524 (jolt-get fnode (keyword #f "name"))) (_a$4525 args) (_a$4526 order-args)) (jolt-invoke _a$4522 _a$4523 _a$4524 _a$4525 _a$4526)) (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-empty? args))) (if (jolt-truthy? and__13__auto) (jolt= nop "+") and__13__auto)) and__13__auto))) "0" (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-empty? args))) (if (jolt-truthy? and__13__auto) (jolt= nop "*") and__13__auto)) and__13__auto))) "1" (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec4527 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (jolt-invoke order-args (lambda (as) (let fnrec4528 ((as as)) (let* ((_a$4529 (var-deref "clojure.core" "str")) (_a$4530 "(jolt-get ") (_a$4531 (jolt-first as)) (_a$4532 " ") (_a$4533 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$4534 (jolt-invoke defstr as)) (_a$4535 ")")) (jolt-invoke _a$4529 _a$4530 _a$4531 _a$4532 _a$4533 _a$4534 _a$4535))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$4537 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$4538 (jolt-cons fnode arg-nodes)) (_a$4539 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$4540 (lambda (G__38) (let fnrec4536 ((G__38 G__38)) (let* ((G__39 G__38) (c (jolt-nth G__39 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__39 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$4537 _a$4538 _a$4539 _a$4540)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__13__auto))) (jolt-throw (let* ((_a$4547 (let* ((_a$4541 (var-deref "clojure.core" "str")) (_a$4542 "emit: unsupported stdlib fn `") (_a$4543 (jolt-get fnode (keyword #f "ns"))) (_a$4544 "/") (_a$4545 (jolt-get fnode (keyword #f "name"))) (_a$4546 "` (no core on Chez yet)")) (jolt-invoke _a$4541 _a$4542 _a$4543 _a$4544 _a$4545 _a$4546))) (_a$4548 (jolt-hash-map))) (jolt-ex-info _a$4547 _a$4548))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec4549 ((as as)) (let* ((_a$4550 (var-deref "clojure.core" "str")) (_a$4551 "(host-static-call ") (_a$4552 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$4553 " ") (_a$4554 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$4555 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$4556 ")")) (jolt-invoke _a$4550 _a$4551 _a$4552 _a$4553 _a$4554 _a$4555 _a$4556))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$4557 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$4558 (jolt-hash-map))) (jolt-ex-info _a$4557 _a$4558))) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) and__13__auto))) (jolt-invoke invoke) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (let* ((_a$4559 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$4560 (jolt-get fnode (keyword #f "ns"))) (_a$4561 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$4559 _a$4560 _a$4561)))) (if (jolt-truthy? and__13__auto) (let* ((_a$4562 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$4563 (jolt-get fnode (keyword #f "ns"))) (_a$4564 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$4562 _a$4563 _a$4564)) and__13__auto)) and__13__auto))) (jolt-invoke order-args (lambda (as) (let fnrec4565 ((as as)) (let* ((_a$4569 (var-deref "clojure.core" "str")) (_a$4570 "(") (_a$4571 (let* ((_a$4566 (var-deref "jolt.backend-scheme" "dl-name")) (_a$4567 (jolt-get fnode (keyword #f "ns"))) (_a$4568 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$4566 _a$4567 _a$4568))) (_a$4572 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$4573 ")")) (jolt-invoke _a$4569 _a$4570 _a$4571 _a$4572 _a$4573))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil))))))))))))))))))) emit-invoke)))
+  (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec4537 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec4538 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec4539 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec4540 () (let* ((_a$4542 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$4543 (jolt-cons fnode arg-nodes)) (_a$4544 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$4545 (lambda (G__36) (let fnrec4541 ((G__36 G__36)) (let* ((G__37 G__36) (f (jolt-nth G__37 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__37 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$4542 _a$4543 _a$4544 _a$4545)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$4546 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$4547 (jolt-get node (keyword #f "num-kind"))) (_a$4548 (jolt-get fnode (keyword #f "name"))) (_a$4549 args) (_a$4550 order-args)) (jolt-invoke _a$4546 _a$4547 _a$4548 _a$4549 _a$4550)) (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-empty? args))) (if (jolt-truthy? and__13__auto) (jolt= nop "+") and__13__auto)) and__13__auto))) "0" (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-empty? args))) (if (jolt-truthy? and__13__auto) (jolt= nop "*") and__13__auto)) and__13__auto))) "1" (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec4551 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (jolt-invoke order-args (lambda (as) (let fnrec4552 ((as as)) (let* ((_a$4553 (var-deref "clojure.core" "str")) (_a$4554 "(jolt-get ") (_a$4555 (jolt-first as)) (_a$4556 " ") (_a$4557 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$4558 (jolt-invoke defstr as)) (_a$4559 ")")) (jolt-invoke _a$4553 _a$4554 _a$4555 _a$4556 _a$4557 _a$4558 _a$4559))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$4561 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$4562 (jolt-cons fnode arg-nodes)) (_a$4563 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$4564 (lambda (G__38) (let fnrec4560 ((G__38 G__38)) (let* ((G__39 G__38) (c (jolt-nth G__39 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__39 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$4561 _a$4562 _a$4563 _a$4564)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__13__auto))) (jolt-throw (let* ((_a$4571 (let* ((_a$4565 (var-deref "clojure.core" "str")) (_a$4566 "emit: unsupported stdlib fn `") (_a$4567 (jolt-get fnode (keyword #f "ns"))) (_a$4568 "/") (_a$4569 (jolt-get fnode (keyword #f "name"))) (_a$4570 "` (no core on Chez yet)")) (jolt-invoke _a$4565 _a$4566 _a$4567 _a$4568 _a$4569 _a$4570))) (_a$4572 (jolt-hash-map))) (jolt-ex-info _a$4571 _a$4572))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec4573 ((as as)) (let* ((_a$4574 (var-deref "clojure.core" "str")) (_a$4575 "(host-static-call ") (_a$4576 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$4577 " ") (_a$4578 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$4579 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$4580 ")")) (jolt-invoke _a$4574 _a$4575 _a$4576 _a$4577 _a$4578 _a$4579 _a$4580))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$4581 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$4582 (jolt-hash-map))) (jolt-ex-info _a$4581 _a$4582))) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) and__13__auto))) (jolt-invoke invoke) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (let* ((_a$4583 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$4584 (jolt-get fnode (keyword #f "ns"))) (_a$4585 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$4583 _a$4584 _a$4585)))) (if (jolt-truthy? and__13__auto) (let* ((_a$4586 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$4587 (jolt-get fnode (keyword #f "ns"))) (_a$4588 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$4586 _a$4587 _a$4588)) and__13__auto)) and__13__auto))) (jolt-invoke order-args (lambda (as) (let fnrec4589 ((as as)) (let* ((_a$4593 (var-deref "clojure.core" "str")) (_a$4594 "(") (_a$4595 (let* ((_a$4590 (var-deref "jolt.backend-scheme" "dl-name")) (_a$4591 (jolt-get fnode (keyword #f "ns"))) (_a$4592 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$4590 _a$4591 _a$4592))) (_a$4596 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$4597 ")")) (jolt-invoke _a$4593 _a$4594 _a$4595 _a$4596 _a$4597))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil))))))))))))))))))) emit-invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec4574 ((node node)) (let* ((core (let* ((temp__4__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__4__auto) (let* ((cs temp__4__auto)) (let* ((_a$4575 (var-deref "clojure.core" "str")) (_a$4576 "(guard (") (_a$4577 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$4578 " (else ") (_a$4579 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$4580 ")) ") (_a$4581 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$4582 ")")) (jolt-invoke _a$4575 _a$4576 _a$4577 _a$4578 _a$4579 _a$4580 _a$4581 _a$4582))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__4__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__4__auto) (let* ((fin temp__4__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try)))
+  (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec4598 ((node node)) (let* ((core (let* ((temp__4__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__4__auto) (let* ((cs temp__4__auto)) (let* ((_a$4599 (var-deref "clojure.core" "str")) (_a$4600 "(guard (") (_a$4601 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$4602 " (else ") (_a$4603 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$4604 ")) ") (_a$4605 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$4606 ")")) (jolt-invoke _a$4599 _a$4600 _a$4601 _a$4602 _a$4603 _a$4604 _a$4605 _a$4606))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__4__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__4__auto) (let* ((fin temp__4__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (lambda (node) (let fnrec4583 ((node node)) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__13__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$4584 (var-deref "jolt.backend-scheme" "native-op")) (_a$4585 (jolt-get node (keyword #f "fn"))) (_a$4586 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$4584 _a$4585 _a$4586)))) (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__13__auto))) #t #f)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))) returns-scheme-bool?)))
+  (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (lambda (node) (let fnrec4607 ((node node)) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__13__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$4608 (var-deref "jolt.backend-scheme" "native-op")) (_a$4609 (jolt-get node (keyword #f "fn"))) (_a$4610 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$4608 _a$4609 _a$4610)))) (if (jolt-truthy? (let* ((and__13__auto nop)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__13__auto))) #t #f)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))) returns-scheme-bool?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec4587 ((node node)) (let* ((G__40 (jolt-get node (keyword #f "op")))) (if (jolt= G__40 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__40 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__40 (keyword #f "var")) (let* ((core-proc (let* ((and__13__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__13__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$4588 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$4589 (jolt-get node (keyword #f "ns"))) (_a$4590 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$4588 _a$4589 _a$4590))) (let* ((_a$4591 (var-deref "jolt.backend-scheme" "dl-name")) (_a$4592 (jolt-get node (keyword #f "ns"))) (_a$4593 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$4591 _a$4592 _a$4593)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__13__auto))) (jolt-throw (let* ((_a$4600 (let* ((_a$4594 (var-deref "clojure.core" "str")) (_a$4595 "emit: unsupported stdlib ref `") (_a$4596 (jolt-get node (keyword #f "ns"))) (_a$4597 "/") (_a$4598 (jolt-get node (keyword #f "name"))) (_a$4599 "` (no core on Chez yet)")) (jolt-invoke _a$4594 _a$4595 _a$4596 _a$4597 _a$4598 _a$4599))) (_a$4601 (jolt-hash-map))) (jolt-ex-info _a$4600 _a$4601))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$4602 (var-deref "clojure.core" "str")) (_a$4603 "(var-deref ") (_a$4604 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4605 " ") (_a$4606 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4607 ")")) (jolt-invoke _a$4602 _a$4603 _a$4604 _a$4605 _a$4606 _a$4607)) jolt-nil))))) (if (jolt= G__40 (keyword #f "the-var")) (let* ((_a$4608 (var-deref "clojure.core" "str")) (_a$4609 "(jolt-var ") (_a$4610 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4611 " ") (_a$4612 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4613 ")")) (jolt-invoke _a$4608 _a$4609 _a$4610 _a$4611 _a$4612 _a$4613)) (if (jolt= G__40 (keyword #f "set-var")) (let* ((_a$4614 (var-deref "clojure.core" "str")) (_a$4615 "(jolt-var-set ") (_a$4616 (jolt-invoke emit (jolt-get node (keyword #f "the-var")))) (_a$4617 " ") (_a$4618 (jolt-invoke emit (jolt-get node (keyword #f "val")))) (_a$4619 ")")) (jolt-invoke _a$4614 _a$4615 _a$4616 _a$4617 _a$4618 _a$4619)) (if (jolt= G__40 (keyword #f "set-field")) (let* ((_a$4620 (var-deref "clojure.core" "str")) (_a$4621 "(jolt-set-field! ") (_a$4622 (jolt-invoke emit (jolt-get node (keyword #f "obj")))) (_a$4623 " (keyword #f ") (_a$4624 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$4625 ") ") (_a$4626 (jolt-invoke emit (jolt-get node (keyword #f "val")))) (_a$4627 ")")) (jolt-invoke _a$4620 _a$4621 _a$4622 _a$4623 _a$4624 _a$4625 _a$4626 _a$4627)) (if (jolt= G__40 (keyword #f "defmacro")) (let* ((_a$4628 (var-deref "clojure.core" "str")) (_a$4629 "(begin (def-var! ") (_a$4630 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4631 " ") (_a$4632 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4633 " ") (_a$4634 (jolt-invoke emit (jolt-get node (keyword #f "fn")))) (_a$4635 ") (mark-macro! ") (_a$4636 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4637 " ") (_a$4638 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4639 ") jolt-nil)")) (jolt-invoke _a$4628 _a$4629 _a$4630 _a$4631 _a$4632 _a$4633 _a$4634 _a$4635 _a$4636 _a$4637 _a$4638 _a$4639)) (if (jolt= G__40 (keyword #f "host")) (jolt-throw (let* ((_a$4640 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$4641 (jolt-hash-map))) (jolt-ex-info _a$4640 _a$4641))) (if (jolt= G__40 (keyword #f "host-static")) (let* ((_a$4642 (var-deref "clojure.core" "str")) (_a$4643 "(host-static-ref ") (_a$4644 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$4645 " ") (_a$4646 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$4647 ")")) (jolt-invoke _a$4642 _a$4643 _a$4644 _a$4645 _a$4646 _a$4647)) (if (jolt= G__40 (keyword #f "host-new")) (let* ((_a$4648 (var-deref "clojure.core" "str")) (_a$4649 "(host-new ") (_a$4650 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$4651 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$4652 ")")) (jolt-invoke _a$4648 _a$4649 _a$4650 _a$4651 _a$4652)) (if (jolt= G__40 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (jolt-invoke emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (jolt-invoke emit test) ")")))) (let* ((_a$4653 (var-deref "clojure.core" "str")) (_a$4654 "(if ") (_a$4655 t) (_a$4656 " ") (_a$4657 (jolt-invoke emit (jolt-get node (keyword #f "then")))) (_a$4658 " ") (_a$4659 (jolt-invoke emit (jolt-get node (keyword #f "else")))) (_a$4660 ")")) (jolt-invoke _a$4653 _a$4654 _a$4655 _a$4656 _a$4657 _a$4658 _a$4659 _a$4660))) (if (jolt= G__40 (keyword #f "do")) (let* ((_a$4661 (var-deref "clojure.core" "str")) (_a$4662 "(begin ") (_a$4663 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$4664 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$4665 (jolt-invoke emit (jolt-get node (keyword #f "ret")))) (_a$4666 ")")) (jolt-invoke _a$4661 _a$4662 _a$4663 _a$4664 _a$4665 _a$4666)) (if (jolt= G__40 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__40 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__40 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__40 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$4670 (var-deref "clojure.core" "mapcat")) (_a$4671 (lambda (p) (let fnrec4667 ((p p)) (let* ((_o$4668 (jolt-invoke emit (jolt-nth p 0))) (_o$4669 (jolt-invoke emit (jolt-nth p 1)))) (jolt-vector _o$4668 _o$4669))))) (_a$4672 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$4670 _a$4671 _a$4672))) (if (jolt= G__40 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__40 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (jolt-invoke emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__40 (keyword #f "coerce")) (let* ((e (jolt-invoke emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__40 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__40 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__40 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (jolt-invoke emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$4673 (var-deref "clojure.core" "str")) (_a$4674 "(jolt-host-call ") (_a$4675 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$4676 " ") (_a$4677 target) (_a$4678 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$4679 ")")) (jolt-invoke _a$4673 _a$4674 _a$4675 _a$4676 _a$4677 _a$4678 _a$4679)) (let* ((_a$4680 (var-deref "clojure.core" "str")) (_a$4681 "(record-method-dispatch ") (_a$4682 target) (_a$4683 " ") (_a$4684 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$4685 " (jolt-vector") (_a$4686 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$4687 "))")) (jolt-invoke _a$4680 _a$4681 _a$4682 _a$4683 _a$4684 _a$4685 _a$4686 _a$4687)))) (if (jolt= G__40 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__40 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__40 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__40 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__40 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__40 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__40 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$4688 (var-deref "clojure.core" "str")) (_a$4689 "(declare-var! ") (_a$4690 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4691 " ") (_a$4692 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4693 ")")) (jolt-invoke _a$4688 _a$4689 _a$4690 _a$4691 _a$4692 _a$4693)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$4694 (var-deref "clojure.core" "str")) (_a$4695 "(def-var-with-meta! ") (_a$4696 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4697 " ") (_a$4698 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4699 " ") (_a$4700 (jolt-invoke emit (jolt-get node (keyword #f "init")))) (_a$4701 " ") (_a$4702 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))) (_a$4703 ")")) (jolt-invoke _a$4694 _a$4695 _a$4696 _a$4697 _a$4698 _a$4699 _a$4700 _a$4701 _a$4702 _a$4703)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$4704 (var-deref "clojure.core" "str")) (_a$4705 "(def-var! ") (_a$4706 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4707 " ") (_a$4708 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4709 " ") (_a$4710 (jolt-invoke emit (jolt-get node (keyword #f "init")))) (_a$4711 ")")) (jolt-invoke _a$4704 _a$4705 _a$4706 _a$4707 _a$4708 _a$4709 _a$4710 _a$4711)) jolt-nil))) (jolt-throw (let* ((_a$4712 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$4713 (jolt-hash-map))) (jolt-ex-info _a$4712 _a$4713))))))))))))))))))))))))))))))))))))))))) emit)))
+  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec4611 ((node node)) (let* ((G__40 (jolt-get node (keyword #f "op")))) (if (jolt= G__40 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__40 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__40 (keyword #f "var")) (let* ((core-proc (let* ((and__13__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__13__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$4612 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$4613 (jolt-get node (keyword #f "ns"))) (_a$4614 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$4612 _a$4613 _a$4614))) (let* ((_a$4615 (var-deref "jolt.backend-scheme" "dl-name")) (_a$4616 (jolt-get node (keyword #f "ns"))) (_a$4617 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$4615 _a$4616 _a$4617)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__13__auto))) (jolt-throw (let* ((_a$4624 (let* ((_a$4618 (var-deref "clojure.core" "str")) (_a$4619 "emit: unsupported stdlib ref `") (_a$4620 (jolt-get node (keyword #f "ns"))) (_a$4621 "/") (_a$4622 (jolt-get node (keyword #f "name"))) (_a$4623 "` (no core on Chez yet)")) (jolt-invoke _a$4618 _a$4619 _a$4620 _a$4621 _a$4622 _a$4623))) (_a$4625 (jolt-hash-map))) (jolt-ex-info _a$4624 _a$4625))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$4626 (var-deref "clojure.core" "str")) (_a$4627 "(var-deref ") (_a$4628 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4629 " ") (_a$4630 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4631 ")")) (jolt-invoke _a$4626 _a$4627 _a$4628 _a$4629 _a$4630 _a$4631)) jolt-nil))))) (if (jolt= G__40 (keyword #f "the-var")) (let* ((_a$4632 (var-deref "clojure.core" "str")) (_a$4633 "(jolt-var ") (_a$4634 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4635 " ") (_a$4636 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4637 ")")) (jolt-invoke _a$4632 _a$4633 _a$4634 _a$4635 _a$4636 _a$4637)) (if (jolt= G__40 (keyword #f "set-var")) (let* ((_a$4638 (var-deref "clojure.core" "str")) (_a$4639 "(jolt-var-set ") (_a$4640 (jolt-invoke emit (jolt-get node (keyword #f "the-var")))) (_a$4641 " ") (_a$4642 (jolt-invoke emit (jolt-get node (keyword #f "val")))) (_a$4643 ")")) (jolt-invoke _a$4638 _a$4639 _a$4640 _a$4641 _a$4642 _a$4643)) (if (jolt= G__40 (keyword #f "set-field")) (let* ((_a$4644 (var-deref "clojure.core" "str")) (_a$4645 "(jolt-set-field! ") (_a$4646 (jolt-invoke emit (jolt-get node (keyword #f "obj")))) (_a$4647 " (keyword #f ") (_a$4648 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$4649 ") ") (_a$4650 (jolt-invoke emit (jolt-get node (keyword #f "val")))) (_a$4651 ")")) (jolt-invoke _a$4644 _a$4645 _a$4646 _a$4647 _a$4648 _a$4649 _a$4650 _a$4651)) (if (jolt= G__40 (keyword #f "defmacro")) (let* ((_a$4652 (var-deref "clojure.core" "str")) (_a$4653 "(begin (def-var! ") (_a$4654 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4655 " ") (_a$4656 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4657 " ") (_a$4658 (jolt-invoke emit (jolt-get node (keyword #f "fn")))) (_a$4659 ") (mark-macro! ") (_a$4660 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4661 " ") (_a$4662 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4663 ") jolt-nil)")) (jolt-invoke _a$4652 _a$4653 _a$4654 _a$4655 _a$4656 _a$4657 _a$4658 _a$4659 _a$4660 _a$4661 _a$4662 _a$4663)) (if (jolt= G__40 (keyword #f "host")) (jolt-throw (let* ((_a$4664 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$4665 (jolt-hash-map))) (jolt-ex-info _a$4664 _a$4665))) (if (jolt= G__40 (keyword #f "host-static")) (let* ((_a$4666 (var-deref "clojure.core" "str")) (_a$4667 "(host-static-ref ") (_a$4668 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$4669 " ") (_a$4670 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$4671 ")")) (jolt-invoke _a$4666 _a$4667 _a$4668 _a$4669 _a$4670 _a$4671)) (if (jolt= G__40 (keyword #f "host-new")) (let* ((_a$4672 (var-deref "clojure.core" "str")) (_a$4673 "(host-new ") (_a$4674 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$4675 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$4676 ")")) (jolt-invoke _a$4672 _a$4673 _a$4674 _a$4675 _a$4676)) (if (jolt= G__40 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (jolt-invoke emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (jolt-invoke emit test) ")")))) (let* ((_a$4677 (var-deref "clojure.core" "str")) (_a$4678 "(if ") (_a$4679 t) (_a$4680 " ") (_a$4681 (jolt-invoke emit (jolt-get node (keyword #f "then")))) (_a$4682 " ") (_a$4683 (jolt-invoke emit (jolt-get node (keyword #f "else")))) (_a$4684 ")")) (jolt-invoke _a$4677 _a$4678 _a$4679 _a$4680 _a$4681 _a$4682 _a$4683 _a$4684))) (if (jolt= G__40 (keyword #f "do")) (let* ((_a$4685 (var-deref "clojure.core" "str")) (_a$4686 "(begin ") (_a$4687 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$4688 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$4689 (jolt-invoke emit (jolt-get node (keyword #f "ret")))) (_a$4690 ")")) (jolt-invoke _a$4685 _a$4686 _a$4687 _a$4688 _a$4689 _a$4690)) (if (jolt= G__40 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__40 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__40 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__40 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$4694 (var-deref "clojure.core" "mapcat")) (_a$4695 (lambda (p) (let fnrec4691 ((p p)) (let* ((_o$4692 (jolt-invoke emit (jolt-nth p 0))) (_o$4693 (jolt-invoke emit (jolt-nth p 1)))) (jolt-vector _o$4692 _o$4693))))) (_a$4696 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$4694 _a$4695 _a$4696))) (if (jolt= G__40 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__40 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (jolt-invoke emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__40 (keyword #f "coerce")) (let* ((e (jolt-invoke emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__40 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__40 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__40 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__40 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (jolt-invoke emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$4697 (var-deref "clojure.core" "str")) (_a$4698 "(jolt-host-call ") (_a$4699 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$4700 " ") (_a$4701 target) (_a$4702 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$4703 ")")) (jolt-invoke _a$4697 _a$4698 _a$4699 _a$4700 _a$4701 _a$4702 _a$4703)) (let* ((_a$4704 (var-deref "clojure.core" "str")) (_a$4705 "(record-method-dispatch ") (_a$4706 target) (_a$4707 " ") (_a$4708 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$4709 " (jolt-vector") (_a$4710 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$4711 "))")) (jolt-invoke _a$4704 _a$4705 _a$4706 _a$4707 _a$4708 _a$4709 _a$4710 _a$4711)))) (if (jolt= G__40 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__40 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__40 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__40 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__40 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__40 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__40 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$4712 (var-deref "clojure.core" "str")) (_a$4713 "(declare-var! ") (_a$4714 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4715 " ") (_a$4716 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4717 ")")) (jolt-invoke _a$4712 _a$4713 _a$4714 _a$4715 _a$4716 _a$4717)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$4718 (var-deref "clojure.core" "str")) (_a$4719 "(def-var-with-meta! ") (_a$4720 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4721 " ") (_a$4722 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4723 " ") (_a$4724 (jolt-invoke emit (jolt-get node (keyword #f "init")))) (_a$4725 " ") (_a$4726 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))) (_a$4727 ")")) (jolt-invoke _a$4718 _a$4719 _a$4720 _a$4721 _a$4722 _a$4723 _a$4724 _a$4725 _a$4726 _a$4727)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$4728 (var-deref "clojure.core" "str")) (_a$4729 "(def-var! ") (_a$4730 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$4731 " ") (_a$4732 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$4733 " ") (_a$4734 (jolt-invoke emit (jolt-get node (keyword #f "init")))) (_a$4735 ")")) (jolt-invoke _a$4728 _a$4729 _a$4730 _a$4731 _a$4732 _a$4733 _a$4734 _a$4735)) jolt-nil))) (jolt-throw (let* ((_a$4736 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$4737 (jolt-hash-map))) (jolt-ex-info _a$4736 _a$4737))))))))))))))))))))))))))))))))))))))))) emit)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec4714 ((m m)) (let* ((or__14__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?)))
+  (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec4738 ((m m)) (let* ((or__14__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec4715 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$4716 (var-deref "clojure.core" "str")) (_a$4717 "(begin ") (_a$4718 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$4719 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$4720 (jolt-invoke emit-top-form (jolt-get node (keyword #f "ret")))) (_a$4721 ")")) (jolt-invoke _a$4716 _a$4717 _a$4718 _a$4719 _a$4720 _a$4721)) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__13__auto)) and__13__auto))) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op"))) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$4722 (var-deref "clojure.core" "str")) (_a$4723 "(begin (define ") (_a$4724 b) (_a$4725 " ") (_a$4726 init) (_a$4727 ") (def-var-with-meta! ") (_a$4728 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$4729 " ") (_a$4730 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4731 " ") (_a$4732 b) (_a$4733 " ") (_a$4734 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))) (_a$4735 "))")) (jolt-invoke _a$4722 _a$4723 _a$4724 _a$4725 _a$4726 _a$4727 _a$4728 _a$4729 _a$4730 _a$4731 _a$4732 _a$4733 _a$4734 _a$4735)) (let* ((_a$4736 (var-deref "clojure.core" "str")) (_a$4737 "(begin (define ") (_a$4738 b) (_a$4739 " ") (_a$4740 init) (_a$4741 ") (def-var! ") (_a$4742 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$4743 " ") (_a$4744 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4745 " ") (_a$4746 b) (_a$4747 "))")) (jolt-invoke _a$4736 _a$4737 _a$4738 _a$4739 _a$4740 _a$4741 _a$4742 _a$4743 _a$4744 _a$4745 _a$4746 _a$4747)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form)))
+  (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec4739 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$4740 (var-deref "clojure.core" "str")) (_a$4741 "(begin ") (_a$4742 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$4743 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$4744 (jolt-invoke emit-top-form (jolt-get node (keyword #f "ret")))) (_a$4745 ")")) (jolt-invoke _a$4740 _a$4741 _a$4742 _a$4743 _a$4744 _a$4745)) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__13__auto)) and__13__auto))) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op"))) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$4746 (var-deref "clojure.core" "str")) (_a$4747 "(begin (define ") (_a$4748 b) (_a$4749 " ") (_a$4750 init) (_a$4751 ") (def-var-with-meta! ") (_a$4752 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$4753 " ") (_a$4754 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4755 " ") (_a$4756 b) (_a$4757 " ") (_a$4758 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))) (_a$4759 "))")) (jolt-invoke _a$4746 _a$4747 _a$4748 _a$4749 _a$4750 _a$4751 _a$4752 _a$4753 _a$4754 _a$4755 _a$4756 _a$4757 _a$4758 _a$4759)) (let* ((_a$4760 (var-deref "clojure.core" "str")) (_a$4761 "(begin (define ") (_a$4762 b) (_a$4763 " ") (_a$4764 init) (_a$4765 ") (def-var! ") (_a$4766 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$4767 " ") (_a$4768 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$4769 " ") (_a$4770 b) (_a$4771 "))")) (jolt-invoke _a$4760 _a$4761 _a$4762 _a$4763 _a$4764 _a$4765 _a$4766 _a$4767 _a$4768 _a$4769 _a$4770 _a$4771)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$4748 "+") (_o$4749 jolt-add) (_o$4750 "-") (_o$4751 jolt-sub) (_o$4752 "*") (_o$4753 jolt-mul) (_o$4754 "/") (_o$4755 jolt-div) (_o$4756 "<") (_o$4757 <) (_o$4758 ">") (_o$4759 >) (_o$4760 "<=") (_o$4761 <=) (_o$4762 ">=") (_o$4763 >=) (_o$4764 "=") (_o$4765 jolt=) (_o$4766 "inc") (_o$4767 jolt-inc) (_o$4768 "dec") (_o$4769 jolt-dec) (_o$4770 "mod") (_o$4771 modulo) (_o$4772 "rem") (_o$4773 remainder) (_o$4774 "quot") (_o$4775 quotient) (_o$4776 "bit-and") (_o$4777 (var-deref "clojure.core" "__bit-and")) (_o$4778 "bit-or") (_o$4779 (var-deref "clojure.core" "__bit-or")) (_o$4780 "bit-xor") (_o$4781 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$4748 _o$4749 _o$4750 _o$4751 _o$4752 _o$4753 _o$4754 _o$4755 _o$4756 _o$4757 _o$4758 _o$4759 _o$4760 _o$4761 _o$4762 _o$4763 _o$4764 _o$4765 _o$4766 _o$4767 _o$4768 _o$4769 _o$4770 _o$4771 _o$4772 _o$4773 _o$4774 _o$4775 _o$4776 _o$4777 _o$4778 _o$4779 _o$4780 _o$4781)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$4772 "+") (_o$4773 jolt-add) (_o$4774 "-") (_o$4775 jolt-sub) (_o$4776 "*") (_o$4777 jolt-mul) (_o$4778 "/") (_o$4779 jolt-div) (_o$4780 "<") (_o$4781 <) (_o$4782 ">") (_o$4783 >) (_o$4784 "<=") (_o$4785 <=) (_o$4786 ">=") (_o$4787 >=) (_o$4788 "=") (_o$4789 jolt=) (_o$4790 "inc") (_o$4791 jolt-inc) (_o$4792 "dec") (_o$4793 jolt-dec) (_o$4794 "mod") (_o$4795 modulo) (_o$4796 "rem") (_o$4797 remainder) (_o$4798 "quot") (_o$4799 quotient) (_o$4800 "bit-and") (_o$4801 (var-deref "clojure.core" "__bit-and")) (_o$4802 "bit-or") (_o$4803 (var-deref "clojure.core" "__bit-or")) (_o$4804 "bit-xor") (_o$4805 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$4772 _o$4773 _o$4774 _o$4775 _o$4776 _o$4777 _o$4778 _o$4779 _o$4780 _o$4781 _o$4782 _o$4783 _o$4784 _o$4785 _o$4786 _o$4787 _o$4788 _o$4789 _o$4790 _o$4791 _o$4792 _o$4793 _o$4794 _o$4795 _o$4796 _o$4797 _o$4798 _o$4799 _o$4800 _o$4801 _o$4802 _o$4803 _o$4804 _o$4805)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec4782 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?)))
+  (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec4806 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec4783 ((n n)) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__13__auto)))))) const-num?)))
+  (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec4807 ((n n)) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__13__auto)))))) const-num?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec4784 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (jolt-truthy? (let* ((or__14__auto (let* ((and__13__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__13__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__13__auto)))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "host"))))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn)))
+  (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec4808 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (jolt-truthy? (let* ((or__14__auto (let* ((and__13__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__13__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__13__auto)))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "host"))))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec4785 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__13__auto ff)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__13__auto)) and__13__auto))) (guard (e (else jolt-nil)) (let* ((_o$4787 (keyword #f "op")) (_o$4788 (keyword #f "const")) (_o$4789 (keyword #f "val")) (_o$4790 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec4786 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$4787 _o$4788 _o$4789 _o$4790))) jolt-nil))) (let* ((or__14__auto folded)) (if (jolt-truthy? or__14__auto) or__14__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (jolt-invoke const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= #f (jolt-get t (keyword #f "val")))))) (jolt-invoke const-fold (jolt-get node (keyword #f "else"))) (jolt-invoke const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$4791 node) (_a$4792 (keyword #f "test")) (_a$4793 t) (_a$4794 (keyword #f "then")) (_a$4795 (jolt-invoke const-fold (jolt-get node (keyword #f "then")))) (_a$4796 (keyword #f "else")) (_a$4797 (jolt-invoke const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$4791 _a$4792 _a$4793 _a$4794 _a$4795 _a$4796 _a$4797)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold)))
+  (def-var! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec4809 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__13__auto ff)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__13__auto)) and__13__auto))) (guard (e (else jolt-nil)) (let* ((_o$4811 (keyword #f "op")) (_o$4812 (keyword #f "const")) (_o$4813 (keyword #f "val")) (_o$4814 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec4810 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$4811 _o$4812 _o$4813 _o$4814))) jolt-nil))) (let* ((or__14__auto folded)) (if (jolt-truthy? or__14__auto) or__14__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (jolt-invoke const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= #f (jolt-get t (keyword #f "val")))))) (jolt-invoke const-fold (jolt-get node (keyword #f "else"))) (jolt-invoke const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$4815 node) (_a$4816 (keyword #f "test")) (_a$4817 t) (_a$4818 (keyword #f "then")) (_a$4819 (jolt-invoke const-fold (jolt-get node (keyword #f "then")))) (_a$4820 (keyword #f "else")) (_a$4821 (jolt-invoke const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$4815 _a$4816 _a$4817 _a$4818 _a$4819 _a$4820 _a$4821)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec4798 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__13__auto)))))) scalar-const?)))
+  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec4822 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__13__auto)))))) scalar-const?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec4799 ((fnode fnode)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__13__auto)))))) kw-callee?)))
+  (def-var! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec4823 ((fnode fnode)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__13__auto)))))) kw-callee?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec4800 ((fnode fnode)) (let* ((or__14__auto (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__13__auto)) and__13__auto)))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__13__auto)))))))) get-callee?)))
+  (def-var! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec4824 ((fnode fnode)) (let* ((or__14__auto (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__13__auto)) and__13__auto)))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__13__auto)))))))) get-callee?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec3567 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__13__auto))) and__13__auto)))))) int-lit?)))
+  (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec3591 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__13__auto))) and__13__auto)))))) int-lit?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "float-lit?" (letrec ((float-lit? (lambda (n) (let fnrec3568 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "float?") v) and__13__auto))) and__13__auto)))))) float-lit?)))
+  (def-var! "jolt.passes.numeric" "float-lit?" (letrec ((float-lit? (lambda (n) (let fnrec3592 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "float?") v) and__13__auto))) and__13__auto)))))) float-lit?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "dbl-spec" (letrec ((dbl-spec (lambda (nm n) (let fnrec3569 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__13__auto (>= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3570 "+") (_o$3571 "-") (_o$3572 "*") (_o$3573 "/") (_o$3574 "min") (_o$3575 "max")) (jolt-hash-set _o$3570 _o$3571 _o$3572 _o$3573 _o$3574 _o$3575)) nm) and__13__auto))) (keyword #f "double") (if (jolt-truthy? (let* ((and__13__auto (jolt= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3576 "inc") (_o$3577 "dec")) (jolt-hash-set _o$3576 _o$3577)) nm) and__13__auto))) (keyword #f "double") (if (jolt-truthy? (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3578 "<") (_o$3579 ">") (_o$3580 "<=") (_o$3581 ">=") (_o$3582 "=") (_o$3583 "==")) (jolt-hash-set _o$3578 _o$3579 _o$3580 _o$3581 _o$3582 _o$3583)) nm) and__13__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) dbl-spec)))
+  (def-var! "jolt.passes.numeric" "dbl-spec" (letrec ((dbl-spec (lambda (nm n) (let fnrec3593 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__13__auto (>= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3594 "+") (_o$3595 "-") (_o$3596 "*") (_o$3597 "/") (_o$3598 "min") (_o$3599 "max")) (jolt-hash-set _o$3594 _o$3595 _o$3596 _o$3597 _o$3598 _o$3599)) nm) and__13__auto))) (keyword #f "double") (if (jolt-truthy? (let* ((and__13__auto (jolt= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3600 "inc") (_o$3601 "dec")) (jolt-hash-set _o$3600 _o$3601)) nm) and__13__auto))) (keyword #f "double") (if (jolt-truthy? (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3602 "<") (_o$3603 ">") (_o$3604 "<=") (_o$3605 ">=") (_o$3606 "=") (_o$3607 "==")) (jolt-hash-set _o$3602 _o$3603 _o$3604 _o$3605 _o$3606 _o$3607)) nm) and__13__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) dbl-spec)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "lng-spec" (letrec ((lng-spec (lambda (nm n) (let fnrec3584 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__13__auto (>= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3585 "+") (_o$3586 "-") (_o$3587 "*") (_o$3588 "min") (_o$3589 "max") (_o$3590 "unchecked-add") (_o$3591 "unchecked-subtract") (_o$3592 "unchecked-multiply")) (jolt-hash-set _o$3585 _o$3586 _o$3587 _o$3588 _o$3589 _o$3590 _o$3591 _o$3592)) nm) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__13__auto (jolt= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3593 "inc") (_o$3594 "dec") (_o$3595 "unchecked-inc") (_o$3596 "unchecked-dec")) (jolt-hash-set _o$3593 _o$3594 _o$3595 _o$3596)) nm) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__13__auto (jolt= n 2))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3597 "quot") (_o$3598 "rem") (_o$3599 "mod")) (jolt-hash-set _o$3597 _o$3598 _o$3599)) nm) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3600 "<") (_o$3601 ">") (_o$3602 "<=") (_o$3603 ">=") (_o$3604 "=") (_o$3605 "==")) (jolt-hash-set _o$3600 _o$3601 _o$3602 _o$3603 _o$3604 _o$3605)) nm) and__13__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))) lng-spec)))
+  (def-var! "jolt.passes.numeric" "lng-spec" (letrec ((lng-spec (lambda (nm n) (let fnrec3608 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__13__auto (>= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3609 "+") (_o$3610 "-") (_o$3611 "*") (_o$3612 "min") (_o$3613 "max") (_o$3614 "unchecked-add") (_o$3615 "unchecked-subtract") (_o$3616 "unchecked-multiply")) (jolt-hash-set _o$3609 _o$3610 _o$3611 _o$3612 _o$3613 _o$3614 _o$3615 _o$3616)) nm) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__13__auto (jolt= n 1))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3617 "inc") (_o$3618 "dec") (_o$3619 "unchecked-inc") (_o$3620 "unchecked-dec")) (jolt-hash-set _o$3617 _o$3618 _o$3619 _o$3620)) nm) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__13__auto (jolt= n 2))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3621 "quot") (_o$3622 "rem") (_o$3623 "mod")) (jolt-hash-set _o$3621 _o$3622 _o$3623)) nm) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt-contains? (let* ((_o$3624 "<") (_o$3625 ">") (_o$3626 "<=") (_o$3627 ">=") (_o$3628 "=") (_o$3629 "==")) (jolt-hash-set _o$3624 _o$3625 _o$3626 _o$3627 _o$3628 _o$3629)) nm) and__13__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))) lng-spec)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "propagate" (letrec ((propagate (lambda (spec) (let fnrec3606 ((spec spec)) (if (jolt= spec (keyword #f "bool")) jolt-nil spec))))) propagate)))
+  (def-var! "jolt.passes.numeric" "propagate" (letrec ((propagate (lambda (spec) (let fnrec3630 ((spec spec)) (if (jolt= spec (keyword #f "bool")) jolt-nil spec))))) propagate)))
 (guard (e (#t #f))
   (declare-var! "jolt.passes.numeric" "an"))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "recur-kinds" (letrec ((recur-kinds (lambda (node tenv) (let fnrec3607 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (let* ((_a$3609 (var-deref "clojure.core" "mapv")) (_a$3610 (lambda (a) (let fnrec3608 ((a a)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv) 0)))) (_a$3611 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$3609 _a$3610 _a$3611))) (if (jolt= op (keyword #f "let")) (let* ((_a$3619 recur-kinds) (_a$3620 (jolt-get node (keyword #f "body"))) (_a$3621 (let* ((_a$3616 (lambda (te b) (let fnrec3612 ((te te) (b b)) (let* ((_a$3613 te) (_a$3614 (jolt-nth b 0)) (_a$3615 (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") (jolt-nth b 1) te) 0))) (jolt-assoc _a$3613 _a$3614 _a$3615))))) (_a$3617 tenv) (_a$3618 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3616 _a$3617 _a$3618)))) (jolt-invoke _a$3619 _a$3620 _a$3621)) (if (jolt= op (keyword #f "if")) (let* ((_a$3622 (jolt-invoke recur-kinds (jolt-get node (keyword #f "then")) tenv)) (_a$3623 (jolt-invoke recur-kinds (jolt-get node (keyword #f "else")) tenv))) (jolt-concat _a$3622 _a$3623)) (if (jolt= op (keyword #f "do")) (jolt-invoke recur-kinds (jolt-get node (keyword #f "ret")) tenv) (if (jolt-truthy? (keyword #f "else")) (jolt-vector) jolt-nil)))))))))) recur-kinds)))
+  (def-var! "jolt.passes.numeric" "recur-kinds" (letrec ((recur-kinds (lambda (node tenv) (let fnrec3631 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (let* ((_a$3633 (var-deref "clojure.core" "mapv")) (_a$3634 (lambda (a) (let fnrec3632 ((a a)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv) 0)))) (_a$3635 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$3633 _a$3634 _a$3635))) (if (jolt= op (keyword #f "let")) (let* ((_a$3643 recur-kinds) (_a$3644 (jolt-get node (keyword #f "body"))) (_a$3645 (let* ((_a$3640 (lambda (te b) (let fnrec3636 ((te te) (b b)) (let* ((_a$3637 te) (_a$3638 (jolt-nth b 0)) (_a$3639 (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") (jolt-nth b 1) te) 0))) (jolt-assoc _a$3637 _a$3638 _a$3639))))) (_a$3641 tenv) (_a$3642 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3640 _a$3641 _a$3642)))) (jolt-invoke _a$3643 _a$3644 _a$3645)) (if (jolt= op (keyword #f "if")) (let* ((_a$3646 (jolt-invoke recur-kinds (jolt-get node (keyword #f "then")) tenv)) (_a$3647 (jolt-invoke recur-kinds (jolt-get node (keyword #f "else")) tenv))) (jolt-concat _a$3646 _a$3647)) (if (jolt= op (keyword #f "do")) (jolt-invoke recur-kinds (jolt-get node (keyword #f "ret")) tenv) (if (jolt-truthy? (keyword #f "else")) (jolt-vector) jolt-nil)))))))))) recur-kinds)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "recur-arg-lists" (letrec ((recur-arg-lists (lambda (node) (let fnrec3624 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "let")) (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "body"))) (if (jolt= op (keyword #f "if")) (let* ((_a$3625 (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "then")))) (_a$3626 (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "else"))))) (jolt-concat _a$3625 _a$3626)) (if (jolt= op (keyword #f "do")) (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "ret"))) (if (jolt-truthy? (keyword #f "else")) (jolt-vector) jolt-nil)))))))))) recur-arg-lists)))
+  (def-var! "jolt.passes.numeric" "recur-arg-lists" (letrec ((recur-arg-lists (lambda (node) (let fnrec3648 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "let")) (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "body"))) (if (jolt= op (keyword #f "if")) (let* ((_a$3649 (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "then")))) (_a$3650 (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "else"))))) (jolt-concat _a$3649 _a$3650)) (if (jolt= op (keyword #f "do")) (jolt-invoke recur-arg-lists (jolt-get node (keyword #f "ret"))) (if (jolt-truthy? (keyword #f "else")) (jolt-vector) jolt-nil)))))))))) recur-arg-lists)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "counter-step?" (letrec ((counter-step? (lambda (arg vname) (let fnrec3627 ((arg arg) (vname vname)) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get arg (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= vname (jolt-get arg (keyword #f "name"))) and__13__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get arg (keyword #f "op"))) (let* ((f (jolt-get arg (keyword #f "fn"))) (as (jolt-get arg (keyword #f "args")))) (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (let* ((nm (jolt-get f (keyword #f "name"))) (v? (lambda (n) (let fnrec3628 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= vname (jolt-get n (keyword #f "name"))) and__13__auto)))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (let* ((_o$3629 "inc") (_o$3630 "dec") (_o$3631 "unchecked-inc") (_o$3632 "unchecked-dec")) (jolt-hash-set _o$3629 _o$3630 _o$3631 _o$3632)) nm))) (if (jolt-truthy? and__13__auto) (jolt= 1 (jolt-count as)) and__13__auto))) (jolt-invoke v? (jolt-nth as 0)) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (let* ((_o$3633 "+") (_o$3634 "unchecked-add")) (jolt-hash-set _o$3633 _o$3634)) nm))) (if (jolt-truthy? and__13__auto) (jolt= 2 (jolt-count as)) and__13__auto))) (let* ((or__14__auto (let* ((and__13__auto (jolt-invoke v? (jolt-nth as 0)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 1)) and__13__auto)))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt-invoke v? (jolt-nth as 1)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 0)) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (let* ((_o$3635 "-") (_o$3636 "unchecked-subtract")) (jolt-hash-set _o$3635 _o$3636)) nm))) (if (jolt-truthy? and__13__auto) (jolt= 2 (jolt-count as)) and__13__auto))) (let* ((and__13__auto (jolt-invoke v? (jolt-nth as 0)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 1)) and__13__auto)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))) and__13__auto)) and__13__auto))) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))) counter-step?)))
+  (def-var! "jolt.passes.numeric" "counter-step?" (letrec ((counter-step? (lambda (arg vname) (let fnrec3651 ((arg arg) (vname vname)) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get arg (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= vname (jolt-get arg (keyword #f "name"))) and__13__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get arg (keyword #f "op"))) (let* ((f (jolt-get arg (keyword #f "fn"))) (as (jolt-get arg (keyword #f "args")))) (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (let* ((nm (jolt-get f (keyword #f "name"))) (v? (lambda (n) (let fnrec3652 ((n n)) (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= vname (jolt-get n (keyword #f "name"))) and__13__auto)))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (let* ((_o$3653 "inc") (_o$3654 "dec") (_o$3655 "unchecked-inc") (_o$3656 "unchecked-dec")) (jolt-hash-set _o$3653 _o$3654 _o$3655 _o$3656)) nm))) (if (jolt-truthy? and__13__auto) (jolt= 1 (jolt-count as)) and__13__auto))) (jolt-invoke v? (jolt-nth as 0)) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (let* ((_o$3657 "+") (_o$3658 "unchecked-add")) (jolt-hash-set _o$3657 _o$3658)) nm))) (if (jolt-truthy? and__13__auto) (jolt= 2 (jolt-count as)) and__13__auto))) (let* ((or__14__auto (let* ((and__13__auto (jolt-invoke v? (jolt-nth as 0)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 1)) and__13__auto)))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt-invoke v? (jolt-nth as 1)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 0)) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (let* ((_o$3659 "-") (_o$3660 "unchecked-subtract")) (jolt-hash-set _o$3659 _o$3660)) nm))) (if (jolt-truthy? and__13__auto) (jolt= 2 (jolt-count as)) and__13__auto))) (let* ((and__13__auto (jolt-invoke v? (jolt-nth as 0)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 1)) and__13__auto)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))) and__13__auto)) and__13__auto))) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))) counter-step?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "loop-kinds" (letrec ((loop-kinds (lambda (names seed body tenv) (let fnrec3637 ((names names) (seed seed) (body body) (tenv tenv)) (let* ((cur seed) (iter 0)) (let loop3638 ((cur cur) (iter iter)) (if (> iter (jolt-count names)) cur (let* ((te (let* ((_a$3643 (lambda (t i) (let fnrec3639 ((t t) (i i)) (let* ((_a$3640 t) (_a$3641 (jolt-nth names i)) (_a$3642 (jolt-nth cur i))) (jolt-assoc _a$3640 _a$3641 _a$3642))))) (_a$3644 tenv) (_a$3645 (jolt-range (jolt-count names)))) (jolt-reduce _a$3643 _a$3644 _a$3645))) (rks (jolt-invoke (var-deref "jolt.passes.numeric" "recur-kinds") body te)) (nxt (let* ((_a$3648 (var-deref "clojure.core" "mapv")) (_a$3649 (lambda (j) (let fnrec3646 ((j j)) (let* ((k (jolt-nth cur j))) (if (jolt-truthy? (let* ((and__13__auto k)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (rk) (let fnrec3647 ((rk rk)) (jolt= k (jolt-nth rk j)))) rks) and__13__auto))) k jolt-nil))))) (_a$3650 (jolt-range (jolt-count names)))) (jolt-invoke _a$3648 _a$3649 _a$3650)))) (if (jolt= nxt cur) cur (loop3638 nxt (jolt-inc iter))))))))))) loop-kinds)))
+  (def-var! "jolt.passes.numeric" "loop-kinds" (letrec ((loop-kinds (lambda (names seed body tenv) (let fnrec3661 ((names names) (seed seed) (body body) (tenv tenv)) (let* ((cur seed) (iter 0)) (let loop3662 ((cur cur) (iter iter)) (if (> iter (jolt-count names)) cur (let* ((te (let* ((_a$3667 (lambda (t i) (let fnrec3663 ((t t) (i i)) (let* ((_a$3664 t) (_a$3665 (jolt-nth names i)) (_a$3666 (jolt-nth cur i))) (jolt-assoc _a$3664 _a$3665 _a$3666))))) (_a$3668 tenv) (_a$3669 (jolt-range (jolt-count names)))) (jolt-reduce _a$3667 _a$3668 _a$3669))) (rks (jolt-invoke (var-deref "jolt.passes.numeric" "recur-kinds") body te)) (nxt (let* ((_a$3672 (var-deref "clojure.core" "mapv")) (_a$3673 (lambda (j) (let fnrec3670 ((j j)) (let* ((k (jolt-nth cur j))) (if (jolt-truthy? (let* ((and__13__auto k)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (rk) (let fnrec3671 ((rk rk)) (jolt= k (jolt-nth rk j)))) rks) and__13__auto))) k jolt-nil))))) (_a$3674 (jolt-range (jolt-count names)))) (jolt-invoke _a$3672 _a$3673 _a$3674)))) (if (jolt= nxt cur) cur (loop3662 nxt (jolt-inc iter))))))))))) loop-kinds)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec3651 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$3652 (jolt-hash-map)) (_a$3653 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$3652 _a$3653))) (pe (let* ((_a$3655 (lambda (e p) (let fnrec3654 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$3656 tenv) (_a$3657 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$3655 _a$3656 _a$3657)))) (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) jolt-nil) pe)))))) arity-env)))
+  (def-var! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec3675 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$3676 (jolt-hash-map)) (_a$3677 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$3676 _a$3677))) (pe (let* ((_a$3679 (lambda (e p) (let fnrec3678 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$3680 tenv) (_a$3681 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$3679 _a$3680 _a$3681)))) (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) jolt-nil) pe)))))) arity-env)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec3658 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__13__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$3660 (var-deref "clojure.core" "mapv")) (_a$3661 (lambda (a) (let fnrec3659 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$3662 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$3660 _a$3661 _a$3662))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3663 ((r r)) (jolt-nth r 1))) ars)) (node1 (jolt-assoc node (keyword #f "args") argnodes)) (n (jolt-count ars))) (if (jolt-truthy? (jolt-get fnode (keyword #f "num-ret"))) (let* ((_o$3664 (jolt-get fnode (keyword #f "num-ret"))) (_o$3665 node1)) (jolt-vector _o$3664 _o$3665)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") nm)) (let* ((_o$3666 jolt-nil) (_o$3667 node1)) (jolt-vector _o$3666 _o$3667)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3668 ((r r)) (let* ((k (jolt-nth r 0)) (nd (jolt-nth r 1))) (if (jolt= k (keyword #f "double")) (keyword #f "double") (if (jolt= k (keyword #f "long")) (keyword #f "long") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (keyword #f "wild") (if (jolt-truthy? (keyword #f "else")) (keyword #f "no") jolt-nil))))))) ars)) (ok? (lambda (allowed need) (let fnrec3669 ((allowed allowed) (need need)) (let* ((and__13__auto (jolt-pos? n))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec3670 ((c c)) (let* ((or__14__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec3671 ((c c)) (jolt= c need))) cls) and__13__auto)) and__13__auto))))) (ds (jolt-invoke (var-deref "jolt.passes.numeric" "dbl-spec") nm n)) (ls (jolt-invoke (var-deref "jolt.passes.numeric" "lng-spec") nm n))) (if (jolt-truthy? (let* ((and__13__auto ds)) (if (jolt-truthy? and__13__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__13__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec3672 ((nd nd)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (jolt-assoc nd (keyword #f "val") (jolt-invoke (var-deref "clojure.core" "double") (jolt-get nd (keyword #f "val")))) nd))) argnodes))) (let* ((_o$3673 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$3674 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$3673 _o$3674))) (if (jolt-truthy? (let* ((and__13__auto ls)) (if (jolt-truthy? and__13__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__13__auto))) (let* ((_o$3675 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$3676 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$3675 _o$3676)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3677 jolt-nil) (_o$3678 node1)) (jolt-vector _o$3677 _o$3678)) jolt-nil)))) jolt-nil)))))))) an-invoke)))
+  (def-var! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec3682 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__13__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$3684 (var-deref "clojure.core" "mapv")) (_a$3685 (lambda (a) (let fnrec3683 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$3686 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$3684 _a$3685 _a$3686))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3687 ((r r)) (jolt-nth r 1))) ars)) (node1 (jolt-assoc node (keyword #f "args") argnodes)) (n (jolt-count ars))) (if (jolt-truthy? (jolt-get fnode (keyword #f "num-ret"))) (let* ((_o$3688 (jolt-get fnode (keyword #f "num-ret"))) (_o$3689 node1)) (jolt-vector _o$3688 _o$3689)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") nm)) (let* ((_o$3690 jolt-nil) (_o$3691 node1)) (jolt-vector _o$3690 _o$3691)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3692 ((r r)) (let* ((k (jolt-nth r 0)) (nd (jolt-nth r 1))) (if (jolt= k (keyword #f "double")) (keyword #f "double") (if (jolt= k (keyword #f "long")) (keyword #f "long") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (keyword #f "wild") (if (jolt-truthy? (keyword #f "else")) (keyword #f "no") jolt-nil))))))) ars)) (ok? (lambda (allowed need) (let fnrec3693 ((allowed allowed) (need need)) (let* ((and__13__auto (jolt-pos? n))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec3694 ((c c)) (let* ((or__14__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec3695 ((c c)) (jolt= c need))) cls) and__13__auto)) and__13__auto))))) (ds (jolt-invoke (var-deref "jolt.passes.numeric" "dbl-spec") nm n)) (ls (jolt-invoke (var-deref "jolt.passes.numeric" "lng-spec") nm n))) (if (jolt-truthy? (let* ((and__13__auto ds)) (if (jolt-truthy? and__13__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__13__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec3696 ((nd nd)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (jolt-assoc nd (keyword #f "val") (jolt-invoke (var-deref "clojure.core" "double") (jolt-get nd (keyword #f "val")))) nd))) argnodes))) (let* ((_o$3697 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$3698 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$3697 _o$3698))) (if (jolt-truthy? (let* ((and__13__auto ls)) (if (jolt-truthy? and__13__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__13__auto))) (let* ((_o$3699 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$3700 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$3699 _o$3700)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3701 jolt-nil) (_o$3702 node1)) (jolt-vector _o$3701 _o$3702)) jolt-nil)))) jolt-nil)))))))) an-invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec3679 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$3680 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$3681 node)) (jolt-vector _o$3680 _o$3681)) (if (jolt= op (keyword #f "local")) (let* ((_o$3682 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$3683 node)) (jolt-vector _o$3682 _o$3683)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$3684 (jolt-get node (keyword #f "kind"))) (_o$3685 (jolt-assoc node (keyword #f "expr") (jolt-nth (jolt-invoke an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$3684 _o$3685)) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.numeric" "an-invoke") node tenv) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3696 (lambda (acc b) (let fnrec3686 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (jolt-invoke an (jolt-nth b 1) te))) (let* ((_o$3692 (let* ((_a$3687 te) (_a$3688 (jolt-nth b 0)) (_a$3689 (jolt-nth ir 0))) (jolt-assoc _a$3687 _a$3688 _a$3689))) (_o$3693 (jolt-conj binds (let* ((_o$3690 (jolt-nth b 0)) (_o$3691 (jolt-nth ir 1))) (jolt-vector _o$3690 _o$3691))))) (jolt-vector _o$3692 _o$3693)))))) (_a$3697 (let* ((_o$3694 tenv) (_o$3695 (jolt-vector))) (jolt-vector _o$3694 _o$3695))) (_a$3698 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3696 _a$3697 _a$3698))) (br (let* ((_a$3699 an) (_a$3700 (jolt-get node (keyword #f "body"))) (_a$3701 (jolt-nth res 0))) (jolt-invoke _a$3699 _a$3700 _a$3701)))) (let* ((_o$3707 (jolt-nth br 0)) (_o$3708 (let* ((_a$3702 node) (_a$3703 (keyword #f "bindings")) (_a$3704 (jolt-nth res 1)) (_a$3705 (keyword #f "body")) (_a$3706 (jolt-nth br 1))) (jolt-assoc _a$3702 _a$3703 _a$3704 _a$3705 _a$3706)))) (jolt-vector _o$3707 _o$3708))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings"))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec3709 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec3710 ((b b)) (jolt-nth (jolt-invoke an (jolt-nth b 1) tenv) 0))) binds)) (rlists (jolt-invoke (var-deref "jolt.passes.numeric" "recur-arg-lists") (jolt-get node (keyword #f "body")))) (seed (let* ((_a$3716 (var-deref "clojure.core" "mapv")) (_a$3717 (lambda (j) (let fnrec3711 ((j j)) (let* ((k (jolt-nth ik j)) (b (jolt-nth binds j))) (if (jolt-truthy? k) k (if (jolt-truthy? (let* ((and__13__auto (jolt-seq rlists))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth b 1)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (args) (let fnrec3712 ((args args)) (let* ((_a$3713 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$3714 (jolt-nth args j)) (_a$3715 (jolt-nth b 0))) (jolt-invoke _a$3713 _a$3714 _a$3715)))) rlists) and__13__auto)) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$3718 (jolt-range (jolt-count names)))) (jolt-invoke _a$3716 _a$3717 _a$3718))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$3723 (lambda (t i) (let fnrec3719 ((t t) (i i)) (let* ((_a$3720 t) (_a$3721 (jolt-nth names i)) (_a$3722 (jolt-nth lk i))) (jolt-assoc _a$3720 _a$3721 _a$3722))))) (_a$3724 tenv) (_a$3725 (jolt-range (jolt-count names)))) (jolt-reduce _a$3723 _a$3724 _a$3725)))) (let* ((_o$3734 jolt-nil) (_o$3735 (let* ((_a$3729 node) (_a$3730 (keyword #f "bindings")) (_a$3731 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec3726 ((b b)) (let* ((_o$3727 (jolt-nth b 0)) (_o$3728 (jolt-nth (jolt-invoke an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$3727 _o$3728)))) binds)) (_a$3732 (keyword #f "body")) (_a$3733 (jolt-nth (jolt-invoke an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$3729 _a$3730 _a$3731 _a$3732 _a$3733)))) (jolt-vector _o$3734 _o$3735))) (if (jolt= op (keyword #f "if")) (let* ((tr (jolt-invoke an (jolt-get node (keyword #f "test")) tenv)) (thn (jolt-invoke an (jolt-get node (keyword #f "then")) tenv)) (els (jolt-invoke an (jolt-get node (keyword #f "else")) tenv)) (tk (jolt-nth thn 0)) (ek (jolt-nth els 0))) (let* ((_o$3743 (if (jolt= tk ek) tk jolt-nil)) (_o$3744 (let* ((_a$3736 node) (_a$3737 (keyword #f "test")) (_a$3738 (jolt-nth tr 1)) (_a$3739 (keyword #f "then")) (_a$3740 (jolt-nth thn 1)) (_a$3741 (keyword #f "else")) (_a$3742 (jolt-nth els 1))) (jolt-assoc _a$3736 _a$3737 _a$3738 _a$3739 _a$3740 _a$3741 _a$3742)))) (jolt-vector _o$3743 _o$3744))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$3746 (var-deref "clojure.core" "mapv")) (_a$3747 (lambda (s) (let fnrec3745 ((s s)) (jolt-nth (jolt-invoke an s tenv) 1)))) (_a$3748 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$3746 _a$3747 _a$3748))) (r (jolt-invoke an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$3749 (jolt-nth r 0)) (_o$3750 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$3749 _o$3750))) (if (jolt= op (keyword #f "fn")) (let* ((_o$3758 jolt-nil) (_o$3759 (jolt-assoc node (keyword #f "arities") (let* ((_a$3755 (var-deref "clojure.core" "mapv")) (_a$3756 (lambda (a) (let fnrec3751 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$3752 an) (_a$3753 (jolt-get a (keyword #f "body"))) (_a$3754 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (jolt-invoke _a$3752 _a$3753 _a$3754)) 1))))) (_a$3757 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$3755 _a$3756 _a$3757))))) (jolt-vector _o$3758 _o$3759)) (if (jolt= op (keyword #f "def")) (let* ((_o$3760 jolt-nil) (_o$3761 (jolt-assoc node (keyword #f "init") (jolt-nth (jolt-invoke an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$3760 _o$3761)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3763 jolt-nil) (_o$3764 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3762 ((c c)) (jolt-nth (jolt-invoke an c tenv) 1))) node))) (jolt-vector _o$3763 _o$3764)) jolt-nil)))))))))))))))) an)))
+  (def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec3703 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$3704 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$3705 node)) (jolt-vector _o$3704 _o$3705)) (if (jolt= op (keyword #f "local")) (let* ((_o$3706 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$3707 node)) (jolt-vector _o$3706 _o$3707)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$3708 (jolt-get node (keyword #f "kind"))) (_o$3709 (jolt-assoc node (keyword #f "expr") (jolt-nth (jolt-invoke an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$3708 _o$3709)) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.numeric" "an-invoke") node tenv) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3720 (lambda (acc b) (let fnrec3710 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (jolt-invoke an (jolt-nth b 1) te))) (let* ((_o$3716 (let* ((_a$3711 te) (_a$3712 (jolt-nth b 0)) (_a$3713 (jolt-nth ir 0))) (jolt-assoc _a$3711 _a$3712 _a$3713))) (_o$3717 (jolt-conj binds (let* ((_o$3714 (jolt-nth b 0)) (_o$3715 (jolt-nth ir 1))) (jolt-vector _o$3714 _o$3715))))) (jolt-vector _o$3716 _o$3717)))))) (_a$3721 (let* ((_o$3718 tenv) (_o$3719 (jolt-vector))) (jolt-vector _o$3718 _o$3719))) (_a$3722 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3720 _a$3721 _a$3722))) (br (let* ((_a$3723 an) (_a$3724 (jolt-get node (keyword #f "body"))) (_a$3725 (jolt-nth res 0))) (jolt-invoke _a$3723 _a$3724 _a$3725)))) (let* ((_o$3731 (jolt-nth br 0)) (_o$3732 (let* ((_a$3726 node) (_a$3727 (keyword #f "bindings")) (_a$3728 (jolt-nth res 1)) (_a$3729 (keyword #f "body")) (_a$3730 (jolt-nth br 1))) (jolt-assoc _a$3726 _a$3727 _a$3728 _a$3729 _a$3730)))) (jolt-vector _o$3731 _o$3732))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings"))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec3733 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec3734 ((b b)) (jolt-nth (jolt-invoke an (jolt-nth b 1) tenv) 0))) binds)) (rlists (jolt-invoke (var-deref "jolt.passes.numeric" "recur-arg-lists") (jolt-get node (keyword #f "body")))) (seed (let* ((_a$3740 (var-deref "clojure.core" "mapv")) (_a$3741 (lambda (j) (let fnrec3735 ((j j)) (let* ((k (jolt-nth ik j)) (b (jolt-nth binds j))) (if (jolt-truthy? k) k (if (jolt-truthy? (let* ((and__13__auto (jolt-seq rlists))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth b 1)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (args) (let fnrec3736 ((args args)) (let* ((_a$3737 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$3738 (jolt-nth args j)) (_a$3739 (jolt-nth b 0))) (jolt-invoke _a$3737 _a$3738 _a$3739)))) rlists) and__13__auto)) and__13__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$3742 (jolt-range (jolt-count names)))) (jolt-invoke _a$3740 _a$3741 _a$3742))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$3747 (lambda (t i) (let fnrec3743 ((t t) (i i)) (let* ((_a$3744 t) (_a$3745 (jolt-nth names i)) (_a$3746 (jolt-nth lk i))) (jolt-assoc _a$3744 _a$3745 _a$3746))))) (_a$3748 tenv) (_a$3749 (jolt-range (jolt-count names)))) (jolt-reduce _a$3747 _a$3748 _a$3749)))) (let* ((_o$3758 jolt-nil) (_o$3759 (let* ((_a$3753 node) (_a$3754 (keyword #f "bindings")) (_a$3755 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec3750 ((b b)) (let* ((_o$3751 (jolt-nth b 0)) (_o$3752 (jolt-nth (jolt-invoke an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$3751 _o$3752)))) binds)) (_a$3756 (keyword #f "body")) (_a$3757 (jolt-nth (jolt-invoke an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$3753 _a$3754 _a$3755 _a$3756 _a$3757)))) (jolt-vector _o$3758 _o$3759))) (if (jolt= op (keyword #f "if")) (let* ((tr (jolt-invoke an (jolt-get node (keyword #f "test")) tenv)) (thn (jolt-invoke an (jolt-get node (keyword #f "then")) tenv)) (els (jolt-invoke an (jolt-get node (keyword #f "else")) tenv)) (tk (jolt-nth thn 0)) (ek (jolt-nth els 0))) (let* ((_o$3767 (if (jolt= tk ek) tk jolt-nil)) (_o$3768 (let* ((_a$3760 node) (_a$3761 (keyword #f "test")) (_a$3762 (jolt-nth tr 1)) (_a$3763 (keyword #f "then")) (_a$3764 (jolt-nth thn 1)) (_a$3765 (keyword #f "else")) (_a$3766 (jolt-nth els 1))) (jolt-assoc _a$3760 _a$3761 _a$3762 _a$3763 _a$3764 _a$3765 _a$3766)))) (jolt-vector _o$3767 _o$3768))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$3770 (var-deref "clojure.core" "mapv")) (_a$3771 (lambda (s) (let fnrec3769 ((s s)) (jolt-nth (jolt-invoke an s tenv) 1)))) (_a$3772 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$3770 _a$3771 _a$3772))) (r (jolt-invoke an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$3773 (jolt-nth r 0)) (_o$3774 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$3773 _o$3774))) (if (jolt= op (keyword #f "fn")) (let* ((_o$3782 jolt-nil) (_o$3783 (jolt-assoc node (keyword #f "arities") (let* ((_a$3779 (var-deref "clojure.core" "mapv")) (_a$3780 (lambda (a) (let fnrec3775 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$3776 an) (_a$3777 (jolt-get a (keyword #f "body"))) (_a$3778 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (jolt-invoke _a$3776 _a$3777 _a$3778)) 1))))) (_a$3781 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$3779 _a$3780 _a$3781))))) (jolt-vector _o$3782 _o$3783)) (if (jolt= op (keyword #f "def")) (let* ((_o$3784 jolt-nil) (_o$3785 (jolt-assoc node (keyword #f "init") (jolt-nth (jolt-invoke an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$3784 _o$3785)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3787 jolt-nil) (_o$3788 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3786 ((c c)) (jolt-nth (jolt-invoke an c tenv) 1))) node))) (jolt-vector _o$3787 _o$3788)) jolt-nil)))))))))))))))) an)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec3765 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate)))
+  (def-var! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec3789 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate)))
 (guard (e (#t #f))
   (def-var! "jolt.passes.inline" "dirty" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "mark!" (letrec ((mark! (lambda () (let fnrec3766 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #t))))) mark!)))
+  (def-var! "jolt.passes.inline" "mark!" (letrec ((mark! (lambda () (let fnrec3790 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #t))))) mark!)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.inline" "rec-shapes" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec3767 ((m m)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "rec-shapes") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-rec-shapes!)))
+  (def-var! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec3791 ((m m)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "rec-shapes") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-rec-shapes!)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.inline" "fresh-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "fresh" (letrec ((fresh (lambda (base) (let fnrec3768 ((base base)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "fresh-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.inline" "fresh-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") base "__il" n))))))) fresh)))
+  (def-var! "jolt.passes.inline" "fresh" (letrec ((fresh (lambda (base) (let fnrec3792 ((base base)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "fresh-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.inline" "fresh-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") base "__il" n))))))) fresh)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "safe-op?" (letrec ((safe-op? (lambda (op) (let fnrec3769 ((op op)) (let* ((or__14__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "host")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "the-var")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "quote")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "if")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "do")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "let")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "invoke")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "map")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "vector")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "set")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "throw")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "coerce")))))))))))))))))))))))))))))))))) safe-op?)))
+  (def-var! "jolt.passes.inline" "safe-op?" (letrec ((safe-op? (lambda (op) (let fnrec3793 ((op op)) (let* ((or__14__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "host")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "the-var")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "quote")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "if")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "do")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "let")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "invoke")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "map")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "vector")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "set")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= op (keyword #f "throw")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "coerce")))))))))))))))))))))))))))))))))) safe-op?)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.inline" "inline-budget" 120 (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec3770 ((node node)) (if (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") (jolt-get node (keyword #f "op")))) 100000 (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (acc c) (let fnrec3771 ((acc acc) (c c)) (+ acc (jolt-invoke body-size c)))) 1 node)))))) body-size)))
+  (def-var! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec3794 ((node node)) (if (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") (jolt-get node (keyword #f "op")))) 100000 (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (acc c) (let fnrec3795 ((acc acc) (c c)) (+ acc (jolt-invoke body-size c)))) 1 node)))))) body-size)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec3772 ((node node) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (let* ((r (jolt-get env (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? r) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__13__auto)) and__13__auto))) (jolt-assoc r (keyword #f "hint") (jolt-get node (keyword #f "hint"))) r) node)) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3784 (lambda (acc b) (let fnrec3773 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (jolt-invoke subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$3780 (jolt-assoc e nm (let* ((_o$3774 (keyword #f "op")) (_o$3775 (keyword #f "local")) (_o$3776 (keyword #f "name")) (_o$3777 f)) (jolt-hash-map _o$3774 _o$3775 _o$3776 _o$3777)))) (_o$3781 (jolt-conj binds (let* ((_o$3778 f) (_o$3779 init)) (jolt-vector _o$3778 _o$3779))))) (jolt-vector _o$3780 _o$3781)))))) (_a$3785 (let* ((_o$3782 env) (_o$3783 (jolt-vector))) (jolt-vector _o$3782 _o$3783))) (_a$3786 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3784 _a$3785 _a$3786)))) (let* ((_a$3790 node) (_a$3791 (keyword #f "bindings")) (_a$3792 (jolt-nth res 1)) (_a$3793 (keyword #f "body")) (_a$3794 (let* ((_a$3787 subst) (_a$3788 (jolt-get node (keyword #f "body"))) (_a$3789 (jolt-nth res 0))) (jolt-invoke _a$3787 _a$3788 _a$3789)))) (jolt-assoc _a$3790 _a$3791 _a$3792 _a$3793 _a$3794))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3795 ((c c)) (jolt-invoke subst c env))) node) jolt-nil)))))))) subst)))
+  (def-var! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec3796 ((node node) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (let* ((r (jolt-get env (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? r) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__13__auto)) and__13__auto))) (jolt-assoc r (keyword #f "hint") (jolt-get node (keyword #f "hint"))) r) node)) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3808 (lambda (acc b) (let fnrec3797 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (jolt-invoke subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$3804 (jolt-assoc e nm (let* ((_o$3798 (keyword #f "op")) (_o$3799 (keyword #f "local")) (_o$3800 (keyword #f "name")) (_o$3801 f)) (jolt-hash-map _o$3798 _o$3799 _o$3800 _o$3801)))) (_o$3805 (jolt-conj binds (let* ((_o$3802 f) (_o$3803 init)) (jolt-vector _o$3802 _o$3803))))) (jolt-vector _o$3804 _o$3805)))))) (_a$3809 (let* ((_o$3806 env) (_o$3807 (jolt-vector))) (jolt-vector _o$3806 _o$3807))) (_a$3810 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3808 _a$3809 _a$3810)))) (let* ((_a$3814 node) (_a$3815 (keyword #f "bindings")) (_a$3816 (jolt-nth res 1)) (_a$3817 (keyword #f "body")) (_a$3818 (let* ((_a$3811 subst) (_a$3812 (jolt-get node (keyword #f "body"))) (_a$3813 (jolt-nth res 0))) (jolt-invoke _a$3811 _a$3812 _a$3813)))) (jolt-assoc _a$3814 _a$3815 _a$3816 _a$3817 _a$3818))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3819 ((c c)) (jolt-invoke subst c env))) node) jolt-nil)))))))) subst)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec3796 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__14__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "const"))))))))) trivial-arg?)))
+  (def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec3820 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__14__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "const"))))))))) trivial-arg?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec3797 ((node node) (scope scope)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (jolt-contains? scope (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3803 (lambda (acc b) (let fnrec3798 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$3799 (jolt-conj sc (jolt-nth b 0))) (_o$3800 (jolt-invoke body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$3799 _o$3800))))))) (_a$3804 (let* ((_o$3801 scope) (_o$3802 #t)) (jolt-vector _o$3801 _o$3802))) (_a$3805 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3803 _a$3804 _a$3805)))) (let* ((and__13__auto (jolt-nth res 1))) (if (jolt-truthy? and__13__auto) (let* ((_a$3806 body-closed?) (_a$3807 (jolt-get node (keyword #f "body"))) (_a$3808 (jolt-nth res 0))) (jolt-invoke _a$3806 _a$3807 _a$3808)) and__13__auto))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec3809 ((ok ok) (c c)) (let* ((and__13__auto ok)) (if (jolt-truthy? and__13__auto) (jolt-invoke body-closed? c scope) and__13__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?)))
+  (def-var! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec3821 ((node node) (scope scope)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (jolt-contains? scope (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3827 (lambda (acc b) (let fnrec3822 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$3823 (jolt-conj sc (jolt-nth b 0))) (_o$3824 (jolt-invoke body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$3823 _o$3824))))))) (_a$3828 (let* ((_o$3825 scope) (_o$3826 #t)) (jolt-vector _o$3825 _o$3826))) (_a$3829 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3827 _a$3828 _a$3829)))) (let* ((and__13__auto (jolt-nth res 1))) (if (jolt-truthy? and__13__auto) (let* ((_a$3830 body-closed?) (_a$3831 (jolt-get node (keyword #f "body"))) (_a$3832 (jolt-nth res 0))) (jolt-invoke _a$3830 _a$3831 _a$3832)) and__13__auto))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec3833 ((ok ok) (c c)) (let* ((and__13__auto ok)) (if (jolt-truthy? and__13__auto) (jolt-invoke body-closed? c scope) and__13__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec3810 ((node node) (ctx ctx)) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((stash (let* ((_a$3811 (var-deref "jolt.host" "inline-ir")) (_a$3812 ctx) (_a$3813 (jolt-get f (keyword #f "ns"))) (_a$3814 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$3811 _a$3812 _a$3813 _a$3814)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$3819 (lambda (m pr) (let fnrec3815 ((m m) (pr pr)) (let* ((_a$3816 m) (_a$3817 (jolt-nth pr 0)) (_a$3818 (jolt-nth pr 1))) (jolt-assoc _a$3816 _a$3817 _a$3818))))) (_a$3820 (jolt-hash-map)) (_a$3821 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$3819 _a$3820 _a$3821))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__13__auto (let* ((_a$3822 (jolt-count params)) (_a$3823 (jolt-count args))) (jolt= _a$3822 _a$3823)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__13__auto)) and__13__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop3824 ((i i) (env env) (binds binds)) (if (< i n) (let* ((p (jolt-nth params i)) (a (jolt-nth args i)) (k (jolt-get nh p))) (if (jolt-truthy? k) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$3831 (jolt-inc i)) (_a$3832 (jolt-assoc env p (let* ((_o$3825 (keyword #f "op")) (_o$3826 (keyword #f "local")) (_o$3827 (keyword #f "name")) (_o$3828 f)) (jolt-hash-map _o$3825 _o$3826 _o$3827 _o$3828)))) (_a$3833 (jolt-conj binds (let* ((_o$3829 f) (_o$3830 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$3829 _o$3830))))) (loop3824 _a$3831 _a$3832 _a$3833))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$3834 (jolt-inc i)) (_a$3835 (jolt-assoc env p a)) (_a$3836 binds)) (loop3824 _a$3834 _a$3835 _a$3836)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$3843 (jolt-inc i)) (_a$3844 (jolt-assoc env p (let* ((_o$3837 (keyword #f "op")) (_o$3838 (keyword #f "local")) (_o$3839 (keyword #f "name")) (_o$3840 f)) (jolt-hash-map _o$3837 _o$3838 _o$3839 _o$3840)))) (_a$3845 (jolt-conj binds (let* ((_o$3841 f) (_o$3842 a)) (jolt-vector _o$3841 _o$3842))))) (loop3824 _a$3843 _a$3844 _a$3845))) jolt-nil)))) (let* ((_o$3846 env) (_o$3847 binds)) (jolt-vector _o$3846 _o$3847)))))) (env (jolt-nth res 0)) (binds (jolt-nth res 1)) (rbody0 (jolt-invoke (var-deref "jolt.passes.inline" "subst") body env)) (rbody (if (jolt-truthy? ret) (jolt-invoke (var-deref "jolt.ir" "coerce-node") ret rbody0) rbody0))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count binds)) rbody (let* ((_o$3848 (keyword #f "op")) (_o$3849 (keyword #f "let")) (_o$3850 (keyword #f "bindings")) (_o$3851 binds) (_o$3852 (keyword #f "body")) (_o$3853 rbody)) (jolt-hash-map _o$3848 _o$3849 _o$3850 _o$3851 _o$3852 _o$3853))))) node)) node)) node)))))) try-inline)))
+  (def-var! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec3834 ((node node) (ctx ctx)) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((stash (let* ((_a$3835 (var-deref "jolt.host" "inline-ir")) (_a$3836 ctx) (_a$3837 (jolt-get f (keyword #f "ns"))) (_a$3838 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$3835 _a$3836 _a$3837 _a$3838)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$3843 (lambda (m pr) (let fnrec3839 ((m m) (pr pr)) (let* ((_a$3840 m) (_a$3841 (jolt-nth pr 0)) (_a$3842 (jolt-nth pr 1))) (jolt-assoc _a$3840 _a$3841 _a$3842))))) (_a$3844 (jolt-hash-map)) (_a$3845 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$3843 _a$3844 _a$3845))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__13__auto (let* ((_a$3846 (jolt-count params)) (_a$3847 (jolt-count args))) (jolt= _a$3846 _a$3847)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__13__auto)) and__13__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop3848 ((i i) (env env) (binds binds)) (if (< i n) (let* ((p (jolt-nth params i)) (a (jolt-nth args i)) (k (jolt-get nh p))) (if (jolt-truthy? k) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$3855 (jolt-inc i)) (_a$3856 (jolt-assoc env p (let* ((_o$3849 (keyword #f "op")) (_o$3850 (keyword #f "local")) (_o$3851 (keyword #f "name")) (_o$3852 f)) (jolt-hash-map _o$3849 _o$3850 _o$3851 _o$3852)))) (_a$3857 (jolt-conj binds (let* ((_o$3853 f) (_o$3854 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$3853 _o$3854))))) (loop3848 _a$3855 _a$3856 _a$3857))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$3858 (jolt-inc i)) (_a$3859 (jolt-assoc env p a)) (_a$3860 binds)) (loop3848 _a$3858 _a$3859 _a$3860)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$3867 (jolt-inc i)) (_a$3868 (jolt-assoc env p (let* ((_o$3861 (keyword #f "op")) (_o$3862 (keyword #f "local")) (_o$3863 (keyword #f "name")) (_o$3864 f)) (jolt-hash-map _o$3861 _o$3862 _o$3863 _o$3864)))) (_a$3869 (jolt-conj binds (let* ((_o$3865 f) (_o$3866 a)) (jolt-vector _o$3865 _o$3866))))) (loop3848 _a$3867 _a$3868 _a$3869))) jolt-nil)))) (let* ((_o$3870 env) (_o$3871 binds)) (jolt-vector _o$3870 _o$3871)))))) (env (jolt-nth res 0)) (binds (jolt-nth res 1)) (rbody0 (jolt-invoke (var-deref "jolt.passes.inline" "subst") body env)) (rbody (if (jolt-truthy? ret) (jolt-invoke (var-deref "jolt.ir" "coerce-node") ret rbody0) rbody0))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count binds)) rbody (let* ((_o$3872 (keyword #f "op")) (_o$3873 (keyword #f "let")) (_o$3874 (keyword #f "bindings")) (_o$3875 binds) (_o$3876 (keyword #f "body")) (_o$3877 rbody)) (jolt-hash-map _o$3872 _o$3873 _o$3874 _o$3875 _o$3876 _o$3877))))) node)) node)) node)))))) try-inline)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec3854 ((node node) (ctx ctx)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "try-inline") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3855 ((c c)) (jolt-invoke inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3856 ((c c)) (jolt-invoke inline-node c ctx))) node)))))) inline-node)))
+  (def-var! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec3878 ((node node) (ctx ctx)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "try-inline") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3879 ((c c)) (jolt-invoke inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3880 ((c c)) (jolt-invoke inline-node c ctx))) node)))))) inline-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec3857 ((binds binds)) (let* ((_a$3863 (lambda (out b) (let fnrec3858 ((out out) (b b)) (let* ((nm (jolt-nth b 0)) (init (jolt-nth b 1))) (if (jolt= (keyword #f "let") (jolt-get init (keyword #f "op"))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (let* ((_a$3861 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$3862 (let* ((_o$3859 nm) (_o$3860 (jolt-get init (keyword #f "body")))) (jolt-vector _o$3859 _o$3860)))) (jolt-conj _a$3861 _a$3862))) (jolt-conj out b)))))) (_a$3864 (jolt-vector)) (_a$3865 binds)) (jolt-reduce _a$3863 _a$3864 _a$3865)))))) flatten-let-bindings)))
+  (def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec3881 ((binds binds)) (let* ((_a$3887 (lambda (out b) (let fnrec3882 ((out out) (b b)) (let* ((nm (jolt-nth b 0)) (init (jolt-nth b 1))) (if (jolt= (keyword #f "let") (jolt-get init (keyword #f "op"))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (let* ((_a$3885 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$3886 (let* ((_o$3883 nm) (_o$3884 (jolt-get init (keyword #f "body")))) (jolt-vector _o$3883 _o$3884)))) (jolt-conj _a$3885 _a$3886))) (jolt-conj out b)))))) (_a$3888 (jolt-vector)) (_a$3889 binds)) (jolt-reduce _a$3887 _a$3888 _a$3889)))))) flatten-let-bindings)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "flatten-lets" (letrec ((flatten-lets (lambda (node) (let fnrec3866 ((node node)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") flatten-lets node))) (jolt-assoc n (keyword #f "bindings") (jolt-invoke (var-deref "jolt.passes.inline" "flatten-let-bindings") (jolt-get n (keyword #f "bindings"))))) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") flatten-lets node)))))) flatten-lets)))
+  (def-var! "jolt.passes.inline" "flatten-lets" (letrec ((flatten-lets (lambda (node) (let fnrec3890 ((node node)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") flatten-lets node))) (jolt-assoc n (keyword #f "bindings") (jolt-invoke (var-deref "jolt.passes.inline" "flatten-let-bindings") (jolt-get n (keyword #f "bindings"))))) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") flatten-lets node)))))) flatten-lets)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "pure-fns" (let* ((_o$3867 "+") (_o$3868 "-") (_o$3869 "*") (_o$3870 "/") (_o$3871 "<") (_o$3872 ">") (_o$3873 "<=") (_o$3874 ">=") (_o$3875 "=") (_o$3876 "not=") (_o$3877 "inc") (_o$3878 "dec") (_o$3879 "mod") (_o$3880 "rem") (_o$3881 "quot") (_o$3882 "min") (_o$3883 "max") (_o$3884 "abs") (_o$3885 "nil?") (_o$3886 "some?") (_o$3887 "not") (_o$3888 "get") (_o$3889 "zero?") (_o$3890 "pos?") (_o$3891 "neg?") (_o$3892 "even?") (_o$3893 "odd?") (_o$3894 "bit-and") (_o$3895 "bit-or") (_o$3896 "bit-xor")) (jolt-hash-set _o$3867 _o$3868 _o$3869 _o$3870 _o$3871 _o$3872 _o$3873 _o$3874 _o$3875 _o$3876 _o$3877 _o$3878 _o$3879 _o$3880 _o$3881 _o$3882 _o$3883 _o$3884 _o$3885 _o$3886 _o$3887 _o$3888 _o$3889 _o$3890 _o$3891 _o$3892 _o$3893 _o$3894 _o$3895 _o$3896)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.inline" "pure-fns" (let* ((_o$3891 "+") (_o$3892 "-") (_o$3893 "*") (_o$3894 "/") (_o$3895 "<") (_o$3896 ">") (_o$3897 "<=") (_o$3898 ">=") (_o$3899 "=") (_o$3900 "not=") (_o$3901 "inc") (_o$3902 "dec") (_o$3903 "mod") (_o$3904 "rem") (_o$3905 "quot") (_o$3906 "min") (_o$3907 "max") (_o$3908 "abs") (_o$3909 "nil?") (_o$3910 "some?") (_o$3911 "not") (_o$3912 "get") (_o$3913 "zero?") (_o$3914 "pos?") (_o$3915 "neg?") (_o$3916 "even?") (_o$3917 "odd?") (_o$3918 "bit-and") (_o$3919 "bit-or") (_o$3920 "bit-xor")) (jolt-hash-set _o$3891 _o$3892 _o$3893 _o$3894 _o$3895 _o$3896 _o$3897 _o$3898 _o$3899 _o$3900 _o$3901 _o$3902 _o$3903 _o$3904 _o$3905 _o$3906 _o$3907 _o$3908 _o$3909 _o$3910 _o$3911 _o$3912 _o$3913 _o$3914 _o$3915 _o$3916 _o$3917 _o$3918 _o$3919 _o$3920)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "pure-fn?" (letrec ((pure-fn? (lambda (f) (let fnrec3897 ((f f)) (let* ((op (jolt-get f (keyword #f "op")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f)) #t (if (jolt= op (keyword #f "var")) (let* ((and__13__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) and__13__auto)) (if (jolt= op (keyword #f "host")) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) pure-fn?)))
+  (def-var! "jolt.passes.inline" "pure-fn?" (letrec ((pure-fn? (lambda (f) (let fnrec3921 ((f f)) (let* ((op (jolt-get f (keyword #f "op")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f)) #t (if (jolt= op (keyword #f "var")) (let* ((and__13__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) and__13__auto)) (if (jolt= op (keyword #f "host")) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) pure-fn?)))
 (guard (e (#t #f))
   (declare-var! "jolt.passes.inline" "ctor-shape"))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec3898 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__13__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__13__auto)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec3899 ((ok ok) (c c)) (let* ((and__13__auto ok)) (if (jolt-truthy? and__13__auto) (jolt-invoke pure? c) and__13__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?)))
+  (def-var! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec3922 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__13__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__13__auto)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec3923 ((ok ok) (c c)) (let* ((and__13__auto ok)) (if (jolt-truthy? and__13__auto) (jolt-invoke pure? c) and__13__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec3900 ((node node)) (let* ((prs (jolt-get node (keyword #f "pairs")))) (let* ((and__13__auto (> (jolt-count prs) 0))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec3901 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__13__auto))))))) const-key-map?)))
+  (def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec3924 ((node node)) (let* ((prs (jolt-get node (keyword #f "pairs")))) (let* ((and__13__auto (> (jolt-count prs) 0))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec3925 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__13__auto))))))) const-key-map?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec3902 ((node node)) (let* ((_a$3904 (var-deref "clojure.core" "every?")) (_a$3905 (lambda (pr) (let fnrec3903 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$3906 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$3904 _a$3905 _a$3906)))))) all-vals-pure?)))
+  (def-var! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec3926 ((node node)) (let* ((_a$3928 (var-deref "clojure.core" "every?")) (_a$3929 (lambda (pr) (let fnrec3927 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$3930 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$3928 _a$3929 _a$3930)))))) all-vals-pure?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec3907 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop3908 ((i i)) (if (< i n) (let* ((pr (jolt-nth prs i))) (if (jolt= (jolt-get (jolt-nth pr 0) (keyword #f "val")) k) (jolt-nth pr 1) (loop3908 (jolt-inc i)))) (let* ((_o$3909 (keyword #f "op")) (_o$3910 (keyword #f "const")) (_o$3911 (keyword #f "val")) (_o$3912 jolt-nil)) (jolt-hash-map _o$3909 _o$3910 _o$3911 _o$3912)))))))))) map-val)))
+  (def-var! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec3931 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop3932 ((i i)) (if (< i n) (let* ((pr (jolt-nth prs i))) (if (jolt= (jolt-get (jolt-nth pr 0) (keyword #f "val")) k) (jolt-nth pr 1) (loop3932 (jolt-inc i)))) (let* ((_o$3933 (keyword #f "op")) (_o$3934 (keyword #f "const")) (_o$3935 (keyword #f "val")) (_o$3936 jolt-nil)) (jolt-hash-map _o$3933 _o$3934 _o$3935 _o$3936)))))))))) map-val)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec3913 ((node node) (nm nm)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key)))
+  (def-var! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec3937 ((node node) (nm nm)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec3914 ((binds binds) (nm nm)) (let* ((i 0)) (let loop3915 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop3915 (jolt-inc i))) #f))))))) any-binding-named?)))
+  (def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec3938 ((binds binds) (nm nm)) (let* ((i 0)) (let loop3939 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop3939 (jolt-inc i))) #f))))))) any-binding-named?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "any-name?" (letrec ((any-name? (lambda (names nm) (let fnrec3916 ((names names) (nm nm)) (let* ((i 0)) (let loop3917 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop3917 (jolt-inc i))) #f))))))) any-name?)))
+  (def-var! "jolt.passes.inline" "any-name?" (letrec ((any-name? (lambda (names nm) (let fnrec3940 ((names names) (nm nm)) (let* ((i 0)) (let loop3941 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop3941 (jolt-inc i))) #f))))))) any-name?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec3918 ((node node) (nm nm)) (let* ((op (jolt-get node (keyword #f "op"))) (k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (let* ((args (jolt-get node (keyword #f "args")))) (if (> (jolt-count args) 1) (let* ((i 1)) (let loop3919 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth args i) nm)) #t (loop3919 (jolt-inc i))) #f))) #f)) (if (jolt= op (keyword #f "local")) (jolt= nm (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "const")) #f (if (jolt= op (keyword #f "var")) #f (if (jolt= op (keyword #f "host")) #f (if (jolt= op (keyword #f "the-var")) #f (if (jolt= op (keyword #f "quote")) #f (if (jolt= op (keyword #f "if")) (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__14__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop3920 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth ss i) nm)) #t (loop3920 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (jolt-invoke local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop3921 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth as i) nm)) #t (loop3921 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop3922 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth xs i) nm)) #t (loop3922 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop3923 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth xs i) nm)) #t (loop3923 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop3924 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop3924 (jolt-inc i) ps)) #f))) (if (jolt= op (keyword #f "let")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__14__auto (let* ((i 0)) (let loop3925 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop3925 (jolt-inc i))) #f))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "recur")) (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop3926 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth as i) nm)) #t (loop3926 (jolt-inc i) as)) #f))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__14__auto (let* ((i 0)) (let loop3927 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop3927 (jolt-inc i))) #f))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "fn")) (let* ((i 0) (ars (jolt-get node (keyword #f "arities")))) (let loop3928 ((i i) (ars ars)) (if (< i (jolt-count ars)) (let* ((ar (jolt-nth ars i)) (ps (jolt-get ar (keyword #f "params")))) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop3928 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__13__auto cb)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__13__auto) (jolt-invoke local-escapes? cb nm) and__13__auto)) and__13__auto))))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__13__auto f)) (if (jolt-truthy? and__13__auto) (jolt-invoke local-escapes? f nm) and__13__auto))))))) (if (jolt= op (keyword #f "def")) (jolt-invoke local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?)))
+  (def-var! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec3942 ((node node) (nm nm)) (let* ((op (jolt-get node (keyword #f "op"))) (k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (let* ((args (jolt-get node (keyword #f "args")))) (if (> (jolt-count args) 1) (let* ((i 1)) (let loop3943 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth args i) nm)) #t (loop3943 (jolt-inc i))) #f))) #f)) (if (jolt= op (keyword #f "local")) (jolt= nm (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "const")) #f (if (jolt= op (keyword #f "var")) #f (if (jolt= op (keyword #f "host")) #f (if (jolt= op (keyword #f "the-var")) #f (if (jolt= op (keyword #f "quote")) #f (if (jolt= op (keyword #f "if")) (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__14__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop3944 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth ss i) nm)) #t (loop3944 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (jolt-invoke local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop3945 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth as i) nm)) #t (loop3945 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop3946 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth xs i) nm)) #t (loop3946 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop3947 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth xs i) nm)) #t (loop3947 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop3948 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop3948 (jolt-inc i) ps)) #f))) (if (jolt= op (keyword #f "let")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__14__auto (let* ((i 0)) (let loop3949 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop3949 (jolt-inc i))) #f))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "recur")) (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop3950 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth as i) nm)) #t (loop3950 (jolt-inc i) as)) #f))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__14__auto (let* ((i 0)) (let loop3951 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop3951 (jolt-inc i))) #f))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "fn")) (let* ((i 0) (ars (jolt-get node (keyword #f "arities")))) (let loop3952 ((i i) (ars ars)) (if (< i (jolt-count ars)) (let* ((ar (jolt-nth ars i)) (ps (jolt-get ar (keyword #f "params")))) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (jolt-invoke local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop3952 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__14__auto (jolt-invoke local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__13__auto cb)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__13__auto) (jolt-invoke local-escapes? cb nm) and__13__auto)) and__13__auto))))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__13__auto f)) (if (jolt-truthy? and__13__auto) (jolt-invoke local-escapes? f nm) and__13__auto))))))) (if (jolt= op (keyword #f "def")) (jolt-invoke local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec3929 ((node node)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((rs (let* ((_a$3934 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$3935 (let* ((_a$3930 (var-deref "clojure.core" "str")) (_a$3931 (jolt-get f (keyword #f "ns"))) (_a$3932 "/") (_a$3933 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$3930 _a$3931 _a$3932 _a$3933)))) (jolt-get _a$3934 _a$3935)))) (if (jolt-truthy? (let* ((and__13__auto rs)) (if (jolt-truthy? and__13__auto) (let* ((_a$3936 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$3937 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$3936 _a$3937)) and__13__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape)))
+  (def-var! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec3953 ((node node)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((rs (let* ((_a$3958 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$3959 (let* ((_a$3954 (var-deref "clojure.core" "str")) (_a$3955 (jolt-get f (keyword #f "ns"))) (_a$3956 "/") (_a$3957 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$3954 _a$3955 _a$3956 _a$3957)))) (jolt-get _a$3958 _a$3959)))) (if (jolt-truthy? (let* ((and__13__auto rs)) (if (jolt-truthy? and__13__auto) (let* ((_a$3960 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$3961 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$3960 _a$3961)) and__13__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec3938 ((node node)) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.inline" "pure?") (jolt-get node (keyword #f "args"))))))) ctor-all-args-pure?)))
+  (def-var! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec3962 ((node node)) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.inline" "pure?") (jolt-get node (keyword #f "args"))))))) ctor-all-args-pure?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec3939 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop3940 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop3940 (jolt-inc i))) jolt-nil)))))))) field-index)))
+  (def-var! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec3963 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop3964 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop3964 (jolt-inc i))) jolt-nil)))))))) field-index)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec3941 ((ctor ctor) (rs rs) (k k)) (let* ((_a$3942 (jolt-get ctor (keyword #f "args"))) (_a$3943 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$3942 _a$3943)))))) ctor-val)))
+  (def-var! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec3965 ((ctor ctor) (rs rs) (k k)) (let* ((_a$3966 (jolt-get ctor (keyword #f "args"))) (_a$3967 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$3966 _a$3967)))))) ctor-val)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec3944 ((node node) (nm nm) (acc acc)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "clojure.core" "swap!") acc jolt-conj k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3945 ((c c)) (begin (jolt-invoke collect-keys! c nm acc) c))) node))))))) collect-keys!)))
+  (def-var! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec3968 ((node node) (nm nm) (acc acc)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "clojure.core" "swap!") acc jolt-conj k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3969 ((c c)) (begin (jolt-invoke collect-keys! c nm acc) c))) node))))))) collect-keys!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec3946 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec3947 ((node node)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "collect-keys!") node nm acc) (let* ((_a$3949 (var-deref "clojure.core" "every?")) (_a$3950 (lambda (k) (let fnrec3948 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$3951 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$3949 _a$3950 _a$3951)))))) nodes))))) lookups-all-fields?)))
+  (def-var! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec3970 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec3971 ((node node)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "collect-keys!") node nm acc) (let* ((_a$3973 (var-deref "clojure.core" "every?")) (_a$3974 (lambda (k) (let fnrec3972 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$3975 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$3973 _a$3974 _a$3975)))))) nodes))))) lookups-all-fields?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec3952 ((src src) (k k)) (if (jolt= (keyword #f "map") (jolt-get src (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") src k) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") src (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") src) k)))))) src-val)))
+  (def-var! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec3976 ((src src) (k k)) (if (jolt= (keyword #f "map") (jolt-get src (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") src k) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") src (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") src) k)))))) src-val)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec3953 ((node node) (nm nm) (src src)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "jolt.passes.inline" "src-val") src k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3954 ((c c)) (jolt-invoke subst-lookup c nm src))) node))))))) subst-lookup)))
+  (def-var! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec3977 ((node node) (nm nm) (src src)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "jolt.passes.inline" "src-val") src k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec3978 ((c c)) (jolt-invoke subst-lookup c nm src))) node))))))) subst-lookup)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec3955 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__13__auto) (jolt= 1 (jolt-count args)) and__13__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__13__auto)) and__13__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") m k)) (let* ((rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") m))) (if (jolt-truthy? (let* ((and__13__auto rs)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__13__auto)) and__13__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") m rs k)) node)))) node)))))) fold-kw-literal)))
+  (def-var! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec3979 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__13__auto) (jolt= 1 (jolt-count args)) and__13__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__13__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__13__auto)) and__13__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") m k)) (let* ((rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") m))) (if (jolt-truthy? (let* ((and__13__auto rs)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__13__auto)) and__13__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") m rs k)) node)))) node)))))) fold-kw-literal)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec3956 ((node node)) (let* ((binds (jolt-get node (keyword #f "bindings"))) (n (jolt-count binds)) (body (jolt-get node (keyword #f "body")))) (let* ((i 0)) (let loop3957 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__13__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__13__auto)) and__13__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__13__auto rs)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (let* ((or__14__auto ismap)) (if (jolt-truthy? or__14__auto) or__14__auto isrec)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n) nm)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (let* ((j (jolt-inc i))) (let loop3958 ((j j)) (if (< j n) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") (jolt-nth (jolt-nth binds j) 1) nm)) #t (loop3958 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto ismap)) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((_a$3963 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$3964 (jolt-conj (let* ((_a$3960 (var-deref "clojure.core" "mapv")) (_a$3961 (lambda (bb) (let fnrec3959 ((bb bb)) (jolt-nth bb 1)))) (_a$3962 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$3960 _a$3961 _a$3962)) body)) (_a$3965 nm) (_a$3966 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$3963 _a$3964 _a$3965 _a$3966)))) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$3970 (var-deref "clojure.core" "mapv")) (_a$3971 (lambda (bb) (let fnrec3967 ((bb bb)) (let* ((_o$3968 (jolt-nth bb 0)) (_o$3969 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$3968 _o$3969))))) (_a$3972 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$3970 _a$3971 _a$3972))) (newbinds (jolt-reduce jolt-conj head tail)) (newbody (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") body nm init))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count newbinds)) newbody (jolt-assoc node (keyword #f "bindings") newbinds (keyword #f "body") newbody)))) (loop3957 (jolt-inc i)))) node)))))))) elim-let-structs)))
+  (def-var! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec3980 ((node node)) (let* ((binds (jolt-get node (keyword #f "bindings"))) (n (jolt-count binds)) (body (jolt-get node (keyword #f "body")))) (let* ((i 0)) (let loop3981 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__13__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__13__auto)) and__13__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__13__auto rs)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (let* ((or__14__auto ismap)) (if (jolt-truthy? or__14__auto) or__14__auto isrec)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n) nm)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (let* ((j (jolt-inc i))) (let loop3982 ((j j)) (if (< j n) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") (jolt-nth (jolt-nth binds j) 1) nm)) #t (loop3982 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto ismap)) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((_a$3987 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$3988 (jolt-conj (let* ((_a$3984 (var-deref "clojure.core" "mapv")) (_a$3985 (lambda (bb) (let fnrec3983 ((bb bb)) (jolt-nth bb 1)))) (_a$3986 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$3984 _a$3985 _a$3986)) body)) (_a$3989 nm) (_a$3990 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$3987 _a$3988 _a$3989 _a$3990)))) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$3994 (var-deref "clojure.core" "mapv")) (_a$3995 (lambda (bb) (let fnrec3991 ((bb bb)) (let* ((_o$3992 (jolt-nth bb 0)) (_o$3993 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$3992 _o$3993))))) (_a$3996 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$3994 _a$3995 _a$3996))) (newbinds (jolt-reduce jolt-conj head tail)) (newbody (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") body nm init))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count newbinds)) newbody (jolt-assoc node (keyword #f "bindings") newbinds (keyword #f "body") newbody)))) (loop3981 (jolt-inc i)))) node)))))))) elim-let-structs)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec3973 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.inline" "fold-kw-literal") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt= op (keyword #f "let")) (jolt-invoke (var-deref "jolt.passes.inline" "elim-let-structs") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node) jolt-nil)))))))) scalar-replace)))
+  (def-var! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec3997 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.inline" "fold-kw-literal") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt= op (keyword #f "let")) (jolt-invoke (var-deref "jolt.passes.inline" "elim-let-structs") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node) jolt-nil)))))))) scalar-replace)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec3374 ((t t)) (jolt-get t (keyword #f "vec")))))) velem)))
+  (def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec3398 ((t t)) (jolt-get t (keyword #f "vec")))))) velem)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "selem" (letrec ((selem (lambda (t) (let fnrec3375 ((t t)) (jolt-get t (keyword #f "set")))))) selem)))
+  (def-var! "jolt.passes.types.lattice" "selem" (letrec ((selem (lambda (t) (let fnrec3399 ((t t)) (jolt-get t (keyword #f "set")))))) selem)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "sfields" (letrec ((sfields (lambda (t) (let fnrec3376 ((t t)) (jolt-get t (keyword #f "struct")))))) sfields)))
+  (def-var! "jolt.passes.types.lattice" "sfields" (letrec ((sfields (lambda (t) (let fnrec3400 ((t t)) (jolt-get t (keyword #f "struct")))))) sfields)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "vec-type?" (letrec ((vec-type? (lambda (t) (let fnrec3377 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)))))) vec-type?)))
+  (def-var! "jolt.passes.types.lattice" "vec-type?" (letrec ((vec-type? (lambda (t) (let fnrec3401 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)))))) vec-type?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "set-type?" (letrec ((set-type? (lambda (t) (let fnrec3378 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)))))) set-type?)))
+  (def-var! "jolt.passes.types.lattice" "set-type?" (letrec ((set-type? (lambda (t) (let fnrec3402 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)))))) set-type?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "struct-type?" (letrec ((struct-type? (lambda (t) (let fnrec3379 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))))) struct-type?)))
+  (def-var! "jolt.passes.types.lattice" "struct-type?" (letrec ((struct-type? (lambda (t) (let fnrec3403 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))))) struct-type?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "mk-vec" (letrec ((mk-vec (lambda (t) (let fnrec3380 ((t t)) (let* ((_o$3381 (keyword #f "vec")) (_o$3382 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$3381 _o$3382)))))) mk-vec)))
+  (def-var! "jolt.passes.types.lattice" "mk-vec" (letrec ((mk-vec (lambda (t) (let fnrec3404 ((t t)) (let* ((_o$3405 (keyword #f "vec")) (_o$3406 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$3405 _o$3406)))))) mk-vec)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "mk-set" (letrec ((mk-set (lambda (t) (let fnrec3383 ((t t)) (let* ((_o$3384 (keyword #f "set")) (_o$3385 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$3384 _o$3385)))))) mk-set)))
+  (def-var! "jolt.passes.types.lattice" "mk-set" (letrec ((mk-set (lambda (t) (let fnrec3407 ((t t)) (let* ((_o$3408 (keyword #f "set")) (_o$3409 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$3408 _o$3409)))))) mk-set)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "mk-struct" (letrec ((mk-struct (lambda (fs) (let fnrec3386 ((fs fs)) (let* ((_o$3387 (keyword #f "struct")) (_o$3388 fs)) (jolt-hash-map _o$3387 _o$3388)))))) mk-struct)))
+  (def-var! "jolt.passes.types.lattice" "mk-struct" (letrec ((mk-struct (lambda (fs) (let fnrec3410 ((fs fs)) (let* ((_o$3411 (keyword #f "struct")) (_o$3412 fs)) (jolt-hash-map _o$3411 _o$3412)))))) mk-struct)))
 (guard (e (#t #f))
   (def-var! "jolt.passes.types.lattice" "union-cap" 4))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "scalar-t?" (letrec ((scalar-t? (lambda (t) (let fnrec3389 ((t t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "truthy")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "phm")))))))))))))) scalar-t?)))
+  (def-var! "jolt.passes.types.lattice" "scalar-t?" (letrec ((scalar-t? (lambda (t) (let fnrec3413 ((t t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "truthy")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "phm")))))))))))))) scalar-t?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "union-type?" (letrec ((union-type? (lambda (t) (let fnrec3390 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get t (keyword #f "union"))))))) union-type?)))
+  (def-var! "jolt.passes.types.lattice" "union-type?" (letrec ((union-type? (lambda (t) (let fnrec3414 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get t (keyword #f "union"))))))) union-type?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "umembers" (letrec ((umembers (lambda (t) (let fnrec3391 ((t t)) (jolt-get t (keyword #f "union")))))) umembers)))
+  (def-var! "jolt.passes.types.lattice" "umembers" (letrec ((umembers (lambda (t) (let fnrec3415 ((t t)) (jolt-get t (keyword #f "union")))))) umembers)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "union-of" (letrec ((union-of (lambda (ts) (let fnrec3392 ((ts ts)) (let* ((flat (let* ((_a$3394 (lambda (acc t) (let fnrec3393 ((acc acc) (t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-reduce jolt-conj acc (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (jolt-conj acc t))))) (_a$3395 (jolt-hash-set)) (_a$3396 ts)) (jolt-reduce _a$3394 _a$3395 _a$3396)))) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.types.lattice" "scalar-t?") flat)) (keyword #f "any") (if (jolt= 0 (jolt-count flat)) (keyword #f "any") (if (jolt= 1 (jolt-count flat)) (jolt-first flat) (if (> (jolt-count flat) (var-deref "jolt.passes.types.lattice" "union-cap")) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3397 (keyword #f "union")) (_o$3398 flat)) (jolt-hash-map _o$3397 _o$3398)) jolt-nil)))))))))) union-of)))
+  (def-var! "jolt.passes.types.lattice" "union-of" (letrec ((union-of (lambda (ts) (let fnrec3416 ((ts ts)) (let* ((flat (let* ((_a$3418 (lambda (acc t) (let fnrec3417 ((acc acc) (t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-reduce jolt-conj acc (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (jolt-conj acc t))))) (_a$3419 (jolt-hash-set)) (_a$3420 ts)) (jolt-reduce _a$3418 _a$3419 _a$3420)))) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.types.lattice" "scalar-t?") flat)) (keyword #f "any") (if (jolt= 0 (jolt-count flat)) (keyword #f "any") (if (jolt= 1 (jolt-count flat)) (jolt-first flat) (if (> (jolt-count flat) (var-deref "jolt.passes.types.lattice" "union-cap")) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3421 (keyword #f "union")) (_o$3422 flat)) (jolt-hash-map _o$3421 _o$3422)) jolt-nil)))))))))) union-of)))
 (guard (e (#t #f))
   (declare-var! "jolt.passes.types.lattice" "join-t"))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "merge-fields" (letrec ((merge-fields (lambda (fa fb) (let fnrec3399 ((fa fa) (fb fb)) (let* ((m1 (let* ((_a$3404 (lambda (m k) (let fnrec3400 ((m m) (k k)) (jolt-assoc m k (let* ((_a$3401 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$3402 (jolt-get fa k (keyword #f "any"))) (_a$3403 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$3401 _a$3402 _a$3403)))))) (_a$3405 (jolt-hash-map)) (_a$3406 (jolt-keys fa))) (jolt-reduce _a$3404 _a$3405 _a$3406)))) (let* ((_a$3411 (lambda (m k) (let fnrec3407 ((m m) (k k)) (if (jolt-truthy? (jolt-get m k)) m (jolt-assoc m k (let* ((_a$3408 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$3409 (jolt-get fa k (keyword #f "any"))) (_a$3410 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$3408 _a$3409 _a$3410))))))) (_a$3412 m1) (_a$3413 (jolt-keys fb))) (jolt-reduce _a$3411 _a$3412 _a$3413))))))) merge-fields)))
+  (def-var! "jolt.passes.types.lattice" "merge-fields" (letrec ((merge-fields (lambda (fa fb) (let fnrec3423 ((fa fa) (fb fb)) (let* ((m1 (let* ((_a$3428 (lambda (m k) (let fnrec3424 ((m m) (k k)) (jolt-assoc m k (let* ((_a$3425 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$3426 (jolt-get fa k (keyword #f "any"))) (_a$3427 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$3425 _a$3426 _a$3427)))))) (_a$3429 (jolt-hash-map)) (_a$3430 (jolt-keys fa))) (jolt-reduce _a$3428 _a$3429 _a$3430)))) (let* ((_a$3435 (lambda (m k) (let fnrec3431 ((m m) (k k)) (if (jolt-truthy? (jolt-get m k)) m (jolt-assoc m k (let* ((_a$3432 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$3433 (jolt-get fa k (keyword #f "any"))) (_a$3434 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$3432 _a$3433 _a$3434))))))) (_a$3436 m1) (_a$3437 (jolt-keys fb))) (jolt-reduce _a$3435 _a$3436 _a$3437))))))) merge-fields)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "join-t" (letrec ((join-t (lambda (a b) (let fnrec3414 ((a a) (b b)) (if (jolt= a b) a (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) b (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) a (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") a))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") b) and__13__auto))) (let* ((merged (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$3415 (var-deref "jolt.passes.types.lattice" "merge-fields")) (_a$3416 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") a)) (_a$3417 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") b))) (jolt-invoke _a$3415 _a$3416 _a$3417))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-get a (keyword #f "shape")))) (if (jolt-truthy? and__13__auto) (let* ((_a$3418 (jolt-get a (keyword #f "shape"))) (_a$3419 (jolt-get b (keyword #f "shape")))) (jolt= _a$3418 _a$3419)) and__13__auto))) (jolt-assoc merged (keyword #f "shape") (jolt-get a (keyword #f "shape"))) merged)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") b) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$3420 join-t) (_a$3421 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a)) (_a$3422 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") b))) (jolt-invoke _a$3420 _a$3421 _a$3422))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") a))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") b) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") (let* ((_a$3423 join-t) (_a$3424 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") a)) (_a$3425 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") b))) (jolt-invoke _a$3423 _a$3424 _a$3425))) (if (jolt-truthy? (keyword #f "else")) (let* ((ma (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") a)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") a) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "scalar-t?") a)) (jolt-hash-set a) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (mb (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") b) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "scalar-t?") b)) (jolt-hash-set b) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt-truthy? (let* ((and__13__auto ma)) (if (jolt-truthy? and__13__auto) mb and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-of") (jolt-reduce jolt-conj ma mb)) (keyword #f "any"))) jolt-nil))))))))))) join-t)))
+  (def-var! "jolt.passes.types.lattice" "join-t" (letrec ((join-t (lambda (a b) (let fnrec3438 ((a a) (b b)) (if (jolt= a b) a (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) b (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) a (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") a))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") b) and__13__auto))) (let* ((merged (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$3439 (var-deref "jolt.passes.types.lattice" "merge-fields")) (_a$3440 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") a)) (_a$3441 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") b))) (jolt-invoke _a$3439 _a$3440 _a$3441))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-get a (keyword #f "shape")))) (if (jolt-truthy? and__13__auto) (let* ((_a$3442 (jolt-get a (keyword #f "shape"))) (_a$3443 (jolt-get b (keyword #f "shape")))) (jolt= _a$3442 _a$3443)) and__13__auto))) (jolt-assoc merged (keyword #f "shape") (jolt-get a (keyword #f "shape"))) merged)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") b) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$3444 join-t) (_a$3445 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a)) (_a$3446 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") b))) (jolt-invoke _a$3444 _a$3445 _a$3446))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") a))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") b) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") (let* ((_a$3447 join-t) (_a$3448 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") a)) (_a$3449 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") b))) (jolt-invoke _a$3447 _a$3448 _a$3449))) (if (jolt-truthy? (keyword #f "else")) (let* ((ma (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") a)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") a) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "scalar-t?") a)) (jolt-hash-set a) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (mb (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") b) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "scalar-t?") b)) (jolt-hash-set b) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt-truthy? (let* ((and__13__auto ma)) (if (jolt-truthy? and__13__auto) mb and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-of") (jolt-reduce jolt-conj ma mb)) (keyword #f "any"))) jolt-nil))))))))))) join-t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "join" (letrec ((join (lambda (a b) (let fnrec3426 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join)))
+  (def-var! "jolt.passes.types.lattice" "join" (letrec ((join (lambda (a b) (let fnrec3450 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join)))
 (guard (e (#t #f))
   (def-var! "jolt.passes.types.lattice" "type-depth" 4))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "cap" (letrec ((cap (lambda (t d) (let fnrec3427 ((t t) (d d)) (if (<= d 0) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)))))) (keyword #f "any") t) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) (let* ((capped (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$3432 (lambda (m k) (let fnrec3428 ((m m) (k k)) (jolt-assoc m k (let* ((_a$3429 cap) (_a$3430 (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k)) (_a$3431 (jolt-dec d))) (jolt-invoke _a$3429 _a$3430 _a$3431)))))) (_a$3433 (jolt-hash-map)) (_a$3434 (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))) (jolt-reduce _a$3432 _a$3433 _a$3434)))) (capped (if (jolt-truthy? (jolt-get t (keyword #f "shape"))) (jolt-assoc capped (keyword #f "shape") (jolt-get t (keyword #f "shape"))) capped)) (capped (if (jolt-truthy? (jolt-get t (keyword #f "type"))) (jolt-assoc capped (keyword #f "type") (jolt-get t (keyword #f "type"))) capped))) capped) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$3435 cap) (_a$3436 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)) (_a$3437 (jolt-dec d))) (jolt-invoke _a$3435 _a$3436 _a$3437))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") (let* ((_a$3438 cap) (_a$3439 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)) (_a$3440 (jolt-dec d))) (jolt-invoke _a$3438 _a$3439 _a$3440))) (if (jolt-truthy? (keyword #f "else")) t jolt-nil))))))))) cap)))
+  (def-var! "jolt.passes.types.lattice" "cap" (letrec ((cap (lambda (t d) (let fnrec3451 ((t t) (d d)) (if (<= d 0) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)))))) (keyword #f "any") t) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) (let* ((capped (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$3456 (lambda (m k) (let fnrec3452 ((m m) (k k)) (jolt-assoc m k (let* ((_a$3453 cap) (_a$3454 (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k)) (_a$3455 (jolt-dec d))) (jolt-invoke _a$3453 _a$3454 _a$3455)))))) (_a$3457 (jolt-hash-map)) (_a$3458 (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))) (jolt-reduce _a$3456 _a$3457 _a$3458)))) (capped (if (jolt-truthy? (jolt-get t (keyword #f "shape"))) (jolt-assoc capped (keyword #f "shape") (jolt-get t (keyword #f "shape"))) capped)) (capped (if (jolt-truthy? (jolt-get t (keyword #f "type"))) (jolt-assoc capped (keyword #f "type") (jolt-get t (keyword #f "type"))) capped))) capped) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$3459 cap) (_a$3460 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)) (_a$3461 (jolt-dec d))) (jolt-invoke _a$3459 _a$3460 _a$3461))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") (let* ((_a$3462 cap) (_a$3463 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)) (_a$3464 (jolt-dec d))) (jolt-invoke _a$3462 _a$3463 _a$3464))) (if (jolt-truthy? (keyword #f "else")) t jolt-nil))))))))) cap)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "struct-safe?" (letrec ((struct-safe? (lambda (t) (let fnrec3441 ((t t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))))) struct-safe?)))
+  (def-var! "jolt.passes.types.lattice" "struct-safe?" (letrec ((struct-safe? (lambda (t) (let fnrec3465 ((t t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))))) struct-safe?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "field-type" (letrec ((field-type (lambda (t k) (let fnrec3442 ((t t) (k k)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k (keyword #f "any")) (keyword #f "any")))))) field-type)))
+  (def-var! "jolt.passes.types.lattice" "field-type" (letrec ((field-type (lambda (t k) (let fnrec3466 ((t t) (k k)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k (keyword #f "any")) (keyword #f "any")))))) field-type)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "shape-order" (letrec ((shape-order (lambda (ks) (let fnrec3443 ((ks ks)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "sort") (lambda (a b) (let fnrec3444 ((a a) (b b)) (let* ((_a$3445 (var-deref "clojure.core" "compare")) (_a$3446 (jolt-invoke (var-deref "clojure.core" "str") a)) (_a$3447 (jolt-invoke (var-deref "clojure.core" "str") b))) (jolt-invoke _a$3445 _a$3446 _a$3447)))) ks)))))) shape-order)))
+  (def-var! "jolt.passes.types.lattice" "shape-order" (letrec ((shape-order (lambda (ks) (let fnrec3467 ((ks ks)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "sort") (lambda (a b) (let fnrec3468 ((a a) (b b)) (let* ((_a$3469 (var-deref "clojure.core" "compare")) (_a$3470 (jolt-invoke (var-deref "clojure.core" "str") a)) (_a$3471 (jolt-invoke (var-deref "clojure.core" "str") b))) (jolt-invoke _a$3469 _a$3470 _a$3471)))) ks)))))) shape-order)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "type-shape" (letrec ((type-shape (lambda (t) (let fnrec3448 ((t t)) (jolt-get t (keyword #f "shape")))))) type-shape)))
+  (def-var! "jolt.passes.types.lattice" "type-shape" (letrec ((type-shape (lambda (t) (let fnrec3472 ((t t)) (jolt-get t (keyword #f "shape")))))) type-shape)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "mark-struct" (letrec ((mark-struct (lambda (node t) (let fnrec3449 ((node node) (t t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-get t (keyword #f "shape"))) (jolt-assoc n (keyword #f "shape") (jolt-get t (keyword #f "shape"))) n)))))) mark-struct)))
+  (def-var! "jolt.passes.types.lattice" "mark-struct" (letrec ((mark-struct (lambda (node t) (let fnrec3473 ((node node) (t t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-get t (keyword #f "shape"))) (jolt-assoc n (keyword #f "shape") (jolt-get t (keyword #f "shape"))) n)))))) mark-struct)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "truthy-type?" (letrec ((truthy-type? (lambda (t) (let fnrec3450 ((t t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "truthy")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "phm")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t))))))))))))))))))) truthy-type?)))
+  (def-var! "jolt.passes.types.lattice" "truthy-type?" (letrec ((truthy-type? (lambda (t) (let fnrec3474 ((t t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "truthy")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "phm")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t))))))))))))))))))) truthy-type?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "num-ret-fns" (let* ((_o$3451 "+") (_o$3452 "-") (_o$3453 "*") (_o$3454 "/") (_o$3455 "inc") (_o$3456 "dec") (_o$3457 "mod") (_o$3458 "rem") (_o$3459 "quot") (_o$3460 "min") (_o$3461 "max") (_o$3462 "abs") (_o$3463 "bit-and") (_o$3464 "bit-or") (_o$3465 "bit-xor") (_o$3466 "count")) (jolt-hash-set _o$3451 _o$3452 _o$3453 _o$3454 _o$3455 _o$3456 _o$3457 _o$3458 _o$3459 _o$3460 _o$3461 _o$3462 _o$3463 _o$3464 _o$3465 _o$3466))))
+  (def-var! "jolt.passes.types.lattice" "num-ret-fns" (let* ((_o$3475 "+") (_o$3476 "-") (_o$3477 "*") (_o$3478 "/") (_o$3479 "inc") (_o$3480 "dec") (_o$3481 "mod") (_o$3482 "rem") (_o$3483 "quot") (_o$3484 "min") (_o$3485 "max") (_o$3486 "abs") (_o$3487 "bit-and") (_o$3488 "bit-or") (_o$3489 "bit-xor") (_o$3490 "count")) (jolt-hash-set _o$3475 _o$3476 _o$3477 _o$3478 _o$3479 _o$3480 _o$3481 _o$3482 _o$3483 _o$3484 _o$3485 _o$3486 _o$3487 _o$3488 _o$3489 _o$3490))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.lattice" "vector-ret-fns" (let* ((_o$3467 "vec") (_o$3468 "vector") (_o$3469 "mapv") (_o$3470 "filterv") (_o$3471 "subvec")) (jolt-hash-set _o$3467 _o$3468 _o$3469 _o$3470 _o$3471))))
+  (def-var! "jolt.passes.types.lattice" "vector-ret-fns" (let* ((_o$3491 "vec") (_o$3492 "vector") (_o$3493 "mapv") (_o$3494 "filterv") (_o$3495 "subvec")) (jolt-hash-set _o$3491 _o$3492 _o$3493 _o$3494 _o$3495))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.check" "not-number?" (letrec ((not-number? (lambda (t) (let fnrec3472 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-number? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__14__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "phm")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)))))))))))))))) not-number?)))
+  (def-var! "jolt.passes.types.check" "not-number?" (letrec ((not-number? (lambda (t) (let fnrec3496 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-number? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__14__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt= t (keyword #f "phm")))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)))))))))))))))) not-number?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.check" "not-seqable?" (letrec ((not-seqable? (lambda (t) (let fnrec3473 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-seqable? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "kw"))))))))) not-seqable?)))
+  (def-var! "jolt.passes.types.check" "not-seqable?" (letrec ((not-seqable? (lambda (t) (let fnrec3497 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-seqable? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "kw"))))))))) not-seqable?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.check" "not-callable?" (letrec ((not-callable? (lambda (t) (let fnrec3474 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-callable? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "str"))))))))) not-callable?)))
+  (def-var! "jolt.passes.types.check" "not-callable?" (letrec ((not-callable? (lambda (t) (let fnrec3498 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-callable? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__14__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "str"))))))))) not-callable?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types.check" "num-ops" (let* ((_o$3475 "+") (_o$3476 "-") (_o$3477 "*") (_o$3478 "/") (_o$3479 "inc") (_o$3480 "dec") (_o$3481 "mod") (_o$3482 "rem") (_o$3483 "quot") (_o$3484 "min") (_o$3485 "max") (_o$3486 "abs") (_o$3487 "bit-and") (_o$3488 "bit-or") (_o$3489 "bit-xor") (_o$3490 "bit-not") (_o$3491 "bit-shift-left") (_o$3492 "bit-shift-right")) (jolt-hash-set _o$3475 _o$3476 _o$3477 _o$3478 _o$3479 _o$3480 _o$3481 _o$3482 _o$3483 _o$3484 _o$3485 _o$3486 _o$3487 _o$3488 _o$3489 _o$3490 _o$3491 _o$3492)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types.check" "num-ops" (let* ((_o$3499 "+") (_o$3500 "-") (_o$3501 "*") (_o$3502 "/") (_o$3503 "inc") (_o$3504 "dec") (_o$3505 "mod") (_o$3506 "rem") (_o$3507 "quot") (_o$3508 "min") (_o$3509 "max") (_o$3510 "abs") (_o$3511 "bit-and") (_o$3512 "bit-or") (_o$3513 "bit-xor") (_o$3514 "bit-not") (_o$3515 "bit-shift-left") (_o$3516 "bit-shift-right")) (jolt-hash-set _o$3499 _o$3500 _o$3501 _o$3502 _o$3503 _o$3504 _o$3505 _o$3506 _o$3507 _o$3508 _o$3509 _o$3510 _o$3511 _o$3512 _o$3513 _o$3514 _o$3515 _o$3516)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types.check" "seq-ops" (let* ((_o$3493 "count") (_o$3494 "first") (_o$3495 "rest") (_o$3496 "next") (_o$3497 "seq") (_o$3498 "nth")) (jolt-hash-set _o$3493 _o$3494 _o$3495 _o$3496 _o$3497 _o$3498)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types.check" "seq-ops" (let* ((_o$3517 "count") (_o$3518 "first") (_o$3519 "rest") (_o$3520 "next") (_o$3521 "seq") (_o$3522 "nth")) (jolt-hash-set _o$3517 _o$3518 _o$3519 _o$3520 _o$3521 _o$3522)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.check" "type-name" (letrec ((type-name (lambda (t) (let fnrec3499 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((_a$3501 (lambda (s m) (let fnrec3500 ((s s) (m m)) (if (jolt= s "") (jolt-invoke type-name m) (jolt-invoke (var-deref "clojure.core" "str") s " or " (jolt-invoke type-name m)))))) (_a$3502 "") (_a$3503 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-reduce _a$3501 _a$3502 _a$3503)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) "a map" (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) "a vector" (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)) "a set" (if (jolt= t (keyword #f "str")) "a string" (if (jolt= t (keyword #f "kw")) "a keyword" (if (jolt= t (keyword #f "num")) "a number" (if (jolt= t (keyword #f "phm")) "a map" (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") t) jolt-nil))))))))))))) type-name)))
+  (def-var! "jolt.passes.types.check" "type-name" (letrec ((type-name (lambda (t) (let fnrec3523 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((_a$3525 (lambda (s m) (let fnrec3524 ((s s) (m m)) (if (jolt= s "") (jolt-invoke type-name m) (jolt-invoke (var-deref "clojure.core" "str") s " or " (jolt-invoke type-name m)))))) (_a$3526 "") (_a$3527 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-reduce _a$3525 _a$3526 _a$3527)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) "a map" (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) "a vector" (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)) "a set" (if (jolt= t (keyword #f "str")) "a string" (if (jolt= t (keyword #f "kw")) "a keyword" (if (jolt= t (keyword #f "num")) "a number" (if (jolt= t (keyword #f "phm")) "a map" (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") t) jolt-nil))))))))))))) type-name)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.check" "check-invoke" (letrec ((check-invoke (lambda (cn args arg-types pos env) (let fnrec3504 ((cn cn) (args args) (arg-types arg-types) (pos pos) (env env)) (if (jolt-contains? (var-deref "jolt.passes.types.check" "num-ops") cn) (let* ((_a$3527 (lambda (_ i) (let fnrec3505 ((_ _) (i i)) (begin (let* ((t (jolt-nth arg-types i))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-number?") t)) (let* ((_a$3523 (var-deref "clojure.core" "swap!")) (_a$3524 (jolt-get env (keyword #f "diags"))) (_a$3525 jolt-conj) (_a$3526 (let* ((_o$3513 (keyword #f "op")) (_o$3514 cn) (_o$3515 (keyword #f "argpos")) (_o$3516 i) (_o$3517 (keyword #f "type")) (_o$3518 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$3519 (keyword #f "pos")) (_o$3520 pos) (_o$3521 (keyword #f "msg")) (_o$3522 (let* ((_a$3506 (var-deref "clojure.core" "str")) (_a$3507 "`") (_a$3508 cn) (_a$3509 "` requires a number, but argument ") (_a$3510 (jolt-inc i)) (_a$3511 " is ") (_a$3512 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$3506 _a$3507 _a$3508 _a$3509 _a$3510 _a$3511 _a$3512)))) (jolt-hash-map _o$3513 _o$3514 _o$3515 _o$3516 _o$3517 _o$3518 _o$3519 _o$3520 _o$3521 _o$3522)))) (jolt-invoke _a$3523 _a$3524 _a$3525 _a$3526)) jolt-nil)) jolt-nil)))) (_a$3528 jolt-nil) (_a$3529 (jolt-range (jolt-count args)))) (jolt-reduce _a$3527 _a$3528 _a$3529)) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (var-deref "jolt.passes.types.check" "seq-ops") cn))) (if (jolt-truthy? and__13__auto) (> (jolt-count args) 0) and__13__auto))) (let* ((t (jolt-nth arg-types 0))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-seqable?") t)) (let* ((_a$3547 (var-deref "clojure.core" "swap!")) (_a$3548 (jolt-get env (keyword #f "diags"))) (_a$3549 jolt-conj) (_a$3550 (let* ((_o$3537 (keyword #f "op")) (_o$3538 cn) (_o$3539 (keyword #f "argpos")) (_o$3540 0) (_o$3541 (keyword #f "type")) (_o$3542 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$3543 (keyword #f "pos")) (_o$3544 pos) (_o$3545 (keyword #f "msg")) (_o$3546 (let* ((_a$3530 (var-deref "clojure.core" "str")) (_a$3531 "`") (_a$3532 cn) (_a$3533 "` requires ") (_a$3534 (if (jolt= cn "count") "a countable collection" "a seqable")) (_a$3535 ", but argument 1 is ") (_a$3536 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$3530 _a$3531 _a$3532 _a$3533 _a$3534 _a$3535 _a$3536)))) (jolt-hash-map _o$3537 _o$3538 _o$3539 _o$3540 _o$3541 _o$3542 _o$3543 _o$3544 _o$3545 _o$3546)))) (jolt-invoke _a$3547 _a$3548 _a$3549 _a$3550)) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) check-invoke)))
+  (def-var! "jolt.passes.types.check" "check-invoke" (letrec ((check-invoke (lambda (cn args arg-types pos env) (let fnrec3528 ((cn cn) (args args) (arg-types arg-types) (pos pos) (env env)) (if (jolt-contains? (var-deref "jolt.passes.types.check" "num-ops") cn) (let* ((_a$3551 (lambda (_ i) (let fnrec3529 ((_ _) (i i)) (begin (let* ((t (jolt-nth arg-types i))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-number?") t)) (let* ((_a$3547 (var-deref "clojure.core" "swap!")) (_a$3548 (jolt-get env (keyword #f "diags"))) (_a$3549 jolt-conj) (_a$3550 (let* ((_o$3537 (keyword #f "op")) (_o$3538 cn) (_o$3539 (keyword #f "argpos")) (_o$3540 i) (_o$3541 (keyword #f "type")) (_o$3542 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$3543 (keyword #f "pos")) (_o$3544 pos) (_o$3545 (keyword #f "msg")) (_o$3546 (let* ((_a$3530 (var-deref "clojure.core" "str")) (_a$3531 "`") (_a$3532 cn) (_a$3533 "` requires a number, but argument ") (_a$3534 (jolt-inc i)) (_a$3535 " is ") (_a$3536 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$3530 _a$3531 _a$3532 _a$3533 _a$3534 _a$3535 _a$3536)))) (jolt-hash-map _o$3537 _o$3538 _o$3539 _o$3540 _o$3541 _o$3542 _o$3543 _o$3544 _o$3545 _o$3546)))) (jolt-invoke _a$3547 _a$3548 _a$3549 _a$3550)) jolt-nil)) jolt-nil)))) (_a$3552 jolt-nil) (_a$3553 (jolt-range (jolt-count args)))) (jolt-reduce _a$3551 _a$3552 _a$3553)) (if (jolt-truthy? (let* ((and__13__auto (jolt-contains? (var-deref "jolt.passes.types.check" "seq-ops") cn))) (if (jolt-truthy? and__13__auto) (> (jolt-count args) 0) and__13__auto))) (let* ((t (jolt-nth arg-types 0))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-seqable?") t)) (let* ((_a$3571 (var-deref "clojure.core" "swap!")) (_a$3572 (jolt-get env (keyword #f "diags"))) (_a$3573 jolt-conj) (_a$3574 (let* ((_o$3561 (keyword #f "op")) (_o$3562 cn) (_o$3563 (keyword #f "argpos")) (_o$3564 0) (_o$3565 (keyword #f "type")) (_o$3566 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$3567 (keyword #f "pos")) (_o$3568 pos) (_o$3569 (keyword #f "msg")) (_o$3570 (let* ((_a$3554 (var-deref "clojure.core" "str")) (_a$3555 "`") (_a$3556 cn) (_a$3557 "` requires ") (_a$3558 (if (jolt= cn "count") "a countable collection" "a seqable")) (_a$3559 ", but argument 1 is ") (_a$3560 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$3554 _a$3555 _a$3556 _a$3557 _a$3558 _a$3559 _a$3560)))) (jolt-hash-map _o$3561 _o$3562 _o$3563 _o$3564 _o$3565 _o$3566 _o$3567 _o$3568 _o$3569 _o$3570)))) (jolt-invoke _a$3571 _a$3572 _a$3573 _a$3574)) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) check-invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types.check" "register-user-fn!" (letrec ((register-user-fn! (lambda (node env) (let fnrec3551 ((node node) (env env)) (let* ((init (jolt-get node (keyword #f "init"))) (m (jolt-get node (keyword #f "meta"))) (redefable (let* ((and__13__auto m)) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt-get m (keyword #f "redef")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-get m (keyword #f "dynamic")))) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-not redefable))) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get init (keyword #f "op"))) and__13__auto))) (let* ((arities (jolt-get init (keyword #f "arities")))) (if (jolt= 1 (jolt-count arities)) (let* ((ar (jolt-first arities))) (if (jolt-not (jolt-get ar (keyword #f "rest"))) (let* ((_a$3562 (var-deref "clojure.core" "swap!")) (_a$3563 (jolt-get env (keyword #f "user-sigs"))) (_a$3564 jolt-assoc) (_a$3565 (let* ((_a$3552 (var-deref "clojure.core" "str")) (_a$3553 (jolt-get node (keyword #f "ns"))) (_a$3554 "/") (_a$3555 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$3552 _a$3553 _a$3554 _a$3555))) (_a$3566 (let* ((_o$3556 (keyword #f "name")) (_o$3557 (jolt-get node (keyword #f "name"))) (_o$3558 (keyword #f "params")) (_o$3559 (jolt-get ar (keyword #f "params"))) (_o$3560 (keyword #f "body")) (_o$3561 (jolt-get ar (keyword #f "body")))) (jolt-hash-map _o$3556 _o$3557 _o$3558 _o$3559 _o$3560 _o$3561)))) (jolt-invoke _a$3562 _a$3563 _a$3564 _a$3565 _a$3566)) jolt-nil)) jolt-nil)) jolt-nil)))))) register-user-fn!)))
+  (def-var! "jolt.passes.types.check" "register-user-fn!" (letrec ((register-user-fn! (lambda (node env) (let fnrec3575 ((node node) (env env)) (let* ((init (jolt-get node (keyword #f "init"))) (m (jolt-get node (keyword #f "meta"))) (redefable (let* ((and__13__auto m)) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt-get m (keyword #f "redef")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-get m (keyword #f "dynamic")))) and__13__auto)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-not redefable))) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get init (keyword #f "op"))) and__13__auto))) (let* ((arities (jolt-get init (keyword #f "arities")))) (if (jolt= 1 (jolt-count arities)) (let* ((ar (jolt-first arities))) (if (jolt-not (jolt-get ar (keyword #f "rest"))) (let* ((_a$3586 (var-deref "clojure.core" "swap!")) (_a$3587 (jolt-get env (keyword #f "user-sigs"))) (_a$3588 jolt-assoc) (_a$3589 (let* ((_a$3576 (var-deref "clojure.core" "str")) (_a$3577 (jolt-get node (keyword #f "ns"))) (_a$3578 "/") (_a$3579 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$3576 _a$3577 _a$3578 _a$3579))) (_a$3590 (let* ((_o$3580 (keyword #f "name")) (_o$3581 (jolt-get node (keyword #f "name"))) (_o$3582 (keyword #f "params")) (_o$3583 (jolt-get ar (keyword #f "params"))) (_o$3584 (keyword #f "body")) (_o$3585 (jolt-get ar (keyword #f "body")))) (jolt-hash-map _o$3580 _o$3581 _o$3582 _o$3583 _o$3584 _o$3585)))) (jolt-invoke _a$3586 _a$3587 _a$3588 _a$3589 _a$3590)) jolt-nil)) jolt-nil)) jolt-nil)))))) register-user-fn!)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "config-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$2878 (keyword #f "rtenv")) (_o$2879 (jolt-hash-map)) (_o$2880 (keyword #f "vtypes")) (_o$2881 (jolt-hash-map)) (_o$2882 (keyword #f "record-shapes")) (_o$2883 (jolt-hash-map)) (_o$2884 (keyword #f "protocol-methods")) (_o$2885 (jolt-hash-map)) (_o$2886 (keyword #f "map-shapes?")) (_o$2887 #f)) (jolt-hash-map _o$2878 _o$2879 _o$2880 _o$2881 _o$2882 _o$2883 _o$2884 _o$2885 _o$2886 _o$2887))) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types" "config-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$2902 (keyword #f "rtenv")) (_o$2903 (jolt-hash-map)) (_o$2904 (keyword #f "vtypes")) (_o$2905 (jolt-hash-map)) (_o$2906 (keyword #f "record-shapes")) (_o$2907 (jolt-hash-map)) (_o$2908 (keyword #f "protocol-methods")) (_o$2909 (jolt-hash-map)) (_o$2910 (keyword #f "map-shapes?")) (_o$2911 #f)) (jolt-hash-map _o$2902 _o$2903 _o$2904 _o$2905 _o$2906 _o$2907 _o$2908 _o$2909 _o$2910 _o$2911))) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.types" "escapes-box" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
@@ -439,102 +441,102 @@
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.types" "last-diags-box" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "check-mode-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$2888 (keyword #f "on")) (_o$2889 #f) (_o$2890 (keyword #f "strict")) (_o$2891 #f)) (jolt-hash-map _o$2888 _o$2889 _o$2890 _o$2891))) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types" "check-mode-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$2912 (keyword #f "on")) (_o$2913 #f) (_o$2914 (keyword #f "strict")) (_o$2915 #f)) (jolt-hash-map _o$2912 _o$2913 _o$2914 _o$2915))) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "mk-env" (letrec ((mk-env (lambda (checking? strict?) (let fnrec2892 ((checking? checking?) (strict? strict?)) (let* ((c (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "config-box")))) (let* ((_o$2893 (keyword #f "rtenv")) (_o$2894 (jolt-get c (keyword #f "rtenv"))) (_o$2895 (keyword #f "vtypes")) (_o$2896 (jolt-get c (keyword #f "vtypes"))) (_o$2897 (keyword #f "record-shapes")) (_o$2898 (jolt-get c (keyword #f "record-shapes"))) (_o$2899 (keyword #f "protocol-methods")) (_o$2900 (jolt-get c (keyword #f "protocol-methods"))) (_o$2901 (keyword #f "map-shapes?")) (_o$2902 (jolt-get c (keyword #f "map-shapes?"))) (_o$2903 (keyword #f "checking?")) (_o$2904 checking?) (_o$2905 (keyword #f "strict?")) (_o$2906 strict?) (_o$2907 (keyword #f "diags")) (_o$2908 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_o$2909 (keyword #f "calls")) (_o$2910 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_o$2911 (keyword #f "checking-set")) (_o$2912 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))) (_o$2913 (keyword #f "diag-memo")) (_o$2914 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map))) (_o$2915 (keyword #f "escapes")) (_o$2916 (var-deref "jolt.passes.types" "escapes-box")) (_o$2917 (keyword #f "user-sigs")) (_o$2918 (var-deref "jolt.passes.types" "user-sig-box"))) (jolt-hash-map _o$2893 _o$2894 _o$2895 _o$2896 _o$2897 _o$2898 _o$2899 _o$2900 _o$2901 _o$2902 _o$2903 _o$2904 _o$2905 _o$2906 _o$2907 _o$2908 _o$2909 _o$2910 _o$2911 _o$2912 _o$2913 _o$2914 _o$2915 _o$2916 _o$2917 _o$2918))))))) mk-env)))
+  (def-var! "jolt.passes.types" "mk-env" (letrec ((mk-env (lambda (checking? strict?) (let fnrec2916 ((checking? checking?) (strict? strict?)) (let* ((c (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "config-box")))) (let* ((_o$2917 (keyword #f "rtenv")) (_o$2918 (jolt-get c (keyword #f "rtenv"))) (_o$2919 (keyword #f "vtypes")) (_o$2920 (jolt-get c (keyword #f "vtypes"))) (_o$2921 (keyword #f "record-shapes")) (_o$2922 (jolt-get c (keyword #f "record-shapes"))) (_o$2923 (keyword #f "protocol-methods")) (_o$2924 (jolt-get c (keyword #f "protocol-methods"))) (_o$2925 (keyword #f "map-shapes?")) (_o$2926 (jolt-get c (keyword #f "map-shapes?"))) (_o$2927 (keyword #f "checking?")) (_o$2928 checking?) (_o$2929 (keyword #f "strict?")) (_o$2930 strict?) (_o$2931 (keyword #f "diags")) (_o$2932 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_o$2933 (keyword #f "calls")) (_o$2934 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_o$2935 (keyword #f "checking-set")) (_o$2936 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))) (_o$2937 (keyword #f "diag-memo")) (_o$2938 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map))) (_o$2939 (keyword #f "escapes")) (_o$2940 (var-deref "jolt.passes.types" "escapes-box")) (_o$2941 (keyword #f "user-sigs")) (_o$2942 (var-deref "jolt.passes.types" "user-sig-box"))) (jolt-hash-map _o$2917 _o$2918 _o$2919 _o$2920 _o$2921 _o$2922 _o$2923 _o$2924 _o$2925 _o$2926 _o$2927 _o$2928 _o$2929 _o$2930 _o$2931 _o$2932 _o$2933 _o$2934 _o$2935 _o$2936 _o$2937 _o$2938 _o$2939 _o$2940 _o$2941 _o$2942))))))) mk-env)))
 (guard (e (#t #f))
   (declare-var! "jolt.passes.types" "record-type-from-entry"))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "field-type-from-tag" (letrec ((field-type-from-tag (lambda (tag depth shapes) (let fnrec2919 ((tag tag) (depth depth) (shapes shapes)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") tag))) (if (jolt-truthy? or__14__auto) or__14__auto (<= depth 0)))) (keyword #f "any") (if (jolt= tag "num") (keyword #f "num") (if (jolt-truthy? (keyword #f "else")) (let* ((e (jolt-get shapes tag))) (if (jolt-truthy? e) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e depth shapes) (keyword #f "any"))) jolt-nil))))))) field-type-from-tag)))
+  (def-var! "jolt.passes.types" "field-type-from-tag" (letrec ((field-type-from-tag (lambda (tag depth shapes) (let fnrec2943 ((tag tag) (depth depth) (shapes shapes)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") tag))) (if (jolt-truthy? or__14__auto) or__14__auto (<= depth 0)))) (keyword #f "any") (if (jolt= tag "num") (keyword #f "num") (if (jolt-truthy? (keyword #f "else")) (let* ((e (jolt-get shapes tag))) (if (jolt-truthy? e) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e depth shapes) (keyword #f "any"))) jolt-nil))))))) field-type-from-tag)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "record-type-from-entry" (letrec ((record-type-from-entry (lambda (rs depth shapes) (let fnrec2920 ((rs rs) (depth depth) (shapes shapes)) (let* ((fields (jolt-get rs (keyword #f "fields"))) (tags (jolt-get rs (keyword #f "tags"))) (fmap (let* ((_a$2929 (lambda (m i) (let fnrec2921 ((m m) (i i)) (let* ((_a$2926 m) (_a$2927 (jolt-nth fields i)) (_a$2928 (let* ((_a$2922 (var-deref "jolt.passes.types" "field-type-from-tag")) (_a$2923 (if (jolt-truthy? tags) (jolt-nth tags i) jolt-nil)) (_a$2924 (jolt-dec depth)) (_a$2925 shapes)) (jolt-invoke _a$2922 _a$2923 _a$2924 _a$2925)))) (jolt-assoc _a$2926 _a$2927 _a$2928))))) (_a$2930 (jolt-hash-map)) (_a$2931 (jolt-range (jolt-count fields)))) (jolt-reduce _a$2929 _a$2930 _a$2931)))) (let* ((_a$2932 (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") fmap)) (_a$2933 (keyword #f "shape")) (_a$2934 (jolt-invoke (var-deref "clojure.core" "vec") fields)) (_a$2935 (keyword #f "type")) (_a$2936 (jolt-get rs (keyword #f "type")))) (jolt-assoc _a$2932 _a$2933 _a$2934 _a$2935 _a$2936))))))) record-type-from-entry)))
+  (def-var! "jolt.passes.types" "record-type-from-entry" (letrec ((record-type-from-entry (lambda (rs depth shapes) (let fnrec2944 ((rs rs) (depth depth) (shapes shapes)) (let* ((fields (jolt-get rs (keyword #f "fields"))) (tags (jolt-get rs (keyword #f "tags"))) (fmap (let* ((_a$2953 (lambda (m i) (let fnrec2945 ((m m) (i i)) (let* ((_a$2950 m) (_a$2951 (jolt-nth fields i)) (_a$2952 (let* ((_a$2946 (var-deref "jolt.passes.types" "field-type-from-tag")) (_a$2947 (if (jolt-truthy? tags) (jolt-nth tags i) jolt-nil)) (_a$2948 (jolt-dec depth)) (_a$2949 shapes)) (jolt-invoke _a$2946 _a$2947 _a$2948 _a$2949)))) (jolt-assoc _a$2950 _a$2951 _a$2952))))) (_a$2954 (jolt-hash-map)) (_a$2955 (jolt-range (jolt-count fields)))) (jolt-reduce _a$2953 _a$2954 _a$2955)))) (let* ((_a$2956 (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") fmap)) (_a$2957 (keyword #f "shape")) (_a$2958 (jolt-invoke (var-deref "clojure.core" "vec") fields)) (_a$2959 (keyword #f "type")) (_a$2960 (jolt-get rs (keyword #f "type")))) (jolt-assoc _a$2956 _a$2957 _a$2958 _a$2959 _a$2960))))))) record-type-from-entry)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "elem-fns" (let* ((_o$2937 "rand-nth") (_o$2938 "first") (_o$2939 "peek") (_o$2940 "last") (_o$2941 "nth") (_o$2942 "fnext") (_o$2943 "second")) (jolt-hash-set _o$2937 _o$2938 _o$2939 _o$2940 _o$2941 _o$2942 _o$2943)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types" "elem-fns" (let* ((_o$2961 "rand-nth") (_o$2962 "first") (_o$2963 "peek") (_o$2964 "last") (_o$2965 "nth") (_o$2966 "fnext") (_o$2967 "second")) (jolt-hash-set _o$2961 _o$2962 _o$2963 _o$2964 _o$2965 _o$2966 _o$2967)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
   (declare-var! "jolt.passes.types" "check-user-call"))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "var-key" (letrec ((var-key (lambda (fnode) (let fnrec2944 ((fnode fnode)) (let* ((_a$2945 (var-deref "clojure.core" "str")) (_a$2946 (jolt-get fnode (keyword #f "ns"))) (_a$2947 "/") (_a$2948 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$2945 _a$2946 _a$2947 _a$2948)))))) var-key)))
+  (def-var! "jolt.passes.types" "var-key" (letrec ((var-key (lambda (fnode) (let fnrec2968 ((fnode fnode)) (let* ((_a$2969 (var-deref "clojure.core" "str")) (_a$2970 (jolt-get fnode (keyword #f "ns"))) (_a$2971 "/") (_a$2972 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$2969 _a$2970 _a$2971 _a$2972)))))) var-key)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "call-ret-type" (letrec ((call-ret-type (lambda (fnode env) (let fnrec2949 ((fnode fnode) (env env)) (let* ((op (jolt-get fnode (keyword #f "op"))) (shapes (jolt-get env (keyword #f "record-shapes")))) (if (jolt= op (keyword #f "var")) (let* ((rs (jolt-get shapes (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)))) (if (jolt-truthy? rs) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") rs (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (let* ((r (let* ((_a$2950 (jolt-get env (keyword #f "rtenv"))) (_a$2951 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$2950 _a$2951)))) (if (jolt-truthy? r) r (let* ((nm (let* ((and__13__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt-get fnode (keyword #f "name")) and__13__auto)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") nm)) (keyword #f "any") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "num-ret-fns") nm) (keyword #f "num") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "vector-ret-fns") nm) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "any")) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))))))) (if (jolt= op (keyword #f "host")) (let* ((nm (jolt-get fnode (keyword #f "name")))) (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "num-ret-fns") nm) (keyword #f "num") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "vector-ret-fns") nm) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "any")) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil)))) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil)))))))) call-ret-type)))
+  (def-var! "jolt.passes.types" "call-ret-type" (letrec ((call-ret-type (lambda (fnode env) (let fnrec2973 ((fnode fnode) (env env)) (let* ((op (jolt-get fnode (keyword #f "op"))) (shapes (jolt-get env (keyword #f "record-shapes")))) (if (jolt= op (keyword #f "var")) (let* ((rs (jolt-get shapes (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)))) (if (jolt-truthy? rs) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") rs (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (let* ((r (let* ((_a$2974 (jolt-get env (keyword #f "rtenv"))) (_a$2975 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$2974 _a$2975)))) (if (jolt-truthy? r) r (let* ((nm (let* ((and__13__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__13__auto) (jolt-get fnode (keyword #f "name")) and__13__auto)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") nm)) (keyword #f "any") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "num-ret-fns") nm) (keyword #f "num") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "vector-ret-fns") nm) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "any")) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))))))) (if (jolt= op (keyword #f "host")) (let* ((nm (jolt-get fnode (keyword #f "name")))) (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "num-ret-fns") nm) (keyword #f "num") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "vector-ret-fns") nm) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "any")) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil)))) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil)))))))) call-ret-type)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "fold-preds" (let* ((_o$2952 "number?") (_o$2953 "string?") (_o$2954 "keyword?") (_o$2955 "record?") (_o$2956 "nil?") (_o$2957 "some?")) (jolt-hash-set _o$2952 _o$2953 _o$2954 _o$2955 _o$2956 _o$2957)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types" "fold-preds" (let* ((_o$2976 "number?") (_o$2977 "string?") (_o$2978 "keyword?") (_o$2979 "record?") (_o$2980 "nil?") (_o$2981 "some?")) (jolt-hash-set _o$2976 _o$2977 _o$2978 _o$2979 _o$2980 _o$2981)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "record-t?" (letrec ((record-t? (lambda (t) (let fnrec2958 ((t t)) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get t (keyword #f "type"))) and__13__auto)))))) record-t?)))
+  (def-var! "jolt.passes.types" "record-t?" (letrec ((record-t? (lambda (t) (let fnrec2982 ((t t)) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get t (keyword #f "type"))) and__13__auto)))))) record-t?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "pred-on" (letrec ((pred-on (lambda (pname t) (let fnrec2959 ((pname pname) (t t)) (if (jolt-truthy? (let* ((or__14__auto (jolt= t (keyword #f "any")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "truthy"))))) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((vs (let* ((_a$2961 (lambda (m) (let fnrec2960 ((m m)) (jolt-invoke pred-on pname m)))) (_a$2962 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-map _a$2961 _a$2962)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-seq vs))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-first vs))))) (if (jolt-truthy? and__13__auto) (jolt-apply jolt= vs) and__13__auto)) and__13__auto))) (jolt-first vs) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) (let* ((G__33 pname)) (if (jolt= G__33 "number?") (jolt= t (keyword #f "num")) (if (jolt= G__33 "string?") (jolt= t (keyword #f "str")) (if (jolt= G__33 "keyword?") (jolt= t (keyword #f "kw")) (if (jolt= G__33 "record?") (jolt-invoke (var-deref "jolt.passes.types" "record-t?") t) (if (jolt= G__33 "nil?") #f (if (jolt= G__33 "some?") #t jolt-nil))))))) jolt-nil))))))) pred-on)))
+  (def-var! "jolt.passes.types" "pred-on" (letrec ((pred-on (lambda (pname t) (let fnrec2983 ((pname pname) (t t)) (if (jolt-truthy? (let* ((or__14__auto (jolt= t (keyword #f "any")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= t (keyword #f "truthy"))))) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((vs (let* ((_a$2985 (lambda (m) (let fnrec2984 ((m m)) (jolt-invoke pred-on pname m)))) (_a$2986 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-map _a$2985 _a$2986)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-seq vs))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-first vs))))) (if (jolt-truthy? and__13__auto) (jolt-apply jolt= vs) and__13__auto)) and__13__auto))) (jolt-first vs) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) (let* ((G__33 pname)) (if (jolt= G__33 "number?") (jolt= t (keyword #f "num")) (if (jolt= G__33 "string?") (jolt= t (keyword #f "str")) (if (jolt= G__33 "keyword?") (jolt= t (keyword #f "kw")) (if (jolt= G__33 "record?") (jolt-invoke (var-deref "jolt.passes.types" "record-t?") t) (if (jolt= G__33 "nil?") #f (if (jolt= G__33 "some?") #t jolt-nil))))))) jolt-nil))))))) pred-on)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "pure-node?" (letrec ((pure-node? (lambda (n) (let fnrec2963 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__14__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "local"))))))))) pure-node?)))
+  (def-var! "jolt.passes.types" "pure-node?" (letrec ((pure-node? (lambda (n) (let fnrec2987 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__14__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= op (keyword #f "local"))))))))) pure-node?)))
 (guard (e (#t #f))
   (declare-var! "jolt.passes.types" "infer"))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "ty" (letrec ((ty (lambda (r) (let fnrec2964 ((r r)) (jolt-nth r 0))))) ty)))
+  (def-var! "jolt.passes.types" "ty" (letrec ((ty (lambda (r) (let fnrec2988 ((r r)) (jolt-nth r 0))))) ty)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "nd" (letrec ((nd (lambda (r) (let fnrec2965 ((r r)) (jolt-nth r 1))))) nd)))
+  (def-var! "jolt.passes.types" "nd" (letrec ((nd (lambda (r) (let fnrec2989 ((r r)) (jolt-nth r 1))))) nd)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "hof-table" (let* ((_o$2982 "map") (_o$2983 (let* ((_o$2966 (keyword #f "epos")) (_o$2967 0)) (jolt-hash-map _o$2966 _o$2967))) (_o$2984 "mapv") (_o$2985 (let* ((_o$2968 (keyword #f "epos")) (_o$2969 0)) (jolt-hash-map _o$2968 _o$2969))) (_o$2986 "filter") (_o$2987 (let* ((_o$2970 (keyword #f "epos")) (_o$2971 0)) (jolt-hash-map _o$2970 _o$2971))) (_o$2988 "filterv") (_o$2989 (let* ((_o$2972 (keyword #f "epos")) (_o$2973 0)) (jolt-hash-map _o$2972 _o$2973))) (_o$2990 "keep") (_o$2991 (let* ((_o$2974 (keyword #f "epos")) (_o$2975 0)) (jolt-hash-map _o$2974 _o$2975))) (_o$2992 "remove") (_o$2993 (let* ((_o$2976 (keyword #f "epos")) (_o$2977 0)) (jolt-hash-map _o$2976 _o$2977))) (_o$2994 "run!") (_o$2995 (let* ((_o$2978 (keyword #f "epos")) (_o$2979 0)) (jolt-hash-map _o$2978 _o$2979))) (_o$2996 "mapcat") (_o$2997 (let* ((_o$2980 (keyword #f "epos")) (_o$2981 0)) (jolt-hash-map _o$2980 _o$2981)))) (jolt-hash-map _o$2982 _o$2983 _o$2984 _o$2985 _o$2986 _o$2987 _o$2988 _o$2989 _o$2990 _o$2991 _o$2992 _o$2993 _o$2994 _o$2995 _o$2996 _o$2997)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "jolt.passes.types" "hof-table" (let* ((_o$3006 "map") (_o$3007 (let* ((_o$2990 (keyword #f "epos")) (_o$2991 0)) (jolt-hash-map _o$2990 _o$2991))) (_o$3008 "mapv") (_o$3009 (let* ((_o$2992 (keyword #f "epos")) (_o$2993 0)) (jolt-hash-map _o$2992 _o$2993))) (_o$3010 "filter") (_o$3011 (let* ((_o$2994 (keyword #f "epos")) (_o$2995 0)) (jolt-hash-map _o$2994 _o$2995))) (_o$3012 "filterv") (_o$3013 (let* ((_o$2996 (keyword #f "epos")) (_o$2997 0)) (jolt-hash-map _o$2996 _o$2997))) (_o$3014 "keep") (_o$3015 (let* ((_o$2998 (keyword #f "epos")) (_o$2999 0)) (jolt-hash-map _o$2998 _o$2999))) (_o$3016 "remove") (_o$3017 (let* ((_o$3000 (keyword #f "epos")) (_o$3001 0)) (jolt-hash-map _o$3000 _o$3001))) (_o$3018 "run!") (_o$3019 (let* ((_o$3002 (keyword #f "epos")) (_o$3003 0)) (jolt-hash-map _o$3002 _o$3003))) (_o$3020 "mapcat") (_o$3021 (let* ((_o$3004 (keyword #f "epos")) (_o$3005 0)) (jolt-hash-map _o$3004 _o$3005)))) (jolt-hash-map _o$3006 _o$3007 _o$3008 _o$3009 _o$3010 _o$3011 _o$3012 _o$3013 _o$3014 _o$3015 _o$3016 _o$3017 _o$3018 _o$3019 _o$3020 _o$3021)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-fn-seeded" (letrec ((infer-fn-seeded (lambda (node seeds tenv env) (let fnrec2998 ((node node) (seeds seeds) (tenv tenv) (env env)) (let* ((res (let* ((_a$3009 (var-deref "clojure.core" "mapv")) (_a$3010 (lambda (a) (let fnrec2999 ((a a)) (let* ((params (jolt-get a (keyword #f "params"))) (pe (let* ((_a$3004 (lambda (e i) (let fnrec3000 ((e e) (i i)) (let* ((_a$3001 e) (_a$3002 (jolt-nth params i)) (_a$3003 (let* ((s (jolt-get seeds i))) (if (jolt-truthy? s) s (keyword #f "any"))))) (jolt-assoc _a$3001 _a$3002 _a$3003))))) (_a$3005 tenv) (_a$3006 (jolt-range (jolt-count params)))) (jolt-reduce _a$3004 _a$3005 _a$3006))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe)) (br (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pe env))) (let* ((_o$3007 (jolt-invoke (var-deref "jolt.passes.types" "ty") br)) (_o$3008 (jolt-assoc a (keyword #f "body") (jolt-invoke (var-deref "jolt.passes.types" "nd") br)))) (jolt-vector _o$3007 _o$3008)))))) (_a$3011 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$3009 _a$3010 _a$3011))) (rets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3012 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) res)) (ret (if (jolt-empty? rets) (keyword #f "any") (let* ((_a$3013 (var-deref "jolt.passes.types.lattice" "join")) (_a$3014 (jolt-first rets)) (_a$3015 (jolt-rest rets))) (jolt-reduce _a$3013 _a$3014 _a$3015))))) (let* ((_o$3017 ret) (_o$3018 (jolt-assoc node (keyword #f "arities") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3016 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) res)))) (jolt-vector _o$3017 _o$3018))))))) infer-fn-seeded)))
+  (def-var! "jolt.passes.types" "infer-fn-seeded" (letrec ((infer-fn-seeded (lambda (node seeds tenv env) (let fnrec3022 ((node node) (seeds seeds) (tenv tenv) (env env)) (let* ((res (let* ((_a$3033 (var-deref "clojure.core" "mapv")) (_a$3034 (lambda (a) (let fnrec3023 ((a a)) (let* ((params (jolt-get a (keyword #f "params"))) (pe (let* ((_a$3028 (lambda (e i) (let fnrec3024 ((e e) (i i)) (let* ((_a$3025 e) (_a$3026 (jolt-nth params i)) (_a$3027 (let* ((s (jolt-get seeds i))) (if (jolt-truthy? s) s (keyword #f "any"))))) (jolt-assoc _a$3025 _a$3026 _a$3027))))) (_a$3029 tenv) (_a$3030 (jolt-range (jolt-count params)))) (jolt-reduce _a$3028 _a$3029 _a$3030))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe)) (br (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pe env))) (let* ((_o$3031 (jolt-invoke (var-deref "jolt.passes.types" "ty") br)) (_o$3032 (jolt-assoc a (keyword #f "body") (jolt-invoke (var-deref "jolt.passes.types" "nd") br)))) (jolt-vector _o$3031 _o$3032)))))) (_a$3035 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$3033 _a$3034 _a$3035))) (rets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3036 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) res)) (ret (if (jolt-empty? rets) (keyword #f "any") (let* ((_a$3037 (var-deref "jolt.passes.types.lattice" "join")) (_a$3038 (jolt-first rets)) (_a$3039 (jolt-rest rets))) (jolt-reduce _a$3037 _a$3038 _a$3039))))) (let* ((_o$3041 ret) (_o$3042 (jolt-assoc node (keyword #f "arities") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3040 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) res)))) (jolt-vector _o$3041 _o$3042))))))) infer-fn-seeded)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-pred-fold" (letrec ((infer-pred-fold (lambda (node fnode cn args tenv env) (let fnrec3019 ((node node) (fnode fnode) (cn cn) (args args) (tenv tenv) (env env)) (let* ((ar (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (v (jolt-invoke (var-deref "jolt.passes.types" "pred-on") cn (jolt-invoke (var-deref "jolt.passes.types" "ty") ar)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") v)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types" "pure-node?") (jolt-invoke (var-deref "jolt.passes.types" "nd") ar)) and__13__auto))) (let* ((_o$3024 (keyword #f "any")) (_o$3025 (let* ((_o$3020 (keyword #f "op")) (_o$3021 (keyword #f "const")) (_o$3022 (keyword #f "val")) (_o$3023 v)) (jolt-hash-map _o$3020 _o$3021 _o$3022 _o$3023)))) (jolt-vector _o$3024 _o$3025)) (let* ((_o$3026 (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env)) (_o$3027 (jolt-assoc node (keyword #f "args") (jolt-vector (jolt-invoke (var-deref "jolt.passes.types" "nd") ar))))) (jolt-vector _o$3026 _o$3027)))))))) infer-pred-fold)))
+  (def-var! "jolt.passes.types" "infer-pred-fold" (letrec ((infer-pred-fold (lambda (node fnode cn args tenv env) (let fnrec3043 ((node node) (fnode fnode) (cn cn) (args args) (tenv tenv) (env env)) (let* ((ar (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (v (jolt-invoke (var-deref "jolt.passes.types" "pred-on") cn (jolt-invoke (var-deref "jolt.passes.types" "ty") ar)))) (if (jolt-truthy? (let* ((and__13__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") v)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types" "pure-node?") (jolt-invoke (var-deref "jolt.passes.types" "nd") ar)) and__13__auto))) (let* ((_o$3048 (keyword #f "any")) (_o$3049 (let* ((_o$3044 (keyword #f "op")) (_o$3045 (keyword #f "const")) (_o$3046 (keyword #f "val")) (_o$3047 v)) (jolt-hash-map _o$3044 _o$3045 _o$3046 _o$3047)))) (jolt-vector _o$3048 _o$3049)) (let* ((_o$3050 (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env)) (_o$3051 (jolt-assoc node (keyword #f "args") (jolt-vector (jolt-invoke (var-deref "jolt.passes.types" "nd") ar))))) (jolt-vector _o$3050 _o$3051)))))))) infer-pred-fold)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec3028 ((node node) (fnode fnode) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get fnode (keyword #f "val")))) (dr (if (jolt= n 2) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil))) (let* ((_o$3031 (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (_o$3032 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$3029 msub) (_o$3030 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$3029 _o$3030)) (jolt-vector msub))))) (jolt-vector _o$3031 _o$3032))))))) infer-kw-lookup)))
+  (def-var! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec3052 ((node node) (fnode fnode) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get fnode (keyword #f "val")))) (dr (if (jolt= n 2) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil))) (let* ((_o$3055 (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (_o$3056 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$3053 msub) (_o$3054 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$3053 _o$3054)) (jolt-vector msub))))) (jolt-vector _o$3055 _o$3056))))))) infer-kw-lookup)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec3033 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (kr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get (jolt-nth args 1) (keyword #f "val")))) (dr (if (jolt= n 3) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 2) tenv env) jolt-nil))) (let* ((_o$3039 (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (_o$3040 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$3034 msub) (_o$3035 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$3036 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$3034 _o$3035 _o$3036)) (let* ((_o$3037 msub) (_o$3038 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$3037 _o$3038)))))) (jolt-vector _o$3039 _o$3040))))))) infer-get-lookup)))
+  (def-var! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec3057 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (kr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get (jolt-nth args 1) (keyword #f "val")))) (dr (if (jolt= n 3) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 2) tenv env) jolt-nil))) (let* ((_o$3063 (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (_o$3064 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$3058 msub) (_o$3059 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$3060 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$3058 _o$3059 _o$3060)) (let* ((_o$3061 msub) (_o$3062 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$3061 _o$3062)))))) (jolt-vector _o$3063 _o$3064))))))) infer-get-lookup)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-reduce-hof" (letrec ((infer-reduce-hof (lambda (node args n tenv env) (let fnrec3041 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((three (>= n 3)) (coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args (if (jolt-truthy? three) 2 1)) tenv env)) (init-r (if (jolt-truthy? three) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (init-t (if (jolt-truthy? init-r) (jolt-invoke (var-deref "jolt.passes.types" "ty") init-r) (keyword #f "any"))) (fn-r (let* ((_a$3046 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$3047 (jolt-nth args 0)) (_a$3048 (let* ((_o$3042 0) (_o$3043 init-t) (_o$3044 1) (_o$3045 et)) (jolt-hash-map _o$3042 _o$3043 _o$3044 _o$3045))) (_a$3049 tenv) (_a$3050 env)) (jolt-invoke _a$3046 _a$3047 _a$3048 _a$3049 _a$3050)))) (let* ((_o$3056 (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") init-t (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r))) (_o$3057 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? three) (let* ((_o$3051 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$3052 (jolt-invoke (var-deref "jolt.passes.types" "nd") init-r)) (_o$3053 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$3051 _o$3052 _o$3053)) (let* ((_o$3054 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$3055 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$3054 _o$3055)))))) (jolt-vector _o$3056 _o$3057))))))) infer-reduce-hof)))
+  (def-var! "jolt.passes.types" "infer-reduce-hof" (letrec ((infer-reduce-hof (lambda (node args n tenv env) (let fnrec3065 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((three (>= n 3)) (coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args (if (jolt-truthy? three) 2 1)) tenv env)) (init-r (if (jolt-truthy? three) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (init-t (if (jolt-truthy? init-r) (jolt-invoke (var-deref "jolt.passes.types" "ty") init-r) (keyword #f "any"))) (fn-r (let* ((_a$3070 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$3071 (jolt-nth args 0)) (_a$3072 (let* ((_o$3066 0) (_o$3067 init-t) (_o$3068 1) (_o$3069 et)) (jolt-hash-map _o$3066 _o$3067 _o$3068 _o$3069))) (_a$3073 tenv) (_a$3074 env)) (jolt-invoke _a$3070 _a$3071 _a$3072 _a$3073 _a$3074)))) (let* ((_o$3080 (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") init-t (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r))) (_o$3081 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? three) (let* ((_o$3075 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$3076 (jolt-invoke (var-deref "jolt.passes.types" "nd") init-r)) (_o$3077 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$3075 _o$3076 _o$3077)) (let* ((_o$3078 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$3079 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$3078 _o$3079)))))) (jolt-vector _o$3080 _o$3081))))))) infer-reduce-hof)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-seq-hof" (letrec ((infer-seq-hof (lambda (node cn args tenv env) (let fnrec3058 ((node node) (cn cn) (args args) (tenv tenv) (env env)) (let* ((coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (fn-r (let* ((_a$3061 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$3062 (jolt-nth args 0)) (_a$3063 (let* ((_o$3059 (jolt-get (jolt-get (var-deref "jolt.passes.types" "hof-table") cn) (keyword #f "epos"))) (_o$3060 et)) (jolt-hash-map _o$3059 _o$3060))) (_a$3064 tenv) (_a$3065 env)) (jolt-invoke _a$3061 _a$3062 _a$3063 _a$3064 _a$3065))) (rt (if (jolt= cn "mapv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r)) (if (jolt= cn "filterv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") et) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))) (let* ((_o$3068 rt) (_o$3069 (jolt-assoc node (keyword #f "args") (let* ((_o$3066 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$3067 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$3066 _o$3067))))) (jolt-vector _o$3068 _o$3069))))))) infer-seq-hof)))
+  (def-var! "jolt.passes.types" "infer-seq-hof" (letrec ((infer-seq-hof (lambda (node cn args tenv env) (let fnrec3082 ((node node) (cn cn) (args args) (tenv tenv) (env env)) (let* ((coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (fn-r (let* ((_a$3085 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$3086 (jolt-nth args 0)) (_a$3087 (let* ((_o$3083 (jolt-get (jolt-get (var-deref "jolt.passes.types" "hof-table") cn) (keyword #f "epos"))) (_o$3084 et)) (jolt-hash-map _o$3083 _o$3084))) (_a$3088 tenv) (_a$3089 env)) (jolt-invoke _a$3085 _a$3086 _a$3087 _a$3088 _a$3089))) (rt (if (jolt= cn "mapv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r)) (if (jolt= cn "filterv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") et) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))) (let* ((_o$3092 rt) (_o$3093 (jolt-assoc node (keyword #f "args") (let* ((_o$3090 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$3091 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$3090 _o$3091))))) (jolt-vector _o$3092 _o$3093))))))) infer-seq-hof)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-conj-into" (letrec ((infer-conj-into (lambda (node fnode cn args n tenv env) (let fnrec3070 ((node node) (fnode fnode) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec3071 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args)) (base (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0))) (rest-ts (let* ((_a$3073 (var-deref "clojure.core" "mapv")) (_a$3074 (lambda (r) (let fnrec3072 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r)))) (_a$3075 (jolt-rest ares))) (jolt-invoke _a$3073 _a$3074 _a$3075))) (rt (if (jolt-truthy? (let* ((and__13__auto (jolt= cn "conj"))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-reduce (var-deref "jolt.passes.types.lattice" "join") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base) rest-ts)) (if (jolt-truthy? (let* ((and__13__auto (jolt= cn "into"))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 2 n))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") (jolt-nth rest-ts 0)) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$3076 (var-deref "jolt.passes.types.lattice" "join")) (_a$3077 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base)) (_a$3078 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") (jolt-nth rest-ts 0)))) (jolt-invoke _a$3076 _a$3077 _a$3078))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (let* ((_o$3080 rt) (_o$3081 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3079 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$3080 _o$3081))))))) infer-conj-into)))
+  (def-var! "jolt.passes.types" "infer-conj-into" (letrec ((infer-conj-into (lambda (node fnode cn args n tenv env) (let fnrec3094 ((node node) (fnode fnode) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec3095 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args)) (base (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0))) (rest-ts (let* ((_a$3097 (var-deref "clojure.core" "mapv")) (_a$3098 (lambda (r) (let fnrec3096 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r)))) (_a$3099 (jolt-rest ares))) (jolt-invoke _a$3097 _a$3098 _a$3099))) (rt (if (jolt-truthy? (let* ((and__13__auto (jolt= cn "conj"))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-reduce (var-deref "jolt.passes.types.lattice" "join") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base) rest-ts)) (if (jolt-truthy? (let* ((and__13__auto (jolt= cn "into"))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 2 n))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") (jolt-nth rest-ts 0)) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$3100 (var-deref "jolt.passes.types.lattice" "join")) (_a$3101 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base)) (_a$3102 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") (jolt-nth rest-ts 0)))) (jolt-invoke _a$3100 _a$3101 _a$3102))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (let* ((_o$3104 rt) (_o$3105 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3103 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$3104 _o$3105))))))) infer-conj-into)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-call" (letrec ((infer-call (lambda (node fnode iscall-var cn args n tenv env) (let fnrec3082 ((node node) (fnode fnode) (iscall-var iscall-var) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((fr (if (jolt-not iscall-var) (jolt-invoke (var-deref "jolt.passes.types" "infer") fnode tenv env) jolt-nil)) (fnode_PRIME_ (if (jolt-truthy? iscall-var) fnode (jolt-invoke (var-deref "jolt.passes.types" "nd") fr))) (callee-t (if (jolt-truthy? iscall-var) (let* ((_a$3083 (jolt-get env (keyword #f "vtypes"))) (_a$3084 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$3083 _a$3084)) (jolt-invoke (var-deref "jolt.passes.types" "ty") fr))) (ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec3085 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args))) (begin (if (jolt-truthy? iscall-var) (let* ((_a$3089 (var-deref "clojure.core" "swap!")) (_a$3090 (jolt-get env (keyword #f "calls"))) (_a$3091 jolt-conj) (_a$3092 (let* ((_o$3087 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_o$3088 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3086 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares))) (jolt-vector _o$3087 _o$3088)))) (jolt-invoke _a$3089 _a$3090 _a$3091 _a$3092)) jolt-nil) (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (let* ((ats (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3093 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)) (pos (jolt-get node (keyword #f "pos")))) (begin (if (jolt-truthy? cn) (jolt-invoke (var-deref "jolt.passes.types.check" "check-invoke") cn args ats pos env) jolt-nil) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-callable?") callee-t)) (let* ((_a$3102 (var-deref "clojure.core" "swap!")) (_a$3103 (jolt-get env (keyword #f "diags"))) (_a$3104 jolt-conj) (_a$3105 (let* ((_o$3094 (keyword #f "op")) (_o$3095 (keyword #f "call")) (_o$3096 (keyword #f "type")) (_o$3097 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t)) (_o$3098 (keyword #f "pos")) (_o$3099 pos) (_o$3100 (keyword #f "msg")) (_o$3101 (jolt-invoke (var-deref "clojure.core" "str") "cannot call " (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t) " as a function"))) (jolt-hash-map _o$3094 _o$3095 _o$3096 _o$3097 _o$3098 _o$3099 _o$3100 _o$3101)))) (jolt-invoke _a$3102 _a$3103 _a$3104 _a$3105)) jolt-nil) (if (jolt-truthy? (let* ((and__13__auto (jolt-get env (keyword #f "strict?")))) (if (jolt-truthy? and__13__auto) iscall-var and__13__auto))) (let* ((k (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (usig (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "user-sigs"))) k))) (if (jolt-truthy? usig) (jolt-invoke (var-deref "jolt.passes.types" "check-user-call") k usig ats pos env) jolt-nil)) jolt-nil))) jolt-nil) (let* ((pm (let* ((and__13__auto iscall-var)) (if (jolt-truthy? and__13__auto) (let* ((_a$3106 (jolt-get env (keyword #f "protocol-methods"))) (_a$3107 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$3106 _a$3107)) and__13__auto))) (rtype (if (jolt-truthy? (let* ((and__13__auto pm)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (jolt-get (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)) (keyword #f "type")) jolt-nil)) (base (jolt-assoc node (keyword #f "fn") fnode_PRIME_ (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3108 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (let* ((_o$3116 (if (jolt= cn "range") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "num")) (if (jolt-truthy? (let* ((and__13__auto cn)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-contains? (var-deref "jolt.passes.types" "elem-fns") cn))) (if (jolt-truthy? and__13__auto) (> n 0) and__13__auto)) and__13__auto))) (let* ((a0 (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a0)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a0) (keyword #f "any"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil)))) (_o$3117 (if (jolt-truthy? rtype) (let* ((_a$3109 base) (_a$3110 (keyword #f "devirt-type")) (_a$3111 rtype) (_a$3112 (keyword #f "devirt-proto")) (_a$3113 (jolt-nth pm 0)) (_a$3114 (keyword #f "devirt-method")) (_a$3115 (jolt-nth pm 1))) (jolt-assoc _a$3109 _a$3110 _a$3111 _a$3112 _a$3113 _a$3114 _a$3115)) base))) (jolt-vector _o$3116 _o$3117))))))))) infer-call)))
+  (def-var! "jolt.passes.types" "infer-call" (letrec ((infer-call (lambda (node fnode iscall-var cn args n tenv env) (let fnrec3106 ((node node) (fnode fnode) (iscall-var iscall-var) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((fr (if (jolt-not iscall-var) (jolt-invoke (var-deref "jolt.passes.types" "infer") fnode tenv env) jolt-nil)) (fnode_PRIME_ (if (jolt-truthy? iscall-var) fnode (jolt-invoke (var-deref "jolt.passes.types" "nd") fr))) (callee-t (if (jolt-truthy? iscall-var) (let* ((_a$3107 (jolt-get env (keyword #f "vtypes"))) (_a$3108 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$3107 _a$3108)) (jolt-invoke (var-deref "jolt.passes.types" "ty") fr))) (ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec3109 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args))) (begin (if (jolt-truthy? iscall-var) (let* ((_a$3113 (var-deref "clojure.core" "swap!")) (_a$3114 (jolt-get env (keyword #f "calls"))) (_a$3115 jolt-conj) (_a$3116 (let* ((_o$3111 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_o$3112 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3110 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares))) (jolt-vector _o$3111 _o$3112)))) (jolt-invoke _a$3113 _a$3114 _a$3115 _a$3116)) jolt-nil) (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (let* ((ats (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3117 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)) (pos (jolt-get node (keyword #f "pos")))) (begin (if (jolt-truthy? cn) (jolt-invoke (var-deref "jolt.passes.types.check" "check-invoke") cn args ats pos env) jolt-nil) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-callable?") callee-t)) (let* ((_a$3126 (var-deref "clojure.core" "swap!")) (_a$3127 (jolt-get env (keyword #f "diags"))) (_a$3128 jolt-conj) (_a$3129 (let* ((_o$3118 (keyword #f "op")) (_o$3119 (keyword #f "call")) (_o$3120 (keyword #f "type")) (_o$3121 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t)) (_o$3122 (keyword #f "pos")) (_o$3123 pos) (_o$3124 (keyword #f "msg")) (_o$3125 (jolt-invoke (var-deref "clojure.core" "str") "cannot call " (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t) " as a function"))) (jolt-hash-map _o$3118 _o$3119 _o$3120 _o$3121 _o$3122 _o$3123 _o$3124 _o$3125)))) (jolt-invoke _a$3126 _a$3127 _a$3128 _a$3129)) jolt-nil) (if (jolt-truthy? (let* ((and__13__auto (jolt-get env (keyword #f "strict?")))) (if (jolt-truthy? and__13__auto) iscall-var and__13__auto))) (let* ((k (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (usig (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "user-sigs"))) k))) (if (jolt-truthy? usig) (jolt-invoke (var-deref "jolt.passes.types" "check-user-call") k usig ats pos env) jolt-nil)) jolt-nil))) jolt-nil) (let* ((pm (let* ((and__13__auto iscall-var)) (if (jolt-truthy? and__13__auto) (let* ((_a$3130 (jolt-get env (keyword #f "protocol-methods"))) (_a$3131 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$3130 _a$3131)) and__13__auto))) (rtype (if (jolt-truthy? (let* ((and__13__auto pm)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (jolt-get (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)) (keyword #f "type")) jolt-nil)) (base (jolt-assoc node (keyword #f "fn") fnode_PRIME_ (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3132 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (let* ((_o$3140 (if (jolt= cn "range") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "num")) (if (jolt-truthy? (let* ((and__13__auto cn)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-contains? (var-deref "jolt.passes.types" "elem-fns") cn))) (if (jolt-truthy? and__13__auto) (> n 0) and__13__auto)) and__13__auto))) (let* ((a0 (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a0)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a0) (keyword #f "any"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil)))) (_o$3141 (if (jolt-truthy? rtype) (let* ((_a$3133 base) (_a$3134 (keyword #f "devirt-type")) (_a$3135 rtype) (_a$3136 (keyword #f "devirt-proto")) (_a$3137 (jolt-nth pm 0)) (_a$3138 (keyword #f "devirt-method")) (_a$3139 (jolt-nth pm 1))) (jolt-assoc _a$3133 _a$3134 _a$3135 _a$3136 _a$3137 _a$3138 _a$3139)) base))) (jolt-vector _o$3140 _o$3141))))))))) infer-call)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-invoke" (letrec ((infer-invoke (lambda (node tenv env) (let fnrec3118 ((node node) (tenv tenv) (env env)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (iscall-var (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op")))) (cn (if (jolt-truthy? (let* ((and__13__auto iscall-var)) (if (jolt-truthy? and__13__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__13__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (args (jolt-get node (keyword #f "args"))) (n (jolt-count args))) (if (jolt-truthy? (let* ((and__13__auto iscall-var)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-contains? (var-deref "jolt.passes.types" "fold-preds") cn))) (if (jolt-truthy? and__13__auto) (jolt= n 1) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-pred-fold") node fnode cn args tenv env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") fnode))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 1))) (if (jolt-truthy? and__13__auto) (<= n 2) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-kw-lookup") node fnode args n tenv env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") fnode))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get (jolt-nth args 1) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get (jolt-nth args 1) (keyword #f "val"))) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-get-lookup") node args n tenv env) (if (jolt-truthy? (let* ((and__13__auto (jolt= cn "reduce"))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-reduce-hof") node args n tenv env) (if (jolt-truthy? (let* ((and__13__auto cn)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-get (var-deref "jolt.passes.types" "hof-table") cn))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-seq-hof") node cn args tenv env) (if (jolt-truthy? (let* ((and__13__auto (let* ((or__14__auto (jolt= cn "conj"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= cn "into"))))) (if (jolt-truthy? and__13__auto) (>= n 1) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-conj-into") node fnode cn args n tenv env) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "infer-call") node fnode iscall-var cn args n tenv env) jolt-nil)))))))))))) infer-invoke)))
+  (def-var! "jolt.passes.types" "infer-invoke" (letrec ((infer-invoke (lambda (node tenv env) (let fnrec3142 ((node node) (tenv tenv) (env env)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (iscall-var (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op")))) (cn (if (jolt-truthy? (let* ((and__13__auto iscall-var)) (if (jolt-truthy? and__13__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__13__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (args (jolt-get node (keyword #f "args"))) (n (jolt-count args))) (if (jolt-truthy? (let* ((and__13__auto iscall-var)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-contains? (var-deref "jolt.passes.types" "fold-preds") cn))) (if (jolt-truthy? and__13__auto) (jolt= n 1) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-pred-fold") node fnode cn args tenv env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") fnode))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 1))) (if (jolt-truthy? and__13__auto) (<= n 2) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-kw-lookup") node fnode args n tenv env) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") fnode))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "const") (jolt-get (jolt-nth args 1) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get (jolt-nth args 1) (keyword #f "val"))) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-get-lookup") node args n tenv env) (if (jolt-truthy? (let* ((and__13__auto (jolt= cn "reduce"))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-reduce-hof") node args n tenv env) (if (jolt-truthy? (let* ((and__13__auto cn)) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-get (var-deref "jolt.passes.types" "hof-table") cn))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (>= n 2))) (if (jolt-truthy? and__13__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__13__auto)) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-seq-hof") node cn args tenv env) (if (jolt-truthy? (let* ((and__13__auto (let* ((or__14__auto (jolt= cn "conj"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= cn "into"))))) (if (jolt-truthy? and__13__auto) (>= n 1) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-conj-into") node fnode cn args n tenv env) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "infer-call") node fnode iscall-var cn args n tenv env) jolt-nil)))))))))))) infer-invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer" (letrec ((infer (lambda (node tenv env) (let fnrec3119 ((node node) (tenv tenv) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$3120 (let* ((v (jolt-get node (keyword #f "val")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (keyword #f "num") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (keyword #f "str") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (keyword #f "kw") (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= #f v)))) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (keyword #f "truthy") jolt-nil))))))) (_o$3121 node)) (jolt-vector _o$3120 _o$3121)) (if (jolt= op (keyword #f "local")) (let* ((t (jolt-get tenv (jolt-get node (keyword #f "name"))))) (let* ((_o$3122 (if (jolt-truthy? t) t (keyword #f "any"))) (_o$3123 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) (jolt-assoc n (keyword #f "shape") (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) n)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-assoc node (keyword #f "hint") (keyword #f "vector")) (if (jolt-truthy? (keyword #f "else")) node jolt-nil))))) (jolt-vector _o$3122 _o$3123))) (if (jolt= op (keyword #f "map")) (let* ((pairs (jolt-get node (keyword #f "pairs"))) (res (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (pr) (let fnrec3124 ((pr pr)) (let* ((kr (jolt-invoke infer (jolt-nth pr 0) tenv env)) (vr (jolt-invoke infer (jolt-nth pr 1) tenv env))) (let* ((_o$3125 (jolt-nth kr 1)) (_o$3126 (jolt-nth vr 1)) (_o$3127 (jolt-nth vr 0)) (_o$3128 (jolt-get (jolt-nth pr 0) (keyword #f "val")))) (jolt-vector _o$3125 _o$3126 _o$3127 _o$3128))))) pairs)) (struct? (let* ((and__13__auto (> (jolt-count res) 0))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec3129 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) pairs))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (r) (let fnrec3130 ((r r)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "truthy-type?") (jolt-nth r 2)))) res) and__13__auto)) and__13__auto))) (base (if (jolt-truthy? struct?) (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$3135 (lambda (m r) (let fnrec3131 ((m m) (r r)) (let* ((_a$3132 m) (_a$3133 (jolt-nth r 3)) (_a$3134 (jolt-nth r 2))) (jolt-assoc _a$3132 _a$3133 _a$3134))))) (_a$3136 (jolt-hash-map)) (_a$3137 res)) (jolt-reduce _a$3135 _a$3136 _a$3137))) (var-deref "jolt.passes.types.lattice" "type-depth")) jolt-nil)) (shp (if (jolt-truthy? (let* ((and__13__auto (jolt-get env (keyword #f "map-shapes?")))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto base)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") base) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "shape-order") (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") base))) jolt-nil)) (t (if (jolt-truthy? base) (if (jolt-truthy? shp) (jolt-assoc base (keyword #f "shape") shp) base) (keyword #f "any"))) (node_PRIME_ (jolt-assoc node (keyword #f "pairs") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3138 ((r r)) (let* ((_o$3139 (jolt-nth r 0)) (_o$3140 (jolt-nth r 1))) (jolt-vector _o$3139 _o$3140)))) res)))) (let* ((_o$3141 t) (_o$3142 (if (jolt-truthy? shp) (jolt-assoc node_PRIME_ (keyword #f "shape") shp) node_PRIME_))) (jolt-vector _o$3141 _o$3142))) (if (jolt= op (keyword #f "vector")) (let* ((irs (let* ((_a$3144 (var-deref "clojure.core" "mapv")) (_a$3145 (lambda (x) (let fnrec3143 ((x x)) (jolt-invoke infer x tenv env)))) (_a$3146 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$3144 _a$3145 _a$3146))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3147 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$3148 (var-deref "jolt.passes.types.lattice" "join")) (_a$3149 (jolt-first ets)) (_a$3150 (jolt-rest ets))) (jolt-reduce _a$3148 _a$3149 _a$3150))))) (let* ((_o$3152 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$3153 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3151 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$3152 _o$3153))) (if (jolt= op (keyword #f "set")) (let* ((irs (let* ((_a$3155 (var-deref "clojure.core" "mapv")) (_a$3156 (lambda (x) (let fnrec3154 ((x x)) (jolt-invoke infer x tenv env)))) (_a$3157 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$3155 _a$3156 _a$3157))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3158 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$3159 (var-deref "jolt.passes.types.lattice" "join")) (_a$3160 (jolt-first ets)) (_a$3161 (jolt-rest ets))) (jolt-reduce _a$3159 _a$3160 _a$3161))))) (let* ((_o$3163 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$3164 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3162 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$3163 _o$3164))) (if (jolt= op (keyword #f "if")) (let* ((tr (jolt-invoke infer (jolt-get node (keyword #f "test")) tenv env)) (thn (jolt-invoke infer (jolt-get node (keyword #f "then")) tenv env)) (els (jolt-invoke infer (jolt-get node (keyword #f "else")) tenv env))) (let* ((_o$3175 (let* ((_a$3165 (var-deref "jolt.passes.types.lattice" "join")) (_a$3166 (jolt-nth thn 0)) (_a$3167 (jolt-nth els 0))) (jolt-invoke _a$3165 _a$3166 _a$3167))) (_o$3176 (let* ((_a$3168 node) (_a$3169 (keyword #f "test")) (_a$3170 (jolt-nth tr 1)) (_a$3171 (keyword #f "then")) (_a$3172 (jolt-nth thn 1)) (_a$3173 (keyword #f "else")) (_a$3174 (jolt-nth els 1))) (jolt-assoc _a$3168 _a$3169 _a$3170 _a$3171 _a$3172 _a$3173 _a$3174)))) (jolt-vector _o$3175 _o$3176))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$3178 (var-deref "clojure.core" "mapv")) (_a$3179 (lambda (s) (let fnrec3177 ((s s)) (jolt-nth (jolt-invoke infer s tenv env) 1)))) (_a$3180 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$3178 _a$3179 _a$3180))) (r (jolt-invoke infer (jolt-get node (keyword #f "ret")) tenv env))) (let* ((_o$3181 (jolt-nth r 0)) (_o$3182 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$3181 _o$3182))) (if (jolt= op (keyword #f "throw")) (let* ((_o$3183 (keyword #f "any")) (_o$3184 (jolt-assoc node (keyword #f "expr") (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "expr")) tenv env) 1)))) (jolt-vector _o$3183 _o$3184)) (if (jolt= op (keyword #f "var")) (begin (let* ((_a$3185 (var-deref "clojure.core" "swap!")) (_a$3186 (jolt-get env (keyword #f "escapes"))) (_a$3187 jolt-conj) (_a$3188 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-invoke _a$3185 _a$3186 _a$3187 _a$3188)) (let* ((_o$3191 (let* ((vt (let* ((_a$3189 (jolt-get env (keyword #f "vtypes"))) (_a$3190 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-get _a$3189 _a$3190)))) (if (jolt-truthy? vt) vt (keyword #f "any")))) (_o$3192 node)) (jolt-vector _o$3191 _o$3192))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.types" "infer-invoke") node tenv env) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3203 (lambda (acc b) (let fnrec3193 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (jolt-invoke infer (jolt-nth b 1) te env))) (let* ((_o$3199 (let* ((_a$3194 te) (_a$3195 (jolt-nth b 0)) (_a$3196 (jolt-nth ir 0))) (jolt-assoc _a$3194 _a$3195 _a$3196))) (_o$3200 (jolt-conj binds (let* ((_o$3197 (jolt-nth b 0)) (_o$3198 (jolt-nth ir 1))) (jolt-vector _o$3197 _o$3198))))) (jolt-vector _o$3199 _o$3200)))))) (_a$3204 (let* ((_o$3201 tenv) (_o$3202 (jolt-vector))) (jolt-vector _o$3201 _o$3202))) (_a$3205 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3203 _a$3204 _a$3205))) (br (let* ((_a$3206 infer) (_a$3207 (jolt-get node (keyword #f "body"))) (_a$3208 (jolt-nth res 0)) (_a$3209 env)) (jolt-invoke _a$3206 _a$3207 _a$3208 _a$3209)))) (let* ((_o$3215 (jolt-nth br 0)) (_o$3216 (let* ((_a$3210 node) (_a$3211 (keyword #f "bindings")) (_a$3212 (jolt-nth res 1)) (_a$3213 (keyword #f "body")) (_a$3214 (jolt-nth br 1))) (jolt-assoc _a$3210 _a$3211 _a$3212 _a$3213 _a$3214)))) (jolt-vector _o$3215 _o$3216))) (if (jolt= op (keyword #f "loop")) (let* ((_o$3228 (keyword #f "any")) (_o$3229 (let* ((_a$3223 node) (_a$3224 (keyword #f "bindings")) (_a$3225 (let* ((_a$3220 (var-deref "clojure.core" "mapv")) (_a$3221 (lambda (b) (let fnrec3217 ((b b)) (let* ((_o$3218 (jolt-nth b 0)) (_o$3219 (jolt-nth (jolt-invoke infer (jolt-nth b 1) tenv env) 1))) (jolt-vector _o$3218 _o$3219))))) (_a$3222 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$3220 _a$3221 _a$3222))) (_a$3226 (keyword #f "body")) (_a$3227 (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "body")) tenv env) 1))) (jolt-assoc _a$3223 _a$3224 _a$3225 _a$3226 _a$3227)))) (jolt-vector _o$3228 _o$3229)) (if (jolt= op (keyword #f "recur")) (let* ((_o$3234 (keyword #f "any")) (_o$3235 (jolt-assoc node (keyword #f "args") (let* ((_a$3231 (var-deref "clojure.core" "mapv")) (_a$3232 (lambda (a) (let fnrec3230 ((a a)) (jolt-nth (jolt-invoke infer a tenv env) 1)))) (_a$3233 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$3231 _a$3232 _a$3233))))) (jolt-vector _o$3234 _o$3235)) (if (jolt= op (keyword #f "fn")) (let* ((_o$3251 (keyword #f "any")) (_o$3252 (jolt-assoc node (keyword #f "arities") (let* ((_a$3248 (var-deref "clojure.core" "mapv")) (_a$3249 (lambda (a) (let fnrec3236 ((a a)) (let* ((shapes (jolt-get env (keyword #f "record-shapes"))) (phm (let* ((_a$3241 (lambda (m pr) (let fnrec3237 ((m m) (pr pr)) (let* ((_a$3238 m) (_a$3239 (jolt-nth pr 0)) (_a$3240 (jolt-nth pr 1))) (jolt-assoc _a$3238 _a$3239 _a$3240))))) (_a$3242 (jolt-hash-map)) (_a$3243 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$3241 _a$3242 _a$3243))) (pe (let* ((_a$3245 (lambda (e p) (let fnrec3244 ((e e) (p p)) (jolt-assoc e p (let* ((ent (jolt-get shapes (jolt-get phm p)))) (if (jolt-truthy? ent) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") ent (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (keyword #f "any"))))))) (_a$3246 tenv) (_a$3247 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$3245 _a$3246 _a$3247))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe))) (jolt-assoc a (keyword #f "body") (jolt-nth (jolt-invoke infer (jolt-get a (keyword #f "body")) pe env) 1)))))) (_a$3250 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$3248 _a$3249 _a$3250))))) (jolt-vector _o$3251 _o$3252)) (if (jolt= op (keyword #f "def")) (begin (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (jolt-invoke (var-deref "jolt.passes.types.check" "register-user-fn!") node env) jolt-nil) (let* ((_o$3253 (keyword #f "any")) (_o$3254 (jolt-assoc node (keyword #f "init") (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "init")) tenv env) 1)))) (jolt-vector _o$3253 _o$3254))) (if (jolt= op (keyword #f "try")) (let* ((_o$3262 (keyword #f "any")) (_o$3263 (let* ((_a$3255 node) (_a$3256 (keyword #f "body")) (_a$3257 (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "body")) tenv env) 1)) (_a$3258 (keyword #f "catch-body")) (_a$3259 (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "catch-body")) tenv env) 1) jolt-nil)) (_a$3260 (keyword #f "finally")) (_a$3261 (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "finally")) tenv env) 1) jolt-nil))) (jolt-assoc _a$3255 _a$3256 _a$3257 _a$3258 _a$3259 _a$3260 _a$3261)))) (jolt-vector _o$3262 _o$3263)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3264 (keyword #f "any")) (_o$3265 node)) (jolt-vector _o$3264 _o$3265)) jolt-nil)))))))))))))))))))))) infer)))
+  (def-var! "jolt.passes.types" "infer" (letrec ((infer (lambda (node tenv env) (let fnrec3143 ((node node) (tenv tenv) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$3144 (let* ((v (jolt-get node (keyword #f "val")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (keyword #f "num") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (keyword #f "str") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (keyword #f "kw") (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") v))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= #f v)))) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (keyword #f "truthy") jolt-nil))))))) (_o$3145 node)) (jolt-vector _o$3144 _o$3145)) (if (jolt= op (keyword #f "local")) (let* ((t (jolt-get tenv (jolt-get node (keyword #f "name"))))) (let* ((_o$3146 (if (jolt-truthy? t) t (keyword #f "any"))) (_o$3147 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) (jolt-assoc n (keyword #f "shape") (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) n)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-assoc node (keyword #f "hint") (keyword #f "vector")) (if (jolt-truthy? (keyword #f "else")) node jolt-nil))))) (jolt-vector _o$3146 _o$3147))) (if (jolt= op (keyword #f "map")) (let* ((pairs (jolt-get node (keyword #f "pairs"))) (res (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (pr) (let fnrec3148 ((pr pr)) (let* ((kr (jolt-invoke infer (jolt-nth pr 0) tenv env)) (vr (jolt-invoke infer (jolt-nth pr 1) tenv env))) (let* ((_o$3149 (jolt-nth kr 1)) (_o$3150 (jolt-nth vr 1)) (_o$3151 (jolt-nth vr 0)) (_o$3152 (jolt-get (jolt-nth pr 0) (keyword #f "val")))) (jolt-vector _o$3149 _o$3150 _o$3151 _o$3152))))) pairs)) (struct? (let* ((and__13__auto (> (jolt-count res) 0))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec3153 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) pairs))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (r) (let fnrec3154 ((r r)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "truthy-type?") (jolt-nth r 2)))) res) and__13__auto)) and__13__auto))) (base (if (jolt-truthy? struct?) (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$3159 (lambda (m r) (let fnrec3155 ((m m) (r r)) (let* ((_a$3156 m) (_a$3157 (jolt-nth r 3)) (_a$3158 (jolt-nth r 2))) (jolt-assoc _a$3156 _a$3157 _a$3158))))) (_a$3160 (jolt-hash-map)) (_a$3161 res)) (jolt-reduce _a$3159 _a$3160 _a$3161))) (var-deref "jolt.passes.types.lattice" "type-depth")) jolt-nil)) (shp (if (jolt-truthy? (let* ((and__13__auto (jolt-get env (keyword #f "map-shapes?")))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto base)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") base) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "shape-order") (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") base))) jolt-nil)) (t (if (jolt-truthy? base) (if (jolt-truthy? shp) (jolt-assoc base (keyword #f "shape") shp) base) (keyword #f "any"))) (node_PRIME_ (jolt-assoc node (keyword #f "pairs") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3162 ((r r)) (let* ((_o$3163 (jolt-nth r 0)) (_o$3164 (jolt-nth r 1))) (jolt-vector _o$3163 _o$3164)))) res)))) (let* ((_o$3165 t) (_o$3166 (if (jolt-truthy? shp) (jolt-assoc node_PRIME_ (keyword #f "shape") shp) node_PRIME_))) (jolt-vector _o$3165 _o$3166))) (if (jolt= op (keyword #f "vector")) (let* ((irs (let* ((_a$3168 (var-deref "clojure.core" "mapv")) (_a$3169 (lambda (x) (let fnrec3167 ((x x)) (jolt-invoke infer x tenv env)))) (_a$3170 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$3168 _a$3169 _a$3170))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3171 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$3172 (var-deref "jolt.passes.types.lattice" "join")) (_a$3173 (jolt-first ets)) (_a$3174 (jolt-rest ets))) (jolt-reduce _a$3172 _a$3173 _a$3174))))) (let* ((_o$3176 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$3177 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3175 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$3176 _o$3177))) (if (jolt= op (keyword #f "set")) (let* ((irs (let* ((_a$3179 (var-deref "clojure.core" "mapv")) (_a$3180 (lambda (x) (let fnrec3178 ((x x)) (jolt-invoke infer x tenv env)))) (_a$3181 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$3179 _a$3180 _a$3181))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3182 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$3183 (var-deref "jolt.passes.types.lattice" "join")) (_a$3184 (jolt-first ets)) (_a$3185 (jolt-rest ets))) (jolt-reduce _a$3183 _a$3184 _a$3185))))) (let* ((_o$3187 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$3188 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec3186 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$3187 _o$3188))) (if (jolt= op (keyword #f "if")) (let* ((tr (jolt-invoke infer (jolt-get node (keyword #f "test")) tenv env)) (thn (jolt-invoke infer (jolt-get node (keyword #f "then")) tenv env)) (els (jolt-invoke infer (jolt-get node (keyword #f "else")) tenv env))) (let* ((_o$3199 (let* ((_a$3189 (var-deref "jolt.passes.types.lattice" "join")) (_a$3190 (jolt-nth thn 0)) (_a$3191 (jolt-nth els 0))) (jolt-invoke _a$3189 _a$3190 _a$3191))) (_o$3200 (let* ((_a$3192 node) (_a$3193 (keyword #f "test")) (_a$3194 (jolt-nth tr 1)) (_a$3195 (keyword #f "then")) (_a$3196 (jolt-nth thn 1)) (_a$3197 (keyword #f "else")) (_a$3198 (jolt-nth els 1))) (jolt-assoc _a$3192 _a$3193 _a$3194 _a$3195 _a$3196 _a$3197 _a$3198)))) (jolt-vector _o$3199 _o$3200))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$3202 (var-deref "clojure.core" "mapv")) (_a$3203 (lambda (s) (let fnrec3201 ((s s)) (jolt-nth (jolt-invoke infer s tenv env) 1)))) (_a$3204 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$3202 _a$3203 _a$3204))) (r (jolt-invoke infer (jolt-get node (keyword #f "ret")) tenv env))) (let* ((_o$3205 (jolt-nth r 0)) (_o$3206 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$3205 _o$3206))) (if (jolt= op (keyword #f "throw")) (let* ((_o$3207 (keyword #f "any")) (_o$3208 (jolt-assoc node (keyword #f "expr") (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "expr")) tenv env) 1)))) (jolt-vector _o$3207 _o$3208)) (if (jolt= op (keyword #f "var")) (begin (let* ((_a$3209 (var-deref "clojure.core" "swap!")) (_a$3210 (jolt-get env (keyword #f "escapes"))) (_a$3211 jolt-conj) (_a$3212 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-invoke _a$3209 _a$3210 _a$3211 _a$3212)) (let* ((_o$3215 (let* ((vt (let* ((_a$3213 (jolt-get env (keyword #f "vtypes"))) (_a$3214 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-get _a$3213 _a$3214)))) (if (jolt-truthy? vt) vt (keyword #f "any")))) (_o$3216 node)) (jolt-vector _o$3215 _o$3216))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.types" "infer-invoke") node tenv env) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$3227 (lambda (acc b) (let fnrec3217 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (jolt-invoke infer (jolt-nth b 1) te env))) (let* ((_o$3223 (let* ((_a$3218 te) (_a$3219 (jolt-nth b 0)) (_a$3220 (jolt-nth ir 0))) (jolt-assoc _a$3218 _a$3219 _a$3220))) (_o$3224 (jolt-conj binds (let* ((_o$3221 (jolt-nth b 0)) (_o$3222 (jolt-nth ir 1))) (jolt-vector _o$3221 _o$3222))))) (jolt-vector _o$3223 _o$3224)))))) (_a$3228 (let* ((_o$3225 tenv) (_o$3226 (jolt-vector))) (jolt-vector _o$3225 _o$3226))) (_a$3229 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$3227 _a$3228 _a$3229))) (br (let* ((_a$3230 infer) (_a$3231 (jolt-get node (keyword #f "body"))) (_a$3232 (jolt-nth res 0)) (_a$3233 env)) (jolt-invoke _a$3230 _a$3231 _a$3232 _a$3233)))) (let* ((_o$3239 (jolt-nth br 0)) (_o$3240 (let* ((_a$3234 node) (_a$3235 (keyword #f "bindings")) (_a$3236 (jolt-nth res 1)) (_a$3237 (keyword #f "body")) (_a$3238 (jolt-nth br 1))) (jolt-assoc _a$3234 _a$3235 _a$3236 _a$3237 _a$3238)))) (jolt-vector _o$3239 _o$3240))) (if (jolt= op (keyword #f "loop")) (let* ((_o$3252 (keyword #f "any")) (_o$3253 (let* ((_a$3247 node) (_a$3248 (keyword #f "bindings")) (_a$3249 (let* ((_a$3244 (var-deref "clojure.core" "mapv")) (_a$3245 (lambda (b) (let fnrec3241 ((b b)) (let* ((_o$3242 (jolt-nth b 0)) (_o$3243 (jolt-nth (jolt-invoke infer (jolt-nth b 1) tenv env) 1))) (jolt-vector _o$3242 _o$3243))))) (_a$3246 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$3244 _a$3245 _a$3246))) (_a$3250 (keyword #f "body")) (_a$3251 (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "body")) tenv env) 1))) (jolt-assoc _a$3247 _a$3248 _a$3249 _a$3250 _a$3251)))) (jolt-vector _o$3252 _o$3253)) (if (jolt= op (keyword #f "recur")) (let* ((_o$3258 (keyword #f "any")) (_o$3259 (jolt-assoc node (keyword #f "args") (let* ((_a$3255 (var-deref "clojure.core" "mapv")) (_a$3256 (lambda (a) (let fnrec3254 ((a a)) (jolt-nth (jolt-invoke infer a tenv env) 1)))) (_a$3257 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$3255 _a$3256 _a$3257))))) (jolt-vector _o$3258 _o$3259)) (if (jolt= op (keyword #f "fn")) (let* ((_o$3275 (keyword #f "any")) (_o$3276 (jolt-assoc node (keyword #f "arities") (let* ((_a$3272 (var-deref "clojure.core" "mapv")) (_a$3273 (lambda (a) (let fnrec3260 ((a a)) (let* ((shapes (jolt-get env (keyword #f "record-shapes"))) (phm (let* ((_a$3265 (lambda (m pr) (let fnrec3261 ((m m) (pr pr)) (let* ((_a$3262 m) (_a$3263 (jolt-nth pr 0)) (_a$3264 (jolt-nth pr 1))) (jolt-assoc _a$3262 _a$3263 _a$3264))))) (_a$3266 (jolt-hash-map)) (_a$3267 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$3265 _a$3266 _a$3267))) (pe (let* ((_a$3269 (lambda (e p) (let fnrec3268 ((e e) (p p)) (jolt-assoc e p (let* ((ent (jolt-get shapes (jolt-get phm p)))) (if (jolt-truthy? ent) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") ent (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (keyword #f "any"))))))) (_a$3270 tenv) (_a$3271 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$3269 _a$3270 _a$3271))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe))) (jolt-assoc a (keyword #f "body") (jolt-nth (jolt-invoke infer (jolt-get a (keyword #f "body")) pe env) 1)))))) (_a$3274 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$3272 _a$3273 _a$3274))))) (jolt-vector _o$3275 _o$3276)) (if (jolt= op (keyword #f "def")) (begin (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (jolt-invoke (var-deref "jolt.passes.types.check" "register-user-fn!") node env) jolt-nil) (let* ((_o$3277 (keyword #f "any")) (_o$3278 (jolt-assoc node (keyword #f "init") (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "init")) tenv env) 1)))) (jolt-vector _o$3277 _o$3278))) (if (jolt= op (keyword #f "try")) (let* ((_o$3286 (keyword #f "any")) (_o$3287 (let* ((_a$3279 node) (_a$3280 (keyword #f "body")) (_a$3281 (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "body")) tenv env) 1)) (_a$3282 (keyword #f "catch-body")) (_a$3283 (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "catch-body")) tenv env) 1) jolt-nil)) (_a$3284 (keyword #f "finally")) (_a$3285 (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-nth (jolt-invoke infer (jolt-get node (keyword #f "finally")) tenv env) 1) jolt-nil))) (jolt-assoc _a$3279 _a$3280 _a$3281 _a$3282 _a$3283 _a$3284 _a$3285)))) (jolt-vector _o$3286 _o$3287)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$3288 (keyword #f "any")) (_o$3289 node)) (jolt-vector _o$3288 _o$3289)) jolt-nil)))))))))))))))))))))) infer)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-top" (letrec ((infer-top (lambda (node env) (let fnrec3266 ((node node) (env env)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) 1))))) infer-top)))
+  (def-var! "jolt.passes.types" "infer-top" (letrec ((infer-top (lambda (node env) (let fnrec3290 ((node node) (env env)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) 1))))) infer-top)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "all-any-env" (letrec ((all-any-env (lambda (params) (let fnrec3267 ((params params)) (let* ((_a$3269 (lambda (e p) (let fnrec3268 ((e e) (p p)) (jolt-assoc e p (keyword #f "any"))))) (_a$3270 (jolt-hash-map)) (_a$3271 params)) (jolt-reduce _a$3269 _a$3270 _a$3271)))))) all-any-env)))
+  (def-var! "jolt.passes.types" "all-any-env" (letrec ((all-any-env (lambda (params) (let fnrec3291 ((params params)) (let* ((_a$3293 (lambda (e p) (let fnrec3292 ((e e) (p p)) (jolt-assoc e p (keyword #f "any"))))) (_a$3294 (jolt-hash-map)) (_a$3295 params)) (jolt-reduce _a$3293 _a$3294 _a$3295)))))) all-any-env)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "isolated-diag-count" (letrec ((isolated-diag-count (lambda (body tenv env) (let fnrec3272 ((body body) (tenv tenv) (env env)) (let* ((sub (jolt-assoc env (keyword #f "diags") (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv sub) (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get sub (keyword #f "diags")))))))))) isolated-diag-count)))
+  (def-var! "jolt.passes.types" "isolated-diag-count" (letrec ((isolated-diag-count (lambda (body tenv env) (let fnrec3296 ((body body) (tenv tenv) (env env)) (let* ((sub (jolt-assoc env (keyword #f "diags") (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv sub) (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get sub (keyword #f "diags")))))))))) isolated-diag-count)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "check-user-call" (letrec ((check-user-call (lambda (key sig arg-types pos env) (let fnrec3273 ((key key) (sig sig) (arg-types arg-types) (pos pos) (env env)) (let* ((cset (jolt-get env (keyword #f "checking-set")))) (if (jolt-not (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") cset) key)) (let* ((prev (jolt-invoke (var-deref "clojure.core" "deref") cset))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") cset (jolt-conj prev key)) (let* ((params (jolt-get sig (keyword #f "params"))) (body (jolt-get sig (keyword #f "body"))) (npar (jolt-count params)) (nargs (jolt-count arg-types)) (memo (jolt-get env (keyword #f "diag-memo")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") npar nargs)) (let* ((_a$3282 (var-deref "clojure.core" "swap!")) (_a$3283 (jolt-get env (keyword #f "diags"))) (_a$3284 jolt-conj) (_a$3285 (let* ((_o$3274 (keyword #f "op")) (_o$3275 (keyword #f "user-call")) (_o$3276 (keyword #f "type")) (_o$3277 (keyword #f "arity")) (_o$3278 (keyword #f "pos")) (_o$3279 pos) (_o$3280 (keyword #f "msg")) (_o$3281 (jolt-invoke (var-deref "clojure.core" "str") "wrong number of args (" nargs ") passed to `" (jolt-get sig (keyword #f "name")) "` (expected " npar ")"))) (jolt-hash-map _o$3274 _o$3275 _o$3276 _o$3277 _o$3278 _o$3279 _o$3280 _o$3281)))) (jolt-invoke _a$3282 _a$3283 _a$3284 _a$3285)) (let* ((base-env (jolt-invoke (var-deref "jolt.passes.types" "all-any-env") params)) (base (let* ((bk (let* ((_o$3286 (keyword #f "base")) (_o$3287 key)) (jolt-vector _o$3286 _o$3287)))) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (let* ((b (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body base-env env))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc bk b) b)))))) (let* ((_a$3315 (lambda (_ i) (let fnrec3288 ((_ _) (i i)) (begin (let* ((at (jolt-nth arg-types i))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "any")))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "truthy")) and__13__auto))) (let* ((mk (let* ((_o$3289 (keyword #f "arg")) (_o$3290 key) (_o$3291 i) (_o$3292 at)) (jolt-vector _o$3289 _o$3290 _o$3291 _o$3292))) (rejects (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (let* ((r (> (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body (jolt-assoc base-env (jolt-nth params i) at) env) base))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc mk r) r))))) (if (jolt-truthy? rejects) (let* ((_a$3311 (var-deref "clojure.core" "swap!")) (_a$3312 (jolt-get env (keyword #f "diags"))) (_a$3313 jolt-conj) (_a$3314 (let* ((_o$3301 (keyword #f "op")) (_o$3302 (keyword #f "user-call")) (_o$3303 (keyword #f "argpos")) (_o$3304 i) (_o$3305 (keyword #f "type")) (_o$3306 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_o$3307 (keyword #f "pos")) (_o$3308 pos) (_o$3309 (keyword #f "msg")) (_o$3310 (let* ((_a$3293 (var-deref "clojure.core" "str")) (_a$3294 "argument ") (_a$3295 (jolt-inc i)) (_a$3296 " to `") (_a$3297 (jolt-get sig (keyword #f "name"))) (_a$3298 "` is ") (_a$3299 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_a$3300 ", which its body provably rejects")) (jolt-invoke _a$3293 _a$3294 _a$3295 _a$3296 _a$3297 _a$3298 _a$3299 _a$3300)))) (jolt-hash-map _o$3301 _o$3302 _o$3303 _o$3304 _o$3305 _o$3306 _o$3307 _o$3308 _o$3309 _o$3310)))) (jolt-invoke _a$3311 _a$3312 _a$3313 _a$3314)) jolt-nil)) jolt-nil)) jolt-nil)))) (_a$3316 jolt-nil) (_a$3317 (jolt-range npar))) (jolt-reduce _a$3315 _a$3316 _a$3317))))) (jolt-invoke (var-deref "clojure.core" "reset!") cset prev))) jolt-nil)))))) check-user-call)))
+  (def-var! "jolt.passes.types" "check-user-call" (letrec ((check-user-call (lambda (key sig arg-types pos env) (let fnrec3297 ((key key) (sig sig) (arg-types arg-types) (pos pos) (env env)) (let* ((cset (jolt-get env (keyword #f "checking-set")))) (if (jolt-not (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") cset) key)) (let* ((prev (jolt-invoke (var-deref "clojure.core" "deref") cset))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") cset (jolt-conj prev key)) (let* ((params (jolt-get sig (keyword #f "params"))) (body (jolt-get sig (keyword #f "body"))) (npar (jolt-count params)) (nargs (jolt-count arg-types)) (memo (jolt-get env (keyword #f "diag-memo")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") npar nargs)) (let* ((_a$3306 (var-deref "clojure.core" "swap!")) (_a$3307 (jolt-get env (keyword #f "diags"))) (_a$3308 jolt-conj) (_a$3309 (let* ((_o$3298 (keyword #f "op")) (_o$3299 (keyword #f "user-call")) (_o$3300 (keyword #f "type")) (_o$3301 (keyword #f "arity")) (_o$3302 (keyword #f "pos")) (_o$3303 pos) (_o$3304 (keyword #f "msg")) (_o$3305 (jolt-invoke (var-deref "clojure.core" "str") "wrong number of args (" nargs ") passed to `" (jolt-get sig (keyword #f "name")) "` (expected " npar ")"))) (jolt-hash-map _o$3298 _o$3299 _o$3300 _o$3301 _o$3302 _o$3303 _o$3304 _o$3305)))) (jolt-invoke _a$3306 _a$3307 _a$3308 _a$3309)) (let* ((base-env (jolt-invoke (var-deref "jolt.passes.types" "all-any-env") params)) (base (let* ((bk (let* ((_o$3310 (keyword #f "base")) (_o$3311 key)) (jolt-vector _o$3310 _o$3311)))) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (let* ((b (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body base-env env))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc bk b) b)))))) (let* ((_a$3339 (lambda (_ i) (let fnrec3312 ((_ _) (i i)) (begin (let* ((at (jolt-nth arg-types i))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "any")))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "truthy")) and__13__auto))) (let* ((mk (let* ((_o$3313 (keyword #f "arg")) (_o$3314 key) (_o$3315 i) (_o$3316 at)) (jolt-vector _o$3313 _o$3314 _o$3315 _o$3316))) (rejects (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (let* ((r (> (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body (jolt-assoc base-env (jolt-nth params i) at) env) base))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc mk r) r))))) (if (jolt-truthy? rejects) (let* ((_a$3335 (var-deref "clojure.core" "swap!")) (_a$3336 (jolt-get env (keyword #f "diags"))) (_a$3337 jolt-conj) (_a$3338 (let* ((_o$3325 (keyword #f "op")) (_o$3326 (keyword #f "user-call")) (_o$3327 (keyword #f "argpos")) (_o$3328 i) (_o$3329 (keyword #f "type")) (_o$3330 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_o$3331 (keyword #f "pos")) (_o$3332 pos) (_o$3333 (keyword #f "msg")) (_o$3334 (let* ((_a$3317 (var-deref "clojure.core" "str")) (_a$3318 "argument ") (_a$3319 (jolt-inc i)) (_a$3320 " to `") (_a$3321 (jolt-get sig (keyword #f "name"))) (_a$3322 "` is ") (_a$3323 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_a$3324 ", which its body provably rejects")) (jolt-invoke _a$3317 _a$3318 _a$3319 _a$3320 _a$3321 _a$3322 _a$3323 _a$3324)))) (jolt-hash-map _o$3325 _o$3326 _o$3327 _o$3328 _o$3329 _o$3330 _o$3331 _o$3332 _o$3333 _o$3334)))) (jolt-invoke _a$3335 _a$3336 _a$3337 _a$3338)) jolt-nil)) jolt-nil)) jolt-nil)))) (_a$3340 jolt-nil) (_a$3341 (jolt-range npar))) (jolt-reduce _a$3339 _a$3340 _a$3341))))) (jolt-invoke (var-deref "clojure.core" "reset!") cset prev))) jolt-nil)))))) check-user-call)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "set-rtenv!" (letrec ((set-rtenv! (lambda (m) (let fnrec3318 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "rtenv") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-rtenv!)))
+  (def-var! "jolt.passes.types" "set-rtenv!" (letrec ((set-rtenv! (lambda (m) (let fnrec3342 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "rtenv") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-rtenv!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "set-record-shapes!" (letrec ((set-record-shapes! (lambda (m) (let fnrec3319 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "record-shapes") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-record-shapes!)))
+  (def-var! "jolt.passes.types" "set-record-shapes!" (letrec ((set-record-shapes! (lambda (m) (let fnrec3343 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "record-shapes") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-record-shapes!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "set-protocol-methods!" (letrec ((set-protocol-methods! (lambda (m) (let fnrec3320 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "protocol-methods") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-protocol-methods!)))
+  (def-var! "jolt.passes.types" "set-protocol-methods!" (letrec ((set-protocol-methods! (lambda (m) (let fnrec3344 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "protocol-methods") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-protocol-methods!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "set-map-shapes!" (letrec ((set-map-shapes! (lambda (b) (let fnrec3321 ((b b)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "map-shapes?") (jolt-invoke (var-deref "clojure.core" "boolean") b)))))) set-map-shapes!)))
+  (def-var! "jolt.passes.types" "set-map-shapes!" (letrec ((set-map-shapes! (lambda (b) (let fnrec3345 ((b b)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "map-shapes?") (jolt-invoke (var-deref "clojure.core" "boolean") b)))))) set-map-shapes!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "set-vtypes!" (letrec ((set-vtypes! (lambda (m) (let fnrec3322 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "vtypes") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-vtypes!)))
+  (def-var! "jolt.passes.types" "set-vtypes!" (letrec ((set-vtypes! (lambda (m) (let fnrec3346 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "vtypes") (let* ((or__14__auto m)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map)))))))) set-vtypes!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "join-types" (letrec ((join-types (lambda (a b) (let fnrec3323 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join-types)))
+  (def-var! "jolt.passes.types" "join-types" (letrec ((join-types (lambda (a b) (let fnrec3347 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join-types)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "reset-escapes!" (letrec ((reset-escapes! (lambda () (let fnrec3324 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "escapes-box") (jolt-hash-set)))))) reset-escapes!)))
+  (def-var! "jolt.passes.types" "reset-escapes!" (letrec ((reset-escapes! (lambda () (let fnrec3348 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "escapes-box") (jolt-hash-set)))))) reset-escapes!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "collected-escapes" (letrec ((collected-escapes (lambda () (let fnrec3325 () (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "escapes-box"))))))) collected-escapes)))
+  (def-var! "jolt.passes.types" "collected-escapes" (letrec ((collected-escapes (lambda () (let fnrec3349 () (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "escapes-box"))))))) collected-escapes)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "check-form" (letrec ((check-form (case-lambda ((node) (let fnrec3326 ((node node)) (jolt-invoke check-form node #f))) ((node strict?) (let fnrec3327 ((node node) (strict? strict?)) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #t strict?))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "diags"))))))))))) check-form)))
+  (def-var! "jolt.passes.types" "check-form" (letrec ((check-form (case-lambda ((node) (let fnrec3350 ((node node)) (jolt-invoke check-form node #f))) ((node strict?) (let fnrec3351 ((node node) (strict? strict?)) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #t strict?))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "diags"))))))))))) check-form)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "infer-body" (letrec ((infer-body (lambda (body tenv) (let fnrec3328 ((body body) (tenv tenv)) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f)) (r (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv env))) (let* ((_o$3329 (jolt-nth r 0)) (_o$3330 (jolt-nth r 1)) (_o$3331 (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "calls"))))) (jolt-vector _o$3329 _o$3330 _o$3331))))))) infer-body)))
+  (def-var! "jolt.passes.types" "infer-body" (letrec ((infer-body (lambda (body tenv) (let fnrec3352 ((body body) (tenv tenv)) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f)) (r (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv env))) (let* ((_o$3353 (jolt-nth r 0)) (_o$3354 (jolt-nth r 1)) (_o$3355 (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "calls"))))) (jolt-vector _o$3353 _o$3354 _o$3355))))))) infer-body)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "reinfer-def" (letrec ((reinfer-def (lambda (def-node ptmap) (let fnrec3332 ((def-node def-node) (ptmap ptmap)) (let* ((fnode (jolt-get def-node (keyword #f "init"))) (env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f)) (shapes (jolt-get env (keyword #f "record-shapes")))) (if (jolt= (keyword #f "fn") (jolt-get fnode (keyword #f "op"))) (jolt-assoc def-node (keyword #f "init") (jolt-assoc fnode (keyword #f "arities") (let* ((_a$3338 (var-deref "clojure.core" "mapv")) (_a$3339 (lambda (a) (let fnrec3333 ((a a)) (let* ((pt (let* ((_a$3335 (lambda (m pr) (let fnrec3334 ((m m) (pr pr)) (let* ((nm (jolt-nth pr 0)) (e (jolt-get shapes (jolt-nth pr 1)))) (if (jolt-truthy? (let* ((and__13__auto e)) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-contains? m nm)) and__13__auto))) (jolt-assoc m nm (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e (var-deref "jolt.passes.types.lattice" "type-depth") shapes)) m))))) (_a$3336 ptmap) (_a$3337 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$3335 _a$3336 _a$3337)))) (jolt-assoc a (keyword #f "body") (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pt env) 1)))))) (_a$3340 (jolt-get fnode (keyword #f "arities")))) (jolt-invoke _a$3338 _a$3339 _a$3340)))) def-node)))))) reinfer-def)))
+  (def-var! "jolt.passes.types" "reinfer-def" (letrec ((reinfer-def (lambda (def-node ptmap) (let fnrec3356 ((def-node def-node) (ptmap ptmap)) (let* ((fnode (jolt-get def-node (keyword #f "init"))) (env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f)) (shapes (jolt-get env (keyword #f "record-shapes")))) (if (jolt= (keyword #f "fn") (jolt-get fnode (keyword #f "op"))) (jolt-assoc def-node (keyword #f "init") (jolt-assoc fnode (keyword #f "arities") (let* ((_a$3362 (var-deref "clojure.core" "mapv")) (_a$3363 (lambda (a) (let fnrec3357 ((a a)) (let* ((pt (let* ((_a$3359 (lambda (m pr) (let fnrec3358 ((m m) (pr pr)) (let* ((nm (jolt-nth pr 0)) (e (jolt-get shapes (jolt-nth pr 1)))) (if (jolt-truthy? (let* ((and__13__auto e)) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-contains? m nm)) and__13__auto))) (jolt-assoc m nm (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e (var-deref "jolt.passes.types.lattice" "type-depth") shapes)) m))))) (_a$3360 ptmap) (_a$3361 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$3359 _a$3360 _a$3361)))) (jolt-assoc a (keyword #f "body") (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pt env) 1)))))) (_a$3364 (jolt-get fnode (keyword #f "arities")))) (jolt-invoke _a$3362 _a$3363 _a$3364)))) def-node)))))) reinfer-def)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "phint-seed" (letrec ((phint-seed (lambda (params phints) (let fnrec3341 ((params params) (phints phints)) (let* ((shapes (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "config-box")) (keyword #f "record-shapes"))) (m (let* ((_a$3346 (lambda (acc pr) (let fnrec3342 ((acc acc) (pr pr)) (let* ((_a$3343 acc) (_a$3344 (jolt-nth pr 0)) (_a$3345 (jolt-nth pr 1))) (jolt-assoc _a$3343 _a$3344 _a$3345))))) (_a$3347 (jolt-hash-map)) (_a$3348 phints)) (jolt-reduce _a$3346 _a$3347 _a$3348)))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nm) (let fnrec3349 ((nm nm)) (let* ((ck (jolt-get m nm)) (e (let* ((and__13__auto ck)) (if (jolt-truthy? and__13__auto) (jolt-get shapes ck) and__13__auto)))) (if (jolt-truthy? e) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e (var-deref "jolt.passes.types.lattice" "type-depth") shapes) jolt-nil)))) params)))))) phint-seed)))
+  (def-var! "jolt.passes.types" "phint-seed" (letrec ((phint-seed (lambda (params phints) (let fnrec3365 ((params params) (phints phints)) (let* ((shapes (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "config-box")) (keyword #f "record-shapes"))) (m (let* ((_a$3370 (lambda (acc pr) (let fnrec3366 ((acc acc) (pr pr)) (let* ((_a$3367 acc) (_a$3368 (jolt-nth pr 0)) (_a$3369 (jolt-nth pr 1))) (jolt-assoc _a$3367 _a$3368 _a$3369))))) (_a$3371 (jolt-hash-map)) (_a$3372 phints)) (jolt-reduce _a$3370 _a$3371 _a$3372)))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nm) (let fnrec3373 ((nm nm)) (let* ((ck (jolt-get m nm)) (e (let* ((and__13__auto ck)) (if (jolt-truthy? and__13__auto) (jolt-get shapes ck) and__13__auto)))) (if (jolt-truthy? e) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e (var-deref "jolt.passes.types.lattice" "type-depth") shapes) jolt-nil)))) params)))))) phint-seed)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "set-check-mode!" (letrec ((set-check-mode! (lambda (on strict?) (let fnrec3350 ((on on) (strict? strict?)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "check-mode-box") (let* ((_o$3351 (keyword #f "on")) (_o$3352 (if (jolt-truthy? on) #t #f)) (_o$3353 (keyword #f "strict")) (_o$3354 (if (jolt-truthy? strict?) #t #f))) (jolt-hash-map _o$3351 _o$3352 _o$3353 _o$3354))))))) set-check-mode!)))
+  (def-var! "jolt.passes.types" "set-check-mode!" (letrec ((set-check-mode! (lambda (on strict?) (let fnrec3374 ((on on) (strict? strict?)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "check-mode-box") (let* ((_o$3375 (keyword #f "on")) (_o$3376 (if (jolt-truthy? on) #t #f)) (_o$3377 (keyword #f "strict")) (_o$3378 (if (jolt-truthy? strict?) #t #f))) (jolt-hash-map _o$3375 _o$3376 _o$3377 _o$3378))))))) set-check-mode!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "take-diags!" (letrec ((take-diags! (lambda () (let fnrec3355 () (let* ((d (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "last-diags-box")))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "last-diags-box") (jolt-vector)) d)))))) take-diags!)))
+  (def-var! "jolt.passes.types" "take-diags!" (letrec ((take-diags! (lambda () (let fnrec3379 () (let* ((d (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "last-diags-box")))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "last-diags-box") (jolt-vector)) d)))))) take-diags!)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.types" "run-inference" (letrec ((run-inference (lambda (opt) (let fnrec3356 ((opt opt)) (if (jolt-truthy? (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "check-mode-box")) (keyword #f "on"))) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #t (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "check-mode-box")) (keyword #f "strict")))) (r (jolt-invoke (var-deref "jolt.passes.types" "infer-top") opt env))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "last-diags-box") (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "diags")))) r)) (jolt-invoke (var-deref "jolt.passes.types" "infer-top") opt (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f))))))) run-inference)))
+  (def-var! "jolt.passes.types" "run-inference" (letrec ((run-inference (lambda (opt) (let fnrec3380 ((opt opt)) (if (jolt-truthy? (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "check-mode-box")) (keyword #f "on"))) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #t (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "check-mode-box")) (keyword #f "strict")))) (r (jolt-invoke (var-deref "jolt.passes.types" "infer-top") opt env))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "last-diags-box") (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "diags")))) r)) (jolt-invoke (var-deref "jolt.passes.types" "infer-top") opt (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f))))))) run-inference)))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes" "inline-fixpoint-cap" 8 (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes" "inline-eligible?" (letrec ((inline-eligible? (lambda (node) (let fnrec3357 ((node node)) (let* ((and__13__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-get node (keyword #f "init")))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 1 (jolt-count (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities")))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-get (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))) (keyword #f "rest"))) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto)))))) inline-eligible?)))
+  (def-var! "jolt.passes" "inline-eligible?" (letrec ((inline-eligible? (lambda (node) (let fnrec3381 ((node node)) (let* ((and__13__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-get node (keyword #f "init")))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op"))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= 1 (jolt-count (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities")))))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-get (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))) (keyword #f "rest"))) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto)))))) inline-eligible?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes" "stash-of" (letrec ((stash-of (lambda (node) (let fnrec3358 ((node node)) (let* ((a (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))))) (let* ((_o$3359 (keyword #f "params")) (_o$3360 (jolt-get a (keyword #f "params"))) (_o$3361 (keyword #f "body")) (_o$3362 (jolt-get a (keyword #f "body"))) (_o$3363 (keyword #f "nhints")) (_o$3364 (jolt-get a (keyword #f "nhints"))) (_o$3365 (keyword #f "ret")) (_o$3366 (jolt-get a (keyword #f "ret-nhint")))) (jolt-hash-map _o$3359 _o$3360 _o$3361 _o$3362 _o$3363 _o$3364 _o$3365 _o$3366))))))) stash-of)))
+  (def-var! "jolt.passes" "stash-of" (letrec ((stash-of (lambda (node) (let fnrec3382 ((node node)) (let* ((a (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))))) (let* ((_o$3383 (keyword #f "params")) (_o$3384 (jolt-get a (keyword #f "params"))) (_o$3385 (keyword #f "body")) (_o$3386 (jolt-get a (keyword #f "body"))) (_o$3387 (keyword #f "nhints")) (_o$3388 (jolt-get a (keyword #f "nhints"))) (_o$3389 (keyword #f "ret")) (_o$3390 (jolt-get a (keyword #f "ret-nhint")))) (jolt-hash-map _o$3383 _o$3384 _o$3385 _o$3386 _o$3387 _o$3388 _o$3389 _o$3390))))))) stash-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes" "run-passes" (letrec ((run-passes (lambda (node ctx) (let fnrec3367 ((node node) (ctx ctx)) (begin (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "inline-enabled?") ctx))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes" "inline-eligible?") node) and__13__auto))) (let* ((_a$3368 (var-deref "jolt.host" "stash-inline!")) (_a$3369 ctx) (_a$3370 (jolt-get node (keyword #f "ns"))) (_a$3371 (jolt-get node (keyword #f "name"))) (_a$3372 (jolt-invoke (var-deref "jolt.passes" "stash-of") node))) (jolt-invoke _a$3368 _a$3369 _a$3370 _a$3371 _a$3372)) jolt-nil) (jolt-invoke (var-deref "jolt.passes.numeric" "annotate") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "inline-enabled?") ctx)) (let* ((_ (jolt-invoke (var-deref "jolt.passes.inline" "set-rec-shapes!") (jolt-invoke (var-deref "jolt.host" "record-shapes") ctx))) (_ (jolt-invoke (var-deref "jolt.passes.types" "set-record-shapes!") (jolt-invoke (var-deref "jolt.host" "record-shapes") ctx))) (opt (let* ((i 0) (n (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node))) (let loop3373 ((i i) (n n)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #f) (let* ((n2 (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (jolt-invoke (var-deref "jolt.passes.inline" "scalar-replace") (jolt-invoke (var-deref "jolt.passes.inline" "flatten-lets") (jolt-invoke (var-deref "jolt.passes.inline" "inline-node") n ctx)))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "dirty")))) (if (jolt-truthy? and__13__auto) (< i (var-deref "jolt.passes" "inline-fixpoint-cap")) and__13__auto))) (loop3373 (jolt-inc i) n2) n2))))))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (jolt-invoke (var-deref "jolt.passes.types" "run-inference") opt))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node)))))))) run-passes)))
\ No newline at end of file
+  (def-var! "jolt.passes" "run-passes" (letrec ((run-passes (lambda (node ctx) (let fnrec3391 ((node node) (ctx ctx)) (begin (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "jolt.host" "inline-enabled?") ctx))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "jolt.passes" "inline-eligible?") node) and__13__auto))) (let* ((_a$3392 (var-deref "jolt.host" "stash-inline!")) (_a$3393 ctx) (_a$3394 (jolt-get node (keyword #f "ns"))) (_a$3395 (jolt-get node (keyword #f "name"))) (_a$3396 (jolt-invoke (var-deref "jolt.passes" "stash-of") node))) (jolt-invoke _a$3392 _a$3393 _a$3394 _a$3395 _a$3396)) jolt-nil) (jolt-invoke (var-deref "jolt.passes.numeric" "annotate") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "inline-enabled?") ctx)) (let* ((_ (jolt-invoke (var-deref "jolt.passes.inline" "set-rec-shapes!") (jolt-invoke (var-deref "jolt.host" "record-shapes") ctx))) (_ (jolt-invoke (var-deref "jolt.passes.types" "set-record-shapes!") (jolt-invoke (var-deref "jolt.host" "record-shapes") ctx))) (opt (let* ((i 0) (n (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node))) (let loop3397 ((i i) (n n)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #f) (let* ((n2 (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (jolt-invoke (var-deref "jolt.passes.inline" "scalar-replace") (jolt-invoke (var-deref "jolt.passes.inline" "flatten-lets") (jolt-invoke (var-deref "jolt.passes.inline" "inline-node") n ctx)))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "dirty")))) (if (jolt-truthy? and__13__auto) (< i (var-deref "jolt.passes" "inline-fixpoint-cap")) and__13__auto))) (loop3397 (jolt-inc i) n2) n2))))))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (jolt-invoke (var-deref "jolt.passes.types" "run-inference") opt))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node)))))))) run-passes)))
\ No newline at end of file
diff --git a/host/chez/seed/prelude.ss b/host/chez/seed/prelude.ss
index 50b3168..dd6969e 100644
--- a/host/chez/seed/prelude.ss
+++ b/host/chez/seed/prelude.ss
@@ -1,497 +1,497 @@
 (guard (e (#t #f))
-  (def-var! "clojure.core" "zero?" (letrec ((zero? (lambda (x) (let fnrec2318 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt= x 0) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "zero? requires a number, got: " x))))))) zero?)))
+  (def-var! "clojure.core" "zero?" (letrec ((zero? (lambda (x) (let fnrec2342 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt= x 0) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "zero? requires a number, got: " x))))))) zero?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pos?" (letrec ((pos? (lambda (x) (let fnrec2319 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (> x 0) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "pos? requires a number, got: " x))))))) pos?)))
+  (def-var! "clojure.core" "pos?" (letrec ((pos? (lambda (x) (let fnrec2343 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (> x 0) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "pos? requires a number, got: " x))))))) pos?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "every?" (letrec ((every? (lambda (pred coll) (let fnrec2320 ((pred pred) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))) #t (if (jolt-truthy? (jolt-invoke pred (jolt-first coll))) (fnrec2320 pred (jolt-next coll)) #f)))))) every?)))
+  (def-var! "clojure.core" "every?" (letrec ((every? (lambda (pred coll) (let fnrec2344 ((pred pred) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))) #t (if (jolt-truthy? (jolt-invoke pred (jolt-first coll))) (fnrec2344 pred (jolt-next coll)) #f)))))) every?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "empty?" (letrec ((empty? (lambda (coll) (let fnrec2321 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) #t (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (jolt-zero? (jolt-count coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (jolt-zero? (jolt-count coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") coll)) (jolt-zero? (jolt-count coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") coll)) (jolt-zero? (jolt-count coll)) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))))))))))) empty?)))
+  (def-var! "clojure.core" "empty?" (letrec ((empty? (lambda (coll) (let fnrec2345 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) #t (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (jolt-zero? (jolt-count coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (jolt-zero? (jolt-count coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") coll)) (jolt-zero? (jolt-count coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") coll)) (jolt-zero? (jolt-count coll)) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))))))))))) empty?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "keys" (letrec ((keys (lambda (m) (let fnrec2322 ((m m)) (let* ((s (jolt-seq m))) (if (jolt-truthy? s) (jolt-map (lambda (e) (let fnrec2323 ((e e)) (jolt-nth e 0))) s) jolt-nil)))))) keys)))
+  (def-var! "clojure.core" "keys" (letrec ((keys (lambda (m) (let fnrec2346 ((m m)) (let* ((s (jolt-seq m))) (if (jolt-truthy? s) (jolt-map (lambda (e) (let fnrec2347 ((e e)) (jolt-nth e 0))) s) jolt-nil)))))) keys)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "vals" (letrec ((vals (lambda (m) (let fnrec2324 ((m m)) (let* ((s (jolt-seq m))) (if (jolt-truthy? s) (jolt-map (lambda (e) (let fnrec2325 ((e e)) (jolt-nth e 1))) s) jolt-nil)))))) vals)))
+  (def-var! "clojure.core" "vals" (letrec ((vals (lambda (m) (let fnrec2348 ((m m)) (let* ((s (jolt-seq m))) (if (jolt-truthy? s) (jolt-map (lambda (e) (let fnrec2349 ((e e)) (jolt-nth e 1))) s) jolt-nil)))))) vals)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "when"
-    (lambda (test . body) (let fnrec2326 ((test test) (body (list->cseq body))) (let* ((_a$2327 (var-deref "clojure.core" "__sqcat")) (_a$2328 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2329 (jolt-invoke (var-deref "clojure.core" "__sq1") test)) (_a$2330 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))) (jolt-invoke _a$2327 _a$2328 _a$2329 _a$2330)))))
+    (lambda (test . body) (let fnrec2350 ((test test) (body (list->cseq body))) (let* ((_a$2351 (var-deref "clojure.core" "__sqcat")) (_a$2352 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2353 (jolt-invoke (var-deref "clojure.core" "__sq1") test)) (_a$2354 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))) (jolt-invoke _a$2351 _a$2352 _a$2353 _a$2354)))))
   (mark-macro! "clojure.core" "when"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "when-not"
-    (lambda (test . body) (let fnrec2331 ((test test) (body (list->cseq body))) (let* ((_a$2335 (var-deref "clojure.core" "__sqcat")) (_a$2336 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2337 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2332 (var-deref "clojure.core" "__sqcat")) (_a$2333 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "not"))) (_a$2334 (jolt-invoke (var-deref "clojure.core" "__sq1") test))) (jolt-invoke _a$2332 _a$2333 _a$2334)))) (_a$2338 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))) (jolt-invoke _a$2335 _a$2336 _a$2337 _a$2338)))))
+    (lambda (test . body) (let fnrec2355 ((test test) (body (list->cseq body))) (let* ((_a$2359 (var-deref "clojure.core" "__sqcat")) (_a$2360 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2361 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2356 (var-deref "clojure.core" "__sqcat")) (_a$2357 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "not"))) (_a$2358 (jolt-invoke (var-deref "clojure.core" "__sq1") test))) (jolt-invoke _a$2356 _a$2357 _a$2358)))) (_a$2362 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))) (jolt-invoke _a$2359 _a$2360 _a$2361 _a$2362)))))
   (mark-macro! "clojure.core" "when-not"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "and"
-    (lambda exprs (let fnrec2339 ((exprs (list->cseq exprs))) (if (jolt-empty? exprs) #t (if (jolt-empty? (jolt-rest exprs)) (jolt-first exprs) (let* ((_a$2351 (var-deref "clojure.core" "__sqcat")) (_a$2352 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2353 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2340 (var-deref "clojure.core" "__sqvec")) (_a$2341 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "and__13__auto"))) (_a$2342 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first exprs)))) (jolt-invoke _a$2340 _a$2341 _a$2342)))) (_a$2354 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2346 (var-deref "clojure.core" "__sqcat")) (_a$2347 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2348 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "and__13__auto"))) (_a$2349 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2343 (var-deref "clojure.core" "__sqcat")) (_a$2344 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "and"))) (_a$2345 (jolt-rest exprs))) (jolt-invoke _a$2343 _a$2344 _a$2345)))) (_a$2350 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "and__13__auto")))) (jolt-invoke _a$2346 _a$2347 _a$2348 _a$2349 _a$2350))))) (jolt-invoke _a$2351 _a$2352 _a$2353 _a$2354)))))))
+    (lambda exprs (let fnrec2363 ((exprs (list->cseq exprs))) (if (jolt-empty? exprs) #t (if (jolt-empty? (jolt-rest exprs)) (jolt-first exprs) (let* ((_a$2375 (var-deref "clojure.core" "__sqcat")) (_a$2376 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2377 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2364 (var-deref "clojure.core" "__sqvec")) (_a$2365 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "and__13__auto"))) (_a$2366 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first exprs)))) (jolt-invoke _a$2364 _a$2365 _a$2366)))) (_a$2378 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2370 (var-deref "clojure.core" "__sqcat")) (_a$2371 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2372 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "and__13__auto"))) (_a$2373 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2367 (var-deref "clojure.core" "__sqcat")) (_a$2368 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "and"))) (_a$2369 (jolt-rest exprs))) (jolt-invoke _a$2367 _a$2368 _a$2369)))) (_a$2374 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "and__13__auto")))) (jolt-invoke _a$2370 _a$2371 _a$2372 _a$2373 _a$2374))))) (jolt-invoke _a$2375 _a$2376 _a$2377 _a$2378)))))))
   (mark-macro! "clojure.core" "and"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "or"
-    (lambda exprs (let fnrec2355 ((exprs (list->cseq exprs))) (if (jolt-empty? exprs) jolt-nil (if (jolt-empty? (jolt-rest exprs)) (jolt-first exprs) (let* ((_a$2367 (var-deref "clojure.core" "__sqcat")) (_a$2368 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2369 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2356 (var-deref "clojure.core" "__sqvec")) (_a$2357 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "or__14__auto"))) (_a$2358 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first exprs)))) (jolt-invoke _a$2356 _a$2357 _a$2358)))) (_a$2370 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2362 (var-deref "clojure.core" "__sqcat")) (_a$2363 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2364 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "or__14__auto"))) (_a$2365 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "or__14__auto"))) (_a$2366 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2359 (var-deref "clojure.core" "__sqcat")) (_a$2360 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "or"))) (_a$2361 (jolt-rest exprs))) (jolt-invoke _a$2359 _a$2360 _a$2361))))) (jolt-invoke _a$2362 _a$2363 _a$2364 _a$2365 _a$2366))))) (jolt-invoke _a$2367 _a$2368 _a$2369 _a$2370)))))))
+    (lambda exprs (let fnrec2379 ((exprs (list->cseq exprs))) (if (jolt-empty? exprs) jolt-nil (if (jolt-empty? (jolt-rest exprs)) (jolt-first exprs) (let* ((_a$2391 (var-deref "clojure.core" "__sqcat")) (_a$2392 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2393 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2380 (var-deref "clojure.core" "__sqvec")) (_a$2381 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "or__14__auto"))) (_a$2382 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first exprs)))) (jolt-invoke _a$2380 _a$2381 _a$2382)))) (_a$2394 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2386 (var-deref "clojure.core" "__sqcat")) (_a$2387 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2388 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "or__14__auto"))) (_a$2389 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "or__14__auto"))) (_a$2390 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2383 (var-deref "clojure.core" "__sqcat")) (_a$2384 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "or"))) (_a$2385 (jolt-rest exprs))) (jolt-invoke _a$2383 _a$2384 _a$2385))))) (jolt-invoke _a$2386 _a$2387 _a$2388 _a$2389 _a$2390))))) (jolt-invoke _a$2391 _a$2392 _a$2393 _a$2394)))))))
   (mark-macro! "clojure.core" "or"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "cond"
-    (lambda clauses (let fnrec2371 ((clauses (list->cseq clauses))) (if (jolt-empty? clauses) jolt-nil (let* ((_a$2375 (var-deref "clojure.core" "__sqcat")) (_a$2376 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2377 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first clauses))) (_a$2378 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth clauses 1))) (_a$2379 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2372 (var-deref "clojure.core" "__sqcat")) (_a$2373 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "cond"))) (_a$2374 (jolt-drop 2 clauses))) (jolt-invoke _a$2372 _a$2373 _a$2374))))) (jolt-invoke _a$2375 _a$2376 _a$2377 _a$2378 _a$2379))))))
+    (lambda clauses (let fnrec2395 ((clauses (list->cseq clauses))) (if (jolt-empty? clauses) jolt-nil (let* ((_a$2399 (var-deref "clojure.core" "__sqcat")) (_a$2400 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2401 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first clauses))) (_a$2402 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth clauses 1))) (_a$2403 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2396 (var-deref "clojure.core" "__sqcat")) (_a$2397 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "cond"))) (_a$2398 (jolt-drop 2 clauses))) (jolt-invoke _a$2396 _a$2397 _a$2398))))) (jolt-invoke _a$2399 _a$2400 _a$2401 _a$2402 _a$2403))))))
   (mark-macro! "clojure.core" "cond"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "ns"
-    (lambda (nm . clauses) (let fnrec2380 ((nm nm) (clauses (list->cseq clauses))) (let* ((nm (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "seq?") nm))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-symbol #f "with-meta") (jolt-first nm)) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "second") nm) nm)) (calls (let* ((_a$2410 (lambda (acc clause) (let fnrec2381 ((acc acc) (clause clause)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") clause)) (let* ((head (jolt-first clause)) (args (jolt-rest clause))) (if (jolt= head (keyword #f "require")) (jolt-conj acc (let* ((_a$2386 (var-deref "clojure.core" "__sqcat")) (_a$2387 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "require"))) (_a$2388 (jolt-map (lambda (s) (let fnrec2382 ((s s)) (let* ((_a$2383 (var-deref "clojure.core" "__sqcat")) (_a$2384 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2385 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2383 _a$2384 _a$2385)))) args))) (jolt-invoke _a$2386 _a$2387 _a$2388))) (if (jolt= head (keyword #f "use")) (jolt-conj acc (let* ((_a$2393 (var-deref "clojure.core" "__sqcat")) (_a$2394 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "use"))) (_a$2395 (jolt-map (lambda (s) (let fnrec2389 ((s s)) (let* ((_a$2390 (var-deref "clojure.core" "__sqcat")) (_a$2391 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2392 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2390 _a$2391 _a$2392)))) args))) (jolt-invoke _a$2393 _a$2394 _a$2395))) (if (jolt= head (keyword #f "import")) (jolt-conj acc (let* ((_a$2400 (var-deref "clojure.core" "__sqcat")) (_a$2401 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "import"))) (_a$2402 (jolt-map (lambda (s) (let fnrec2396 ((s s)) (let* ((_a$2397 (var-deref "clojure.core" "__sqcat")) (_a$2398 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2399 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2397 _a$2398 _a$2399)))) args))) (jolt-invoke _a$2400 _a$2401 _a$2402))) (if (jolt= head (keyword #f "refer-clojure")) (jolt-conj acc (let* ((_a$2407 (var-deref "clojure.core" "__sqcat")) (_a$2408 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "refer-clojure"))) (_a$2409 (jolt-map (lambda (s) (let fnrec2403 ((s s)) (let* ((_a$2404 (var-deref "clojure.core" "__sqcat")) (_a$2405 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2406 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2404 _a$2405 _a$2406)))) args))) (jolt-invoke _a$2407 _a$2408 _a$2409))) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))) acc)))) (_a$2411 (jolt-vector)) (_a$2412 clauses)) (jolt-reduce _a$2410 _a$2411 _a$2412)))) (let* ((_a$2419 (var-deref "clojure.core" "__sqcat")) (_a$2420 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2421 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2416 (var-deref "clojure.core" "__sqcat")) (_a$2417 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "in-ns"))) (_a$2418 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2413 (var-deref "clojure.core" "__sqcat")) (_a$2414 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2415 (jolt-invoke (var-deref "clojure.core" "__sq1") nm))) (jolt-invoke _a$2413 _a$2414 _a$2415))))) (jolt-invoke _a$2416 _a$2417 _a$2418)))) (_a$2422 calls)) (jolt-invoke _a$2419 _a$2420 _a$2421 _a$2422))))))
+    (lambda (nm . clauses) (let fnrec2404 ((nm nm) (clauses (list->cseq clauses))) (let* ((nm (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "seq?") nm))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-symbol #f "with-meta") (jolt-first nm)) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "second") nm) nm)) (calls (let* ((_a$2434 (lambda (acc clause) (let fnrec2405 ((acc acc) (clause clause)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") clause)) (let* ((head (jolt-first clause)) (args (jolt-rest clause))) (if (jolt= head (keyword #f "require")) (jolt-conj acc (let* ((_a$2410 (var-deref "clojure.core" "__sqcat")) (_a$2411 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "require"))) (_a$2412 (jolt-map (lambda (s) (let fnrec2406 ((s s)) (let* ((_a$2407 (var-deref "clojure.core" "__sqcat")) (_a$2408 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2409 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2407 _a$2408 _a$2409)))) args))) (jolt-invoke _a$2410 _a$2411 _a$2412))) (if (jolt= head (keyword #f "use")) (jolt-conj acc (let* ((_a$2417 (var-deref "clojure.core" "__sqcat")) (_a$2418 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "use"))) (_a$2419 (jolt-map (lambda (s) (let fnrec2413 ((s s)) (let* ((_a$2414 (var-deref "clojure.core" "__sqcat")) (_a$2415 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2416 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2414 _a$2415 _a$2416)))) args))) (jolt-invoke _a$2417 _a$2418 _a$2419))) (if (jolt= head (keyword #f "import")) (jolt-conj acc (let* ((_a$2424 (var-deref "clojure.core" "__sqcat")) (_a$2425 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "import"))) (_a$2426 (jolt-map (lambda (s) (let fnrec2420 ((s s)) (let* ((_a$2421 (var-deref "clojure.core" "__sqcat")) (_a$2422 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2423 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2421 _a$2422 _a$2423)))) args))) (jolt-invoke _a$2424 _a$2425 _a$2426))) (if (jolt= head (keyword #f "refer-clojure")) (jolt-conj acc (let* ((_a$2431 (var-deref "clojure.core" "__sqcat")) (_a$2432 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "refer-clojure"))) (_a$2433 (jolt-map (lambda (s) (let fnrec2427 ((s s)) (let* ((_a$2428 (var-deref "clojure.core" "__sqcat")) (_a$2429 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2430 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2428 _a$2429 _a$2430)))) args))) (jolt-invoke _a$2431 _a$2432 _a$2433))) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))) acc)))) (_a$2435 (jolt-vector)) (_a$2436 clauses)) (jolt-reduce _a$2434 _a$2435 _a$2436)))) (let* ((_a$2443 (var-deref "clojure.core" "__sqcat")) (_a$2444 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2445 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2440 (var-deref "clojure.core" "__sqcat")) (_a$2441 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "in-ns"))) (_a$2442 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2437 (var-deref "clojure.core" "__sqcat")) (_a$2438 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2439 (jolt-invoke (var-deref "clojure.core" "__sq1") nm))) (jolt-invoke _a$2437 _a$2438 _a$2439))))) (jolt-invoke _a$2440 _a$2441 _a$2442)))) (_a$2446 calls)) (jolt-invoke _a$2443 _a$2444 _a$2445 _a$2446))))))
   (mark-macro! "clojure.core" "ns"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "->"
-    (lambda (x . forms) (let fnrec2423 ((x x) (forms (list->cseq forms))) (if (jolt-empty? forms) x (let* ((form (jolt-first forms)) (threaded (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (let* ((_a$2424 (var-deref "clojure.core" "__sqcat")) (_a$2425 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first form))) (_a$2426 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$2427 (jolt-rest form))) (jolt-invoke _a$2424 _a$2425 _a$2426 _a$2427)) (let* ((_a$2428 (var-deref "clojure.core" "__sqcat")) (_a$2429 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$2430 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$2428 _a$2429 _a$2430))))) (let* ((_a$2431 (var-deref "clojure.core" "__sqcat")) (_a$2432 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->"))) (_a$2433 (jolt-invoke (var-deref "clojure.core" "__sq1") threaded)) (_a$2434 (jolt-rest forms))) (jolt-invoke _a$2431 _a$2432 _a$2433 _a$2434)))))))
+    (lambda (x . forms) (let fnrec2447 ((x x) (forms (list->cseq forms))) (if (jolt-empty? forms) x (let* ((form (jolt-first forms)) (threaded (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (let* ((_a$2448 (var-deref "clojure.core" "__sqcat")) (_a$2449 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first form))) (_a$2450 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$2451 (jolt-rest form))) (jolt-invoke _a$2448 _a$2449 _a$2450 _a$2451)) (let* ((_a$2452 (var-deref "clojure.core" "__sqcat")) (_a$2453 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$2454 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$2452 _a$2453 _a$2454))))) (let* ((_a$2455 (var-deref "clojure.core" "__sqcat")) (_a$2456 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->"))) (_a$2457 (jolt-invoke (var-deref "clojure.core" "__sq1") threaded)) (_a$2458 (jolt-rest forms))) (jolt-invoke _a$2455 _a$2456 _a$2457 _a$2458)))))))
   (mark-macro! "clojure.core" "->"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "->>"
-    (lambda (x . forms) (let fnrec2435 ((x x) (forms (list->cseq forms))) (if (jolt-empty? forms) x (let* ((form (jolt-first forms)) (threaded (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (let* ((_a$2436 (var-deref "clojure.core" "__sqcat")) (_a$2437 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first form))) (_a$2438 (jolt-rest form)) (_a$2439 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$2436 _a$2437 _a$2438 _a$2439)) (let* ((_a$2440 (var-deref "clojure.core" "__sqcat")) (_a$2441 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$2442 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$2440 _a$2441 _a$2442))))) (let* ((_a$2443 (var-deref "clojure.core" "__sqcat")) (_a$2444 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->>"))) (_a$2445 (jolt-invoke (var-deref "clojure.core" "__sq1") threaded)) (_a$2446 (jolt-rest forms))) (jolt-invoke _a$2443 _a$2444 _a$2445 _a$2446)))))))
+    (lambda (x . forms) (let fnrec2459 ((x x) (forms (list->cseq forms))) (if (jolt-empty? forms) x (let* ((form (jolt-first forms)) (threaded (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (let* ((_a$2460 (var-deref "clojure.core" "__sqcat")) (_a$2461 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first form))) (_a$2462 (jolt-rest form)) (_a$2463 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$2460 _a$2461 _a$2462 _a$2463)) (let* ((_a$2464 (var-deref "clojure.core" "__sqcat")) (_a$2465 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$2466 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$2464 _a$2465 _a$2466))))) (let* ((_a$2467 (var-deref "clojure.core" "__sqcat")) (_a$2468 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->>"))) (_a$2469 (jolt-invoke (var-deref "clojure.core" "__sq1") threaded)) (_a$2470 (jolt-rest forms))) (jolt-invoke _a$2467 _a$2468 _a$2469 _a$2470)))))))
   (mark-macro! "clojure.core" "->>"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "declare"
-    (lambda syms (let fnrec2447 ((syms (list->cseq syms))) (let* ((_a$2452 (var-deref "clojure.core" "__sqcat")) (_a$2453 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2454 (jolt-map (lambda (s) (let fnrec2448 ((s s)) (let* ((_a$2449 (var-deref "clojure.core" "__sqcat")) (_a$2450 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$2451 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2449 _a$2450 _a$2451)))) syms))) (jolt-invoke _a$2452 _a$2453 _a$2454)))))
+    (lambda syms (let fnrec2471 ((syms (list->cseq syms))) (let* ((_a$2476 (var-deref "clojure.core" "__sqcat")) (_a$2477 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2478 (jolt-map (lambda (s) (let fnrec2472 ((s s)) (let* ((_a$2473 (var-deref "clojure.core" "__sqcat")) (_a$2474 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$2475 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$2473 _a$2474 _a$2475)))) syms))) (jolt-invoke _a$2476 _a$2477 _a$2478)))))
   (mark-macro! "clojure.core" "declare"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "destructure" (letrec ((destructure (lambda (bindings) (let fnrec2455 ((bindings bindings)) (let* ((find-or (lambda (or-map nm) (let fnrec2456 ((or-map or-map) (nm nm)) (let* ((_a$2462 (lambda (acc k) (let fnrec2457 ((acc acc) (k k)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") k))) (if (jolt-truthy? and__13__auto) (jolt= nm (jolt-invoke (var-deref "clojure.core" "name") k)) and__13__auto))) (let* ((_o$2458 #t) (_o$2459 (jolt-get or-map k))) (jolt-vector _o$2458 _o$2459)) acc)))) (_a$2463 (let* ((_o$2460 #f) (_o$2461 jolt-nil)) (jolt-vector _o$2460 _o$2461))) (_a$2464 (if (jolt-truthy? or-map) (jolt-keys or-map) (jolt-vector)))) (jolt-reduce _a$2462 _a$2463 _a$2464))))) (amp? (lambda (x) (let fnrec2465 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt= "&" (jolt-invoke (var-deref "clojure.core" "name") x)) and__13__auto))))) (proc (letrec ((proc (lambda (pat init acc) (let fnrec2466 ((pat pat) (init init) (acc acc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") pat)) (jolt-conj (jolt-conj acc pat) init) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") pat)) (let* ((g (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))) (n (jolt-count pat)) (vloop (letrec ((vloop (lambda (i idx a) (let fnrec2467 ((i i) (idx idx) (a a)) (if (< i n) (let* ((elem (jolt-nth pat i))) (if (jolt-truthy? (jolt-invoke amp? elem)) (let* ((_a$2476 vloop) (_a$2477 (+ i 2)) (_a$2478 idx) (_a$2479 (let* ((_a$2472 proc) (_a$2473 (jolt-nth pat (jolt-inc i))) (_a$2474 (let* ((_a$2468 (var-deref "clojure.core" "__sqcat")) (_a$2469 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nthnext"))) (_a$2470 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2471 (jolt-invoke (var-deref "clojure.core" "__sq1") idx))) (jolt-invoke _a$2468 _a$2469 _a$2470 _a$2471))) (_a$2475 a)) (jolt-invoke _a$2472 _a$2473 _a$2474 _a$2475)))) (jolt-invoke _a$2476 _a$2477 _a$2478 _a$2479)) (if (jolt= elem (keyword #f "as")) (let* ((_a$2480 vloop) (_a$2481 (+ i 2)) (_a$2482 idx) (_a$2483 (jolt-invoke proc (jolt-nth pat (jolt-inc i)) g a))) (jolt-invoke _a$2480 _a$2481 _a$2482 _a$2483)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2489 vloop) (_a$2490 (jolt-inc i)) (_a$2491 (jolt-inc idx)) (_a$2492 (jolt-invoke proc elem (let* ((_a$2484 (var-deref "clojure.core" "__sqcat")) (_a$2485 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nth"))) (_a$2486 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2487 (jolt-invoke (var-deref "clojure.core" "__sq1") idx)) (_a$2488 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2484 _a$2485 _a$2486 _a$2487 _a$2488)) a))) (jolt-invoke _a$2489 _a$2490 _a$2491 _a$2492)) jolt-nil)))) a))))) vloop))) (jolt-invoke vloop 0 0 (jolt-conj (jolt-conj acc g) init))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") pat)) (let* ((g (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))) (gm (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))) (coerce (let* ((_a$2525 (var-deref "clojure.core" "__sqcat")) (_a$2526 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2527 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2493 (var-deref "clojure.core" "__sqcat")) (_a$2494 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "sequential?"))) (_a$2495 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2493 _a$2494 _a$2495)))) (_a$2528 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2520 (var-deref "clojure.core" "__sqcat")) (_a$2521 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2522 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2509 (var-deref "clojure.core" "__sqcat")) (_a$2510 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "and"))) (_a$2511 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2499 (var-deref "clojure.core" "__sqcat")) (_a$2500 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "="))) (_a$2501 (jolt-invoke (var-deref "clojure.core" "__sq1") 1)) (_a$2502 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2496 (var-deref "clojure.core" "__sqcat")) (_a$2497 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "count"))) (_a$2498 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2496 _a$2497 _a$2498))))) (jolt-invoke _a$2499 _a$2500 _a$2501 _a$2502)))) (_a$2512 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2506 (var-deref "clojure.core" "__sqcat")) (_a$2507 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "map?"))) (_a$2508 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2503 (var-deref "clojure.core" "__sqcat")) (_a$2504 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "first"))) (_a$2505 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2503 _a$2504 _a$2505))))) (jolt-invoke _a$2506 _a$2507 _a$2508))))) (jolt-invoke _a$2509 _a$2510 _a$2511 _a$2512)))) (_a$2523 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2513 (var-deref "clojure.core" "__sqcat")) (_a$2514 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "first"))) (_a$2515 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2513 _a$2514 _a$2515)))) (_a$2524 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2516 (var-deref "clojure.core" "__sqcat")) (_a$2517 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "apply"))) (_a$2518 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "hash-map"))) (_a$2519 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2516 _a$2517 _a$2518 _a$2519))))) (jolt-invoke _a$2520 _a$2521 _a$2522 _a$2523 _a$2524)))) (_a$2529 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2525 _a$2526 _a$2527 _a$2528 _a$2529))) (or-map (jolt-get pat (keyword #f "or"))) (as-sym (jolt-get pat (keyword #f "as"))) (bound (jolt-conj (jolt-conj (jolt-conj (jolt-conj acc g) init) gm) coerce)) (base (if (jolt-truthy? as-sym) (jolt-conj (jolt-conj bound as-sym) gm) bound)) (group (lambda (a kw kind) (let fnrec2530 ((a a) (kw kw) (kind kind)) (let* ((names (jolt-get pat kw))) (if (jolt-truthy? names) (jolt-reduce (lambda (aa s) (let fnrec2531 ((aa aa) (s s)) (let* ((local (jolt-invoke (var-deref "clojure.core" "name") s)) (nsp (jolt-invoke (var-deref "clojure.core" "namespace") s)) (keyform (if (jolt= kind (keyword #f "kw")) (jolt-invoke (var-deref "clojure.core" "keyword") (if (jolt-truthy? nsp) (jolt-invoke (var-deref "clojure.core" "str") nsp "/" local) local)) (if (jolt= kind (keyword #f "str")) local (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2532 (var-deref "clojure.core" "__sqcat")) (_a$2533 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2534 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "symbol") nsp local)))) (jolt-invoke _a$2532 _a$2533 _a$2534)) jolt-nil)))) (fo (jolt-invoke find-or or-map local))) (let* ((_a$2544 (jolt-conj aa (jolt-invoke (var-deref "clojure.core" "symbol") local))) (_a$2545 (if (jolt-truthy? (jolt-nth fo 0)) (let* ((_a$2535 (var-deref "clojure.core" "__sqcat")) (_a$2536 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$2537 (jolt-invoke (var-deref "clojure.core" "__sq1") gm)) (_a$2538 (jolt-invoke (var-deref "clojure.core" "__sq1") keyform)) (_a$2539 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth fo 1)))) (jolt-invoke _a$2535 _a$2536 _a$2537 _a$2538 _a$2539)) (let* ((_a$2540 (var-deref "clojure.core" "__sqcat")) (_a$2541 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$2542 (jolt-invoke (var-deref "clojure.core" "__sq1") gm)) (_a$2543 (jolt-invoke (var-deref "clojure.core" "__sq1") keyform))) (jolt-invoke _a$2540 _a$2541 _a$2542 _a$2543))))) (jolt-conj _a$2544 _a$2545))))) a names) a))))) (g1 (jolt-invoke group base (keyword #f "keys") (keyword #f "kw"))) (g2 (jolt-invoke group g1 (keyword #f "strs") (keyword #f "str"))) (g3 (jolt-invoke group g2 (keyword #f "syms") (keyword #f "sym")))) (let* ((_a$2551 (lambda (a k) (let fnrec2546 ((a a) (k k)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") k)) a (jolt-invoke proc k (let* ((_a$2547 (var-deref "clojure.core" "__sqcat")) (_a$2548 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$2549 (jolt-invoke (var-deref "clojure.core" "__sq1") gm)) (_a$2550 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get pat k)))) (jolt-invoke _a$2547 _a$2548 _a$2549 _a$2550)) a))))) (_a$2552 g3) (_a$2553 (jolt-keys pat))) (jolt-reduce _a$2551 _a$2552 _a$2553))) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "unsupported destructuring pattern: " (jolt-invoke (var-deref "clojure.core" "pr-str") pat))) jolt-nil)))))))) proc)) (ploop (letrec ((ploop (lambda (i acc) (let fnrec2554 ((i i) (acc acc)) (if (< i (jolt-count bindings)) (let* ((_a$2559 ploop) (_a$2560 (+ i 2)) (_a$2561 (let* ((_a$2555 proc) (_a$2556 (jolt-nth bindings i)) (_a$2557 (jolt-nth bindings (jolt-inc i))) (_a$2558 acc)) (jolt-invoke _a$2555 _a$2556 _a$2557 _a$2558)))) (jolt-invoke _a$2559 _a$2560 _a$2561)) acc))))) ploop))) (jolt-invoke ploop 0 (jolt-vector))))))) destructure)))
+  (def-var! "clojure.core" "destructure" (letrec ((destructure (lambda (bindings) (let fnrec2479 ((bindings bindings)) (let* ((find-or (lambda (or-map nm) (let fnrec2480 ((or-map or-map) (nm nm)) (let* ((_a$2486 (lambda (acc k) (let fnrec2481 ((acc acc) (k k)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") k))) (if (jolt-truthy? and__13__auto) (jolt= nm (jolt-invoke (var-deref "clojure.core" "name") k)) and__13__auto))) (let* ((_o$2482 #t) (_o$2483 (jolt-get or-map k))) (jolt-vector _o$2482 _o$2483)) acc)))) (_a$2487 (let* ((_o$2484 #f) (_o$2485 jolt-nil)) (jolt-vector _o$2484 _o$2485))) (_a$2488 (if (jolt-truthy? or-map) (jolt-keys or-map) (jolt-vector)))) (jolt-reduce _a$2486 _a$2487 _a$2488))))) (amp? (lambda (x) (let fnrec2489 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt= "&" (jolt-invoke (var-deref "clojure.core" "name") x)) and__13__auto))))) (proc (letrec ((proc (lambda (pat init acc) (let fnrec2490 ((pat pat) (init init) (acc acc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") pat)) (jolt-conj (jolt-conj acc pat) init) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") pat)) (let* ((g (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))) (n (jolt-count pat)) (vloop (letrec ((vloop (lambda (i idx a) (let fnrec2491 ((i i) (idx idx) (a a)) (if (< i n) (let* ((elem (jolt-nth pat i))) (if (jolt-truthy? (jolt-invoke amp? elem)) (let* ((_a$2500 vloop) (_a$2501 (+ i 2)) (_a$2502 idx) (_a$2503 (let* ((_a$2496 proc) (_a$2497 (jolt-nth pat (jolt-inc i))) (_a$2498 (let* ((_a$2492 (var-deref "clojure.core" "__sqcat")) (_a$2493 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nthnext"))) (_a$2494 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2495 (jolt-invoke (var-deref "clojure.core" "__sq1") idx))) (jolt-invoke _a$2492 _a$2493 _a$2494 _a$2495))) (_a$2499 a)) (jolt-invoke _a$2496 _a$2497 _a$2498 _a$2499)))) (jolt-invoke _a$2500 _a$2501 _a$2502 _a$2503)) (if (jolt= elem (keyword #f "as")) (let* ((_a$2504 vloop) (_a$2505 (+ i 2)) (_a$2506 idx) (_a$2507 (jolt-invoke proc (jolt-nth pat (jolt-inc i)) g a))) (jolt-invoke _a$2504 _a$2505 _a$2506 _a$2507)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2513 vloop) (_a$2514 (jolt-inc i)) (_a$2515 (jolt-inc idx)) (_a$2516 (jolt-invoke proc elem (let* ((_a$2508 (var-deref "clojure.core" "__sqcat")) (_a$2509 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nth"))) (_a$2510 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2511 (jolt-invoke (var-deref "clojure.core" "__sq1") idx)) (_a$2512 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2508 _a$2509 _a$2510 _a$2511 _a$2512)) a))) (jolt-invoke _a$2513 _a$2514 _a$2515 _a$2516)) jolt-nil)))) a))))) vloop))) (jolt-invoke vloop 0 0 (jolt-conj (jolt-conj acc g) init))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") pat)) (let* ((g (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))) (gm (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))) (coerce (let* ((_a$2549 (var-deref "clojure.core" "__sqcat")) (_a$2550 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2551 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2517 (var-deref "clojure.core" "__sqcat")) (_a$2518 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "sequential?"))) (_a$2519 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2517 _a$2518 _a$2519)))) (_a$2552 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2544 (var-deref "clojure.core" "__sqcat")) (_a$2545 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2546 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2533 (var-deref "clojure.core" "__sqcat")) (_a$2534 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "and"))) (_a$2535 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2523 (var-deref "clojure.core" "__sqcat")) (_a$2524 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "="))) (_a$2525 (jolt-invoke (var-deref "clojure.core" "__sq1") 1)) (_a$2526 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2520 (var-deref "clojure.core" "__sqcat")) (_a$2521 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "count"))) (_a$2522 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2520 _a$2521 _a$2522))))) (jolt-invoke _a$2523 _a$2524 _a$2525 _a$2526)))) (_a$2536 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2530 (var-deref "clojure.core" "__sqcat")) (_a$2531 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "map?"))) (_a$2532 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2527 (var-deref "clojure.core" "__sqcat")) (_a$2528 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "first"))) (_a$2529 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2527 _a$2528 _a$2529))))) (jolt-invoke _a$2530 _a$2531 _a$2532))))) (jolt-invoke _a$2533 _a$2534 _a$2535 _a$2536)))) (_a$2547 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2537 (var-deref "clojure.core" "__sqcat")) (_a$2538 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "first"))) (_a$2539 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2537 _a$2538 _a$2539)))) (_a$2548 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2540 (var-deref "clojure.core" "__sqcat")) (_a$2541 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "apply"))) (_a$2542 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "hash-map"))) (_a$2543 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2540 _a$2541 _a$2542 _a$2543))))) (jolt-invoke _a$2544 _a$2545 _a$2546 _a$2547 _a$2548)))) (_a$2553 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2549 _a$2550 _a$2551 _a$2552 _a$2553))) (or-map (jolt-get pat (keyword #f "or"))) (as-sym (jolt-get pat (keyword #f "as"))) (bound (jolt-conj (jolt-conj (jolt-conj (jolt-conj acc g) init) gm) coerce)) (base (if (jolt-truthy? as-sym) (jolt-conj (jolt-conj bound as-sym) gm) bound)) (group (lambda (a kw kind) (let fnrec2554 ((a a) (kw kw) (kind kind)) (let* ((names (jolt-get pat kw))) (if (jolt-truthy? names) (jolt-reduce (lambda (aa s) (let fnrec2555 ((aa aa) (s s)) (let* ((local (jolt-invoke (var-deref "clojure.core" "name") s)) (nsp (jolt-invoke (var-deref "clojure.core" "namespace") s)) (keyform (if (jolt= kind (keyword #f "kw")) (jolt-invoke (var-deref "clojure.core" "keyword") (if (jolt-truthy? nsp) (jolt-invoke (var-deref "clojure.core" "str") nsp "/" local) local)) (if (jolt= kind (keyword #f "str")) local (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2556 (var-deref "clojure.core" "__sqcat")) (_a$2557 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2558 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "symbol") nsp local)))) (jolt-invoke _a$2556 _a$2557 _a$2558)) jolt-nil)))) (fo (jolt-invoke find-or or-map local))) (let* ((_a$2568 (jolt-conj aa (jolt-invoke (var-deref "clojure.core" "symbol") local))) (_a$2569 (if (jolt-truthy? (jolt-nth fo 0)) (let* ((_a$2559 (var-deref "clojure.core" "__sqcat")) (_a$2560 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$2561 (jolt-invoke (var-deref "clojure.core" "__sq1") gm)) (_a$2562 (jolt-invoke (var-deref "clojure.core" "__sq1") keyform)) (_a$2563 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth fo 1)))) (jolt-invoke _a$2559 _a$2560 _a$2561 _a$2562 _a$2563)) (let* ((_a$2564 (var-deref "clojure.core" "__sqcat")) (_a$2565 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$2566 (jolt-invoke (var-deref "clojure.core" "__sq1") gm)) (_a$2567 (jolt-invoke (var-deref "clojure.core" "__sq1") keyform))) (jolt-invoke _a$2564 _a$2565 _a$2566 _a$2567))))) (jolt-conj _a$2568 _a$2569))))) a names) a))))) (g1 (jolt-invoke group base (keyword #f "keys") (keyword #f "kw"))) (g2 (jolt-invoke group g1 (keyword #f "strs") (keyword #f "str"))) (g3 (jolt-invoke group g2 (keyword #f "syms") (keyword #f "sym")))) (let* ((_a$2575 (lambda (a k) (let fnrec2570 ((a a) (k k)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") k)) a (jolt-invoke proc k (let* ((_a$2571 (var-deref "clojure.core" "__sqcat")) (_a$2572 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$2573 (jolt-invoke (var-deref "clojure.core" "__sq1") gm)) (_a$2574 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-get pat k)))) (jolt-invoke _a$2571 _a$2572 _a$2573 _a$2574)) a))))) (_a$2576 g3) (_a$2577 (jolt-keys pat))) (jolt-reduce _a$2575 _a$2576 _a$2577))) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "unsupported destructuring pattern: " (jolt-invoke (var-deref "clojure.core" "pr-str") pat))) jolt-nil)))))))) proc)) (ploop (letrec ((ploop (lambda (i acc) (let fnrec2578 ((i i) (acc acc)) (if (< i (jolt-count bindings)) (let* ((_a$2583 ploop) (_a$2584 (+ i 2)) (_a$2585 (let* ((_a$2579 proc) (_a$2580 (jolt-nth bindings i)) (_a$2581 (jolt-nth bindings (jolt-inc i))) (_a$2582 acc)) (jolt-invoke _a$2579 _a$2580 _a$2581 _a$2582)))) (jolt-invoke _a$2583 _a$2584 _a$2585)) acc))))) ploop))) (jolt-invoke ploop 0 (jolt-vector))))))) destructure)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "let"
-    (lambda (bindings . body) (let fnrec2562 ((bindings bindings) (body (list->cseq body))) (let* ((_a$2563 (var-deref "clojure.core" "__sqcat")) (_a$2564 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2565 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "destructure") bindings)))) (_a$2566 body)) (jolt-invoke _a$2563 _a$2564 _a$2565 _a$2566)))))
+    (lambda (bindings . body) (let fnrec2586 ((bindings bindings) (body (list->cseq body))) (let* ((_a$2587 (var-deref "clojure.core" "__sqcat")) (_a$2588 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2589 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "destructure") bindings)))) (_a$2590 body)) (jolt-invoke _a$2587 _a$2588 _a$2589 _a$2590)))))
   (mark-macro! "clojure.core" "let"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "loop"
-    (lambda (bindings . body) (let fnrec2567 ((bindings bindings) (body (list->cseq body))) (let* ((d (jolt-invoke (var-deref "clojure.core" "destructure") bindings))) (if (jolt= d bindings) (let* ((_a$2568 (var-deref "clojure.core" "__sqcat")) (_a$2569 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "loop*"))) (_a$2570 (jolt-invoke (var-deref "clojure.core" "__sq1") bindings)) (_a$2571 body)) (jolt-invoke _a$2568 _a$2569 _a$2570 _a$2571)) (let* ((bs (jolt-invoke (var-deref "clojure.core" "take-nth") 2 bindings)) (vs (jolt-invoke (var-deref "clojure.core" "take-nth") 2 (jolt-drop 1 bindings))) (gs (jolt-map (lambda (b) (let fnrec2572 ((b b)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") b)) b (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))))) bs)) (outer (let* ((_a$2574 (lambda (acc t) (let fnrec2573 ((acc acc) (t t)) (let* ((b (jolt-nth t 0)) (v (jolt-nth t 1)) (g (jolt-nth t 2))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") b)) (jolt-conj (jolt-conj acc g) v) (jolt-conj (jolt-conj (jolt-conj (jolt-conj acc g) v) b) g)))))) (_a$2575 (jolt-vector)) (_a$2576 (jolt-map jolt-vector bs vs gs))) (jolt-reduce _a$2574 _a$2575 _a$2576))) (inner (let* ((_a$2580 (lambda (acc t) (let fnrec2577 ((acc acc) (t t)) (let* ((_a$2578 (jolt-conj acc (jolt-nth t 0))) (_a$2579 (jolt-nth t 1))) (jolt-conj _a$2578 _a$2579))))) (_a$2581 (jolt-vector)) (_a$2582 (jolt-map jolt-vector bs gs))) (jolt-reduce _a$2580 _a$2581 _a$2582))) (loopv (let* ((_a$2584 (lambda (acc g) (let fnrec2583 ((acc acc) (g g)) (jolt-conj (jolt-conj acc g) g)))) (_a$2585 (jolt-vector)) (_a$2586 gs)) (jolt-reduce _a$2584 _a$2585 _a$2586)))) (let* ((_a$2595 (var-deref "clojure.core" "__sqcat")) (_a$2596 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2597 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") outer))) (_a$2598 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2591 (var-deref "clojure.core" "__sqcat")) (_a$2592 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "loop*"))) (_a$2593 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") loopv))) (_a$2594 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2587 (var-deref "clojure.core" "__sqcat")) (_a$2588 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2589 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") inner))) (_a$2590 body)) (jolt-invoke _a$2587 _a$2588 _a$2589 _a$2590))))) (jolt-invoke _a$2591 _a$2592 _a$2593 _a$2594))))) (jolt-invoke _a$2595 _a$2596 _a$2597 _a$2598))))))))
+    (lambda (bindings . body) (let fnrec2591 ((bindings bindings) (body (list->cseq body))) (let* ((d (jolt-invoke (var-deref "clojure.core" "destructure") bindings))) (if (jolt= d bindings) (let* ((_a$2592 (var-deref "clojure.core" "__sqcat")) (_a$2593 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "loop*"))) (_a$2594 (jolt-invoke (var-deref "clojure.core" "__sq1") bindings)) (_a$2595 body)) (jolt-invoke _a$2592 _a$2593 _a$2594 _a$2595)) (let* ((bs (jolt-invoke (var-deref "clojure.core" "take-nth") 2 bindings)) (vs (jolt-invoke (var-deref "clojure.core" "take-nth") 2 (jolt-drop 1 bindings))) (gs (jolt-map (lambda (b) (let fnrec2596 ((b b)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") b)) b (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym"))))))) bs)) (outer (let* ((_a$2598 (lambda (acc t) (let fnrec2597 ((acc acc) (t t)) (let* ((b (jolt-nth t 0)) (v (jolt-nth t 1)) (g (jolt-nth t 2))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") b)) (jolt-conj (jolt-conj acc g) v) (jolt-conj (jolt-conj (jolt-conj (jolt-conj acc g) v) b) g)))))) (_a$2599 (jolt-vector)) (_a$2600 (jolt-map jolt-vector bs vs gs))) (jolt-reduce _a$2598 _a$2599 _a$2600))) (inner (let* ((_a$2604 (lambda (acc t) (let fnrec2601 ((acc acc) (t t)) (let* ((_a$2602 (jolt-conj acc (jolt-nth t 0))) (_a$2603 (jolt-nth t 1))) (jolt-conj _a$2602 _a$2603))))) (_a$2605 (jolt-vector)) (_a$2606 (jolt-map jolt-vector bs gs))) (jolt-reduce _a$2604 _a$2605 _a$2606))) (loopv (let* ((_a$2608 (lambda (acc g) (let fnrec2607 ((acc acc) (g g)) (jolt-conj (jolt-conj acc g) g)))) (_a$2609 (jolt-vector)) (_a$2610 gs)) (jolt-reduce _a$2608 _a$2609 _a$2610)))) (let* ((_a$2619 (var-deref "clojure.core" "__sqcat")) (_a$2620 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2621 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") outer))) (_a$2622 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2615 (var-deref "clojure.core" "__sqcat")) (_a$2616 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "loop*"))) (_a$2617 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") loopv))) (_a$2618 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2611 (var-deref "clojure.core" "__sqcat")) (_a$2612 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2613 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") inner))) (_a$2614 body)) (jolt-invoke _a$2611 _a$2612 _a$2613 _a$2614))))) (jolt-invoke _a$2615 _a$2616 _a$2617 _a$2618))))) (jolt-invoke _a$2619 _a$2620 _a$2621 _a$2622))))))))
   (mark-macro! "clojure.core" "loop"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "fn"
-    (lambda raw (let fnrec2599 ((raw (list->cseq raw))) (let* ((nm (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first raw))) (jolt-first raw) jolt-nil)) (aftn (if (jolt-truthy? nm) (jolt-next raw) raw)) (unhint (lambda (x) (let fnrec2600 ((x x)) (if (jolt-truthy? (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") x)) (jolt= (jolt-symbol #f "with-meta") (jolt-first x)) #f)) (jolt-nth x 1) x)))) (md (letrec ((go (lambda (ps nps lets) (let fnrec2601 ((ps ps) (nps nps) (lets lets)) (if (jolt-truthy? (jolt-seq ps)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first ps))) (let* ((_a$2602 go) (_a$2603 (jolt-next ps)) (_a$2604 (jolt-conj nps (jolt-first ps))) (_a$2605 lets)) (jolt-invoke _a$2602 _a$2603 _a$2604 _a$2605)) (let* ((g (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym")))))) (let* ((_a$2606 go) (_a$2607 (jolt-next ps)) (_a$2608 (jolt-conj nps g)) (_a$2609 (jolt-conj (jolt-conj lets (jolt-first ps)) g))) (jolt-invoke _a$2606 _a$2607 _a$2608 _a$2609)))) (let* ((_o$2610 nps) (_o$2611 lets)) (jolt-vector _o$2610 _o$2611))))))) go)) (mk (lambda (sig) (let fnrec2612 ((sig sig)) (let* ((ps (jolt-invoke unhint (jolt-first sig))) (hinted (jolt-not (jolt= ps (jolt-first sig)))) (r (let* ((_a$2613 md) (_a$2614 (jolt-seq ps)) (_a$2615 (jolt-vector)) (_a$2616 (jolt-vector))) (jolt-invoke _a$2613 _a$2614 _a$2615 _a$2616)))) (if (jolt-truthy? (if (jolt-empty? (jolt-nth r 1)) (jolt-not hinted) #f)) sig (let* ((pv (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-nth r 0))) (lv (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-nth r 1)))) (if (jolt-empty? (jolt-nth r 1)) (let* ((_a$2617 (var-deref "clojure.core" "__sqcat")) (_a$2618 (jolt-invoke (var-deref "clojure.core" "__sq1") pv)) (_a$2619 (jolt-rest sig))) (jolt-invoke _a$2617 _a$2618 _a$2619)) (let* ((_a$2624 (var-deref "clojure.core" "__sqcat")) (_a$2625 (jolt-invoke (var-deref "clojure.core" "__sq1") pv)) (_a$2626 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2620 (var-deref "clojure.core" "__sqcat")) (_a$2621 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2622 (jolt-invoke (var-deref "clojure.core" "__sq1") lv)) (_a$2623 (jolt-rest sig))) (jolt-invoke _a$2620 _a$2621 _a$2622 _a$2623))))) (jolt-invoke _a$2624 _a$2625 _a$2626)))))))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") (jolt-invoke unhint (jolt-first aftn)))) (let* ((a (jolt-invoke mk aftn))) (if (jolt-truthy? nm) (let* ((_a$2627 (var-deref "clojure.core" "__sqcat")) (_a$2628 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$2629 (jolt-invoke (var-deref "clojure.core" "__sq1") nm)) (_a$2630 a)) (jolt-invoke _a$2627 _a$2628 _a$2629 _a$2630)) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*")) a))) (let* ((as (jolt-invoke (var-deref "clojure.core" "vec") (jolt-map mk aftn)))) (if (jolt-truthy? nm) (let* ((_a$2631 (var-deref "clojure.core" "__sqcat")) (_a$2632 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$2633 (jolt-invoke (var-deref "clojure.core" "__sq1") nm)) (_a$2634 as)) (jolt-invoke _a$2631 _a$2632 _a$2633 _a$2634)) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*")) as))))))))
+    (lambda raw (let fnrec2623 ((raw (list->cseq raw))) (let* ((nm (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first raw))) (jolt-first raw) jolt-nil)) (aftn (if (jolt-truthy? nm) (jolt-next raw) raw)) (unhint (lambda (x) (let fnrec2624 ((x x)) (if (jolt-truthy? (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") x)) (jolt= (jolt-symbol #f "with-meta") (jolt-first x)) #f)) (jolt-nth x 1) x)))) (md (letrec ((go (lambda (ps nps lets) (let fnrec2625 ((ps ps) (nps nps) (lets lets)) (if (jolt-truthy? (jolt-seq ps)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first ps))) (let* ((_a$2626 go) (_a$2627 (jolt-next ps)) (_a$2628 (jolt-conj nps (jolt-first ps))) (_a$2629 lets)) (jolt-invoke _a$2626 _a$2627 _a$2628 _a$2629)) (let* ((g (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym")))))) (let* ((_a$2630 go) (_a$2631 (jolt-next ps)) (_a$2632 (jolt-conj nps g)) (_a$2633 (jolt-conj (jolt-conj lets (jolt-first ps)) g))) (jolt-invoke _a$2630 _a$2631 _a$2632 _a$2633)))) (let* ((_o$2634 nps) (_o$2635 lets)) (jolt-vector _o$2634 _o$2635))))))) go)) (mk (lambda (sig) (let fnrec2636 ((sig sig)) (let* ((ps (jolt-invoke unhint (jolt-first sig))) (hinted (jolt-not (jolt= ps (jolt-first sig)))) (r (let* ((_a$2637 md) (_a$2638 (jolt-seq ps)) (_a$2639 (jolt-vector)) (_a$2640 (jolt-vector))) (jolt-invoke _a$2637 _a$2638 _a$2639 _a$2640)))) (if (jolt-truthy? (if (jolt-empty? (jolt-nth r 1)) (jolt-not hinted) #f)) sig (let* ((pv (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-nth r 0))) (lv (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-nth r 1)))) (if (jolt-empty? (jolt-nth r 1)) (let* ((_a$2641 (var-deref "clojure.core" "__sqcat")) (_a$2642 (jolt-invoke (var-deref "clojure.core" "__sq1") pv)) (_a$2643 (jolt-rest sig))) (jolt-invoke _a$2641 _a$2642 _a$2643)) (let* ((_a$2648 (var-deref "clojure.core" "__sqcat")) (_a$2649 (jolt-invoke (var-deref "clojure.core" "__sq1") pv)) (_a$2650 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2644 (var-deref "clojure.core" "__sqcat")) (_a$2645 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2646 (jolt-invoke (var-deref "clojure.core" "__sq1") lv)) (_a$2647 (jolt-rest sig))) (jolt-invoke _a$2644 _a$2645 _a$2646 _a$2647))))) (jolt-invoke _a$2648 _a$2649 _a$2650)))))))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") (jolt-invoke unhint (jolt-first aftn)))) (let* ((a (jolt-invoke mk aftn))) (if (jolt-truthy? nm) (let* ((_a$2651 (var-deref "clojure.core" "__sqcat")) (_a$2652 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$2653 (jolt-invoke (var-deref "clojure.core" "__sq1") nm)) (_a$2654 a)) (jolt-invoke _a$2651 _a$2652 _a$2653 _a$2654)) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*")) a))) (let* ((as (jolt-invoke (var-deref "clojure.core" "vec") (jolt-map mk aftn)))) (if (jolt-truthy? nm) (let* ((_a$2655 (var-deref "clojure.core" "__sqcat")) (_a$2656 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$2657 (jolt-invoke (var-deref "clojure.core" "__sq1") nm)) (_a$2658 as)) (jolt-invoke _a$2655 _a$2656 _a$2657 _a$2658)) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*")) as))))))))
   (mark-macro! "clojure.core" "fn"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defn"
-    (lambda (fn-name . body) (let fnrec2635 ((fn-name fn-name) (body (list->cseq body))) (let* ((body (if (jolt-truthy? (let* ((and__13__auto (jolt-seq body))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first body)) and__13__auto))) (jolt-rest body) body)) (body (if (jolt-truthy? (let* ((and__13__auto (jolt-seq body))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") (jolt-first body)))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first body))) and__13__auto)) and__13__auto))) (jolt-rest body) body)) (fn-only-name (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") fn-name)) fn-name (jolt-first (jolt-rest fn-name))))) (let* ((_a$2640 (var-deref "clojure.core" "__sqcat")) (_a$2641 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$2642 (jolt-invoke (var-deref "clojure.core" "__sq1") fn-name)) (_a$2643 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2636 (var-deref "clojure.core" "__sqcat")) (_a$2637 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2638 (jolt-invoke (var-deref "clojure.core" "__sq1") fn-only-name)) (_a$2639 body)) (jolt-invoke _a$2636 _a$2637 _a$2638 _a$2639))))) (jolt-invoke _a$2640 _a$2641 _a$2642 _a$2643))))))
+    (lambda (fn-name . body) (let fnrec2659 ((fn-name fn-name) (body (list->cseq body))) (let* ((body (if (jolt-truthy? (let* ((and__13__auto (jolt-seq body))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first body)) and__13__auto))) (jolt-rest body) body)) (body (if (jolt-truthy? (let* ((and__13__auto (jolt-seq body))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") (jolt-first body)))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first body))) and__13__auto)) and__13__auto))) (jolt-rest body) body)) (fn-only-name (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") fn-name)) fn-name (jolt-first (jolt-rest fn-name))))) (let* ((_a$2664 (var-deref "clojure.core" "__sqcat")) (_a$2665 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$2666 (jolt-invoke (var-deref "clojure.core" "__sq1") fn-name)) (_a$2667 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2660 (var-deref "clojure.core" "__sqcat")) (_a$2661 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2662 (jolt-invoke (var-deref "clojure.core" "__sq1") fn-only-name)) (_a$2663 body)) (jolt-invoke _a$2660 _a$2661 _a$2662 _a$2663))))) (jolt-invoke _a$2664 _a$2665 _a$2666 _a$2667))))))
   (mark-macro! "clojure.core" "defn"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defn-"
-    (lambda (fn-name . body) (let fnrec2644 ((fn-name fn-name) (body (list->cseq body))) (let* ((_a$2645 (var-deref "clojure.core" "__sqcat")) (_a$2646 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "defn"))) (_a$2647 (jolt-invoke (var-deref "clojure.core" "__sq1") fn-name)) (_a$2648 body)) (jolt-invoke _a$2645 _a$2646 _a$2647 _a$2648)))))
+    (lambda (fn-name . body) (let fnrec2668 ((fn-name fn-name) (body (list->cseq body))) (let* ((_a$2669 (var-deref "clojure.core" "__sqcat")) (_a$2670 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "defn"))) (_a$2671 (jolt-invoke (var-deref "clojure.core" "__sq1") fn-name)) (_a$2672 body)) (jolt-invoke _a$2669 _a$2670 _a$2671 _a$2672)))))
   (mark-macro! "clojure.core" "defn-"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "fresh-sym" (letrec ((fresh-sym (lambda () (let fnrec2649 () (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym")))))))) fresh-sym)))
+  (def-var! "clojure.core" "fresh-sym" (letrec ((fresh-sym (lambda () (let fnrec2673 () (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym")))))))) fresh-sym)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "cond->"
-    (lambda (expr . clauses) (let fnrec2650 ((expr expr) (clauses (list->cseq clauses))) (let* ((step (letrec ((step (lambda (prev cls) (let fnrec2651 ((prev prev) (cls cls)) (if (jolt-empty? cls) prev (let* ((t (jolt-first cls)) (f (jolt-nth cls 1)) (gn (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (call (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") f)) (let* ((_a$2652 (var-deref "clojure.core" "__sqcat")) (_a$2653 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first f))) (_a$2654 (jolt-invoke (var-deref "clojure.core" "__sq1") prev)) (_a$2655 (jolt-rest f))) (jolt-invoke _a$2652 _a$2653 _a$2654 _a$2655)) (let* ((_a$2656 (var-deref "clojure.core" "__sqcat")) (_a$2657 (jolt-invoke (var-deref "clojure.core" "__sq1") f)) (_a$2658 (jolt-invoke (var-deref "clojure.core" "__sq1") prev))) (jolt-invoke _a$2656 _a$2657 _a$2658))))) (let* ((_a$2667 (var-deref "clojure.core" "__sqcat")) (_a$2668 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2669 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2664 (var-deref "clojure.core" "__sqvec")) (_a$2665 (jolt-invoke (var-deref "clojure.core" "__sq1") gn)) (_a$2666 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2659 (var-deref "clojure.core" "__sqcat")) (_a$2660 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2661 (jolt-invoke (var-deref "clojure.core" "__sq1") t)) (_a$2662 (jolt-invoke (var-deref "clojure.core" "__sq1") call)) (_a$2663 (jolt-invoke (var-deref "clojure.core" "__sq1") prev))) (jolt-invoke _a$2659 _a$2660 _a$2661 _a$2662 _a$2663))))) (jolt-invoke _a$2664 _a$2665 _a$2666)))) (_a$2670 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke step gn (jolt-drop 2 cls))))) (jolt-invoke _a$2667 _a$2668 _a$2669 _a$2670)))))))) step)) (g0 (jolt-invoke (var-deref "clojure.core" "fresh-sym")))) (let* ((_a$2674 (var-deref "clojure.core" "__sqcat")) (_a$2675 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2676 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2671 (var-deref "clojure.core" "__sqvec")) (_a$2672 (jolt-invoke (var-deref "clojure.core" "__sq1") g0)) (_a$2673 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$2671 _a$2672 _a$2673)))) (_a$2677 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke step g0 clauses)))) (jolt-invoke _a$2674 _a$2675 _a$2676 _a$2677))))))
+    (lambda (expr . clauses) (let fnrec2674 ((expr expr) (clauses (list->cseq clauses))) (let* ((step (letrec ((step (lambda (prev cls) (let fnrec2675 ((prev prev) (cls cls)) (if (jolt-empty? cls) prev (let* ((t (jolt-first cls)) (f (jolt-nth cls 1)) (gn (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (call (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") f)) (let* ((_a$2676 (var-deref "clojure.core" "__sqcat")) (_a$2677 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first f))) (_a$2678 (jolt-invoke (var-deref "clojure.core" "__sq1") prev)) (_a$2679 (jolt-rest f))) (jolt-invoke _a$2676 _a$2677 _a$2678 _a$2679)) (let* ((_a$2680 (var-deref "clojure.core" "__sqcat")) (_a$2681 (jolt-invoke (var-deref "clojure.core" "__sq1") f)) (_a$2682 (jolt-invoke (var-deref "clojure.core" "__sq1") prev))) (jolt-invoke _a$2680 _a$2681 _a$2682))))) (let* ((_a$2691 (var-deref "clojure.core" "__sqcat")) (_a$2692 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2693 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2688 (var-deref "clojure.core" "__sqvec")) (_a$2689 (jolt-invoke (var-deref "clojure.core" "__sq1") gn)) (_a$2690 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2683 (var-deref "clojure.core" "__sqcat")) (_a$2684 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2685 (jolt-invoke (var-deref "clojure.core" "__sq1") t)) (_a$2686 (jolt-invoke (var-deref "clojure.core" "__sq1") call)) (_a$2687 (jolt-invoke (var-deref "clojure.core" "__sq1") prev))) (jolt-invoke _a$2683 _a$2684 _a$2685 _a$2686 _a$2687))))) (jolt-invoke _a$2688 _a$2689 _a$2690)))) (_a$2694 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke step gn (jolt-drop 2 cls))))) (jolt-invoke _a$2691 _a$2692 _a$2693 _a$2694)))))))) step)) (g0 (jolt-invoke (var-deref "clojure.core" "fresh-sym")))) (let* ((_a$2698 (var-deref "clojure.core" "__sqcat")) (_a$2699 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2700 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2695 (var-deref "clojure.core" "__sqvec")) (_a$2696 (jolt-invoke (var-deref "clojure.core" "__sq1") g0)) (_a$2697 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$2695 _a$2696 _a$2697)))) (_a$2701 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke step g0 clauses)))) (jolt-invoke _a$2698 _a$2699 _a$2700 _a$2701))))))
   (mark-macro! "clojure.core" "cond->"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "case"
-    (lambda (expr . clauses) (let fnrec2678 ((expr expr) (clauses (list->cseq clauses))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (mk-const (lambda (c) (let fnrec2679 ((c c)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") c))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "seq?") c)))) (let* ((_a$2680 (var-deref "clojure.core" "__sqcat")) (_a$2681 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2682 (jolt-invoke (var-deref "clojure.core" "__sq1") c))) (jolt-invoke _a$2680 _a$2681 _a$2682)) c)))) (mk-test (lambda (c) (let fnrec2683 ((c c)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") c)) (let* ((_a$2689 (var-deref "clojure.core" "__sqcat")) (_a$2690 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "or"))) (_a$2691 (jolt-map (lambda (v) (let fnrec2684 ((v v)) (let* ((_a$2685 (var-deref "clojure.core" "__sqcat")) (_a$2686 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "="))) (_a$2687 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2688 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke mk-const v)))) (jolt-invoke _a$2685 _a$2686 _a$2687 _a$2688)))) c))) (jolt-invoke _a$2689 _a$2690 _a$2691)) (let* ((_a$2692 (var-deref "clojure.core" "__sqcat")) (_a$2693 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "="))) (_a$2694 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2695 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke mk-const c)))) (jolt-invoke _a$2692 _a$2693 _a$2694 _a$2695)))))) (collect (letrec ((collect (lambda (cls acc) (let fnrec2696 ((cls cls) (acc acc)) (if (jolt-truthy? (let* ((or__14__auto (jolt-empty? cls))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-empty? (jolt-rest cls))))) acc (let* ((t (jolt-first cls)) (acc (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") t)) (jolt-reduce jolt-conj acc t) (jolt-conj acc t)))) (jolt-invoke collect (jolt-drop 2 cls) acc))))))) collect)) (first-dup (letrec ((fd (lambda (items seen) (let fnrec2697 ((items items) (seen seen)) (if (jolt-empty? items) jolt-nil (let* ((x (jolt-first items))) (if (jolt-truthy? (jolt-reduce (lambda (f s) (let fnrec2698 ((f f) (s s)) (let* ((or__14__auto f)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= s x))))) #f seen)) (jolt-vector x) (let* ((_a$2699 fd) (_a$2700 (jolt-rest items)) (_a$2701 (jolt-conj seen x))) (jolt-invoke _a$2699 _a$2700 _a$2701))))))))) fd)) (dup (let* ((_a$2702 first-dup) (_a$2703 (jolt-invoke collect clauses (jolt-vector))) (_a$2704 (jolt-vector))) (jolt-invoke _a$2702 _a$2703 _a$2704))) (build (letrec ((build (lambda (cls) (let fnrec2705 ((cls cls)) (if (jolt-empty? cls) (let* ((_a$2714 (var-deref "clojure.core" "__sqcat")) (_a$2715 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "throw"))) (_a$2716 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2710 (var-deref "clojure.core" "__sqcat")) (_a$2711 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "ex-info"))) (_a$2712 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2706 (var-deref "clojure.core" "__sqcat")) (_a$2707 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "str"))) (_a$2708 (jolt-invoke (var-deref "clojure.core" "__sq1") "No matching clause: ")) (_a$2709 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2706 _a$2707 _a$2708 _a$2709)))) (_a$2713 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$2710 _a$2711 _a$2712 _a$2713))))) (jolt-invoke _a$2714 _a$2715 _a$2716)) (if (jolt-empty? (jolt-rest cls)) (jolt-first cls) (let* ((_a$2717 (var-deref "clojure.core" "__sqcat")) (_a$2718 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2719 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke mk-test (jolt-first cls)))) (_a$2720 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth cls 1))) (_a$2721 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke build (jolt-drop 2 cls))))) (jolt-invoke _a$2717 _a$2718 _a$2719 _a$2720 _a$2721)))))))) build))) (if (jolt-truthy? dup) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Duplicate case test constant: " (jolt-first dup))) (let* ((_a$2725 (var-deref "clojure.core" "__sqcat")) (_a$2726 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2727 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2722 (var-deref "clojure.core" "__sqvec")) (_a$2723 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2724 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$2722 _a$2723 _a$2724)))) (_a$2728 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke build clauses)))) (jolt-invoke _a$2725 _a$2726 _a$2727 _a$2728)))))))
+    (lambda (expr . clauses) (let fnrec2702 ((expr expr) (clauses (list->cseq clauses))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (mk-const (lambda (c) (let fnrec2703 ((c c)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") c))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "seq?") c)))) (let* ((_a$2704 (var-deref "clojure.core" "__sqcat")) (_a$2705 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$2706 (jolt-invoke (var-deref "clojure.core" "__sq1") c))) (jolt-invoke _a$2704 _a$2705 _a$2706)) c)))) (mk-test (lambda (c) (let fnrec2707 ((c c)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") c)) (let* ((_a$2713 (var-deref "clojure.core" "__sqcat")) (_a$2714 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "or"))) (_a$2715 (jolt-map (lambda (v) (let fnrec2708 ((v v)) (let* ((_a$2709 (var-deref "clojure.core" "__sqcat")) (_a$2710 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "="))) (_a$2711 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2712 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke mk-const v)))) (jolt-invoke _a$2709 _a$2710 _a$2711 _a$2712)))) c))) (jolt-invoke _a$2713 _a$2714 _a$2715)) (let* ((_a$2716 (var-deref "clojure.core" "__sqcat")) (_a$2717 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "="))) (_a$2718 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2719 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke mk-const c)))) (jolt-invoke _a$2716 _a$2717 _a$2718 _a$2719)))))) (collect (letrec ((collect (lambda (cls acc) (let fnrec2720 ((cls cls) (acc acc)) (if (jolt-truthy? (let* ((or__14__auto (jolt-empty? cls))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-empty? (jolt-rest cls))))) acc (let* ((t (jolt-first cls)) (acc (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") t)) (jolt-reduce jolt-conj acc t) (jolt-conj acc t)))) (jolt-invoke collect (jolt-drop 2 cls) acc))))))) collect)) (first-dup (letrec ((fd (lambda (items seen) (let fnrec2721 ((items items) (seen seen)) (if (jolt-empty? items) jolt-nil (let* ((x (jolt-first items))) (if (jolt-truthy? (jolt-reduce (lambda (f s) (let fnrec2722 ((f f) (s s)) (let* ((or__14__auto f)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= s x))))) #f seen)) (jolt-vector x) (let* ((_a$2723 fd) (_a$2724 (jolt-rest items)) (_a$2725 (jolt-conj seen x))) (jolt-invoke _a$2723 _a$2724 _a$2725))))))))) fd)) (dup (let* ((_a$2726 first-dup) (_a$2727 (jolt-invoke collect clauses (jolt-vector))) (_a$2728 (jolt-vector))) (jolt-invoke _a$2726 _a$2727 _a$2728))) (build (letrec ((build (lambda (cls) (let fnrec2729 ((cls cls)) (if (jolt-empty? cls) (let* ((_a$2738 (var-deref "clojure.core" "__sqcat")) (_a$2739 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "throw"))) (_a$2740 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2734 (var-deref "clojure.core" "__sqcat")) (_a$2735 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "ex-info"))) (_a$2736 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2730 (var-deref "clojure.core" "__sqcat")) (_a$2731 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "str"))) (_a$2732 (jolt-invoke (var-deref "clojure.core" "__sq1") "No matching clause: ")) (_a$2733 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$2730 _a$2731 _a$2732 _a$2733)))) (_a$2737 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$2734 _a$2735 _a$2736 _a$2737))))) (jolt-invoke _a$2738 _a$2739 _a$2740)) (if (jolt-empty? (jolt-rest cls)) (jolt-first cls) (let* ((_a$2741 (var-deref "clojure.core" "__sqcat")) (_a$2742 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2743 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke mk-test (jolt-first cls)))) (_a$2744 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth cls 1))) (_a$2745 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke build (jolt-drop 2 cls))))) (jolt-invoke _a$2741 _a$2742 _a$2743 _a$2744 _a$2745)))))))) build))) (if (jolt-truthy? dup) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Duplicate case test constant: " (jolt-first dup))) (let* ((_a$2749 (var-deref "clojure.core" "__sqcat")) (_a$2750 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2751 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2746 (var-deref "clojure.core" "__sqvec")) (_a$2747 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$2748 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$2746 _a$2747 _a$2748)))) (_a$2752 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke build clauses)))) (jolt-invoke _a$2749 _a$2750 _a$2751 _a$2752)))))))
   (mark-macro! "clojure.core" "case"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "for"
-    (lambda (bindings body) (let fnrec2729 ((bindings bindings) (body body)) (let* ((scan (letrec ((scan (lambda (bvec i bind coll mods) (let fnrec2730 ((bvec bvec) (i i) (bind bind) (coll coll) (mods mods)) (if (jolt-truthy? (let* ((and__13__auto (< i (jolt-count bvec)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-nth bvec i)) and__13__auto))) (let* ((k (jolt-nth bvec i)) (v (jolt-nth bvec (jolt-inc i)))) (if (jolt= k (keyword #f "when")) (let* ((_a$2733 scan) (_a$2734 bvec) (_a$2735 (+ i 2)) (_a$2736 bind) (_a$2737 coll) (_a$2738 (jolt-conj mods (let* ((_o$2731 (keyword #f "when")) (_o$2732 v)) (jolt-vector _o$2731 _o$2732))))) (jolt-invoke _a$2733 _a$2734 _a$2735 _a$2736 _a$2737 _a$2738)) (if (jolt= k (keyword #f "let")) (let* ((_a$2741 scan) (_a$2742 bvec) (_a$2743 (+ i 2)) (_a$2744 bind) (_a$2745 coll) (_a$2746 (jolt-conj mods (let* ((_o$2739 (keyword #f "let")) (_o$2740 v)) (jolt-vector _o$2739 _o$2740))))) (jolt-invoke _a$2741 _a$2742 _a$2743 _a$2744 _a$2745 _a$2746)) (if (jolt= k (keyword #f "while")) (let* ((_a$2755 scan) (_a$2756 bvec) (_a$2757 (+ i 2)) (_a$2758 bind) (_a$2759 (let* ((_a$2751 (var-deref "clojure.core" "__sqcat")) (_a$2752 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "take-while"))) (_a$2753 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2747 (var-deref "clojure.core" "__sqcat")) (_a$2748 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2749 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") bind)))) (_a$2750 (jolt-invoke (var-deref "clojure.core" "__sq1") v))) (jolt-invoke _a$2747 _a$2748 _a$2749 _a$2750)))) (_a$2754 (jolt-invoke (var-deref "clojure.core" "__sq1") coll))) (jolt-invoke _a$2751 _a$2752 _a$2753 _a$2754))) (_a$2760 mods)) (jolt-invoke _a$2755 _a$2756 _a$2757 _a$2758 _a$2759 _a$2760)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke scan bvec (jolt-inc i) bind coll mods) jolt-nil))))) (let* ((_o$2761 i) (_o$2762 bind) (_o$2763 coll) (_o$2764 mods)) (jolt-vector _o$2761 _o$2762 _o$2763 _o$2764))))))) scan)) (parse-groups (letrec ((parse-groups (lambda (bvec i groups) (let fnrec2765 ((bvec bvec) (i i) (groups groups)) (if (>= i (jolt-count bvec)) groups (let* ((r (let* ((_a$2766 scan) (_a$2767 bvec) (_a$2768 (+ i 2)) (_a$2769 (jolt-nth bvec i)) (_a$2770 (jolt-nth bvec (jolt-inc i))) (_a$2771 (jolt-vector))) (jolt-invoke _a$2766 _a$2767 _a$2768 _a$2769 _a$2770 _a$2771)))) (let* ((_a$2775 parse-groups) (_a$2776 bvec) (_a$2777 (jolt-nth r 0)) (_a$2778 (jolt-conj groups (let* ((_o$2772 (jolt-nth r 1)) (_o$2773 (jolt-nth r 2)) (_o$2774 (jolt-nth r 3))) (jolt-vector _o$2772 _o$2773 _o$2774))))) (jolt-invoke _a$2775 _a$2776 _a$2777 _a$2778)))))))) parse-groups)) (wrap-mods (letrec ((wrap-mods (lambda (mods inner) (let fnrec2779 ((mods mods) (inner inner)) (if (jolt-empty? mods) inner (let* ((m (jolt-first mods)) (sub (jolt-invoke wrap-mods (jolt-rest mods) inner))) (if (jolt= (jolt-first m) (keyword #f "when")) (let* ((_a$2780 (var-deref "clojure.core" "__sqcat")) (_a$2781 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2782 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth m 1))) (_a$2783 (jolt-invoke (var-deref "clojure.core" "__sq1") sub)) (_a$2784 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec"))))) (jolt-invoke _a$2780 _a$2781 _a$2782 _a$2783 _a$2784)) (let* ((_a$2785 (var-deref "clojure.core" "__sqcat")) (_a$2786 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2787 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth m 1))) (_a$2788 (jolt-invoke (var-deref "clojure.core" "__sq1") sub))) (jolt-invoke _a$2785 _a$2786 _a$2787 _a$2788))))))))) wrap-mods)) (build (letrec ((build (lambda (idx groups) (let fnrec2789 ((idx idx) (groups groups)) (let* ((g (jolt-nth groups idx)) (my-bind (jolt-nth g 0)) (my-coll (jolt-nth g 1)) (my-mods (jolt-nth g 2)) (is-last (jolt= idx (jolt-dec (jolt-count groups))))) (if (jolt-truthy? (let* ((and__13__auto is-last)) (if (jolt-truthy? and__13__auto) (jolt-empty? my-mods) and__13__auto))) (let* ((_a$2794 (var-deref "clojure.core" "__sqcat")) (_a$2795 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "map"))) (_a$2796 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2790 (var-deref "clojure.core" "__sqcat")) (_a$2791 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2792 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") my-bind)))) (_a$2793 (jolt-invoke (var-deref "clojure.core" "__sq1") body))) (jolt-invoke _a$2790 _a$2791 _a$2792 _a$2793)))) (_a$2797 (jolt-invoke (var-deref "clojure.core" "__sq1") my-coll))) (jolt-invoke _a$2794 _a$2795 _a$2796 _a$2797)) (let* ((base (if (jolt-truthy? is-last) (let* ((_a$2798 (var-deref "clojure.core" "__sqcat")) (_a$2799 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "list"))) (_a$2800 (jolt-invoke (var-deref "clojure.core" "__sq1") body))) (jolt-invoke _a$2798 _a$2799 _a$2800)) (jolt-invoke build (jolt-inc idx) groups)))) (let* ((_a$2805 (var-deref "clojure.core" "__sqcat")) (_a$2806 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "mapcat"))) (_a$2807 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2801 (var-deref "clojure.core" "__sqcat")) (_a$2802 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2803 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") my-bind)))) (_a$2804 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke wrap-mods my-mods base)))) (jolt-invoke _a$2801 _a$2802 _a$2803 _a$2804)))) (_a$2808 (jolt-invoke (var-deref "clojure.core" "__sq1") my-coll))) (jolt-invoke _a$2805 _a$2806 _a$2807 _a$2808))))))))) build))) (if (>= (jolt-count bindings) 2) (jolt-invoke build 0 (jolt-invoke parse-groups bindings 0 (jolt-vector))) body)))))
+    (lambda (bindings body) (let fnrec2753 ((bindings bindings) (body body)) (let* ((scan (letrec ((scan (lambda (bvec i bind coll mods) (let fnrec2754 ((bvec bvec) (i i) (bind bind) (coll coll) (mods mods)) (if (jolt-truthy? (let* ((and__13__auto (< i (jolt-count bvec)))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-nth bvec i)) and__13__auto))) (let* ((k (jolt-nth bvec i)) (v (jolt-nth bvec (jolt-inc i)))) (if (jolt= k (keyword #f "when")) (let* ((_a$2757 scan) (_a$2758 bvec) (_a$2759 (+ i 2)) (_a$2760 bind) (_a$2761 coll) (_a$2762 (jolt-conj mods (let* ((_o$2755 (keyword #f "when")) (_o$2756 v)) (jolt-vector _o$2755 _o$2756))))) (jolt-invoke _a$2757 _a$2758 _a$2759 _a$2760 _a$2761 _a$2762)) (if (jolt= k (keyword #f "let")) (let* ((_a$2765 scan) (_a$2766 bvec) (_a$2767 (+ i 2)) (_a$2768 bind) (_a$2769 coll) (_a$2770 (jolt-conj mods (let* ((_o$2763 (keyword #f "let")) (_o$2764 v)) (jolt-vector _o$2763 _o$2764))))) (jolt-invoke _a$2765 _a$2766 _a$2767 _a$2768 _a$2769 _a$2770)) (if (jolt= k (keyword #f "while")) (let* ((_a$2779 scan) (_a$2780 bvec) (_a$2781 (+ i 2)) (_a$2782 bind) (_a$2783 (let* ((_a$2775 (var-deref "clojure.core" "__sqcat")) (_a$2776 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "take-while"))) (_a$2777 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2771 (var-deref "clojure.core" "__sqcat")) (_a$2772 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2773 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") bind)))) (_a$2774 (jolt-invoke (var-deref "clojure.core" "__sq1") v))) (jolt-invoke _a$2771 _a$2772 _a$2773 _a$2774)))) (_a$2778 (jolt-invoke (var-deref "clojure.core" "__sq1") coll))) (jolt-invoke _a$2775 _a$2776 _a$2777 _a$2778))) (_a$2784 mods)) (jolt-invoke _a$2779 _a$2780 _a$2781 _a$2782 _a$2783 _a$2784)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke scan bvec (jolt-inc i) bind coll mods) jolt-nil))))) (let* ((_o$2785 i) (_o$2786 bind) (_o$2787 coll) (_o$2788 mods)) (jolt-vector _o$2785 _o$2786 _o$2787 _o$2788))))))) scan)) (parse-groups (letrec ((parse-groups (lambda (bvec i groups) (let fnrec2789 ((bvec bvec) (i i) (groups groups)) (if (>= i (jolt-count bvec)) groups (let* ((r (let* ((_a$2790 scan) (_a$2791 bvec) (_a$2792 (+ i 2)) (_a$2793 (jolt-nth bvec i)) (_a$2794 (jolt-nth bvec (jolt-inc i))) (_a$2795 (jolt-vector))) (jolt-invoke _a$2790 _a$2791 _a$2792 _a$2793 _a$2794 _a$2795)))) (let* ((_a$2799 parse-groups) (_a$2800 bvec) (_a$2801 (jolt-nth r 0)) (_a$2802 (jolt-conj groups (let* ((_o$2796 (jolt-nth r 1)) (_o$2797 (jolt-nth r 2)) (_o$2798 (jolt-nth r 3))) (jolt-vector _o$2796 _o$2797 _o$2798))))) (jolt-invoke _a$2799 _a$2800 _a$2801 _a$2802)))))))) parse-groups)) (wrap-mods (letrec ((wrap-mods (lambda (mods inner) (let fnrec2803 ((mods mods) (inner inner)) (if (jolt-empty? mods) inner (let* ((m (jolt-first mods)) (sub (jolt-invoke wrap-mods (jolt-rest mods) inner))) (if (jolt= (jolt-first m) (keyword #f "when")) (let* ((_a$2804 (var-deref "clojure.core" "__sqcat")) (_a$2805 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2806 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth m 1))) (_a$2807 (jolt-invoke (var-deref "clojure.core" "__sq1") sub)) (_a$2808 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec"))))) (jolt-invoke _a$2804 _a$2805 _a$2806 _a$2807 _a$2808)) (let* ((_a$2809 (var-deref "clojure.core" "__sqcat")) (_a$2810 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$2811 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth m 1))) (_a$2812 (jolt-invoke (var-deref "clojure.core" "__sq1") sub))) (jolt-invoke _a$2809 _a$2810 _a$2811 _a$2812))))))))) wrap-mods)) (build (letrec ((build (lambda (idx groups) (let fnrec2813 ((idx idx) (groups groups)) (let* ((g (jolt-nth groups idx)) (my-bind (jolt-nth g 0)) (my-coll (jolt-nth g 1)) (my-mods (jolt-nth g 2)) (is-last (jolt= idx (jolt-dec (jolt-count groups))))) (if (jolt-truthy? (let* ((and__13__auto is-last)) (if (jolt-truthy? and__13__auto) (jolt-empty? my-mods) and__13__auto))) (let* ((_a$2818 (var-deref "clojure.core" "__sqcat")) (_a$2819 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "map"))) (_a$2820 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2814 (var-deref "clojure.core" "__sqcat")) (_a$2815 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2816 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") my-bind)))) (_a$2817 (jolt-invoke (var-deref "clojure.core" "__sq1") body))) (jolt-invoke _a$2814 _a$2815 _a$2816 _a$2817)))) (_a$2821 (jolt-invoke (var-deref "clojure.core" "__sq1") my-coll))) (jolt-invoke _a$2818 _a$2819 _a$2820 _a$2821)) (let* ((base (if (jolt-truthy? is-last) (let* ((_a$2822 (var-deref "clojure.core" "__sqcat")) (_a$2823 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "list"))) (_a$2824 (jolt-invoke (var-deref "clojure.core" "__sq1") body))) (jolt-invoke _a$2822 _a$2823 _a$2824)) (jolt-invoke build (jolt-inc idx) groups)))) (let* ((_a$2829 (var-deref "clojure.core" "__sqcat")) (_a$2830 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "mapcat"))) (_a$2831 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2825 (var-deref "clojure.core" "__sqcat")) (_a$2826 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$2827 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") my-bind)))) (_a$2828 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke wrap-mods my-mods base)))) (jolt-invoke _a$2825 _a$2826 _a$2827 _a$2828)))) (_a$2832 (jolt-invoke (var-deref "clojure.core" "__sq1") my-coll))) (jolt-invoke _a$2829 _a$2830 _a$2831 _a$2832))))))))) build))) (if (>= (jolt-count bindings) 2) (jolt-invoke build 0 (jolt-invoke parse-groups bindings 0 (jolt-vector))) body)))))
   (mark-macro! "clojure.core" "for"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "doseq"
-    (lambda (bindings . body) (let fnrec2809 ((bindings bindings) (body (list->cseq body))) (let* ((_a$2821 (var-deref "clojure.core" "__sqcat")) (_a$2822 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2823 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2818 (var-deref "clojure.core" "__sqcat")) (_a$2819 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "count"))) (_a$2820 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2814 (var-deref "clojure.core" "__sqcat")) (_a$2815 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "for"))) (_a$2816 (jolt-invoke (var-deref "clojure.core" "__sq1") bindings)) (_a$2817 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2810 (var-deref "clojure.core" "__sqcat")) (_a$2811 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2812 body) (_a$2813 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2810 _a$2811 _a$2812 _a$2813))))) (jolt-invoke _a$2814 _a$2815 _a$2816 _a$2817))))) (jolt-invoke _a$2818 _a$2819 _a$2820)))) (_a$2824 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2821 _a$2822 _a$2823 _a$2824)))))
+    (lambda (bindings . body) (let fnrec2833 ((bindings bindings) (body (list->cseq body))) (let* ((_a$2845 (var-deref "clojure.core" "__sqcat")) (_a$2846 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2847 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2842 (var-deref "clojure.core" "__sqcat")) (_a$2843 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "count"))) (_a$2844 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2838 (var-deref "clojure.core" "__sqcat")) (_a$2839 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "for"))) (_a$2840 (jolt-invoke (var-deref "clojure.core" "__sq1") bindings)) (_a$2841 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2834 (var-deref "clojure.core" "__sqcat")) (_a$2835 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$2836 body) (_a$2837 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2834 _a$2835 _a$2836 _a$2837))))) (jolt-invoke _a$2838 _a$2839 _a$2840 _a$2841))))) (jolt-invoke _a$2842 _a$2843 _a$2844)))) (_a$2848 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2845 _a$2846 _a$2847 _a$2848)))))
   (mark-macro! "clojure.core" "doseq"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "when-let"
-    (lambda (bindings . body) (let fnrec2825 ((bindings bindings) (body (list->cseq body))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$2841 (var-deref "clojure.core" "__sqcat")) (_a$2842 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2843 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2826 (var-deref "clojure.core" "__sqvec")) (_a$2827 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__15__auto"))) (_a$2828 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$2826 _a$2827 _a$2828)))) (_a$2844 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2836 (var-deref "clojure.core" "__sqcat")) (_a$2837 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2838 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__15__auto"))) (_a$2839 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2832 (var-deref "clojure.core" "__sqcat")) (_a$2833 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2834 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2829 (var-deref "clojure.core" "__sqvec")) (_a$2830 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$2831 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__15__auto")))) (jolt-invoke _a$2829 _a$2830 _a$2831)))) (_a$2835 body)) (jolt-invoke _a$2832 _a$2833 _a$2834 _a$2835)))) (_a$2840 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2836 _a$2837 _a$2838 _a$2839 _a$2840))))) (jolt-invoke _a$2841 _a$2842 _a$2843 _a$2844))))))
+    (lambda (bindings . body) (let fnrec2849 ((bindings bindings) (body (list->cseq body))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$2865 (var-deref "clojure.core" "__sqcat")) (_a$2866 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2867 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2850 (var-deref "clojure.core" "__sqvec")) (_a$2851 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__15__auto"))) (_a$2852 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$2850 _a$2851 _a$2852)))) (_a$2868 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2860 (var-deref "clojure.core" "__sqcat")) (_a$2861 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$2862 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__15__auto"))) (_a$2863 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2856 (var-deref "clojure.core" "__sqcat")) (_a$2857 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$2858 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2853 (var-deref "clojure.core" "__sqvec")) (_a$2854 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$2855 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__15__auto")))) (jolt-invoke _a$2853 _a$2854 _a$2855)))) (_a$2859 body)) (jolt-invoke _a$2856 _a$2857 _a$2858 _a$2859)))) (_a$2864 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$2860 _a$2861 _a$2862 _a$2863 _a$2864))))) (jolt-invoke _a$2865 _a$2866 _a$2867 _a$2868))))))
   (mark-macro! "clojure.core" "when-let"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "lazy-seq"
-    (lambda body (let fnrec2845 ((body (list->cseq body))) (let* ((_a$2853 (var-deref "clojure.core" "__sqcat")) (_a$2854 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-lazy-seq"))) (_a$2855 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2849 (var-deref "clojure.core" "__sqcat")) (_a$2850 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$2851 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$2852 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2846 (var-deref "clojure.core" "__sqcat")) (_a$2847 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "coll->cells"))) (_a$2848 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))) (jolt-invoke _a$2846 _a$2847 _a$2848))))) (jolt-invoke _a$2849 _a$2850 _a$2851 _a$2852))))) (jolt-invoke _a$2853 _a$2854 _a$2855)))))
+    (lambda body (let fnrec2869 ((body (list->cseq body))) (let* ((_a$2877 (var-deref "clojure.core" "__sqcat")) (_a$2878 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-lazy-seq"))) (_a$2879 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2873 (var-deref "clojure.core" "__sqcat")) (_a$2874 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$2875 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$2876 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$2870 (var-deref "clojure.core" "__sqcat")) (_a$2871 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "coll->cells"))) (_a$2872 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))) (jolt-invoke _a$2870 _a$2871 _a$2872))))) (jolt-invoke _a$2873 _a$2874 _a$2875 _a$2876))))) (jolt-invoke _a$2877 _a$2878 _a$2879)))))
   (mark-macro! "clojure.core" "lazy-seq"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "lazy-cat"
-    (lambda colls (let fnrec2856 ((colls (list->cseq colls))) (let* ((_a$2861 (var-deref "clojure.core" "__sqcat")) (_a$2862 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "concat"))) (_a$2863 (jolt-map (lambda (c) (let fnrec2857 ((c c)) (let* ((_a$2858 (var-deref "clojure.core" "__sqcat")) (_a$2859 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "lazy-seq"))) (_a$2860 (jolt-invoke (var-deref "clojure.core" "__sq1") c))) (jolt-invoke _a$2858 _a$2859 _a$2860)))) colls))) (jolt-invoke _a$2861 _a$2862 _a$2863)))))
+    (lambda colls (let fnrec2880 ((colls (list->cseq colls))) (let* ((_a$2885 (var-deref "clojure.core" "__sqcat")) (_a$2886 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "concat"))) (_a$2887 (jolt-map (lambda (c) (let fnrec2881 ((c c)) (let* ((_a$2882 (var-deref "clojure.core" "__sqcat")) (_a$2883 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "lazy-seq"))) (_a$2884 (jolt-invoke (var-deref "clojure.core" "__sq1") c))) (jolt-invoke _a$2882 _a$2883 _a$2884)))) colls))) (jolt-invoke _a$2885 _a$2886 _a$2887)))))
   (mark-macro! "clojure.core" "lazy-cat"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "not=" (letrec ((not= (case-lambda ((x) (let fnrec2864 ((x x)) #f)) ((x y) (let fnrec2865 ((x x) (y y)) (jolt-not (jolt= x y)))) ((x y . more) (let fnrec2866 ((x x) (y y) (more (list->cseq more))) (jolt-not (jolt-apply jolt= x y more))))))) not=)))
+  (def-var! "clojure.core" "not=" (letrec ((not= (case-lambda ((x) (let fnrec2888 ((x x)) #f)) ((x y) (let fnrec2889 ((x x) (y y)) (jolt-not (jolt= x y)))) ((x y . more) (let fnrec2890 ((x x) (y y) (more (list->cseq more))) (jolt-not (jolt-apply jolt= x y more))))))) not=)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unreduced" (letrec ((unreduced (lambda (x) (let fnrec2867 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) (jolt-invoke (var-deref "clojure.core" "deref") x) x))))) unreduced)))
+  (def-var! "clojure.core" "unreduced" (letrec ((unreduced (lambda (x) (let fnrec2891 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) (jolt-invoke (var-deref "clojure.core" "deref") x) x))))) unreduced)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "second" (letrec ((second (lambda (coll) (let fnrec2868 ((coll coll)) (jolt-first (jolt-next coll)))))) second)))
+  (def-var! "clojure.core" "second" (letrec ((second (lambda (coll) (let fnrec2892 ((coll coll)) (jolt-first (jolt-next coll)))))) second)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "peek" (letrec ((peek (lambda (coll) (let fnrec2869 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (if (jolt-zero? (jolt-count coll)) jolt-nil (jolt-nth coll (jolt-dec (jolt-count coll)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") coll)) (jolt-first coll) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "peek not supported on: " coll)) jolt-nil)))))))) peek)))
+  (def-var! "clojure.core" "peek" (letrec ((peek (lambda (coll) (let fnrec2893 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (if (jolt-zero? (jolt-count coll)) jolt-nil (jolt-nth coll (jolt-dec (jolt-count coll)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") coll)) (jolt-first coll) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "peek not supported on: " coll)) jolt-nil)))))))) peek)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "subvec" (letrec ((subvec (case-lambda ((v start) (let fnrec2870 ((v v) (start start)) (jolt-invoke subvec v start (jolt-count v)))) ((v start end) (let fnrec2871 ((v v) (start start) (end end)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "vector?") v)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "subvec requires a vector")) jolt-nil) (let* ((coerce (lambda (x) (let fnrec2872 ((x x)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "subvec index must be a number")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") x x)) 0 (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "long") x) jolt-nil)))))) (s (jolt-invoke coerce start)) (e (jolt-invoke coerce end))) (begin (if (jolt-truthy? (let* ((or__14__auto (< s 0))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (< e s))) (if (jolt-truthy? or__14__auto) or__14__auto (< (jolt-count v) e)))))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "subvec index out of range: " s " " e)) jolt-nil) (let* ((i s) (acc (jolt-vector))) (let loop2873 ((i i) (acc acc)) (if (< i e) (let* ((_a$2874 (jolt-inc i)) (_a$2875 (jolt-conj acc (jolt-nth v i)))) (loop2873 _a$2874 _a$2875)) acc))))))))))) subvec)))
+  (def-var! "clojure.core" "subvec" (letrec ((subvec (case-lambda ((v start) (let fnrec2894 ((v v) (start start)) (jolt-invoke subvec v start (jolt-count v)))) ((v start end) (let fnrec2895 ((v v) (start start) (end end)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "vector?") v)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "subvec requires a vector")) jolt-nil) (let* ((coerce (lambda (x) (let fnrec2896 ((x x)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "subvec index must be a number")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") x x)) 0 (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "long") x) jolt-nil)))))) (s (jolt-invoke coerce start)) (e (jolt-invoke coerce end))) (begin (if (jolt-truthy? (let* ((or__14__auto (< s 0))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (< e s))) (if (jolt-truthy? or__14__auto) or__14__auto (< (jolt-count v) e)))))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "subvec index out of range: " s " " e)) jolt-nil) (let* ((i s) (acc (jolt-vector))) (let loop2897 ((i i) (acc acc)) (if (< i e) (let* ((_a$2898 (jolt-inc i)) (_a$2899 (jolt-conj acc (jolt-nth v i)))) (loop2897 _a$2898 _a$2899)) acc))))))))))) subvec)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "mapv" (letrec ((mapv (lambda (f . colls) (let fnrec2876 ((f f) (colls (list->cseq colls))) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-apply jolt-map f colls)))))) mapv)))
+  (def-var! "clojure.core" "mapv" (letrec ((mapv (lambda (f . colls) (let fnrec2900 ((f f) (colls (list->cseq colls))) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-apply jolt-map f colls)))))) mapv)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "update" (letrec ((update (lambda (m k f . args) (let fnrec2877 ((m m) (k k) (f f) (args (list->cseq args))) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))) update)))
+  (def-var! "clojure.core" "update" (letrec ((update (lambda (m k f . args) (let fnrec2901 ((m m) (k k) (f f) (args (list->cseq args))) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))) update)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "vreset!" (letrec ((vreset! (lambda (vol newval) (let fnrec2047 ((vol vol) (newval newval)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") vol (keyword #f "val") newval) newval))))) vreset!)))
+  (def-var! "clojure.core" "vreset!" (letrec ((vreset! (lambda (vol newval) (let fnrec2071 ((vol vol) (newval newval)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") vol (keyword #f "val") newval) newval))))) vreset!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "vswap!" (letrec ((vswap! (lambda (vol f . args) (let fnrec2048 ((vol vol) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "vreset!") vol (jolt-apply f (jolt-get vol (keyword #f "val")) args)))))) vswap!)))
+  (def-var! "clojure.core" "vswap!" (letrec ((vswap! (lambda (vol f . args) (let fnrec2072 ((vol vol) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "vreset!") vol (jolt-apply f (jolt-get vol (keyword #f "val")) args)))))) vswap!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ffirst" (letrec ((ffirst (lambda (coll) (let fnrec2049 ((coll coll)) (jolt-first (jolt-first coll)))))) ffirst)))
+  (def-var! "clojure.core" "ffirst" (letrec ((ffirst (lambda (coll) (let fnrec2073 ((coll coll)) (jolt-first (jolt-first coll)))))) ffirst)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nfirst" (letrec ((nfirst (lambda (coll) (let fnrec2050 ((coll coll)) (jolt-next (jolt-first coll)))))) nfirst)))
+  (def-var! "clojure.core" "nfirst" (letrec ((nfirst (lambda (coll) (let fnrec2074 ((coll coll)) (jolt-next (jolt-first coll)))))) nfirst)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "fnext" (letrec ((fnext (lambda (coll) (let fnrec2051 ((coll coll)) (jolt-first (jolt-next coll)))))) fnext)))
+  (def-var! "clojure.core" "fnext" (letrec ((fnext (lambda (coll) (let fnrec2075 ((coll coll)) (jolt-first (jolt-next coll)))))) fnext)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nnext" (letrec ((nnext (lambda (coll) (let fnrec2052 ((coll coll)) (jolt-next (jolt-next coll)))))) nnext)))
+  (def-var! "clojure.core" "nnext" (letrec ((nnext (lambda (coll) (let fnrec2076 ((coll coll)) (jolt-next (jolt-next coll)))))) nnext)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "last" (letrec ((last (lambda (s) (let fnrec2053 ((s s)) (if (jolt-truthy? (jolt-next s)) (fnrec2053 (jolt-next s)) (jolt-first s)))))) last)))
+  (def-var! "clojure.core" "last" (letrec ((last (lambda (s) (let fnrec2077 ((s s)) (if (jolt-truthy? (jolt-next s)) (fnrec2077 (jolt-next s)) (jolt-first s)))))) last)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "butlast" (letrec ((butlast (lambda (s) (let fnrec2054 ((s s)) (let* ((ret (jolt-vector)) (s s)) (let loop2055 ((ret ret) (s s)) (if (jolt-truthy? (jolt-next s)) (let* ((_a$2056 (jolt-conj ret (jolt-first s))) (_a$2057 (jolt-next s))) (loop2055 _a$2056 _a$2057)) (jolt-seq ret)))))))) butlast)))
+  (def-var! "clojure.core" "butlast" (letrec ((butlast (lambda (s) (let fnrec2078 ((s s)) (let* ((ret (jolt-vector)) (s s)) (let loop2079 ((ret ret) (s s)) (if (jolt-truthy? (jolt-next s)) (let* ((_a$2080 (jolt-conj ret (jolt-first s))) (_a$2081 (jolt-next s))) (loop2079 _a$2080 _a$2081)) (jolt-seq ret)))))))) butlast)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "partition-by" (letrec ((partition-by (case-lambda ((f) (let fnrec2058 ((f f)) (lambda (rf) (let fnrec2059 ((rf rf)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector))) (pv (jolt-invoke (var-deref "clojure.core" "volatile!") jolt-nil)) (started (jolt-invoke (var-deref "clojure.core" "volatile!") #f))) (case-lambda (() (let fnrec2060 () (jolt-invoke rf))) ((result) (let fnrec2061 ((result result)) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf)) (result (if (jolt-zero? (jolt-count b)) result (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result b)))))) (jolt-invoke rf result)))) ((result input) (let fnrec2062 ((result result) (input input)) (let* ((val (jolt-invoke f input))) (if (jolt-truthy? (let* ((or__14__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") started)))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= val (jolt-invoke (var-deref "clojure.core" "deref") pv))))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") started #t) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) result) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (let* ((ret (jolt-invoke rf result b))) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "reduced?") ret)) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) jolt-nil) ret)))))))))))))) ((f coll) (let fnrec2063 ((f f) (coll coll)) (let* ((step (letrec ((step (lambda (s) (let fnrec2064 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2065 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((fst (jolt-first s)) (fv (jolt-invoke f fst)) (run (jolt-cons fst (let* ((_a$2067 (var-deref "clojure.core" "take-while")) (_a$2068 (lambda (x) (let fnrec2066 ((x x)) (jolt= fv (jolt-invoke f x))))) (_a$2069 (jolt-rest s))) (jolt-invoke _a$2067 _a$2068 _a$2069))))) (jolt-cons run (jolt-invoke step (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2070 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-drop (jolt-count run) s)))))))) jolt-nil)))))))))) step))) (jolt-invoke step coll))))))) partition-by)))
+  (def-var! "clojure.core" "partition-by" (letrec ((partition-by (case-lambda ((f) (let fnrec2082 ((f f)) (lambda (rf) (let fnrec2083 ((rf rf)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector))) (pv (jolt-invoke (var-deref "clojure.core" "volatile!") jolt-nil)) (started (jolt-invoke (var-deref "clojure.core" "volatile!") #f))) (case-lambda (() (let fnrec2084 () (jolt-invoke rf))) ((result) (let fnrec2085 ((result result)) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf)) (result (if (jolt-zero? (jolt-count b)) result (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result b)))))) (jolt-invoke rf result)))) ((result input) (let fnrec2086 ((result result) (input input)) (let* ((val (jolt-invoke f input))) (if (jolt-truthy? (let* ((or__14__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") started)))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= val (jolt-invoke (var-deref "clojure.core" "deref") pv))))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") started #t) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) result) (let* ((b (jolt-invoke (var-deref "clojure.core" "deref") buf))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") buf (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "vreset!") pv val) (let* ((ret (jolt-invoke rf result b))) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "reduced?") ret)) (jolt-invoke (var-deref "clojure.core" "vswap!") buf jolt-conj input) jolt-nil) ret)))))))))))))) ((f coll) (let fnrec2087 ((f f) (coll coll)) (let* ((step (letrec ((step (lambda (s) (let fnrec2088 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2089 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((fst (jolt-first s)) (fv (jolt-invoke f fst)) (run (jolt-cons fst (let* ((_a$2091 (var-deref "clojure.core" "take-while")) (_a$2092 (lambda (x) (let fnrec2090 ((x x)) (jolt= fv (jolt-invoke f x))))) (_a$2093 (jolt-rest s))) (jolt-invoke _a$2091 _a$2092 _a$2093))))) (jolt-cons run (jolt-invoke step (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec2094 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-drop (jolt-count run) s)))))))) jolt-nil)))))))))) step))) (jolt-invoke step coll))))))) partition-by)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "some?" (letrec ((some? (lambda (x) (let fnrec2071 ((x x)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") x)))))) some?)))
+  (def-var! "clojure.core" "some?" (letrec ((some? (lambda (x) (let fnrec2095 ((x x)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") x)))))) some?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "identity" (letrec ((identity (lambda (x) (let fnrec2072 ((x x)) x)))) identity)))
+  (def-var! "clojure.core" "identity" (letrec ((identity (lambda (x) (let fnrec2096 ((x x)) x)))) identity)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "constantly" (letrec ((constantly (lambda (x) (let fnrec2073 ((x x)) (lambda args (let fnrec2074 ((args (list->cseq args))) x)))))) constantly)))
+  (def-var! "clojure.core" "constantly" (letrec ((constantly (lambda (x) (let fnrec2097 ((x x)) (lambda args (let fnrec2098 ((args (list->cseq args))) x)))))) constantly)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "neg?" (letrec ((neg? (lambda (x) (let fnrec2075 ((x x)) (< x 0))))) neg?)))
+  (def-var! "clojure.core" "neg?" (letrec ((neg? (lambda (x) (let fnrec2099 ((x x)) (< x 0))))) neg?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bit-and" (letrec ((bit-and (case-lambda ((x y) (let fnrec2076 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and") x y))) ((x y . more) (let fnrec2077 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and") (jolt-invoke (var-deref "clojure.core" "__bit-and") x y) more)))))) bit-and)))
+  (def-var! "clojure.core" "bit-and" (letrec ((bit-and (case-lambda ((x y) (let fnrec2100 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and") x y))) ((x y . more) (let fnrec2101 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and") (jolt-invoke (var-deref "clojure.core" "__bit-and") x y) more)))))) bit-and)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bit-or" (letrec ((bit-or (case-lambda ((x y) (let fnrec2078 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-or") x y))) ((x y . more) (let fnrec2079 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-or") (jolt-invoke (var-deref "clojure.core" "__bit-or") x y) more)))))) bit-or)))
+  (def-var! "clojure.core" "bit-or" (letrec ((bit-or (case-lambda ((x y) (let fnrec2102 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-or") x y))) ((x y . more) (let fnrec2103 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-or") (jolt-invoke (var-deref "clojure.core" "__bit-or") x y) more)))))) bit-or)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bit-xor" (letrec ((bit-xor (case-lambda ((x y) (let fnrec2080 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y))) ((x y . more) (let fnrec2081 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-xor") (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y) more)))))) bit-xor)))
+  (def-var! "clojure.core" "bit-xor" (letrec ((bit-xor (case-lambda ((x y) (let fnrec2104 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y))) ((x y . more) (let fnrec2105 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-xor") (jolt-invoke (var-deref "clojure.core" "__bit-xor") x y) more)))))) bit-xor)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bit-and-not" (letrec ((bit-and-not (case-lambda ((x y) (let fnrec2082 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y))) ((x y . more) (let fnrec2083 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and-not") (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y) more)))))) bit-and-not)))
+  (def-var! "clojure.core" "bit-and-not" (letrec ((bit-and-not (case-lambda ((x y) (let fnrec2106 ((x x) (y y)) (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y))) ((x y . more) (let fnrec2107 ((x x) (y y) (more (list->cseq more))) (jolt-reduce (var-deref "clojure.core" "__bit-and-not") (jolt-invoke (var-deref "clojure.core" "__bit-and-not") x y) more)))))) bit-and-not)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pr-str" (letrec ((pr-str (lambda xs (let fnrec2084 ((xs (list->cseq xs))) (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop2085 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((_a$2090 (let* ((_a$2086 (var-deref "clojure.core" "str")) (_a$2087 out) (_a$2088 (if (jolt-truthy? first?) "" " ")) (_a$2089 (jolt-invoke (var-deref "clojure.core" "__pr-str1") (jolt-first s)))) (jolt-invoke _a$2086 _a$2087 _a$2088 _a$2089))) (_a$2091 (jolt-next s)) (_a$2092 #f)) (loop2085 _a$2090 _a$2091 _a$2092)) out))))))) pr-str)))
+  (def-var! "clojure.core" "pr-str" (letrec ((pr-str (lambda xs (let fnrec2108 ((xs (list->cseq xs))) (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop2109 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((_a$2114 (let* ((_a$2110 (var-deref "clojure.core" "str")) (_a$2111 out) (_a$2112 (if (jolt-truthy? first?) "" " ")) (_a$2113 (jolt-invoke (var-deref "clojure.core" "__pr-str1") (jolt-first s)))) (jolt-invoke _a$2110 _a$2111 _a$2112 _a$2113))) (_a$2115 (jolt-next s)) (_a$2116 #f)) (loop2109 _a$2114 _a$2115 _a$2116)) out))))))) pr-str)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pr" (letrec ((pr (lambda xs (let fnrec2093 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (jolt-apply (var-deref "clojure.core" "pr-str") xs)) jolt-nil))))) pr)))
+  (def-var! "clojure.core" "pr" (letrec ((pr (lambda xs (let fnrec2117 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (jolt-apply (var-deref "clojure.core" "pr-str") xs)) jolt-nil))))) pr)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "prn" (letrec ((prn (lambda xs (let fnrec2094 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "pr") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) prn)))
+  (def-var! "clojure.core" "prn" (letrec ((prn (lambda xs (let fnrec2118 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "pr") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) prn)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "print" (letrec ((print (lambda xs (let fnrec2095 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop2096 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((x (jolt-first s)) (r (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) "nil" (jolt-invoke (var-deref "clojure.core" "str") x)))) (let* ((_a$2097 (jolt-invoke (var-deref "clojure.core" "str") out (if (jolt-truthy? first?) "" " ") r)) (_a$2098 (jolt-next s)) (_a$2099 #f)) (loop2096 _a$2097 _a$2098 _a$2099))) out)))) jolt-nil))))) print)))
+  (def-var! "clojure.core" "print" (letrec ((print (lambda xs (let fnrec2119 ((xs (list->cseq xs))) (begin (jolt-invoke (var-deref "clojure.core" "__write") (let* ((out "") (s (jolt-seq xs)) (first? #t)) (let loop2120 ((out out) (s s) (first? first?)) (if (jolt-truthy? s) (let* ((x (jolt-first s)) (r (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) "nil" (jolt-invoke (var-deref "clojure.core" "str") x)))) (let* ((_a$2121 (jolt-invoke (var-deref "clojure.core" "str") out (if (jolt-truthy? first?) "" " ") r)) (_a$2122 (jolt-next s)) (_a$2123 #f)) (loop2120 _a$2121 _a$2122 _a$2123))) out)))) jolt-nil))))) print)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "println" (letrec ((println (lambda xs (let fnrec2100 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "print") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) println)))
+  (def-var! "clojure.core" "println" (letrec ((println (lambda xs (let fnrec2124 ((xs (list->cseq xs))) (begin (jolt-apply (var-deref "clojure.core" "print") xs) (jolt-invoke (var-deref "clojure.core" "__write") "\n") jolt-nil))))) println)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "frequencies" (letrec ((frequencies (lambda (coll) (let fnrec2101 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "persistent!") (let* ((_a$2103 (lambda (counts x) (let fnrec2102 ((counts counts) (x x)) (jolt-invoke (var-deref "clojure.core" "assoc!") counts x (jolt-inc (jolt-get counts x 0)))))) (_a$2104 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (_a$2105 coll)) (jolt-reduce _a$2103 _a$2104 _a$2105))))))) frequencies)))
+  (def-var! "clojure.core" "frequencies" (letrec ((frequencies (lambda (coll) (let fnrec2125 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "persistent!") (let* ((_a$2127 (lambda (counts x) (let fnrec2126 ((counts counts) (x x)) (jolt-invoke (var-deref "clojure.core" "assoc!") counts x (jolt-inc (jolt-get counts x 0)))))) (_a$2128 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (_a$2129 coll)) (jolt-reduce _a$2127 _a$2128 _a$2129))))))) frequencies)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "group-by" (letrec ((group-by (lambda (f coll) (let fnrec2106 ((f f) (coll coll)) (let* ((tm (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (ks (let* ((_a$2108 (lambda (ks x) (let fnrec2107 ((ks ks) (x x)) (let* ((k (jolt-invoke f x)) (b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-vector x)) (jolt-invoke (var-deref "clojure.core" "conj!") ks k)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "conj!") (jolt-invoke (var-deref "clojure.core" "transient") b) x)) ks) (begin (jolt-invoke (var-deref "clojure.core" "conj!") b x) ks))))))) (_a$2109 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (_a$2110 coll)) (jolt-reduce _a$2108 _a$2109 _a$2110)))) (begin (let* ((_a$2112 (lambda (_ k) (let fnrec2111 ((_ _) (k k)) (let* ((b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) jolt-nil (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "persistent!") b))))))) (_a$2113 jolt-nil) (_a$2114 (jolt-invoke (var-deref "clojure.core" "persistent!") ks))) (jolt-reduce _a$2112 _a$2113 _a$2114)) (jolt-invoke (var-deref "clojure.core" "persistent!") tm))))))) group-by)))
+  (def-var! "clojure.core" "group-by" (letrec ((group-by (lambda (f coll) (let fnrec2130 ((f f) (coll coll)) (let* ((tm (jolt-invoke (var-deref "clojure.core" "transient") (jolt-hash-map))) (ks (let* ((_a$2132 (lambda (ks x) (let fnrec2131 ((ks ks) (x x)) (let* ((k (jolt-invoke f x)) (b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-vector x)) (jolt-invoke (var-deref "clojure.core" "conj!") ks k)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) (begin (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "conj!") (jolt-invoke (var-deref "clojure.core" "transient") b) x)) ks) (begin (jolt-invoke (var-deref "clojure.core" "conj!") b x) ks))))))) (_a$2133 (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (_a$2134 coll)) (jolt-reduce _a$2132 _a$2133 _a$2134)))) (begin (let* ((_a$2136 (lambda (_ k) (let fnrec2135 ((_ _) (k k)) (let* ((b (jolt-get tm k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") b)) jolt-nil (jolt-invoke (var-deref "clojure.core" "assoc!") tm k (jolt-invoke (var-deref "clojure.core" "persistent!") b))))))) (_a$2137 jolt-nil) (_a$2138 (jolt-invoke (var-deref "clojure.core" "persistent!") ks))) (jolt-reduce _a$2136 _a$2137 _a$2138)) (jolt-invoke (var-deref "clojure.core" "persistent!") tm))))))) group-by)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "not-empty" (letrec ((not-empty (lambda (coll) (let fnrec2115 ((coll coll)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") coll))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-zero? (jolt-count coll))))) jolt-nil coll))))) not-empty)))
+  (def-var! "clojure.core" "not-empty" (letrec ((not-empty (lambda (coll) (let fnrec2139 ((coll coll)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") coll))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-zero? (jolt-count coll))))) jolt-nil coll))))) not-empty)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "filterv" (letrec ((filterv (lambda (pred coll) (let fnrec2116 ((pred pred) (coll coll)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-filter pred coll)))))) filterv)))
+  (def-var! "clojure.core" "filterv" (letrec ((filterv (lambda (pred coll) (let fnrec2140 ((pred pred) (coll coll)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-filter pred coll)))))) filterv)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "max-key" (letrec ((max-key (case-lambda ((k x) (let fnrec2117 ((k k) (x x)) x)) ((k x y) (let fnrec2118 ((k k) (x x) (y y)) (if (let* ((_a$2119 (jolt-invoke k x)) (_a$2120 (jolt-invoke k y))) (> _a$2119 _a$2120)) x y))) ((k x y . more) (let fnrec2121 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (> kx ky) x y)) (kv (if (> kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop2122 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (>= kw kv) (loop2122 w kw (jolt-next more)) (loop2122 v kv (jolt-next more)))) v))))))))) max-key)))
+  (def-var! "clojure.core" "max-key" (letrec ((max-key (case-lambda ((k x) (let fnrec2141 ((k k) (x x)) x)) ((k x y) (let fnrec2142 ((k k) (x x) (y y)) (if (let* ((_a$2143 (jolt-invoke k x)) (_a$2144 (jolt-invoke k y))) (> _a$2143 _a$2144)) x y))) ((k x y . more) (let fnrec2145 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (> kx ky) x y)) (kv (if (> kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop2146 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (>= kw kv) (loop2146 w kw (jolt-next more)) (loop2146 v kv (jolt-next more)))) v))))))))) max-key)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "min-key" (letrec ((min-key (case-lambda ((k x) (let fnrec2123 ((k k) (x x)) x)) ((k x y) (let fnrec2124 ((k k) (x x) (y y)) (if (let* ((_a$2125 (jolt-invoke k x)) (_a$2126 (jolt-invoke k y))) (< _a$2125 _a$2126)) x y))) ((k x y . more) (let fnrec2127 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (< kx ky) x y)) (kv (if (< kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop2128 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (<= kw kv) (loop2128 w kw (jolt-next more)) (loop2128 v kv (jolt-next more)))) v))))))))) min-key)))
+  (def-var! "clojure.core" "min-key" (letrec ((min-key (case-lambda ((k x) (let fnrec2147 ((k k) (x x)) x)) ((k x y) (let fnrec2148 ((k k) (x x) (y y)) (if (let* ((_a$2149 (jolt-invoke k x)) (_a$2150 (jolt-invoke k y))) (< _a$2149 _a$2150)) x y))) ((k x y . more) (let fnrec2151 ((k k) (x x) (y y) (more (list->cseq more))) (let* ((kx (jolt-invoke k x)) (ky (jolt-invoke k y)) (v (if (< kx ky) x y)) (kv (if (< kx ky) kx ky))) (let* ((v v) (kv kv) (more more)) (let loop2152 ((v v) (kv kv) (more more)) (if (jolt-truthy? (jolt-seq more)) (let* ((w (jolt-first more)) (kw (jolt-invoke k w))) (if (<= kw kv) (loop2152 w kw (jolt-next more)) (loop2152 v kv (jolt-next more)))) v))))))))) min-key)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "juxt" (letrec ((juxt (lambda fs (let fnrec2129 ((fs (list->cseq fs))) (lambda args (let fnrec2130 ((args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (f) (let fnrec2131 ((f f)) (jolt-apply f args))) fs))))))) juxt)))
+  (def-var! "clojure.core" "juxt" (letrec ((juxt (lambda fs (let fnrec2153 ((fs (list->cseq fs))) (lambda args (let fnrec2154 ((args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (f) (let fnrec2155 ((f f)) (jolt-apply f args))) fs))))))) juxt)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "every-pred" (letrec ((every-pred (lambda preds (let fnrec2132 ((preds (list->cseq preds))) (lambda xs (let fnrec2133 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (p) (let fnrec2134 ((p p)) (jolt-invoke (var-deref "clojure.core" "every?") p xs))) preds))))))) every-pred)))
+  (def-var! "clojure.core" "every-pred" (letrec ((every-pred (lambda preds (let fnrec2156 ((preds (list->cseq preds))) (lambda xs (let fnrec2157 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (p) (let fnrec2158 ((p p)) (jolt-invoke (var-deref "clojure.core" "every?") p xs))) preds))))))) every-pred)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "some" (letrec ((some (lambda (pred coll) (let fnrec2135 ((pred pred) (coll coll)) (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((or__14__auto (jolt-invoke pred (jolt-first s)))) (if (jolt-truthy? or__14__auto) or__14__auto (fnrec2135 pred (jolt-next s))))) jolt-nil)))))) some)))
+  (def-var! "clojure.core" "some" (letrec ((some (lambda (pred coll) (let fnrec2159 ((pred pred) (coll coll)) (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((or__14__auto (jolt-invoke pred (jolt-first s)))) (if (jolt-truthy? or__14__auto) or__14__auto (fnrec2159 pred (jolt-next s))))) jolt-nil)))))) some)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "some-fn" (letrec ((some-fn (lambda preds (let fnrec2136 ((preds (list->cseq preds))) (lambda xs (let fnrec2137 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "some") (lambda (p) (let fnrec2138 ((p p)) (jolt-invoke (var-deref "clojure.core" "some") p xs))) preds))))))) some-fn)))
+  (def-var! "clojure.core" "some-fn" (letrec ((some-fn (lambda preds (let fnrec2160 ((preds (list->cseq preds))) (lambda xs (let fnrec2161 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "some") (lambda (p) (let fnrec2162 ((p p)) (jolt-invoke (var-deref "clojure.core" "some") p xs))) preds))))))) some-fn)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "not-any?" (letrec ((not-any? (lambda (pred coll) (let fnrec2139 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "some") pred coll)))))) not-any?)))
+  (def-var! "clojure.core" "not-any?" (letrec ((not-any? (lambda (pred coll) (let fnrec2163 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "some") pred coll)))))) not-any?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "not-every?" (letrec ((not-every? (lambda (pred coll) (let fnrec2140 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") pred coll)))))) not-every?)))
+  (def-var! "clojure.core" "not-every?" (letrec ((not-every? (lambda (pred coll) (let fnrec2164 ((pred pred) (coll coll)) (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") pred coll)))))) not-every?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "split-at" (letrec ((split-at (lambda (n coll) (let fnrec2141 ((n n) (coll coll)) (let* ((_o$2142 (jolt-take n coll)) (_o$2143 (jolt-drop n coll))) (jolt-vector _o$2142 _o$2143)))))) split-at)))
+  (def-var! "clojure.core" "split-at" (letrec ((split-at (lambda (n coll) (let fnrec2165 ((n n) (coll coll)) (let* ((_o$2166 (jolt-take n coll)) (_o$2167 (jolt-drop n coll))) (jolt-vector _o$2166 _o$2167)))))) split-at)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "split-with" (letrec ((split-with (lambda (pred coll) (let fnrec2144 ((pred pred) (coll coll)) (let* ((_o$2145 (jolt-invoke (var-deref "clojure.core" "take-while") pred coll)) (_o$2146 (jolt-invoke (var-deref "clojure.core" "drop-while") pred coll))) (jolt-vector _o$2145 _o$2146)))))) split-with)))
+  (def-var! "clojure.core" "split-with" (letrec ((split-with (lambda (pred coll) (let fnrec2168 ((pred pred) (coll coll)) (let* ((_o$2169 (jolt-invoke (var-deref "clojure.core" "take-while") pred coll)) (_o$2170 (jolt-invoke (var-deref "clojure.core" "drop-while") pred coll))) (jolt-vector _o$2169 _o$2170)))))) split-with)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "qualified-keyword?" (letrec ((qualified-keyword? (lambda (x) (let fnrec2147 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-keyword?)))
+  (def-var! "clojure.core" "qualified-keyword?" (letrec ((qualified-keyword? (lambda (x) (let fnrec2171 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-keyword?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "simple-keyword?" (letrec ((simple-keyword? (lambda (x) (let fnrec2148 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-keyword?)))
+  (def-var! "clojure.core" "simple-keyword?" (letrec ((simple-keyword? (lambda (x) (let fnrec2172 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-keyword?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "qualified-symbol?" (letrec ((qualified-symbol? (lambda (x) (let fnrec2149 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-symbol?)))
+  (def-var! "clojure.core" "qualified-symbol?" (letrec ((qualified-symbol? (lambda (x) (let fnrec2173 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) qualified-symbol?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "simple-symbol?" (letrec ((simple-symbol? (lambda (x) (let fnrec2150 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-symbol?)))
+  (def-var! "clojure.core" "simple-symbol?" (letrec ((simple-symbol? (lambda (x) (let fnrec2174 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "namespace") x)) and__13__auto)))))) simple-symbol?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ident?" (letrec ((ident? (lambda (x) (let fnrec2151 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))))))) ident?)))
+  (def-var! "clojure.core" "ident?" (letrec ((ident? (lambda (x) (let fnrec2175 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))))))) ident?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "qualified-ident?" (letrec ((qualified-ident? (lambda (x) (let fnrec2152 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-keyword?") x))))))) qualified-ident?)))
+  (def-var! "clojure.core" "qualified-ident?" (letrec ((qualified-ident? (lambda (x) (let fnrec2176 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "qualified-keyword?") x))))))) qualified-ident?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "simple-ident?" (letrec ((simple-ident? (lambda (x) (let fnrec2153 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-keyword?") x))))))) simple-ident?)))
+  (def-var! "clojure.core" "simple-ident?" (letrec ((simple-ident? (lambda (x) (let fnrec2177 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "simple-keyword?") x))))))) simple-ident?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ratio?" (letrec ((ratio? (lambda (x) (let fnrec2154 ((x x)) #f)))) ratio?)))
+  (def-var! "clojure.core" "ratio?" (letrec ((ratio? (lambda (x) (let fnrec2178 ((x x)) #f)))) ratio?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "decimal?" (letrec ((decimal? (lambda (x) (let fnrec2155 ((x x)) #f)))) decimal?)))
+  (def-var! "clojure.core" "decimal?" (letrec ((decimal? (lambda (x) (let fnrec2179 ((x x)) #f)))) decimal?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "class?" (letrec ((class? (lambda (x) (let fnrec2156 ((x x)) #f)))) class?)))
+  (def-var! "clojure.core" "class?" (letrec ((class? (lambda (x) (let fnrec2180 ((x x)) #f)))) class?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "rational?" (letrec ((rational? (lambda (x) (let fnrec2157 ((x x)) (jolt-invoke (var-deref "clojure.core" "int?") x))))) rational?)))
+  (def-var! "clojure.core" "rational?" (letrec ((rational? (lambda (x) (let fnrec2181 ((x x)) (jolt-invoke (var-deref "clojure.core" "int?") x))))) rational?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nat-int?" (letrec ((nat-int? (lambda (x) (let fnrec2158 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (>= x 0) and__13__auto)))))) nat-int?)))
+  (def-var! "clojure.core" "nat-int?" (letrec ((nat-int? (lambda (x) (let fnrec2182 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (>= x 0) and__13__auto)))))) nat-int?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "neg-int?" (letrec ((neg-int? (lambda (x) (let fnrec2159 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-neg? x) and__13__auto)))))) neg-int?)))
+  (def-var! "clojure.core" "neg-int?" (letrec ((neg-int? (lambda (x) (let fnrec2183 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-neg? x) and__13__auto)))))) neg-int?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pos-int?" (letrec ((pos-int? (lambda (x) (let fnrec2160 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-pos? x) and__13__auto)))))) pos-int?)))
+  (def-var! "clojure.core" "pos-int?" (letrec ((pos-int? (lambda (x) (let fnrec2184 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "int?") x))) (if (jolt-truthy? and__13__auto) (jolt-pos? x) and__13__auto)))))) pos-int?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "replicate" (letrec ((replicate (lambda (n x) (let fnrec2161 ((n n) (x x)) (let* ((_a$2163 (lambda (_) (let fnrec2162 ((_ _)) x))) (_a$2164 (jolt-range n))) (jolt-map _a$2163 _a$2164)))))) replicate)))
+  (def-var! "clojure.core" "replicate" (letrec ((replicate (lambda (n x) (let fnrec2185 ((n n) (x x)) (let* ((_a$2187 (lambda (_) (let fnrec2186 ((_ _)) x))) (_a$2188 (jolt-range n))) (jolt-map _a$2187 _a$2188)))))) replicate)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "take-last" (letrec ((take-last (lambda (n coll) (let fnrec2165 ((n n) (coll coll)) (let* ((c (jolt-invoke (var-deref "clojure.core" "vec") coll)) (len (jolt-count c))) (if (jolt-pos? len) (jolt-seq (jolt-invoke (var-deref "clojure.core" "subvec") c (max 0 (- len n)))) jolt-nil)))))) take-last)))
+  (def-var! "clojure.core" "take-last" (letrec ((take-last (lambda (n coll) (let fnrec2189 ((n n) (coll coll)) (let* ((c (jolt-invoke (var-deref "clojure.core" "vec") coll)) (len (jolt-count c))) (if (jolt-pos? len) (jolt-seq (jolt-invoke (var-deref "clojure.core" "subvec") c (max 0 (- len n)))) jolt-nil)))))) take-last)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "drop-last" (letrec ((drop-last (case-lambda ((coll) (let fnrec2166 ((coll coll)) (jolt-invoke drop-last 1 coll))) ((n coll) (let fnrec2167 ((n n) (coll coll)) (let* ((_a$2169 (lambda (x _) (let fnrec2168 ((x x) (_ _)) x))) (_a$2170 coll) (_a$2171 (jolt-drop n coll))) (jolt-map _a$2169 _a$2170 _a$2171))))))) drop-last)))
+  (def-var! "clojure.core" "drop-last" (letrec ((drop-last (case-lambda ((coll) (let fnrec2190 ((coll coll)) (jolt-invoke drop-last 1 coll))) ((n coll) (let fnrec2191 ((n n) (coll coll)) (let* ((_a$2193 (lambda (x _) (let fnrec2192 ((x x) (_ _)) x))) (_a$2194 coll) (_a$2195 (jolt-drop n coll))) (jolt-map _a$2193 _a$2194 _a$2195))))))) drop-last)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "distinct?" (letrec ((distinct? (case-lambda ((x) (let fnrec2172 ((x x)) #t)) ((x y) (let fnrec2173 ((x x) (y y)) (jolt-not (jolt= x y)))) ((x y . more) (let fnrec2174 ((x x) (y y) (more (list->cseq more))) (if (jolt-not (jolt= x y)) (let* ((s (let* ((_o$2176 x) (_o$2177 y)) (jolt-hash-set _o$2176 _o$2177))) (xs more)) (let loop2175 ((s s) (xs xs)) (if (jolt-truthy? xs) (let* ((x (jolt-first xs))) (if (jolt-contains? s x) #f (let* ((_a$2178 (jolt-conj s x)) (_a$2179 (jolt-next xs))) (loop2175 _a$2178 _a$2179)))) #t))) #f)))))) distinct?)))
+  (def-var! "clojure.core" "distinct?" (letrec ((distinct? (case-lambda ((x) (let fnrec2196 ((x x)) #t)) ((x y) (let fnrec2197 ((x x) (y y)) (jolt-not (jolt= x y)))) ((x y . more) (let fnrec2198 ((x x) (y y) (more (list->cseq more))) (if (jolt-not (jolt= x y)) (let* ((s (let* ((_o$2200 x) (_o$2201 y)) (jolt-hash-set _o$2200 _o$2201))) (xs more)) (let loop2199 ((s s) (xs xs)) (if (jolt-truthy? xs) (let* ((x (jolt-first xs))) (if (jolt-contains? s x) #f (let* ((_a$2202 (jolt-conj s x)) (_a$2203 (jolt-next xs))) (loop2199 _a$2202 _a$2203)))) #t))) #f)))))) distinct?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "replace" (letrec ((replace (lambda (smap coll) (let fnrec2180 ((smap smap) (coll coll)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (x) (let fnrec2181 ((x x)) (jolt-get smap x x))) coll))))) replace)))
+  (def-var! "clojure.core" "replace" (letrec ((replace (lambda (smap coll) (let fnrec2204 ((smap smap) (coll coll)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (x) (let fnrec2205 ((x x)) (jolt-get smap x x))) coll))))) replace)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nthnext" (letrec ((nthnext (lambda (coll n) (let fnrec2182 ((coll coll) (n n)) (let* ((n n) (xs (jolt-seq coll))) (let loop2183 ((n n) (xs xs)) (if (jolt-truthy? (let* ((and__13__auto xs)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$2184 (jolt-dec n)) (_a$2185 (jolt-next xs))) (loop2183 _a$2184 _a$2185)) xs))))))) nthnext)))
+  (def-var! "clojure.core" "nthnext" (letrec ((nthnext (lambda (coll n) (let fnrec2206 ((coll coll) (n n)) (let* ((n n) (xs (jolt-seq coll))) (let loop2207 ((n n) (xs xs)) (if (jolt-truthy? (let* ((and__13__auto xs)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$2208 (jolt-dec n)) (_a$2209 (jolt-next xs))) (loop2207 _a$2208 _a$2209)) xs))))))) nthnext)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bounded-count" (letrec ((bounded-count (lambda (n coll) (let fnrec2186 ((n n) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "counted?") coll)) (jolt-count coll) (let* ((i 0) (s (jolt-seq coll))) (let loop2187 ((i i) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (< i n) and__13__auto))) (let* ((_a$2188 (jolt-inc i)) (_a$2189 (jolt-next s))) (loop2187 _a$2188 _a$2189)) i)))))))) bounded-count)))
+  (def-var! "clojure.core" "bounded-count" (letrec ((bounded-count (lambda (n coll) (let fnrec2210 ((n n) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "counted?") coll)) (jolt-count coll) (let* ((i 0) (s (jolt-seq coll))) (let loop2211 ((i i) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (< i n) and__13__auto))) (let* ((_a$2212 (jolt-inc i)) (_a$2213 (jolt-next s))) (loop2211 _a$2212 _a$2213)) i)))))))) bounded-count)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "run!" (letrec ((run! (lambda (proc coll) (let fnrec2190 ((proc proc) (coll coll)) (begin (jolt-reduce (lambda (_ x) (let fnrec2191 ((_ _) (x x)) (begin (jolt-invoke proc x) jolt-nil))) jolt-nil coll) jolt-nil))))) run!)))
+  (def-var! "clojure.core" "run!" (letrec ((run! (lambda (proc coll) (let fnrec2214 ((proc proc) (coll coll)) (begin (jolt-reduce (lambda (_ x) (let fnrec2215 ((_ _) (x x)) (begin (jolt-invoke proc x) jolt-nil))) jolt-nil coll) jolt-nil))))) run!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "completing" (letrec ((completing (case-lambda ((f) (let fnrec2192 ((f f)) (jolt-invoke completing f jolt-identity))) ((f cf) (let fnrec2193 ((f f) (cf cf)) (case-lambda (() (let fnrec2194 () (jolt-invoke f))) ((x) (let fnrec2195 ((x x)) (jolt-invoke cf x))) ((x y) (let fnrec2196 ((x x) (y y)) (jolt-invoke f x y))))))))) completing)))
+  (def-var! "clojure.core" "completing" (letrec ((completing (case-lambda ((f) (let fnrec2216 ((f f)) (jolt-invoke completing f jolt-identity))) ((f cf) (let fnrec2217 ((f f) (cf cf)) (case-lambda (() (let fnrec2218 () (jolt-invoke f))) ((x) (let fnrec2219 ((x x)) (jolt-invoke cf x))) ((x y) (let fnrec2220 ((x x) (y y)) (jolt-invoke f x y))))))))) completing)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nthrest" (letrec ((nthrest (lambda (coll n) (let fnrec2197 ((coll coll) (n n)) (if (jolt-pos? n) (let* ((or__14__auto (let* ((n n) (xs coll)) (let loop2198 ((n n) (xs xs)) (let* ((s (let* ((and__13__auto (jolt-pos? n))) (if (jolt-truthy? and__13__auto) (jolt-seq xs) and__13__auto)))) (if (jolt-truthy? s) (let* ((_a$2199 (jolt-dec n)) (_a$2200 (jolt-rest s))) (loop2198 _a$2199 _a$2200)) (jolt-seq xs))))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-list ))) coll))))) nthrest)))
+  (def-var! "clojure.core" "nthrest" (letrec ((nthrest (lambda (coll n) (let fnrec2221 ((coll coll) (n n)) (if (jolt-pos? n) (let* ((or__14__auto (let* ((n n) (xs coll)) (let loop2222 ((n n) (xs xs)) (let* ((s (let* ((and__13__auto (jolt-pos? n))) (if (jolt-truthy? and__13__auto) (jolt-seq xs) and__13__auto)))) (if (jolt-truthy? s) (let* ((_a$2223 (jolt-dec n)) (_a$2224 (jolt-rest s))) (loop2222 _a$2223 _a$2224)) (jolt-seq xs))))))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-list ))) coll))))) nthrest)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "abs" (letrec ((abs (lambda (x) (let fnrec2201 ((x x)) (if (jolt-neg? x) (- 0 x) x))))) abs)))
+  (def-var! "clojure.core" "abs" (letrec ((abs (lambda (x) (let fnrec2225 ((x x)) (if (jolt-neg? x) (- 0 x) x))))) abs)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "NaN?" (letrec ((NaN? (lambda (x) (let fnrec2202 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt-not (jolt= x x)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "NaN? requires a number"))))))) NaN?)))
+  (def-var! "clojure.core" "NaN?" (letrec ((NaN? (lambda (x) (let fnrec2226 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) (jolt-not (jolt= x x)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "NaN? requires a number"))))))) NaN?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "object?" (letrec ((object? (lambda (x) (let fnrec2203 ((x x)) #f)))) object?)))
+  (def-var! "clojure.core" "object?" (letrec ((object? (lambda (x) (let fnrec2227 ((x x)) #f)))) object?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "undefined?" (letrec ((undefined? (lambda (x) (let fnrec2204 ((x x)) #f)))) undefined?)))
+  (def-var! "clojure.core" "undefined?" (letrec ((undefined? (lambda (x) (let fnrec2228 ((x x)) #f)))) undefined?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "keyword-identical?" (letrec ((keyword-identical? (lambda (a b) (let fnrec2205 ((a a) (b b)) (jolt= a b))))) keyword-identical?)))
+  (def-var! "clojure.core" "keyword-identical?" (letrec ((keyword-identical? (lambda (a b) (let fnrec2229 ((a a) (b b)) (jolt= a b))))) keyword-identical?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "any?" (letrec ((any? (lambda (x) (let fnrec2206 ((x x)) #t)))) any?)))
+  (def-var! "clojure.core" "any?" (letrec ((any? (lambda (x) (let fnrec2230 ((x x)) #t)))) any?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "printf" (letrec ((printf (lambda (fmt . args) (let fnrec2207 ((fmt fmt) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "print") (jolt-apply (var-deref "clojure.core" "format") fmt args)))))) printf)))
+  (def-var! "clojure.core" "printf" (letrec ((printf (lambda (fmt . args) (let fnrec2231 ((fmt fmt) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "print") (jolt-apply (var-deref "clojure.core" "format") fmt args)))))) printf)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bound?" (letrec ((bound? (lambda vars (let fnrec2208 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec2209 ((v v)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get v (keyword #f "root"))))) vars))))) bound?)))
+  (def-var! "clojure.core" "bound?" (letrec ((bound? (lambda vars (let fnrec2232 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec2233 ((v v)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get v (keyword #f "root"))))) vars))))) bound?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "with-bindings*" (letrec ((with-bindings* (lambda (binding-map f . args) (let fnrec2210 ((binding-map binding-map) (f f) (args (list->cseq args))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") binding-map) (dynamic-wind (lambda () #f) (lambda () (jolt-apply f args)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))) with-bindings*)))
+  (def-var! "clojure.core" "with-bindings*" (letrec ((with-bindings* (lambda (binding-map f . args) (let fnrec2234 ((binding-map binding-map) (f f) (args (list->cseq args))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") binding-map) (dynamic-wind (lambda () #f) (lambda () (jolt-apply f args)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))) with-bindings*)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bound-fn*" (letrec ((bound-fn* (lambda (f) (let fnrec2211 ((f f)) (let* ((bs (jolt-invoke (var-deref "clojure.core" "get-thread-bindings")))) (lambda args (let fnrec2212 ((args (list->cseq args))) (jolt-apply (var-deref "clojure.core" "with-bindings*") bs f args)))))))) bound-fn*)))
+  (def-var! "clojure.core" "bound-fn*" (letrec ((bound-fn* (lambda (f) (let fnrec2235 ((f f)) (let* ((bs (jolt-invoke (var-deref "clojure.core" "get-thread-bindings")))) (lambda args (let fnrec2236 ((args (list->cseq args))) (jolt-apply (var-deref "clojure.core" "with-bindings*") bs f args)))))))) bound-fn*)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "thread-bound?" (letrec ((thread-bound? (lambda vars (let fnrec2213 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec2214 ((v v)) (jolt-invoke (var-deref "clojure.core" "__thread-bound?") v))) vars))))) thread-bound?)))
+  (def-var! "clojure.core" "thread-bound?" (letrec ((thread-bound? (lambda vars (let fnrec2237 ((vars (list->cseq vars))) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (v) (let fnrec2238 ((v v)) (jolt-invoke (var-deref "clojure.core" "__thread-bound?") v))) vars))))) thread-bound?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "key" (letrec ((key (lambda (e) (let fnrec2215 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 0) (jolt-throw (jolt-ex-info "key requires a map entry" (jolt-hash-map)))))))) key)))
+  (def-var! "clojure.core" "key" (letrec ((key (lambda (e) (let fnrec2239 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 0) (jolt-throw (jolt-ex-info "key requires a map entry" (jolt-hash-map)))))))) key)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "val" (letrec ((val (lambda (e) (let fnrec2216 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 1) (jolt-throw (jolt-ex-info "val requires a map entry" (jolt-hash-map)))))))) val)))
+  (def-var! "clojure.core" "val" (letrec ((val (lambda (e) (let fnrec2240 ((e e)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map-entry?") e)) (jolt-nth e 1) (jolt-throw (jolt-ex-info "val requires a map entry" (jolt-hash-map)))))))) val)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "make-hierarchy" (letrec ((make-hierarchy (lambda () (let fnrec2217 () (let* ((_o$2218 (keyword #f "parents")) (_o$2219 (jolt-hash-map)) (_o$2220 (keyword #f "descendants")) (_o$2221 (jolt-hash-map)) (_o$2222 (keyword #f "ancestors")) (_o$2223 (jolt-hash-map))) (jolt-hash-map _o$2218 _o$2219 _o$2220 _o$2221 _o$2222 _o$2223)))))) make-hierarchy)))
+  (def-var! "clojure.core" "make-hierarchy" (letrec ((make-hierarchy (lambda () (let fnrec2241 () (let* ((_o$2242 (keyword #f "parents")) (_o$2243 (jolt-hash-map)) (_o$2244 (keyword #f "descendants")) (_o$2245 (jolt-hash-map)) (_o$2246 (keyword #f "ancestors")) (_o$2247 (jolt-hash-map))) (jolt-hash-map _o$2242 _o$2243 _o$2244 _o$2245 _o$2246 _o$2247)))))) make-hierarchy)))
 (guard (e (#t #f))
   (def-var-with-meta! "clojure.core" "global-hierarchy" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-invoke (var-deref "clojure.core" "make-hierarchy"))) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "isa?" (letrec ((isa? (case-lambda ((child parent) (let fnrec2224 ((child child) (parent parent)) (jolt-invoke isa? (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) child parent))) ((h child parent) (let fnrec2225 ((h h) (child child) (parent parent)) (let* ((or__14__auto (jolt= child parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-contains? (let* ((_a$2226 (jolt-get h (keyword #f "ancestors"))) (_a$2227 child) (_a$2228 (jolt-hash-set))) (jolt-get _a$2226 _a$2227 _a$2228)) parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") parent))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") child))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (let* ((_a$2229 (jolt-count parent)) (_a$2230 (jolt-count child))) (jolt= _a$2229 _a$2230)))) (if (jolt-truthy? and__13__auto) (let* ((ret #t) (i 0)) (let loop2231 ((ret ret) (i i)) (if (jolt-truthy? (let* ((or__14__auto (jolt-not ret))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= i (jolt-count parent))))) ret (let* ((_a$2236 (let* ((_a$2232 isa?) (_a$2233 h) (_a$2234 (jolt-nth child i)) (_a$2235 (jolt-nth parent i))) (jolt-invoke _a$2232 _a$2233 _a$2234 _a$2235))) (_a$2237 (jolt-inc i))) (loop2231 _a$2236 _a$2237))))) and__13__auto)) and__13__auto)) and__13__auto))))))))))) isa?)))
+  (def-var! "clojure.core" "isa?" (letrec ((isa? (case-lambda ((child parent) (let fnrec2248 ((child child) (parent parent)) (jolt-invoke isa? (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) child parent))) ((h child parent) (let fnrec2249 ((h h) (child child) (parent parent)) (let* ((or__14__auto (jolt= child parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-contains? (let* ((_a$2250 (jolt-get h (keyword #f "ancestors"))) (_a$2251 child) (_a$2252 (jolt-hash-set))) (jolt-get _a$2250 _a$2251 _a$2252)) parent))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") parent))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") child))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (let* ((_a$2253 (jolt-count parent)) (_a$2254 (jolt-count child))) (jolt= _a$2253 _a$2254)))) (if (jolt-truthy? and__13__auto) (let* ((ret #t) (i 0)) (let loop2255 ((ret ret) (i i)) (if (jolt-truthy? (let* ((or__14__auto (jolt-not ret))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= i (jolt-count parent))))) ret (let* ((_a$2260 (let* ((_a$2256 isa?) (_a$2257 h) (_a$2258 (jolt-nth child i)) (_a$2259 (jolt-nth parent i))) (jolt-invoke _a$2256 _a$2257 _a$2258 _a$2259))) (_a$2261 (jolt-inc i))) (loop2255 _a$2260 _a$2261))))) and__13__auto)) and__13__auto)) and__13__auto))))))))))) isa?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "parents" (letrec ((parents (case-lambda ((tag) (let fnrec2238 ((tag tag)) (jolt-invoke parents (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2239 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "parents")) tag))))))) parents)))
+  (def-var! "clojure.core" "parents" (letrec ((parents (case-lambda ((tag) (let fnrec2262 ((tag tag)) (jolt-invoke parents (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2263 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "parents")) tag))))))) parents)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ancestors" (letrec ((ancestors (case-lambda ((tag) (let fnrec2240 ((tag tag)) (jolt-invoke ancestors (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2241 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "ancestors")) tag))))))) ancestors)))
+  (def-var! "clojure.core" "ancestors" (letrec ((ancestors (case-lambda ((tag) (let fnrec2264 ((tag tag)) (jolt-invoke ancestors (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2265 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "ancestors")) tag))))))) ancestors)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "descendants" (letrec ((descendants (case-lambda ((tag) (let fnrec2242 ((tag tag)) (jolt-invoke descendants (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2243 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "descendants")) tag))))))) descendants)))
+  (def-var! "clojure.core" "descendants" (letrec ((descendants (case-lambda ((tag) (let fnrec2266 ((tag tag)) (jolt-invoke descendants (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "global-hierarchy")) tag))) ((h tag) (let fnrec2267 ((h h) (tag tag)) (jolt-invoke (var-deref "clojure.core" "not-empty") (jolt-get (jolt-get h (keyword #f "descendants")) tag))))))) descendants)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "derive" (letrec ((derive (case-lambda ((tag parent) (let fnrec2244 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") derive tag parent) jolt-nil))) ((h tag parent) (let fnrec2245 ((h h) (tag tag) (parent parent)) (let* ((tp (jolt-get h (keyword #f "parents"))) (td (jolt-get h (keyword #f "descendants"))) (ta (jolt-get h (keyword #f "ancestors"))) (tf (lambda (m source sources target targets) (let fnrec2246 ((m m) (source source) (sources sources) (target target) (targets targets)) (let* ((_a$2251 (lambda (ret k) (let fnrec2247 ((ret ret) (k k)) (jolt-assoc ret k (let* ((_a$2248 jolt-conj) (_a$2249 (jolt-get targets k (jolt-hash-set))) (_a$2250 (jolt-cons target (jolt-get targets target)))) (jolt-reduce _a$2248 _a$2249 _a$2250)))))) (_a$2252 m) (_a$2253 (jolt-cons source (jolt-get sources source)))) (jolt-reduce _a$2251 _a$2252 _a$2253)))))) (let* ((or__14__auto (if (jolt-not (jolt-contains? (jolt-get tp tag (jolt-hash-set)) parent)) (begin (if (jolt-contains? (jolt-get ta tag (jolt-hash-set)) parent) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") tag " already has " parent " as ancestor")) jolt-nil) (if (jolt-contains? (jolt-get ta parent (jolt-hash-set)) tag) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cyclic derivation: " parent " has " tag " as ancestor")) jolt-nil) (let* ((_o$2254 (keyword #f "parents")) (_o$2255 (jolt-assoc tp tag (jolt-conj (jolt-get tp tag (jolt-hash-set)) parent))) (_o$2256 (keyword #f "ancestors")) (_o$2257 (jolt-invoke tf ta tag td parent ta)) (_o$2258 (keyword #f "descendants")) (_o$2259 (jolt-invoke tf td parent ta tag td))) (jolt-hash-map _o$2254 _o$2255 _o$2256 _o$2257 _o$2258 _o$2259))) jolt-nil))) (if (jolt-truthy? or__14__auto) or__14__auto h)))))))) derive)))
+  (def-var! "clojure.core" "derive" (letrec ((derive (case-lambda ((tag parent) (let fnrec2268 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") derive tag parent) jolt-nil))) ((h tag parent) (let fnrec2269 ((h h) (tag tag) (parent parent)) (let* ((tp (jolt-get h (keyword #f "parents"))) (td (jolt-get h (keyword #f "descendants"))) (ta (jolt-get h (keyword #f "ancestors"))) (tf (lambda (m source sources target targets) (let fnrec2270 ((m m) (source source) (sources sources) (target target) (targets targets)) (let* ((_a$2275 (lambda (ret k) (let fnrec2271 ((ret ret) (k k)) (jolt-assoc ret k (let* ((_a$2272 jolt-conj) (_a$2273 (jolt-get targets k (jolt-hash-set))) (_a$2274 (jolt-cons target (jolt-get targets target)))) (jolt-reduce _a$2272 _a$2273 _a$2274)))))) (_a$2276 m) (_a$2277 (jolt-cons source (jolt-get sources source)))) (jolt-reduce _a$2275 _a$2276 _a$2277)))))) (let* ((or__14__auto (if (jolt-not (jolt-contains? (jolt-get tp tag (jolt-hash-set)) parent)) (begin (if (jolt-contains? (jolt-get ta tag (jolt-hash-set)) parent) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") tag " already has " parent " as ancestor")) jolt-nil) (if (jolt-contains? (jolt-get ta parent (jolt-hash-set)) tag) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cyclic derivation: " parent " has " tag " as ancestor")) jolt-nil) (let* ((_o$2278 (keyword #f "parents")) (_o$2279 (jolt-assoc tp tag (jolt-conj (jolt-get tp tag (jolt-hash-set)) parent))) (_o$2280 (keyword #f "ancestors")) (_o$2281 (jolt-invoke tf ta tag td parent ta)) (_o$2282 (keyword #f "descendants")) (_o$2283 (jolt-invoke tf td parent ta tag td))) (jolt-hash-map _o$2278 _o$2279 _o$2280 _o$2281 _o$2282 _o$2283))) jolt-nil))) (if (jolt-truthy? or__14__auto) or__14__auto h)))))))) derive)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "underive" (letrec ((underive (case-lambda ((tag parent) (let fnrec2260 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") underive tag parent) jolt-nil))) ((h tag parent) (let fnrec2261 ((h h) (tag tag) (parent parent)) (let* ((parent-map (jolt-get h (keyword #f "parents"))) (childs-parents (if (jolt-truthy? (jolt-get parent-map tag)) (jolt-invoke (var-deref "clojure.core" "disj") (jolt-get parent-map tag) parent) (jolt-hash-set))) (new-parents (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not-empty") childs-parents)) (jolt-assoc parent-map tag childs-parents) (jolt-dissoc parent-map tag))) (deriv-seq (let* ((_a$2268 (var-deref "clojure.core" "mapcat")) (_a$2269 (lambda (e) (let fnrec2262 ((e e)) (let* ((_a$2266 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$2267 (let* ((_a$2263 (var-deref "clojure.core" "interpose")) (_a$2264 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$2265 (jolt-invoke (var-deref "clojure.core" "val") e))) (jolt-invoke _a$2263 _a$2264 _a$2265)))) (jolt-cons _a$2266 _a$2267))))) (_a$2270 (jolt-seq new-parents))) (jolt-invoke _a$2268 _a$2269 _a$2270)))) (if (jolt-contains? (jolt-get parent-map tag (jolt-hash-set)) parent) (let* ((_a$2272 (lambda (p G__31) (let fnrec2271 ((p p) (G__31 G__31)) (let* ((G__32 G__31) (t (jolt-nth G__32 0 jolt-nil)) (pr (jolt-nth G__32 1 jolt-nil))) (jolt-invoke (var-deref "clojure.core" "derive") p t pr))))) (_a$2273 (jolt-invoke (var-deref "clojure.core" "make-hierarchy"))) (_a$2274 (jolt-invoke (var-deref "clojure.core" "partition") 2 deriv-seq))) (jolt-reduce _a$2272 _a$2273 _a$2274)) h))))))) underive)))
+  (def-var! "clojure.core" "underive" (letrec ((underive (case-lambda ((tag parent) (let fnrec2284 ((tag tag) (parent parent)) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "global-hierarchy") underive tag parent) jolt-nil))) ((h tag parent) (let fnrec2285 ((h h) (tag tag) (parent parent)) (let* ((parent-map (jolt-get h (keyword #f "parents"))) (childs-parents (if (jolt-truthy? (jolt-get parent-map tag)) (jolt-invoke (var-deref "clojure.core" "disj") (jolt-get parent-map tag) parent) (jolt-hash-set))) (new-parents (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not-empty") childs-parents)) (jolt-assoc parent-map tag childs-parents) (jolt-dissoc parent-map tag))) (deriv-seq (let* ((_a$2292 (var-deref "clojure.core" "mapcat")) (_a$2293 (lambda (e) (let fnrec2286 ((e e)) (let* ((_a$2290 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$2291 (let* ((_a$2287 (var-deref "clojure.core" "interpose")) (_a$2288 (jolt-invoke (var-deref "clojure.core" "key") e)) (_a$2289 (jolt-invoke (var-deref "clojure.core" "val") e))) (jolt-invoke _a$2287 _a$2288 _a$2289)))) (jolt-cons _a$2290 _a$2291))))) (_a$2294 (jolt-seq new-parents))) (jolt-invoke _a$2292 _a$2293 _a$2294)))) (if (jolt-contains? (jolt-get parent-map tag (jolt-hash-set)) parent) (let* ((_a$2296 (lambda (p G__31) (let fnrec2295 ((p p) (G__31 G__31)) (let* ((G__32 G__31) (t (jolt-nth G__32 0 jolt-nil)) (pr (jolt-nth G__32 1 jolt-nil))) (jolt-invoke (var-deref "clojure.core" "derive") p t pr))))) (_a$2297 (jolt-invoke (var-deref "clojure.core" "make-hierarchy"))) (_a$2298 (jolt-invoke (var-deref "clojure.core" "partition") 2 deriv-seq))) (jolt-reduce _a$2296 _a$2297 _a$2298)) h))))))) underive)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sequential?" (letrec ((sequential? (lambda (x) (let fnrec2275 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "seq?") x))))))) sequential?)))
+  (def-var! "clojure.core" "sequential?" (letrec ((sequential? (lambda (x) (let fnrec2299 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "seq?") x))))))) sequential?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "associative?" (letrec ((associative? (lambda (x) (let fnrec2276 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))))))) associative?)))
+  (def-var! "clojure.core" "associative?" (letrec ((associative? (lambda (x) (let fnrec2300 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))))))) associative?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "counted?" (letrec ((counted? (lambda (x) (let fnrec2277 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "list?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))))))) counted?)))
+  (def-var! "clojure.core" "counted?" (letrec ((counted? (lambda (x) (let fnrec2301 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "list?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))))))) counted?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "indexed?" (letrec ((indexed? (lambda (x) (let fnrec2278 ((x x)) (jolt-invoke (var-deref "clojure.core" "vector?") x))))) indexed?)))
+  (def-var! "clojure.core" "indexed?" (letrec ((indexed? (lambda (x) (let fnrec2302 ((x x)) (jolt-invoke (var-deref "clojure.core" "vector?") x))))) indexed?)))
 (guard (e (#t #f))
   (declare-var! "clojure.core" "sorted?"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "reversible?" (letrec ((reversible? (lambda (x) (let fnrec2279 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted?") x))))))) reversible?)))
+  (def-var! "clojure.core" "reversible?" (letrec ((reversible? (lambda (x) (let fnrec2303 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted?") x))))))) reversible?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "seqable?" (letrec ((seqable? (lambda (x) (let fnrec2280 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "coll?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))) seqable?)))
+  (def-var! "clojure.core" "seqable?" (letrec ((seqable? (lambda (x) (let fnrec2304 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "coll?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "string?") x))))))))) seqable?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "boolean?" (letrec ((boolean? (lambda (x) (let fnrec2281 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "true?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "false?") x))))))) boolean?)))
+  (def-var! "clojure.core" "boolean?" (letrec ((boolean? (lambda (x) (let fnrec2305 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "true?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "false?") x))))))) boolean?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "double?" (letrec ((double? (lambda (x) (let fnrec2282 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "integer?") x)) and__13__auto)))))) double?)))
+  (def-var! "clojure.core" "double?" (letrec ((double? (lambda (x) (let fnrec2306 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "integer?") x)) and__13__auto)))))) double?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "float?" (letrec ((float? (lambda (x) (let fnrec2283 ((x x)) (jolt-invoke (var-deref "clojure.core" "double?") x))))) float?)))
+  (def-var! "clojure.core" "float?" (letrec ((float? (lambda (x) (let fnrec2307 ((x x)) (jolt-invoke (var-deref "clojure.core" "double?") x))))) float?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "infinite?" (letrec ((infinite? (lambda (x) (let fnrec2284 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= x +inf.0))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= x -inf.0))) and__13__auto)))))) infinite?)))
+  (def-var! "clojure.core" "infinite?" (letrec ((infinite? (lambda (x) (let fnrec2308 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt= x +inf.0))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= x -inf.0))) and__13__auto)))))) infinite?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "atom?" (letrec ((atom? (lambda (x) (let fnrec2285 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "atom")))))) atom?)))
+  (def-var! "clojure.core" "atom?" (letrec ((atom? (lambda (x) (let fnrec2309 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "atom")))))) atom?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "volatile?" (letrec ((volatile? (lambda (x) (let fnrec2286 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "volatile")))))) volatile?)))
+  (def-var! "clojure.core" "volatile?" (letrec ((volatile? (lambda (x) (let fnrec2310 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "volatile")))))) volatile?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "reader-conditional?" (letrec ((reader-conditional? (lambda (x) (let fnrec2287 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "reader-conditional")))))) reader-conditional?)))
+  (def-var! "clojure.core" "reader-conditional?" (letrec ((reader-conditional? (lambda (x) (let fnrec2311 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "reader-conditional")))))) reader-conditional?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tagged-literal?" (letrec ((tagged-literal? (lambda (x) (let fnrec2288 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "tagged-literal")))))) tagged-literal?)))
+  (def-var! "clojure.core" "tagged-literal?" (letrec ((tagged-literal? (lambda (x) (let fnrec2312 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "tagged-literal")))))) tagged-literal?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "record?" (letrec ((record? (lambda (x) (let fnrec2289 ((x x)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get x (keyword "jolt" "deftype"))))))) record?)))
+  (def-var! "clojure.core" "record?" (letrec ((record? (lambda (x) (let fnrec2313 ((x x)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get x (keyword "jolt" "deftype"))))))) record?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "uuid?" (letrec ((uuid? (lambda (x) (let fnrec2290 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "uuid")))))) uuid?)))
+  (def-var! "clojure.core" "uuid?" (letrec ((uuid? (lambda (x) (let fnrec2314 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "uuid")))))) uuid?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "inst?" (letrec ((inst? (lambda (x) (let fnrec2291 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "inst")))))) inst?)))
+  (def-var! "clojure.core" "inst?" (letrec ((inst? (lambda (x) (let fnrec2315 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "inst")))))) inst?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "char?" (letrec ((char? (lambda (x) (let fnrec2292 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "char")))))) char?)))
+  (def-var! "clojure.core" "char?" (letrec ((char? (lambda (x) (let fnrec2316 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "char")))))) char?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "realized?" (letrec ((realized? (lambda (x) (let fnrec2293 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (if (jolt= (keyword "jolt" "lazy-seq") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "atom?") x)) #t (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "realized? not supported on: " x)) jolt-nil))))))))) realized?)))
+  (def-var! "clojure.core" "realized?" (letrec ((realized? (lambda (x) (let fnrec2317 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (if (jolt= (keyword "jolt" "lazy-seq") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "realized"))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "atom?") x)) #t (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "realized? not supported on: " x)) jolt-nil))))))))) realized?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "force" (letrec ((force (lambda (x) (let fnrec2294 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "deref") x) x))))) force)))
+  (def-var! "clojure.core" "force" (letrec ((force (lambda (x) (let fnrec2318 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "delay?") x)) (jolt-invoke (var-deref "clojure.core" "deref") x) x))))) force)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pop" (letrec ((pop (lambda (coll) (let fnrec2295 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (if (jolt-zero? (jolt-count coll)) (jolt-throw "Can't pop empty vector") (jolt-invoke (var-deref "clojure.core" "subvec") coll 0 (jolt-dec (jolt-count coll)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))) (jolt-throw "Can't pop empty list") (jolt-rest coll)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "pop not supported on: " coll)) jolt-nil)))))))) pop)))
+  (def-var! "clojure.core" "pop" (letrec ((pop (lambda (coll) (let fnrec2319 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (if (jolt-zero? (jolt-count coll)) (jolt-throw "Can't pop empty vector") (jolt-invoke (var-deref "clojure.core" "subvec") coll 0 (jolt-dec (jolt-count coll)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-seq coll))) (jolt-throw "Can't pop empty list") (jolt-rest coll)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "pop not supported on: " coll)) jolt-nil)))))))) pop)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "dorun" (letrec ((dorun (case-lambda ((coll) (let fnrec2296 ((coll coll)) (let* ((s (jolt-seq coll))) (let loop2297 ((s s)) (if (jolt-truthy? s) (loop2297 (jolt-next s)) jolt-nil))))) ((n coll) (let fnrec2298 ((n n) (coll coll)) (let* ((n n) (s (jolt-seq coll))) (let loop2299 ((n n) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$2300 (jolt-dec n)) (_a$2301 (jolt-next s))) (loop2299 _a$2300 _a$2301)) jolt-nil)))))))) dorun)))
+  (def-var! "clojure.core" "dorun" (letrec ((dorun (case-lambda ((coll) (let fnrec2320 ((coll coll)) (let* ((s (jolt-seq coll))) (let loop2321 ((s s)) (if (jolt-truthy? s) (loop2321 (jolt-next s)) jolt-nil))))) ((n coll) (let fnrec2322 ((n n) (coll coll)) (let* ((n n) (s (jolt-seq coll))) (let loop2323 ((n n) (s s)) (if (jolt-truthy? (let* ((and__13__auto s)) (if (jolt-truthy? and__13__auto) (jolt-pos? n) and__13__auto))) (let* ((_a$2324 (jolt-dec n)) (_a$2325 (jolt-next s))) (loop2323 _a$2324 _a$2325)) jolt-nil)))))))) dorun)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "doall" (letrec ((doall (case-lambda ((coll) (let fnrec2302 ((coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") coll) coll))) ((n coll) (let fnrec2303 ((n n) (coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") n coll) coll)))))) doall)))
+  (def-var! "clojure.core" "doall" (letrec ((doall (case-lambda ((coll) (let fnrec2326 ((coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") coll) coll))) ((n coll) (let fnrec2327 ((n n) (coll coll)) (begin (jolt-invoke (var-deref "clojure.core" "dorun") n coll) coll)))))) doall)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "spread" (letrec ((spread (lambda (arglist) (let fnrec2304 ((arglist arglist)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") arglist)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-next arglist))) (jolt-seq (jolt-first arglist)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2305 (jolt-first arglist)) (_a$2306 (jolt-invoke spread (jolt-next arglist)))) (jolt-cons _a$2305 _a$2306)) jolt-nil))))))) spread)))
+  (def-var! "clojure.core" "spread" (letrec ((spread (lambda (arglist) (let fnrec2328 ((arglist arglist)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") arglist)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-next arglist))) (jolt-seq (jolt-first arglist)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$2329 (jolt-first arglist)) (_a$2330 (jolt-invoke spread (jolt-next arglist)))) (jolt-cons _a$2329 _a$2330)) jolt-nil))))))) spread)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "list*" (letrec ((list* (case-lambda ((args) (let fnrec2307 ((args args)) (jolt-seq args))) ((a args) (let fnrec2308 ((a a) (args args)) (jolt-cons a args))) ((a b args) (let fnrec2309 ((a a) (b b) (args args)) (jolt-cons a (jolt-cons b args)))) ((a b c args) (let fnrec2310 ((a a) (b b) (c c) (args args)) (jolt-cons a (jolt-cons b (jolt-cons c args))))) ((a b c d . more) (let fnrec2311 ((a a) (b b) (c c) (d d) (more (list->cseq more))) (jolt-cons a (jolt-cons b (jolt-cons c (jolt-cons d (jolt-invoke (var-deref "clojure.core" "spread") more)))))))))) list*)))
+  (def-var! "clojure.core" "list*" (letrec ((list* (case-lambda ((args) (let fnrec2331 ((args args)) (jolt-seq args))) ((a args) (let fnrec2332 ((a a) (args args)) (jolt-cons a args))) ((a b args) (let fnrec2333 ((a a) (b b) (args args)) (jolt-cons a (jolt-cons b args)))) ((a b c args) (let fnrec2334 ((a a) (b b) (c c) (args args)) (jolt-cons a (jolt-cons b (jolt-cons c args))))) ((a b c d . more) (let fnrec2335 ((a a) (b b) (c c) (d d) (more (list->cseq more))) (jolt-cons a (jolt-cons b (jolt-cons c (jolt-cons d (jolt-invoke (var-deref "clojure.core" "spread") more)))))))))) list*)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "print-str" (letrec ((print-str (lambda xs (let fnrec2312 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2313 () (jolt-apply (var-deref "clojure.core" "print") xs)))))))) print-str)))
+  (def-var! "clojure.core" "print-str" (letrec ((print-str (lambda xs (let fnrec2336 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2337 () (jolt-apply (var-deref "clojure.core" "print") xs)))))))) print-str)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "println-str" (letrec ((println-str (lambda xs (let fnrec2314 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2315 () (jolt-apply (var-deref "clojure.core" "println") xs)))))))) println-str)))
+  (def-var! "clojure.core" "println-str" (letrec ((println-str (lambda xs (let fnrec2338 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2339 () (jolt-apply (var-deref "clojure.core" "println") xs)))))))) println-str)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "prn-str" (letrec ((prn-str (lambda xs (let fnrec2316 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2317 () (jolt-apply (var-deref "clojure.core" "prn") xs)))))))) prn-str)))
+  (def-var! "clojure.core" "prn-str" (letrec ((prn-str (lambda xs (let fnrec2340 ((xs (list->cseq xs))) (jolt-invoke (var-deref "clojure.core" "__with-out-str") (lambda () (let fnrec2341 () (jolt-apply (var-deref "clojure.core" "prn") xs)))))))) prn-str)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "rand-int" (letrec ((rand-int (lambda (n) (let fnrec1678 ((n n)) (jolt-invoke (var-deref "clojure.core" "int") (jolt-invoke (var-deref "clojure.core" "rand") n)))))) rand-int)))
+  (def-var! "clojure.core" "rand-int" (letrec ((rand-int (lambda (n) (let fnrec1702 ((n n)) (jolt-invoke (var-deref "clojure.core" "int") (jolt-invoke (var-deref "clojure.core" "rand") n)))))) rand-int)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "shuffle" (letrec ((shuffle (lambda (coll) (let fnrec1679 ((coll coll)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-throw (let* ((_a$1680 (jolt-invoke (var-deref "clojure.core" "str") "shuffle requires a collection, got: " coll)) (_a$1681 (jolt-hash-map))) (jolt-ex-info _a$1680 _a$1681))) jolt-nil) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll)) (i (jolt-dec (jolt-count v)))) (let loop1682 ((v v) (i i)) (if (jolt-pos? i) (let* ((j (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-inc i))) (t (jolt-nth v i))) (let* ((_a$1683 (jolt-assoc (jolt-assoc v i (jolt-nth v j)) j t)) (_a$1684 (jolt-dec i))) (loop1682 _a$1683 _a$1684))) v)))))))) shuffle)))
+  (def-var! "clojure.core" "shuffle" (letrec ((shuffle (lambda (coll) (let fnrec1703 ((coll coll)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-throw (let* ((_a$1704 (jolt-invoke (var-deref "clojure.core" "str") "shuffle requires a collection, got: " coll)) (_a$1705 (jolt-hash-map))) (jolt-ex-info _a$1704 _a$1705))) jolt-nil) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll)) (i (jolt-dec (jolt-count v)))) (let loop1706 ((v v) (i i)) (if (jolt-pos? i) (let* ((j (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-inc i))) (t (jolt-nth v i))) (let* ((_a$1707 (jolt-assoc (jolt-assoc v i (jolt-nth v j)) j t)) (_a$1708 (jolt-dec i))) (loop1706 _a$1707 _a$1708))) v)))))))) shuffle)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sort-by" (letrec ((sort-by (case-lambda ((keyfn coll) (let fnrec1685 ((keyfn keyfn) (coll coll)) (jolt-invoke sort-by keyfn (var-deref "clojure.core" "compare") coll))) ((keyfn comp coll) (let fnrec1686 ((keyfn keyfn) (comp comp) (coll coll)) (jolt-invoke (var-deref "clojure.core" "sort") (lambda (x y) (let fnrec1687 ((x x) (y y)) (let* ((_a$1688 comp) (_a$1689 (jolt-invoke keyfn x)) (_a$1690 (jolt-invoke keyfn y))) (jolt-invoke _a$1688 _a$1689 _a$1690)))) coll)))))) sort-by)))
+  (def-var! "clojure.core" "sort-by" (letrec ((sort-by (case-lambda ((keyfn coll) (let fnrec1709 ((keyfn keyfn) (coll coll)) (jolt-invoke sort-by keyfn (var-deref "clojure.core" "compare") coll))) ((keyfn comp coll) (let fnrec1710 ((keyfn keyfn) (comp comp) (coll coll)) (jolt-invoke (var-deref "clojure.core" "sort") (lambda (x y) (let fnrec1711 ((x x) (y y)) (let* ((_a$1712 comp) (_a$1713 (jolt-invoke keyfn x)) (_a$1714 (jolt-invoke keyfn y))) (jolt-invoke _a$1712 _a$1713 _a$1714)))) coll)))))) sort-by)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "parse-uuid" (letrec ((parse-uuid (lambda (s) (let fnrec1691 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "re-matches") (jolt-regex "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}") s)) (jolt-invoke (var-deref "clojure.core" "__make-uuid") s) jolt-nil) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-uuid requires a string, got: " s))))))) parse-uuid)))
+  (def-var! "clojure.core" "parse-uuid" (letrec ((parse-uuid (lambda (s) (let fnrec1715 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "re-matches") (jolt-regex "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}") s)) (jolt-invoke (var-deref "clojure.core" "__make-uuid") s) jolt-nil) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-uuid requires a string, got: " s))))))) parse-uuid)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "random-uuid" (letrec ((random-uuid (lambda () (let fnrec1692 () (let* ((hx4 (lambda () (let fnrec1693 () (jolt-invoke (var-deref "clojure.core" "format") "%04x" (jolt-invoke (var-deref "clojure.core" "rand-int") 65536))))) (hx3 (lambda () (let fnrec1694 () (jolt-invoke (var-deref "clojure.core" "format") "%03x" (jolt-invoke (var-deref "clojure.core" "rand-int") 4096)))))) (jolt-invoke (var-deref "clojure.core" "parse-uuid") (let* ((_a$1695 (var-deref "clojure.core" "str")) (_a$1696 (jolt-invoke hx4)) (_a$1697 (jolt-invoke hx4)) (_a$1698 "-") (_a$1699 (jolt-invoke hx4)) (_a$1700 "-4") (_a$1701 (jolt-invoke hx3)) (_a$1702 "-") (_a$1703 (jolt-invoke (var-deref "clojure.core" "format") "%x" (+ 8 (jolt-invoke (var-deref "clojure.core" "rand-int") 4)))) (_a$1704 (jolt-invoke hx3)) (_a$1705 "-") (_a$1706 (jolt-invoke hx4)) (_a$1707 (jolt-invoke hx4)) (_a$1708 (jolt-invoke hx4))) (jolt-invoke _a$1695 _a$1696 _a$1697 _a$1698 _a$1699 _a$1700 _a$1701 _a$1702 _a$1703 _a$1704 _a$1705 _a$1706 _a$1707 _a$1708)))))))) random-uuid)))
+  (def-var! "clojure.core" "random-uuid" (letrec ((random-uuid (lambda () (let fnrec1716 () (let* ((hx4 (lambda () (let fnrec1717 () (jolt-invoke (var-deref "clojure.core" "format") "%04x" (jolt-invoke (var-deref "clojure.core" "rand-int") 65536))))) (hx3 (lambda () (let fnrec1718 () (jolt-invoke (var-deref "clojure.core" "format") "%03x" (jolt-invoke (var-deref "clojure.core" "rand-int") 4096)))))) (jolt-invoke (var-deref "clojure.core" "parse-uuid") (let* ((_a$1719 (var-deref "clojure.core" "str")) (_a$1720 (jolt-invoke hx4)) (_a$1721 (jolt-invoke hx4)) (_a$1722 "-") (_a$1723 (jolt-invoke hx4)) (_a$1724 "-4") (_a$1725 (jolt-invoke hx3)) (_a$1726 "-") (_a$1727 (jolt-invoke (var-deref "clojure.core" "format") "%x" (+ 8 (jolt-invoke (var-deref "clojure.core" "rand-int") 4)))) (_a$1728 (jolt-invoke hx3)) (_a$1729 "-") (_a$1730 (jolt-invoke hx4)) (_a$1731 (jolt-invoke hx4)) (_a$1732 (jolt-invoke hx4))) (jolt-invoke _a$1719 _a$1720 _a$1721 _a$1722 _a$1723 _a$1724 _a$1725 _a$1726 _a$1727 _a$1728 _a$1729 _a$1730 _a$1731 _a$1732)))))))) random-uuid)))
 (guard (e (#t #f))
-  (def-var-with-meta! "clojure.core" "char-escape-strings" (let* ((_o$1709 (integer->char 10)) (_o$1710 "\\n") (_o$1711 (integer->char 9)) (_o$1712 "\\t") (_o$1713 (integer->char 13)) (_o$1714 "\\r") (_o$1715 (integer->char 12)) (_o$1716 "\\f") (_o$1717 (integer->char 8)) (_o$1718 "\\b") (_o$1719 (integer->char 34)) (_o$1720 "\\\"") (_o$1721 (integer->char 92)) (_o$1722 "\\\\")) (jolt-hash-map _o$1709 _o$1710 _o$1711 _o$1712 _o$1713 _o$1714 _o$1715 _o$1716 _o$1717 _o$1718 _o$1719 _o$1720 _o$1721 _o$1722)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "clojure.core" "char-escape-strings" (let* ((_o$1733 (integer->char 10)) (_o$1734 "\\n") (_o$1735 (integer->char 9)) (_o$1736 "\\t") (_o$1737 (integer->char 13)) (_o$1738 "\\r") (_o$1739 (integer->char 12)) (_o$1740 "\\f") (_o$1741 (integer->char 8)) (_o$1742 "\\b") (_o$1743 (integer->char 34)) (_o$1744 "\\\"") (_o$1745 (integer->char 92)) (_o$1746 "\\\\")) (jolt-hash-map _o$1733 _o$1734 _o$1735 _o$1736 _o$1737 _o$1738 _o$1739 _o$1740 _o$1741 _o$1742 _o$1743 _o$1744 _o$1745 _o$1746)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "char-escape-string" (letrec ((char-escape-string (lambda (c) (let fnrec1723 ((c c)) (jolt-get (var-deref "clojure.core" "char-escape-strings") c))))) char-escape-string)))
+  (def-var! "clojure.core" "char-escape-string" (letrec ((char-escape-string (lambda (c) (let fnrec1747 ((c c)) (jolt-get (var-deref "clojure.core" "char-escape-strings") c))))) char-escape-string)))
 (guard (e (#t #f))
-  (def-var-with-meta! "clojure.core" "char-name-strings" (let* ((_o$1724 (integer->char 10)) (_o$1725 "newline") (_o$1726 (integer->char 9)) (_o$1727 "tab") (_o$1728 (integer->char 13)) (_o$1729 "return") (_o$1730 (integer->char 12)) (_o$1731 "formfeed") (_o$1732 (integer->char 8)) (_o$1733 "backspace") (_o$1734 (integer->char 32)) (_o$1735 "space")) (jolt-hash-map _o$1724 _o$1725 _o$1726 _o$1727 _o$1728 _o$1729 _o$1730 _o$1731 _o$1732 _o$1733 _o$1734 _o$1735)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "clojure.core" "char-name-strings" (let* ((_o$1748 (integer->char 10)) (_o$1749 "newline") (_o$1750 (integer->char 9)) (_o$1751 "tab") (_o$1752 (integer->char 13)) (_o$1753 "return") (_o$1754 (integer->char 12)) (_o$1755 "formfeed") (_o$1756 (integer->char 8)) (_o$1757 "backspace") (_o$1758 (integer->char 32)) (_o$1759 "space")) (jolt-hash-map _o$1748 _o$1749 _o$1750 _o$1751 _o$1752 _o$1753 _o$1754 _o$1755 _o$1756 _o$1757 _o$1758 _o$1759)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "char-name-string" (letrec ((char-name-string (lambda (c) (let fnrec1736 ((c c)) (jolt-get (var-deref "clojure.core" "char-name-strings") c))))) char-name-string)))
+  (def-var! "clojure.core" "char-name-string" (letrec ((char-name-string (lambda (c) (let fnrec1760 ((c c)) (jolt-get (var-deref "clojure.core" "char-name-strings") c))))) char-name-string)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "rand-nth" (letrec ((rand-nth (lambda (coll) (let fnrec1737 ((coll coll)) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll))) (jolt-nth v (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-count v)))))))) rand-nth)))
+  (def-var! "clojure.core" "rand-nth" (letrec ((rand-nth (lambda (coll) (let fnrec1761 ((coll coll)) (let* ((v (jolt-invoke (var-deref "clojure.core" "vec") coll))) (jolt-nth v (jolt-invoke (var-deref "clojure.core" "rand-int") (jolt-count v)))))))) rand-nth)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "random-sample" (letrec ((random-sample (case-lambda ((prob) (let fnrec1738 ((prob prob)) (jolt-invoke jolt-filter (lambda (_) (let fnrec1739 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob)))))) ((prob coll) (let fnrec1740 ((prob prob) (coll coll)) (jolt-filter (lambda (_) (let fnrec1741 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob))) coll)))))) random-sample)))
+  (def-var! "clojure.core" "random-sample" (letrec ((random-sample (case-lambda ((prob) (let fnrec1762 ((prob prob)) (jolt-invoke jolt-filter (lambda (_) (let fnrec1763 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob)))))) ((prob coll) (let fnrec1764 ((prob prob) (coll coll)) (jolt-filter (lambda (_) (let fnrec1765 ((_ _)) (< (jolt-invoke (var-deref "clojure.core" "rand")) prob))) coll)))))) random-sample)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "comparator" (letrec ((comparator (lambda (pred) (let fnrec1742 ((pred pred)) (lambda (a b) (let fnrec1743 ((a a) (b b)) (if (jolt-truthy? (jolt-invoke pred a b)) -1 (if (jolt-truthy? (jolt-invoke pred b a)) 1 (if (jolt-truthy? (keyword #f "else")) 0 jolt-nil))))))))) comparator)))
+  (def-var! "clojure.core" "comparator" (letrec ((comparator (lambda (pred) (let fnrec1766 ((pred pred)) (lambda (a b) (let fnrec1767 ((a a) (b b)) (if (jolt-truthy? (jolt-invoke pred a b)) -1 (if (jolt-truthy? (jolt-invoke pred b a)) 1 (if (jolt-truthy? (keyword #f "else")) 0 jolt-nil))))))))) comparator)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "reductions" (letrec ((reductions (case-lambda ((f coll) (let fnrec1744 ((f f) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1745 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (let* ((_a$1746 reductions) (_a$1747 f) (_a$1748 (jolt-first s)) (_a$1749 (jolt-rest s))) (jolt-invoke _a$1746 _a$1747 _a$1748 _a$1749)) (jolt-list (jolt-invoke f)))))))))) ((f init coll) (let fnrec1750 ((f f) (init init) (coll coll)) (jolt-cons init (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1751 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$1752 reductions) (_a$1753 f) (_a$1754 (jolt-invoke f init (jolt-first s))) (_a$1755 (jolt-rest s))) (jolt-invoke _a$1752 _a$1753 _a$1754 _a$1755))) jolt-nil)))))))))))) reductions)))
+  (def-var! "clojure.core" "reductions" (letrec ((reductions (case-lambda ((f coll) (let fnrec1768 ((f f) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1769 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (let* ((_a$1770 reductions) (_a$1771 f) (_a$1772 (jolt-first s)) (_a$1773 (jolt-rest s))) (jolt-invoke _a$1770 _a$1771 _a$1772 _a$1773)) (jolt-list (jolt-invoke f)))))))))) ((f init coll) (let fnrec1774 ((f f) (init init) (coll coll)) (jolt-cons init (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1775 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$1776 reductions) (_a$1777 f) (_a$1778 (jolt-invoke f init (jolt-first s))) (_a$1779 (jolt-rest s))) (jolt-invoke _a$1776 _a$1777 _a$1778 _a$1779))) jolt-nil)))))))))))) reductions)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-seq" (letrec ((tree-seq (lambda (branch? children root) (let fnrec1756 ((branch? branch?) (children children) (root root)) (let* ((walk (letrec ((walk (lambda (node) (let fnrec1757 ((node node)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1758 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons node (if (jolt-truthy? (jolt-invoke branch? node)) (jolt-invoke (var-deref "clojure.core" "mapcat") walk (jolt-invoke children node)) jolt-nil)))))))))) walk))) (jolt-invoke walk root)))))) tree-seq)))
+  (def-var! "clojure.core" "tree-seq" (letrec ((tree-seq (lambda (branch? children root) (let fnrec1780 ((branch? branch?) (children children) (root root)) (let* ((walk (letrec ((walk (lambda (node) (let fnrec1781 ((node node)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1782 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons node (if (jolt-truthy? (jolt-invoke branch? node)) (jolt-invoke (var-deref "clojure.core" "mapcat") walk (jolt-invoke children node)) jolt-nil)))))))))) walk))) (jolt-invoke walk root)))))) tree-seq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "file-seq" (letrec ((file-seq (lambda (root) (let fnrec1759 ((root root)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "__file?") root)) (let* ((_a$1762 (var-deref "clojure.core" "tree-seq")) (_a$1763 (lambda (f) (let fnrec1760 ((f f)) (jolt-host-call "isDirectory" f)))) (_a$1764 (lambda (f) (let fnrec1761 ((f f)) (jolt-seq (jolt-host-call "listFiles" f))))) (_a$1765 root)) (jolt-invoke _a$1762 _a$1763 _a$1764 _a$1765)) (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "__dir?") (var-deref "clojure.core" "__list-dir") root)))))) file-seq)))
+  (def-var! "clojure.core" "file-seq" (letrec ((file-seq (lambda (root) (let fnrec1783 ((root root)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "__file?") root)) (let* ((_a$1786 (var-deref "clojure.core" "tree-seq")) (_a$1787 (lambda (f) (let fnrec1784 ((f f)) (jolt-host-call "isDirectory" f)))) (_a$1788 (lambda (f) (let fnrec1785 ((f f)) (jolt-seq (jolt-host-call "listFiles" f))))) (_a$1789 root)) (jolt-invoke _a$1786 _a$1787 _a$1788 _a$1789)) (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "__dir?") (var-deref "clojure.core" "__list-dir") root)))))) file-seq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "flatten" (letrec ((flatten (lambda (coll) (let fnrec1766 ((coll coll)) (let* ((_a$1767 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "sequential?"))) (_a$1768 (jolt-rest (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "sequential?") jolt-seq coll)))) (jolt-filter _a$1767 _a$1768)))))) flatten)))
+  (def-var! "clojure.core" "flatten" (letrec ((flatten (lambda (coll) (let fnrec1790 ((coll coll)) (let* ((_a$1791 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "sequential?"))) (_a$1792 (jolt-rest (jolt-invoke (var-deref "clojure.core" "tree-seq") (var-deref "clojure.core" "sequential?") jolt-seq coll)))) (jolt-filter _a$1791 _a$1792)))))) flatten)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "xml-seq" (letrec ((xml-seq (lambda (root) (let fnrec1769 ((root root)) (let* ((_a$1770 (var-deref "clojure.core" "tree-seq")) (_a$1771 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "string?"))) (_a$1772 (jolt-invoke (var-deref "clojure.core" "comp") jolt-seq (keyword #f "content"))) (_a$1773 root)) (jolt-invoke _a$1770 _a$1771 _a$1772 _a$1773)))))) xml-seq)))
+  (def-var! "clojure.core" "xml-seq" (letrec ((xml-seq (lambda (root) (let fnrec1793 ((root root)) (let* ((_a$1794 (var-deref "clojure.core" "tree-seq")) (_a$1795 (jolt-invoke (var-deref "clojure.core" "complement") (var-deref "clojure.core" "string?"))) (_a$1796 (jolt-invoke (var-deref "clojure.core" "comp") jolt-seq (keyword #f "content"))) (_a$1797 root)) (jolt-invoke _a$1794 _a$1795 _a$1796 _a$1797)))))) xml-seq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "interleave" (letrec ((interleave (case-lambda (() (let fnrec1774 () (jolt-list ))) ((c1) (let fnrec1775 ((c1 c1)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1776 () (jolt-invoke (var-deref "clojure.core" "coll->cells") c1)))))) ((c1 c2) (let fnrec1777 ((c1 c1) (c2 c2)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1778 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s1 (jolt-seq c1)) (s2 (jolt-seq c2))) (if (jolt-truthy? (let* ((and__13__auto s1)) (if (jolt-truthy? and__13__auto) s2 and__13__auto))) (let* ((_a$1784 (jolt-first s1)) (_a$1785 (let* ((_a$1782 (jolt-first s2)) (_a$1783 (let* ((_a$1779 interleave) (_a$1780 (jolt-rest s1)) (_a$1781 (jolt-rest s2))) (jolt-invoke _a$1779 _a$1780 _a$1781)))) (jolt-cons _a$1782 _a$1783)))) (jolt-cons _a$1784 _a$1785)) jolt-nil)))))))) ((c1 c2 . cs) (let fnrec1786 ((c1 c1) (c2 c2) (cs (list->cseq cs))) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1787 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((ss (jolt-map jolt-seq (jolt-invoke (var-deref "clojure.core" "list*") c1 c2 cs)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "every?") jolt-identity ss)) (let* ((_a$1788 (jolt-map jolt-first ss)) (_a$1789 (jolt-apply interleave (jolt-map jolt-rest ss)))) (jolt-concat _a$1788 _a$1789)) jolt-nil))))))))))) interleave)))
+  (def-var! "clojure.core" "interleave" (letrec ((interleave (case-lambda (() (let fnrec1798 () (jolt-list ))) ((c1) (let fnrec1799 ((c1 c1)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1800 () (jolt-invoke (var-deref "clojure.core" "coll->cells") c1)))))) ((c1 c2) (let fnrec1801 ((c1 c1) (c2 c2)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1802 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((s1 (jolt-seq c1)) (s2 (jolt-seq c2))) (if (jolt-truthy? (let* ((and__13__auto s1)) (if (jolt-truthy? and__13__auto) s2 and__13__auto))) (let* ((_a$1808 (jolt-first s1)) (_a$1809 (let* ((_a$1806 (jolt-first s2)) (_a$1807 (let* ((_a$1803 interleave) (_a$1804 (jolt-rest s1)) (_a$1805 (jolt-rest s2))) (jolt-invoke _a$1803 _a$1804 _a$1805)))) (jolt-cons _a$1806 _a$1807)))) (jolt-cons _a$1808 _a$1809)) jolt-nil)))))))) ((c1 c2 . cs) (let fnrec1810 ((c1 c1) (c2 c2) (cs (list->cseq cs))) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1811 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((ss (jolt-map jolt-seq (jolt-invoke (var-deref "clojure.core" "list*") c1 c2 cs)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "every?") jolt-identity ss)) (let* ((_a$1812 (jolt-map jolt-first ss)) (_a$1813 (jolt-apply interleave (jolt-map jolt-rest ss)))) (jolt-concat _a$1812 _a$1813)) jolt-nil))))))))))) interleave)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "rationalize" (letrec ((rationalize (lambda (x) (let fnrec1790 ((x x)) x)))) rationalize)))
+  (def-var! "clojure.core" "rationalize" (letrec ((rationalize (lambda (x) (let fnrec1814 ((x x)) x)))) rationalize)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "dedupe" (letrec ((dedupe (case-lambda (() (let fnrec1791 () (lambda (rf) (let fnrec1792 ((rf rf)) (let* ((pv (jolt-invoke (var-deref "clojure.core" "volatile!") (let* ((_o$1793 #f) (_o$1794 jolt-nil)) (jolt-vector _o$1793 _o$1794))))) (case-lambda (() (let fnrec1795 () (jolt-invoke rf))) ((result) (let fnrec1796 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec1797 ((result result) (input input)) (let* ((G__27 (jolt-invoke (var-deref "clojure.core" "deref") pv)) (seen (jolt-nth G__27 0 jolt-nil)) (prior (jolt-nth G__27 1 jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") pv (let* ((_o$1798 #t) (_o$1799 input)) (jolt-vector _o$1798 _o$1799))) (if (jolt-truthy? (let* ((and__13__auto seen)) (if (jolt-truthy? and__13__auto) (jolt= prior input) and__13__auto))) result (jolt-invoke rf result input)))))))))))) ((coll) (let fnrec1800 ((coll coll)) (let* ((step (letrec ((step (lambda (s prev) (let fnrec1801 ((s s) (prev prev)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1802 () (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((x (jolt-first s))) (if (jolt= x prev) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-invoke step (jolt-rest s) prev)) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke step (jolt-rest s) x))))) jolt-nil))))))))) step))) (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1803 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((_a$1807 (jolt-first s)) (_a$1808 (let* ((_a$1804 step) (_a$1805 (jolt-rest s)) (_a$1806 (jolt-first s))) (jolt-invoke _a$1804 _a$1805 _a$1806)))) (jolt-cons _a$1807 _a$1808)))))) (jolt-list ))))))))) dedupe)))
+  (def-var! "clojure.core" "dedupe" (letrec ((dedupe (case-lambda (() (let fnrec1815 () (lambda (rf) (let fnrec1816 ((rf rf)) (let* ((pv (jolt-invoke (var-deref "clojure.core" "volatile!") (let* ((_o$1817 #f) (_o$1818 jolt-nil)) (jolt-vector _o$1817 _o$1818))))) (case-lambda (() (let fnrec1819 () (jolt-invoke rf))) ((result) (let fnrec1820 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec1821 ((result result) (input input)) (let* ((G__27 (jolt-invoke (var-deref "clojure.core" "deref") pv)) (seen (jolt-nth G__27 0 jolt-nil)) (prior (jolt-nth G__27 1 jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") pv (let* ((_o$1822 #t) (_o$1823 input)) (jolt-vector _o$1822 _o$1823))) (if (jolt-truthy? (let* ((and__13__auto seen)) (if (jolt-truthy? and__13__auto) (jolt= prior input) and__13__auto))) result (jolt-invoke rf result input)))))))))))) ((coll) (let fnrec1824 ((coll coll)) (let* ((step (letrec ((step (lambda (s prev) (let fnrec1825 ((s s) (prev prev)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1826 () (let* ((s (jolt-seq s))) (if (jolt-truthy? s) (let* ((x (jolt-first s))) (if (jolt= x prev) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-invoke step (jolt-rest s) prev)) (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke step (jolt-rest s) x))))) jolt-nil))))))))) step))) (let* ((s (jolt-seq coll))) (if (jolt-truthy? s) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec1827 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((_a$1831 (jolt-first s)) (_a$1832 (let* ((_a$1828 step) (_a$1829 (jolt-rest s)) (_a$1830 (jolt-first s))) (jolt-invoke _a$1828 _a$1829 _a$1830)))) (jolt-cons _a$1831 _a$1832)))))) (jolt-list ))))))))) dedupe)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "seq-to-map-for-destructuring" (letrec ((seq-to-map-for-destructuring (lambda (s) (let fnrec1809 ((s s)) (if (jolt-truthy? (jolt-next s)) (let* ((m (jolt-hash-map)) (xs (jolt-seq s))) (let loop1810 ((m m) (xs xs)) (if (jolt-truthy? xs) (if (jolt-truthy? (jolt-next xs)) (let* ((_a$1814 (let* ((_a$1811 m) (_a$1812 (jolt-first xs)) (_a$1813 (jolt-invoke (var-deref "clojure.core" "second") xs))) (jolt-assoc _a$1811 _a$1812 _a$1813))) (_a$1815 (jolt-invoke (var-deref "clojure.core" "nnext") xs))) (loop1810 _a$1814 _a$1815)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "No value supplied for key: " (jolt-first xs)))) m))) (if (jolt-truthy? (jolt-seq s)) (jolt-first s) (jolt-hash-map))))))) seq-to-map-for-destructuring)))
+  (def-var! "clojure.core" "seq-to-map-for-destructuring" (letrec ((seq-to-map-for-destructuring (lambda (s) (let fnrec1833 ((s s)) (if (jolt-truthy? (jolt-next s)) (let* ((m (jolt-hash-map)) (xs (jolt-seq s))) (let loop1834 ((m m) (xs xs)) (if (jolt-truthy? xs) (if (jolt-truthy? (jolt-next xs)) (let* ((_a$1838 (let* ((_a$1835 m) (_a$1836 (jolt-first xs)) (_a$1837 (jolt-invoke (var-deref "clojure.core" "second") xs))) (jolt-assoc _a$1835 _a$1836 _a$1837))) (_a$1839 (jolt-invoke (var-deref "clojure.core" "nnext") xs))) (loop1834 _a$1838 _a$1839)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "No value supplied for key: " (jolt-first xs)))) m))) (if (jolt-truthy? (jolt-seq s)) (jolt-first s) (jolt-hash-map))))))) seq-to-map-for-destructuring)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "vary-meta" (letrec ((vary-meta (lambda (obj f . args) (let fnrec1816 ((obj obj) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "with-meta") obj (jolt-apply f (jolt-invoke (var-deref "clojure.core" "meta") obj) args)))))) vary-meta)))
+  (def-var! "clojure.core" "vary-meta" (letrec ((vary-meta (lambda (obj f . args) (let fnrec1840 ((obj obj) (f f) (args (list->cseq args))) (jolt-invoke (var-deref "clojure.core" "with-meta") obj (jolt-apply f (jolt-invoke (var-deref "clojure.core" "meta") obj) args)))))) vary-meta)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "namespace-munge" (letrec ((namespace-munge (lambda (s) (let fnrec1817 ((s s)) (jolt-apply (var-deref "clojure.core" "str") (let* ((_a$1819 (lambda (c) (let fnrec1818 ((c c)) (if (jolt= c (integer->char 45)) (integer->char 95) c)))) (_a$1820 (jolt-seq (jolt-invoke (var-deref "clojure.core" "str") s)))) (jolt-map _a$1819 _a$1820))))))) namespace-munge)))
+  (def-var! "clojure.core" "namespace-munge" (letrec ((namespace-munge (lambda (s) (let fnrec1841 ((s s)) (jolt-apply (var-deref "clojure.core" "str") (let* ((_a$1843 (lambda (c) (let fnrec1842 ((c c)) (if (jolt= c (integer->char 45)) (integer->char 95) c)))) (_a$1844 (jolt-seq (jolt-invoke (var-deref "clojure.core" "str") s)))) (jolt-map _a$1843 _a$1844))))))) namespace-munge)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "reduce-kv" (letrec ((reduce-kv (lambda (f init coll) (let fnrec1821 ((f f) (init init) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (let* ((_a$1823 (lambda (acc i) (let fnrec1822 ((acc acc) (i i)) (jolt-invoke f acc i (jolt-nth coll i))))) (_a$1824 init) (_a$1825 (jolt-range (jolt-count coll)))) (jolt-reduce _a$1823 _a$1824 _a$1825)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (let* ((_a$1827 (lambda (acc k) (let fnrec1826 ((acc acc) (k k)) (jolt-invoke f acc k (jolt-get coll k))))) (_a$1828 init) (_a$1829 (jolt-keys coll))) (jolt-reduce _a$1827 _a$1828 _a$1829)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) init (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "reduce-kv not supported on: " coll)) jolt-nil)))))))) reduce-kv)))
+  (def-var! "clojure.core" "reduce-kv" (letrec ((reduce-kv (lambda (f init coll) (let fnrec1845 ((f f) (init init) (coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (let* ((_a$1847 (lambda (acc i) (let fnrec1846 ((acc acc) (i i)) (jolt-invoke f acc i (jolt-nth coll i))))) (_a$1848 init) (_a$1849 (jolt-range (jolt-count coll)))) (jolt-reduce _a$1847 _a$1848 _a$1849)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (let* ((_a$1851 (lambda (acc k) (let fnrec1850 ((acc acc) (k k)) (jolt-invoke f acc k (jolt-get coll k))))) (_a$1852 init) (_a$1853 (jolt-keys coll))) (jolt-reduce _a$1851 _a$1852 _a$1853)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) init (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "reduce-kv not supported on: " coll)) jolt-nil)))))))) reduce-kv)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ex-info-val?" (letrec ((ex-info-val? (lambda (x) (let fnrec1830 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "ex-info")))))) ex-info-val?)))
+  (def-var! "clojure.core" "ex-info-val?" (letrec ((ex-info-val? (lambda (x) (let fnrec1854 ((x x)) (jolt= (jolt-get x (keyword "jolt" "type")) (keyword "jolt" "ex-info")))))) ex-info-val?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ex-unwrap" (letrec ((ex-unwrap (lambda (e) (let fnrec1831 ((e e)) (if (jolt= (jolt-get e (keyword "jolt" "type")) (keyword "jolt" "exception")) (jolt-get e (keyword #f "value")) e))))) ex-unwrap)))
+  (def-var! "clojure.core" "ex-unwrap" (letrec ((ex-unwrap (lambda (e) (let fnrec1855 ((e e)) (if (jolt= (jolt-get e (keyword "jolt" "type")) (keyword "jolt" "exception")) (jolt-get e (keyword #f "value")) e))))) ex-unwrap)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ex-data" (letrec ((ex-data (lambda (e) (let fnrec1832 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "data")) jolt-nil)))))) ex-data)))
+  (def-var! "clojure.core" "ex-data" (letrec ((ex-data (lambda (e) (let fnrec1856 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "data")) jolt-nil)))))) ex-data)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ex-message" (letrec ((ex-message (lambda (e) (let fnrec1833 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "message")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) ex-message)))
+  (def-var! "clojure.core" "ex-message" (letrec ((ex-message (lambda (e) (let fnrec1857 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "message")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) ex-message)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ex-cause" (letrec ((ex-cause (lambda (e) (let fnrec1834 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "cause")) jolt-nil)))))) ex-cause)))
+  (def-var! "clojure.core" "ex-cause" (letrec ((ex-cause (lambda (e) (let fnrec1858 ((e e)) (let* ((e (jolt-invoke (var-deref "clojure.core" "ex-unwrap") e))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "ex-info-val?") e)) (jolt-get e (keyword #f "cause")) jolt-nil)))))) ex-cause)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "inst-ms" (letrec ((inst-ms (lambda (x) (let fnrec1835 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "inst?") x)) (jolt-get x (keyword #f "ms")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "inst-ms requires an inst, got: " x))))))) inst-ms)))
+  (def-var! "clojure.core" "inst-ms" (letrec ((inst-ms (lambda (x) (let fnrec1859 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "inst?") x)) (jolt-get x (keyword #f "ms")) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "inst-ms requires an inst, got: " x))))))) inst-ms)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "update-keys" (letrec ((update-keys (lambda (m f) (let fnrec1836 ((m m) (f f)) (let* ((_a$1838 (var-deref "clojure.core" "reduce-kv")) (_a$1839 (lambda (acc k v) (let fnrec1837 ((acc acc) (k k) (v v)) (jolt-assoc acc (jolt-invoke f k) v)))) (_a$1840 (jolt-hash-map )) (_a$1841 m)) (jolt-invoke _a$1838 _a$1839 _a$1840 _a$1841)))))) update-keys)))
+  (def-var! "clojure.core" "update-keys" (letrec ((update-keys (lambda (m f) (let fnrec1860 ((m m) (f f)) (let* ((_a$1862 (var-deref "clojure.core" "reduce-kv")) (_a$1863 (lambda (acc k v) (let fnrec1861 ((acc acc) (k k) (v v)) (jolt-assoc acc (jolt-invoke f k) v)))) (_a$1864 (jolt-hash-map )) (_a$1865 m)) (jolt-invoke _a$1862 _a$1863 _a$1864 _a$1865)))))) update-keys)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "update-vals" (letrec ((update-vals (lambda (m f) (let fnrec1842 ((m m) (f f)) (let* ((_a$1844 (var-deref "clojure.core" "reduce-kv")) (_a$1845 (lambda (acc k v) (let fnrec1843 ((acc acc) (k k) (v v)) (jolt-assoc acc k (jolt-invoke f v))))) (_a$1846 (jolt-hash-map )) (_a$1847 m)) (jolt-invoke _a$1844 _a$1845 _a$1846 _a$1847)))))) update-vals)))
+  (def-var! "clojure.core" "update-vals" (letrec ((update-vals (lambda (m f) (let fnrec1866 ((m m) (f f)) (let* ((_a$1868 (var-deref "clojure.core" "reduce-kv")) (_a$1869 (lambda (acc k v) (let fnrec1867 ((acc acc) (k k) (v v)) (jolt-assoc acc k (jolt-invoke f v))))) (_a$1870 (jolt-hash-map )) (_a$1871 m)) (jolt-invoke _a$1868 _a$1869 _a$1870 _a$1871)))))) update-vals)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "partitionv" (letrec ((partitionv (case-lambda ((n coll) (let fnrec1848 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n coll)))) ((n step coll) (let fnrec1849 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n step coll)))) ((n step pad coll) (let fnrec1850 ((n n) (step step) (pad pad) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n step pad coll))))))) partitionv)))
+  (def-var! "clojure.core" "partitionv" (letrec ((partitionv (case-lambda ((n coll) (let fnrec1872 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n coll)))) ((n step coll) (let fnrec1873 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n step coll)))) ((n step pad coll) (let fnrec1874 ((n n) (step step) (pad pad) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition") n step pad coll))))))) partitionv)))
 (guard (e (#t #f))
   (declare-var! "clojure.core" "partition-all"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "partitionv-all" (letrec ((partitionv-all (case-lambda ((n coll) (let fnrec1851 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n coll)))) ((n step coll) (let fnrec1852 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n step coll))))))) partitionv-all)))
+  (def-var! "clojure.core" "partitionv-all" (letrec ((partitionv-all (case-lambda ((n coll) (let fnrec1875 ((n n) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n coll)))) ((n step coll) (let fnrec1876 ((n n) (step step) (coll coll)) (jolt-map (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "partition-all") n step coll))))))) partitionv-all)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "splitv-at" (letrec ((splitv-at (lambda (n coll) (let fnrec1853 ((n n) (coll coll)) (let* ((_o$1854 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-take n coll))) (_o$1855 (jolt-drop n coll))) (jolt-vector _o$1854 _o$1855)))))) splitv-at)))
+  (def-var! "clojure.core" "splitv-at" (letrec ((splitv-at (lambda (n coll) (let fnrec1877 ((n n) (coll coll)) (let* ((_o$1878 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-take n coll))) (_o$1879 (jolt-drop n coll))) (jolt-vector _o$1878 _o$1879)))))) splitv-at)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "with-redefs-fn" (letrec ((with-redefs-fn (lambda (binding-map func) (let fnrec1856 ((binding-map binding-map) (func func)) (let* ((vars (jolt-invoke (var-deref "clojure.core" "vec") (jolt-keys binding-map))) (saved (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "var-get") vars))) (begin (begin (jolt-count (jolt-map (lambda (v) (let fnrec1857 ((v v)) (begin (jolt-invoke (var-deref "clojure.core" "var-set") v (jolt-get binding-map v)) jolt-nil))) vars)) jolt-nil) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke func)) (lambda () (let* ((i 0)) (let loop1858 ((i i)) (if (< i (jolt-count vars)) (begin (let* ((_a$1859 (var-deref "clojure.core" "var-set")) (_a$1860 (jolt-nth vars i)) (_a$1861 (jolt-nth saved i))) (jolt-invoke _a$1859 _a$1860 _a$1861)) (loop1858 (jolt-inc i))) jolt-nil))))))))))) with-redefs-fn)))
+  (def-var! "clojure.core" "with-redefs-fn" (letrec ((with-redefs-fn (lambda (binding-map func) (let fnrec1880 ((binding-map binding-map) (func func)) (let* ((vars (jolt-invoke (var-deref "clojure.core" "vec") (jolt-keys binding-map))) (saved (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "var-get") vars))) (begin (begin (jolt-count (jolt-map (lambda (v) (let fnrec1881 ((v v)) (begin (jolt-invoke (var-deref "clojure.core" "var-set") v (jolt-get binding-map v)) jolt-nil))) vars)) jolt-nil) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke func)) (lambda () (let* ((i 0)) (let loop1882 ((i i)) (if (< i (jolt-count vars)) (begin (let* ((_a$1883 (var-deref "clojure.core" "var-set")) (_a$1884 (jolt-nth vars i)) (_a$1885 (jolt-nth saved i))) (jolt-invoke _a$1883 _a$1884 _a$1885)) (loop1882 (jolt-inc i))) jolt-nil))))))))))) with-redefs-fn)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "chunked-seq?" (letrec ((chunked-seq? (lambda (x) (let fnrec1862 ((x x)) #f)))) chunked-seq?)))
+  (def-var! "clojure.core" "chunked-seq?" (letrec ((chunked-seq? (lambda (x) (let fnrec1886 ((x x)) #f)))) chunked-seq?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "swap-vals!" (letrec ((swap-vals! (lambda (a f . args) (let fnrec1863 ((a a) (f f) (args (list->cseq args))) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((_o$1864 old) (_o$1865 (jolt-apply (var-deref "clojure.core" "swap!") a f args))) (jolt-vector _o$1864 _o$1865))))))) swap-vals!)))
+  (def-var! "clojure.core" "swap-vals!" (letrec ((swap-vals! (lambda (a f . args) (let fnrec1887 ((a a) (f f) (args (list->cseq args))) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((_o$1888 old) (_o$1889 (jolt-apply (var-deref "clojure.core" "swap!") a f args))) (jolt-vector _o$1888 _o$1889))))))) swap-vals!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "reset-vals!" (letrec ((reset-vals! (lambda (a newval) (let fnrec1866 ((a a) (newval newval)) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) (let* ((_o$1867 old) (_o$1868 newval)) (jolt-vector _o$1867 _o$1868)))))))) reset-vals!)))
+  (def-var! "clojure.core" "reset-vals!" (letrec ((reset-vals! (lambda (a newval) (let fnrec1890 ((a a) (newval newval)) (let* ((old (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) (let* ((_o$1891 old) (_o$1892 newval)) (jolt-vector _o$1891 _o$1892)))))))) reset-vals!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "compare-and-set!" (letrec ((compare-and-set! (lambda (a oldval newval) (let fnrec1869 ((a a) (oldval oldval) (newval newval)) (if (jolt= oldval (jolt-invoke (var-deref "clojure.core" "deref") a)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) #t) #f))))) compare-and-set!)))
+  (def-var! "clojure.core" "compare-and-set!" (letrec ((compare-and-set! (lambda (a oldval newval) (let fnrec1893 ((a a) (oldval oldval) (newval newval)) (if (jolt= oldval (jolt-invoke (var-deref "clojure.core" "deref") a)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") a newval) #t) #f))))) compare-and-set!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "get-validator" (letrec ((get-validator (lambda (a) (let fnrec1870 ((a a)) (jolt-get a (keyword #f "validator")))))) get-validator)))
+  (def-var! "clojure.core" "get-validator" (letrec ((get-validator (lambda (a) (let fnrec1894 ((a a)) (jolt-get a (keyword #f "validator")))))) get-validator)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "add-watch" (letrec ((add-watch (lambda (a key f) (let fnrec1871 ((a a) (key key) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key f) a))))) add-watch)))
+  (def-var! "clojure.core" "add-watch" (letrec ((add-watch (lambda (a key f) (let fnrec1895 ((a a) (key key) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key f) a))))) add-watch)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "remove-watch" (letrec ((remove-watch (lambda (a key) (let fnrec1872 ((a a) (key key)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key jolt-nil) a))))) remove-watch)))
+  (def-var! "clojure.core" "remove-watch" (letrec ((remove-watch (lambda (a key) (let fnrec1896 ((a a) (key key)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-get a (keyword #f "watches")) key jolt-nil) a))))) remove-watch)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "set-validator!" (letrec ((set-validator! (lambda (a f) (let fnrec1873 ((a a) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") a (keyword #f "validator") f) jolt-nil))))) set-validator!)))
+  (def-var! "clojure.core" "set-validator!" (letrec ((set-validator! (lambda (a f) (let fnrec1897 ((a a) (f f)) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") a (keyword #f "validator") f) jolt-nil))))) set-validator!)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "future-done?" (letrec ((future-done? (lambda (x) (let fnrec1874 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (jolt-throw "future-done? requires a future")))))) future-done?)))
+  (def-var! "clojure.core" "future-done?" (letrec ((future-done? (lambda (x) (let fnrec1898 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "future?") x)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cached"))) (jolt-throw "future-done? requires a future")))))) future-done?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "future-cancelled?" (letrec ((future-cancelled? (lambda (x) (let fnrec1875 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "future?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cancelled"))) and__13__auto)))))) future-cancelled?)))
+  (def-var! "clojure.core" "future-cancelled?" (letrec ((future-cancelled? (lambda (x) (let fnrec1899 ((x x)) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "future?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-get x (keyword #f "cancelled"))) and__13__auto)))))) future-cancelled?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ns-name" (letrec ((ns-name (lambda (ns) (let fnrec1876 ((ns ns)) (let* ((nm (jolt-get ns (keyword #f "name")))) (if (jolt-truthy? nm) (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") nm)) jolt-nil)))))) ns-name)))
+  (def-var! "clojure.core" "ns-name" (letrec ((ns-name (lambda (ns) (let fnrec1900 ((ns ns)) (let* ((nm (jolt-get ns (keyword #f "name")))) (if (jolt-truthy? nm) (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") nm)) jolt-nil)))))) ns-name)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "aget" (letrec ((aget (lambda (arr . idxs) (let fnrec1877 ((arr arr) (idxs (list->cseq idxs))) (jolt-reduce (lambda (v i) (let fnrec1878 ((v v) (i i)) (jolt-nth v i))) arr idxs))))) aget)))
+  (def-var! "clojure.core" "aget" (letrec ((aget (lambda (arr . idxs) (let fnrec1901 ((arr arr) (idxs (list->cseq idxs))) (jolt-reduce (lambda (v i) (let fnrec1902 ((v v) (i i)) (jolt-nth v i))) arr idxs))))) aget)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "alength" (letrec ((alength (lambda (arr) (let fnrec1879 ((arr arr)) (jolt-count arr))))) alength)))
+  (def-var! "clojure.core" "alength" (letrec ((alength (lambda (arr) (let fnrec1903 ((arr arr)) (jolt-count arr))))) alength)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "aset" (letrec ((aset (lambda (arr . idxs+val) (let fnrec1880 ((arr arr) (idxs+val (list->cseq idxs+val))) (let* ((n (jolt-count idxs+val)) (val (jolt-nth idxs+val (jolt-dec n))) (target (let* ((_a$1882 (lambda (t k) (let fnrec1881 ((t t) (k k)) (jolt-nth t k)))) (_a$1883 arr) (_a$1884 (jolt-take (- n 2) idxs+val))) (jolt-reduce _a$1882 _a$1883 _a$1884)))) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") target (jolt-nth idxs+val (- n 2)) val) val)))))) aset)))
+  (def-var! "clojure.core" "aset" (letrec ((aset (lambda (arr . idxs+val) (let fnrec1904 ((arr arr) (idxs+val (list->cseq idxs+val))) (let* ((n (jolt-count idxs+val)) (val (jolt-nth idxs+val (jolt-dec n))) (target (let* ((_a$1906 (lambda (t k) (let fnrec1905 ((t t) (k k)) (jolt-nth t k)))) (_a$1907 arr) (_a$1908 (jolt-take (- n 2) idxs+val))) (jolt-reduce _a$1906 _a$1907 _a$1908)))) (begin (jolt-invoke (var-deref "jolt.host" "ref-put!") target (jolt-nth idxs+val (- n 2)) val) val)))))) aset)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "complement" (letrec ((complement (lambda (f) (let fnrec1885 ((f f)) (lambda args (let fnrec1886 ((args (list->cseq args))) (jolt-not (jolt-apply f args)))))))) complement)))
+  (def-var! "clojure.core" "complement" (letrec ((complement (lambda (f) (let fnrec1909 ((f f)) (lambda args (let fnrec1910 ((args (list->cseq args))) (jolt-not (jolt-apply f args)))))))) complement)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "fnil" (letrec ((fnil (case-lambda ((f x) (let fnrec1887 ((f f) (x x)) (lambda (a . args) (let fnrec1888 ((a a) (args (list->cseq args))) (jolt-apply f (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a) args))))) ((f x y) (let fnrec1889 ((f f) (x x) (y y)) (lambda (a b . args) (let fnrec1890 ((a a) (b b) (args (list->cseq args))) (let* ((_a$1891 f) (_a$1892 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$1893 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$1894 args)) (jolt-apply _a$1891 _a$1892 _a$1893 _a$1894)))))) ((f x y z) (let fnrec1895 ((f f) (x x) (y y) (z z)) (lambda (a b c . args) (let fnrec1896 ((a a) (b b) (c c) (args (list->cseq args))) (let* ((_a$1897 f) (_a$1898 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$1899 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$1900 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") c)) z c)) (_a$1901 args)) (jolt-apply _a$1897 _a$1898 _a$1899 _a$1900 _a$1901))))))))) fnil)))
+  (def-var! "clojure.core" "fnil" (letrec ((fnil (case-lambda ((f x) (let fnrec1911 ((f f) (x x)) (lambda (a . args) (let fnrec1912 ((a a) (args (list->cseq args))) (jolt-apply f (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a) args))))) ((f x y) (let fnrec1913 ((f f) (x x) (y y)) (lambda (a b . args) (let fnrec1914 ((a a) (b b) (args (list->cseq args))) (let* ((_a$1915 f) (_a$1916 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$1917 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$1918 args)) (jolt-apply _a$1915 _a$1916 _a$1917 _a$1918)))))) ((f x y z) (let fnrec1919 ((f f) (x x) (y y) (z z)) (lambda (a b c . args) (let fnrec1920 ((a a) (b b) (c c) (args (list->cseq args))) (let* ((_a$1921 f) (_a$1922 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) x a)) (_a$1923 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) y b)) (_a$1924 (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") c)) z c)) (_a$1925 args)) (jolt-apply _a$1921 _a$1922 _a$1923 _a$1924 _a$1925))))))))) fnil)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "clojure-version" (letrec ((clojure-version (lambda () (let fnrec1902 () "1.11.0-jolt")))) clojure-version)))
+  (def-var! "clojure.core" "clojure-version" (letrec ((clojure-version (lambda () (let fnrec1926 () "1.11.0-jolt")))) clojure-version)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "numerator" (letrec ((numerator (lambda (x) (let fnrec1903 ((x x)) (jolt-throw (jolt-ex-info "numerator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) numerator)))
+  (def-var! "clojure.core" "numerator" (letrec ((numerator (lambda (x) (let fnrec1927 ((x x)) (jolt-throw (jolt-ex-info "numerator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) numerator)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "denominator" (letrec ((denominator (lambda (x) (let fnrec1904 ((x x)) (jolt-throw (jolt-ex-info "denominator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) denominator)))
+  (def-var! "clojure.core" "denominator" (letrec ((denominator (lambda (x) (let fnrec1928 ((x x)) (jolt-throw (jolt-ex-info "denominator requires a ratio (Jolt has no ratios)" (jolt-hash-map))))))) denominator)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "supers" (letrec ((supers (lambda (x) (let fnrec1905 ((x x)) (jolt-hash-set))))) supers)))
+  (def-var! "clojure.core" "supers" (letrec ((supers (lambda (x) (let fnrec1929 ((x x)) (jolt-hash-set))))) supers)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "munge" (letrec ((munge (lambda (s) (let fnrec1906 ((s s)) (let* ((m (jolt-invoke (var-deref "clojure.core" "str-replace-all") "-" "_" (jolt-invoke (var-deref "clojure.core" "str") s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") s)) (jolt-invoke (var-deref "clojure.core" "symbol") m) m)))))) munge)))
+  (def-var! "clojure.core" "munge" (letrec ((munge (lambda (s) (let fnrec1930 ((s s)) (let* ((m (jolt-invoke (var-deref "clojure.core" "str-replace-all") "-" "_" (jolt-invoke (var-deref "clojure.core" "str") s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") s)) (jolt-invoke (var-deref "clojure.core" "symbol") m) m)))))) munge)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "test" (letrec ((test (lambda (v) (let fnrec1907 ((v v)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") v) (keyword #f "test")))) (if (jolt-truthy? t) (begin (jolt-invoke t) (keyword #f "ok")) (keyword #f "no-test"))))))) test)))
+  (def-var! "clojure.core" "test" (letrec ((test (lambda (v) (let fnrec1931 ((v v)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") v) (keyword #f "test")))) (if (jolt-truthy? t) (begin (jolt-invoke t) (keyword #f "ok")) (keyword #f "no-test"))))))) test)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "find" (letrec ((find (lambda (m k) (let fnrec1908 ((m m) (k k)) (if (jolt-contains? m k) (jolt-first (let* ((_o$1909 k) (_o$1910 (jolt-get m k))) (jolt-hash-map _o$1909 _o$1910))) jolt-nil))))) find)))
+  (def-var! "clojure.core" "find" (letrec ((find (lambda (m k) (let fnrec1932 ((m m) (k k)) (if (jolt-contains? m k) (jolt-first (let* ((_o$1933 k) (_o$1934 (jolt-get m k))) (jolt-hash-map _o$1933 _o$1934))) jolt-nil))))) find)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "true?" (letrec ((true? (lambda (x) (let fnrec1911 ((x x)) (jolt= #t x))))) true?)))
+  (def-var! "clojure.core" "true?" (letrec ((true? (lambda (x) (let fnrec1935 ((x x)) (jolt= #t x))))) true?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "false?" (letrec ((false? (lambda (x) (let fnrec1912 ((x x)) (jolt= #f x))))) false?)))
+  (def-var! "clojure.core" "false?" (letrec ((false? (lambda (x) (let fnrec1936 ((x x)) (jolt= #f x))))) false?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "select-keys" (letrec ((select-keys (lambda (map keyseq) (let fnrec1913 ((map map) (keyseq keyseq)) (let* ((_a$1915 (lambda (m k) (let fnrec1914 ((m m) (k k)) (if (jolt-contains? map k) (jolt-assoc m k (jolt-get map k)) m)))) (_a$1916 (jolt-hash-map )) (_a$1917 keyseq)) (jolt-reduce _a$1915 _a$1916 _a$1917)))))) select-keys)))
+  (def-var! "clojure.core" "select-keys" (letrec ((select-keys (lambda (map keyseq) (let fnrec1937 ((map map) (keyseq keyseq)) (let* ((_a$1939 (lambda (m k) (let fnrec1938 ((m m) (k k)) (if (jolt-contains? map k) (jolt-assoc m k (jolt-get map k)) m)))) (_a$1940 (jolt-hash-map )) (_a$1941 keyseq)) (jolt-reduce _a$1939 _a$1940 _a$1941)))))) select-keys)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "zipmap" (letrec ((zipmap (lambda (keys vals) (let fnrec1918 ((keys keys) (vals vals)) (let* ((m (jolt-hash-map )) (ks (jolt-seq keys)) (vs (jolt-seq vals))) (let loop1919 ((m m) (ks ks) (vs vs)) (if (jolt-truthy? (let* ((and__13__auto ks)) (if (jolt-truthy? and__13__auto) vs and__13__auto))) (let* ((_a$1923 (let* ((_a$1920 m) (_a$1921 (jolt-first ks)) (_a$1922 (jolt-first vs))) (jolt-assoc _a$1920 _a$1921 _a$1922))) (_a$1924 (jolt-next ks)) (_a$1925 (jolt-next vs))) (loop1919 _a$1923 _a$1924 _a$1925)) m))))))) zipmap)))
+  (def-var! "clojure.core" "zipmap" (letrec ((zipmap (lambda (keys vals) (let fnrec1942 ((keys keys) (vals vals)) (let* ((m (jolt-hash-map )) (ks (jolt-seq keys)) (vs (jolt-seq vals))) (let loop1943 ((m m) (ks ks) (vs vs)) (if (jolt-truthy? (let* ((and__13__auto ks)) (if (jolt-truthy? and__13__auto) vs and__13__auto))) (let* ((_a$1947 (let* ((_a$1944 m) (_a$1945 (jolt-first ks)) (_a$1946 (jolt-first vs))) (jolt-assoc _a$1944 _a$1945 _a$1946))) (_a$1948 (jolt-next ks)) (_a$1949 (jolt-next vs))) (loop1943 _a$1947 _a$1948 _a$1949)) m))))))) zipmap)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "merge" (letrec ((merge (lambda maps (let fnrec1926 ((maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (jolt-reduce (lambda (acc m) (let fnrec1927 ((acc acc) (m m)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) acc (jolt-conj (let* ((or__14__auto acc)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map ))) m)))) maps) jolt-nil))))) merge)))
+  (def-var! "clojure.core" "merge" (letrec ((merge (lambda maps (let fnrec1950 ((maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (jolt-reduce (lambda (acc m) (let fnrec1951 ((acc acc) (m m)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) acc (jolt-conj (let* ((or__14__auto acc)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map ))) m)))) maps) jolt-nil))))) merge)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "merge-with" (letrec ((merge-with (lambda (f . maps) (let fnrec1928 ((f f) (maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (let* ((merge-entry (lambda (m e) (let fnrec1929 ((m m) (e e)) (let* ((k (jolt-invoke (var-deref "clojure.core" "key") e)) (v (jolt-invoke (var-deref "clojure.core" "val") e))) (if (jolt-contains? m k) (jolt-assoc m k (jolt-invoke f (jolt-get m k) v)) (jolt-assoc m k v)))))) (merge2 (lambda (m1 m2) (let fnrec1930 ((m1 m1) (m2 m2)) (let* ((_a$1931 merge-entry) (_a$1932 (let* ((or__14__auto m1)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map )))) (_a$1933 (jolt-seq m2))) (jolt-reduce _a$1931 _a$1932 _a$1933)))))) (jolt-reduce merge2 maps)) jolt-nil))))) merge-with)))
+  (def-var! "clojure.core" "merge-with" (letrec ((merge-with (lambda (f . maps) (let fnrec1952 ((f f) (maps (list->cseq maps))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "some") jolt-identity maps)) (let* ((merge-entry (lambda (m e) (let fnrec1953 ((m m) (e e)) (let* ((k (jolt-invoke (var-deref "clojure.core" "key") e)) (v (jolt-invoke (var-deref "clojure.core" "val") e))) (if (jolt-contains? m k) (jolt-assoc m k (jolt-invoke f (jolt-get m k) v)) (jolt-assoc m k v)))))) (merge2 (lambda (m1 m2) (let fnrec1954 ((m1 m1) (m2 m2)) (let* ((_a$1955 merge-entry) (_a$1956 (let* ((or__14__auto m1)) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-hash-map )))) (_a$1957 (jolt-seq m2))) (jolt-reduce _a$1955 _a$1956 _a$1957)))))) (jolt-reduce merge2 maps)) jolt-nil))))) merge-with)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "get-in" (letrec ((get-in (case-lambda ((m ks) (let fnrec1934 ((m m) (ks ks)) (jolt-reduce jolt-get m ks))) ((m ks not-found) (let fnrec1935 ((m m) (ks ks) (not-found not-found)) (let* ((sentinel (jolt-hash-map ))) (let* ((m m) (ks (jolt-seq ks))) (let loop1936 ((m m) (ks ks)) (if (jolt-truthy? ks) (let* ((nxt (jolt-get m (jolt-first ks) sentinel))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "identical?") sentinel nxt)) not-found (loop1936 nxt (jolt-next ks)))) m))))))))) get-in)))
+  (def-var! "clojure.core" "get-in" (letrec ((get-in (case-lambda ((m ks) (let fnrec1958 ((m m) (ks ks)) (jolt-reduce jolt-get m ks))) ((m ks not-found) (let fnrec1959 ((m m) (ks ks) (not-found not-found)) (let* ((sentinel (jolt-hash-map ))) (let* ((m m) (ks (jolt-seq ks))) (let loop1960 ((m m) (ks ks)) (if (jolt-truthy? ks) (let* ((nxt (jolt-get m (jolt-first ks) sentinel))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "identical?") sentinel nxt)) not-found (loop1960 nxt (jolt-next ks)))) m))))))))) get-in)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "memoize" (letrec ((memoize (lambda (f) (let fnrec1937 ((f f)) (let* ((mem (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map )))) (lambda args (let fnrec1938 ((args (list->cseq args))) (let* ((e (jolt-invoke (var-deref "clojure.core" "find") (jolt-invoke (var-deref "clojure.core" "deref") mem) args))) (if (jolt-truthy? e) (jolt-invoke (var-deref "clojure.core" "val") e) (let* ((ret (jolt-apply f args))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") mem jolt-assoc args ret) ret))))))))))) memoize)))
+  (def-var! "clojure.core" "memoize" (letrec ((memoize (lambda (f) (let fnrec1961 ((f f)) (let* ((mem (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map )))) (lambda args (let fnrec1962 ((args (list->cseq args))) (let* ((e (jolt-invoke (var-deref "clojure.core" "find") (jolt-invoke (var-deref "clojure.core" "deref") mem) args))) (if (jolt-truthy? e) (jolt-invoke (var-deref "clojure.core" "val") e) (let* ((ret (jolt-apply f args))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") mem jolt-assoc args ret) ret))))))))))) memoize)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "partial" (letrec ((partial (case-lambda ((f) (let fnrec1939 ((f f)) f)) ((f a) (let fnrec1940 ((f f) (a a)) (lambda args (let fnrec1941 ((args (list->cseq args))) (jolt-apply f a args))))) ((f a b) (let fnrec1942 ((f f) (a a) (b b)) (lambda args (let fnrec1943 ((args (list->cseq args))) (jolt-apply f a b args))))) ((f a b c) (let fnrec1944 ((f f) (a a) (b b) (c c)) (lambda args (let fnrec1945 ((args (list->cseq args))) (jolt-apply f a b c args))))) ((f a b c . more) (let fnrec1946 ((f f) (a a) (b b) (c c) (more (list->cseq more))) (lambda args (let fnrec1947 ((args (list->cseq args))) (jolt-apply f a b c (jolt-concat more args))))))))) partial)))
+  (def-var! "clojure.core" "partial" (letrec ((partial (case-lambda ((f) (let fnrec1963 ((f f)) f)) ((f a) (let fnrec1964 ((f f) (a a)) (lambda args (let fnrec1965 ((args (list->cseq args))) (jolt-apply f a args))))) ((f a b) (let fnrec1966 ((f f) (a a) (b b)) (lambda args (let fnrec1967 ((args (list->cseq args))) (jolt-apply f a b args))))) ((f a b c) (let fnrec1968 ((f f) (a a) (b b) (c c)) (lambda args (let fnrec1969 ((args (list->cseq args))) (jolt-apply f a b c args))))) ((f a b c . more) (let fnrec1970 ((f f) (a a) (b b) (c c) (more (list->cseq more))) (lambda args (let fnrec1971 ((args (list->cseq args))) (jolt-apply f a b c (jolt-concat more args))))))))) partial)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "trampoline" (letrec ((trampoline (case-lambda ((f) (let fnrec1948 ((f f)) (let* ((ret (jolt-invoke f))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "fn?") ret)) (jolt-invoke trampoline ret) ret)))) ((f . args) (let fnrec1949 ((f f) (args (list->cseq args))) (jolt-invoke trampoline (lambda () (let fnrec1950 () (jolt-apply f args))))))))) trampoline)))
+  (def-var! "clojure.core" "trampoline" (letrec ((trampoline (case-lambda ((f) (let fnrec1972 ((f f)) (let* ((ret (jolt-invoke f))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "fn?") ret)) (jolt-invoke trampoline ret) ret)))) ((f . args) (let fnrec1973 ((f f) (args (list->cseq args))) (jolt-invoke trampoline (lambda () (let fnrec1974 () (jolt-apply f args))))))))) trampoline)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "max" (letrec ((max (case-lambda ((x) (let fnrec1951 ((x x)) x)) ((x y) (let fnrec1952 ((x x) (y y)) (if (> x y) x y))) ((x y . more) (let fnrec1953 ((x x) (y y) (more (list->cseq more))) (jolt-reduce max (jolt-invoke max x y) more)))))) max)))
+  (def-var! "clojure.core" "max" (letrec ((max (case-lambda ((x) (let fnrec1975 ((x x)) x)) ((x y) (let fnrec1976 ((x x) (y y)) (if (> x y) x y))) ((x y . more) (let fnrec1977 ((x x) (y y) (more (list->cseq more))) (jolt-reduce max (jolt-invoke max x y) more)))))) max)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "min" (letrec ((min (case-lambda ((x) (let fnrec1954 ((x x)) x)) ((x y) (let fnrec1955 ((x x) (y y)) (if (< x y) x y))) ((x y . more) (let fnrec1956 ((x x) (y y) (more (list->cseq more))) (jolt-reduce min (jolt-invoke min x y) more)))))) min)))
+  (def-var! "clojure.core" "min" (letrec ((min (case-lambda ((x) (let fnrec1978 ((x x)) x)) ((x y) (let fnrec1979 ((x x) (y y)) (if (< x y) x y))) ((x y . more) (let fnrec1980 ((x x) (y y) (more (list->cseq more))) (jolt-reduce min (jolt-invoke min x y) more)))))) min)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "reverse" (letrec ((reverse (lambda (coll) (let fnrec1957 ((coll coll)) (jolt-reduce jolt-conj (jolt-list ) coll))))) reverse)))
+  (def-var! "clojure.core" "reverse" (letrec ((reverse (lambda (coll) (let fnrec1981 ((coll coll)) (jolt-reduce jolt-conj (jolt-list ) coll))))) reverse)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "empty" (letrec ((empty (lambda (coll) (let fnrec1958 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted?") coll)) (jolt-invoke (jolt-get (jolt-invoke (var-deref "jolt.host" "ref-get") coll (keyword #f "ops")) (keyword #f "empty")) coll) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (jolt-hash-map) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") coll)) (jolt-hash-set) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (jolt-vector) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-list ) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))))) empty)))
+  (def-var! "clojure.core" "empty" (letrec ((empty (lambda (coll) (let fnrec1982 ((coll coll)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") coll)) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted?") coll)) (jolt-invoke (jolt-get (jolt-invoke (var-deref "jolt.host" "ref-get") coll (keyword #f "ops")) (keyword #f "empty")) coll) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") coll)) (jolt-hash-map) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") coll)) (jolt-hash-set) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") coll)) (jolt-vector) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "coll?") coll)) (jolt-list ) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))))) empty)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "assoc-in" (letrec ((assoc-in (lambda (m G__28 v) (let fnrec1959 ((m m) (G__28 G__28) (v v)) (let* ((G__29 G__28) (k (jolt-nth G__29 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__29 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke assoc-in (jolt-get m k) ks v)) (jolt-assoc m k v))))))) assoc-in)))
+  (def-var! "clojure.core" "assoc-in" (letrec ((assoc-in (lambda (m G__28 v) (let fnrec1983 ((m m) (G__28 G__28) (v v)) (let* ((G__29 G__28) (k (jolt-nth G__29 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__29 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke assoc-in (jolt-get m k) ks v)) (jolt-assoc m k v))))))) assoc-in)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "update-in" (letrec ((update-in (lambda (m ks f . args) (let fnrec1960 ((m m) (ks ks) (f f) (args (list->cseq args))) (let* ((up (letrec ((up (lambda (m ks f args) (let fnrec1961 ((m m) (ks ks) (f f) (args args)) (let* ((G__30 ks) (k (jolt-nth G__30 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__30 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke up (jolt-get m k) ks f args)) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))))) up))) (jolt-invoke up m ks f args)))))) update-in)))
+  (def-var! "clojure.core" "update-in" (letrec ((update-in (lambda (m ks f . args) (let fnrec1984 ((m m) (ks ks) (f f) (args (list->cseq args))) (let* ((up (letrec ((up (lambda (m ks f args) (let fnrec1985 ((m m) (ks ks) (f f) (args args)) (let* ((G__30 ks) (k (jolt-nth G__30 0 jolt-nil)) (ks (jolt-invoke (var-deref "clojure.core" "nthnext") G__30 1))) (if (jolt-truthy? ks) (jolt-assoc m k (jolt-invoke up (jolt-get m k) ks f args)) (jolt-assoc m k (jolt-apply f (jolt-get m k) args)))))))) up))) (jolt-invoke up m ks f args)))))) update-in)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "find-keyword" (letrec ((find-keyword (case-lambda ((nm) (let fnrec1962 ((nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") nm))) ((ns nm) (let fnrec1963 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") ns nm)))))) find-keyword)))
+  (def-var! "clojure.core" "find-keyword" (letrec ((find-keyword (case-lambda ((nm) (let fnrec1986 ((nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") nm))) ((ns nm) (let fnrec1987 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "keyword") ns nm)))))) find-keyword)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "inst-ms*" (letrec ((inst-ms* (lambda (i) (let fnrec1964 ((i i)) (jolt-invoke (var-deref "clojure.core" "inst-ms") i))))) inst-ms*)))
+  (def-var! "clojure.core" "inst-ms*" (letrec ((inst-ms* (lambda (i) (let fnrec1988 ((i i)) (jolt-invoke (var-deref "clojure.core" "inst-ms") i))))) inst-ms*)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "comp" (letrec ((comp (case-lambda (() (let fnrec1965 () jolt-identity)) ((f) (let fnrec1966 ((f f)) f)) ((f g) (let fnrec1967 ((f f) (g g)) (case-lambda (() (let fnrec1968 () (jolt-invoke f (jolt-invoke g)))) ((x) (let fnrec1969 ((x x)) (jolt-invoke f (jolt-invoke g x)))) ((x y) (let fnrec1970 ((x x) (y y)) (jolt-invoke f (jolt-invoke g x y)))) ((x y z) (let fnrec1971 ((x x) (y y) (z z)) (jolt-invoke f (jolt-invoke g x y z)))) ((x y z . args) (let fnrec1972 ((x x) (y y) (z z) (args (list->cseq args))) (jolt-invoke f (jolt-apply g x y z args))))))) ((f g . fs) (let fnrec1973 ((f f) (g g) (fs (list->cseq fs))) (jolt-reduce comp (jolt-invoke comp f g) fs)))))) comp)))
+  (def-var! "clojure.core" "comp" (letrec ((comp (case-lambda (() (let fnrec1989 () jolt-identity)) ((f) (let fnrec1990 ((f f)) f)) ((f g) (let fnrec1991 ((f f) (g g)) (case-lambda (() (let fnrec1992 () (jolt-invoke f (jolt-invoke g)))) ((x) (let fnrec1993 ((x x)) (jolt-invoke f (jolt-invoke g x)))) ((x y) (let fnrec1994 ((x x) (y y)) (jolt-invoke f (jolt-invoke g x y)))) ((x y z) (let fnrec1995 ((x x) (y y) (z z)) (jolt-invoke f (jolt-invoke g x y z)))) ((x y z . args) (let fnrec1996 ((x x) (y y) (z z) (args (list->cseq args))) (jolt-invoke f (jolt-apply g x y z args))))))) ((f g . fs) (let fnrec1997 ((f f) (g g) (fs (list->cseq fs))) (jolt-reduce comp (jolt-invoke comp f g) fs)))))) comp)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ifn?" (letrec ((ifn? (lambda (x) (let fnrec1974 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "fn?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "var?") x))))))))))))))))) ifn?)))
+  (def-var! "clojure.core" "ifn?" (letrec ((ifn? (lambda (x) (let fnrec1998 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "fn?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "keyword?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "set?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "var?") x))))))))))))))))) ifn?)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "+'" jolt-add))
 (guard (e (#t #f))
@@ -503,17 +503,17 @@
 (guard (e (#t #f))
   (def-var! "clojure.core" "dec'" jolt-dec))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-add" (letrec ((unchecked-add (lambda (x y) (let fnrec1975 ((x x) (y y)) (+ x y))))) unchecked-add)))
+  (def-var! "clojure.core" "unchecked-add" (letrec ((unchecked-add (lambda (x y) (let fnrec1999 ((x x) (y y)) (+ x y))))) unchecked-add)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-subtract" (letrec ((unchecked-subtract (lambda (x y) (let fnrec1976 ((x x) (y y)) (- x y))))) unchecked-subtract)))
+  (def-var! "clojure.core" "unchecked-subtract" (letrec ((unchecked-subtract (lambda (x y) (let fnrec2000 ((x x) (y y)) (- x y))))) unchecked-subtract)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-multiply" (letrec ((unchecked-multiply (lambda (x y) (let fnrec1977 ((x x) (y y)) (* x y))))) unchecked-multiply)))
+  (def-var! "clojure.core" "unchecked-multiply" (letrec ((unchecked-multiply (lambda (x y) (let fnrec2001 ((x x) (y y)) (* x y))))) unchecked-multiply)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-negate" (letrec ((unchecked-negate (lambda (x) (let fnrec1978 ((x x)) (- x))))) unchecked-negate)))
+  (def-var! "clojure.core" "unchecked-negate" (letrec ((unchecked-negate (lambda (x) (let fnrec2002 ((x x)) (- x))))) unchecked-negate)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-inc" (letrec ((unchecked-inc (lambda (x) (let fnrec1979 ((x x)) (+ x 1))))) unchecked-inc)))
+  (def-var! "clojure.core" "unchecked-inc" (letrec ((unchecked-inc (lambda (x) (let fnrec2003 ((x x)) (+ x 1))))) unchecked-inc)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-dec" (letrec ((unchecked-dec (lambda (x) (let fnrec1980 ((x x)) (- x 1))))) unchecked-dec)))
+  (def-var! "clojure.core" "unchecked-dec" (letrec ((unchecked-dec (lambda (x) (let fnrec2004 ((x x)) (- x 1))))) unchecked-dec)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "unchecked-add-int" (var-deref "clojure.core" "unchecked-add")))
 (guard (e (#t #f))
@@ -527,529 +527,529 @@
 (guard (e (#t #f))
   (def-var! "clojure.core" "unchecked-dec-int" (var-deref "clojure.core" "unchecked-dec")))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-divide-int" (letrec ((unchecked-divide-int (lambda (x y) (let fnrec1981 ((x x) (y y)) (quotient x y))))) unchecked-divide-int)))
+  (def-var! "clojure.core" "unchecked-divide-int" (letrec ((unchecked-divide-int (lambda (x y) (let fnrec2005 ((x x) (y y)) (quotient x y))))) unchecked-divide-int)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-remainder-int" (letrec ((unchecked-remainder-int (lambda (x y) (let fnrec1982 ((x x) (y y)) (remainder x y))))) unchecked-remainder-int)))
+  (def-var! "clojure.core" "unchecked-remainder-int" (letrec ((unchecked-remainder-int (lambda (x y) (let fnrec2006 ((x x) (y y)) (remainder x y))))) unchecked-remainder-int)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-int" (letrec ((unchecked-int (lambda (x) (let fnrec1983 ((x x)) (jolt-invoke (var-deref "clojure.core" "int") x))))) unchecked-int)))
+  (def-var! "clojure.core" "unchecked-int" (letrec ((unchecked-int (lambda (x) (let fnrec2007 ((x x)) (jolt-invoke (var-deref "clojure.core" "int") x))))) unchecked-int)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "unchecked-long" (var-deref "clojure.core" "unchecked-int")))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "int?" (letrec ((int? (lambda (x) (let fnrec1984 ((x x)) (jolt-invoke (var-deref "clojure.core" "integer?") x))))) int?)))
+  (def-var! "clojure.core" "int?" (letrec ((int? (lambda (x) (let fnrec2008 ((x x)) (jolt-invoke (var-deref "clojure.core" "integer?") x))))) int?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "num" (letrec ((num (lambda (x) (let fnrec1985 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) x (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "num requires a number, got: " x))))))) num)))
+  (def-var! "clojure.core" "num" (letrec ((num (lambda (x) (let fnrec2009 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) x (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "num requires a number, got: " x))))))) num)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "==" (letrec ((== (case-lambda ((x) (let fnrec1986 ((x x)) #t)) ((x y) (let fnrec1987 ((x x) (y y)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "number?") y) and__13__auto))) (jolt= x y) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cannot cast to number: " (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) y x)))))) ((x y . more) (let fnrec1988 ((x x) (y y) (more (list->cseq more))) (if (jolt-truthy? (jolt-invoke == x y)) (jolt-apply == y more) #f)))))) ==)))
+  (def-var! "clojure.core" "==" (letrec ((== (case-lambda ((x) (let fnrec2010 ((x x)) #t)) ((x y) (let fnrec2011 ((x x) (y y)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "number?") x))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "number?") y) and__13__auto))) (jolt= x y) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Cannot cast to number: " (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") x)) y x)))))) ((x y . more) (let fnrec2012 ((x x) (y y) (more (list->cseq more))) (if (jolt-truthy? (jolt-invoke == x y)) (jolt-apply == y more) #f)))))) ==)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ensure-reduced" (letrec ((ensure-reduced (lambda (x) (let fnrec1989 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) x (jolt-invoke (var-deref "clojure.core" "reduced") x)))))) ensure-reduced)))
+  (def-var! "clojure.core" "ensure-reduced" (letrec ((ensure-reduced (lambda (x) (let fnrec2013 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") x)) x (jolt-invoke (var-deref "clojure.core" "reduced") x)))))) ensure-reduced)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "halt-when" (letrec ((halt-when (case-lambda ((pred) (let fnrec1990 ((pred pred)) (jolt-invoke halt-when pred jolt-nil))) ((pred retf) (let fnrec1991 ((pred pred) (retf retf)) (lambda (rf) (let fnrec1992 ((rf rf)) (case-lambda (() (let fnrec1993 () (jolt-invoke rf))) ((result) (let fnrec1994 ((result result)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__13__auto) (jolt-contains? result (keyword "clojure.core" "halt")) and__13__auto))) (jolt-get result (keyword "clojure.core" "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec1995 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword "clojure.core" "halt") (if (jolt-truthy? retf) (jolt-invoke retf (jolt-invoke rf result) input) input))) (jolt-invoke rf result input)))))))))))) halt-when)))
+  (def-var! "clojure.core" "halt-when" (letrec ((halt-when (case-lambda ((pred) (let fnrec2014 ((pred pred)) (jolt-invoke halt-when pred jolt-nil))) ((pred retf) (let fnrec2015 ((pred pred) (retf retf)) (lambda (rf) (let fnrec2016 ((rf rf)) (case-lambda (() (let fnrec2017 () (jolt-invoke rf))) ((result) (let fnrec2018 ((result result)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") result))) (if (jolt-truthy? and__13__auto) (jolt-contains? result (keyword "clojure.core" "halt")) and__13__auto))) (jolt-get result (keyword "clojure.core" "halt")) (jolt-invoke rf result)))) ((result input) (let fnrec2019 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke pred input)) (jolt-invoke (var-deref "clojure.core" "reduced") (jolt-hash-map (keyword "clojure.core" "halt") (if (jolt-truthy? retf) (jolt-invoke retf (jolt-invoke rf result) input) input))) (jolt-invoke rf result input)))))))))))) halt-when)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "parse-boolean" (letrec ((parse-boolean (lambda (s) (let fnrec1996 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt= s "true") #t (if (jolt= s "false") #f (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-boolean requires a string, got: " s))))))) parse-boolean)))
+  (def-var! "clojure.core" "parse-boolean" (letrec ((parse-boolean (lambda (s) (let fnrec2020 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") s)) (if (jolt= s "true") #t (if (jolt= s "false") #f (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "parse-boolean requires a string, got: " s))))))) parse-boolean)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "newline" (letrec ((newline (lambda () (let fnrec1997 () (begin (jolt-invoke (var-deref "clojure.core" "print") "\n") jolt-nil))))) newline)))
+  (def-var! "clojure.core" "newline" (letrec ((newline (lambda () (let fnrec2021 () (begin (jolt-invoke (var-deref "clojure.core" "print") "\n") jolt-nil))))) newline)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "seque" (letrec ((seque (case-lambda ((s) (let fnrec1998 ((s s)) s)) ((n-or-q s) (let fnrec1999 ((n-or-q n-or-q) (s s)) s))))) seque)))
+  (def-var! "clojure.core" "seque" (letrec ((seque (case-lambda ((s) (let fnrec2022 ((s s)) s)) ((n-or-q s) (let fnrec2023 ((n-or-q n-or-q) (s s)) s))))) seque)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "array-seq" (letrec ((array-seq (lambda (arr . _) (let fnrec2000 ((arr arr) (_ (list->cseq _))) (jolt-seq arr))))) array-seq)))
+  (def-var! "clojure.core" "array-seq" (letrec ((array-seq (lambda (arr . _) (let fnrec2024 ((arr arr) (_ (list->cseq _))) (jolt-seq arr))))) array-seq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "to-array-2d" (letrec ((to-array-2d (lambda (coll) (let fnrec2001 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "to-array") (jolt-map (var-deref "clojure.core" "to-array") coll)))))) to-array-2d)))
+  (def-var! "clojure.core" "to-array-2d" (letrec ((to-array-2d (lambda (coll) (let fnrec2025 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "to-array") (jolt-map (var-deref "clojure.core" "to-array") coll)))))) to-array-2d)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-byte" (letrec ((unchecked-byte (lambda (x) (let fnrec2002 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 255))))) unchecked-byte)))
+  (def-var! "clojure.core" "unchecked-byte" (letrec ((unchecked-byte (lambda (x) (let fnrec2026 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 255))))) unchecked-byte)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-short" (letrec ((unchecked-short (lambda (x) (let fnrec2003 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535))))) unchecked-short)))
+  (def-var! "clojure.core" "unchecked-short" (letrec ((unchecked-short (lambda (x) (let fnrec2027 ((x x)) (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535))))) unchecked-short)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-char" (letrec ((unchecked-char (lambda (x) (let fnrec2004 ((x x)) (jolt-invoke (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535)))))) unchecked-char)))
+  (def-var! "clojure.core" "unchecked-char" (letrec ((unchecked-char (lambda (x) (let fnrec2028 ((x x)) (jolt-invoke (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "bit-and") (jolt-invoke (var-deref "clojure.core" "int") x) 65535)))))) unchecked-char)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-float" (letrec ((unchecked-float (lambda (x) (let fnrec2005 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-float)))
+  (def-var! "clojure.core" "unchecked-float" (letrec ((unchecked-float (lambda (x) (let fnrec2029 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-float)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "unchecked-double" (letrec ((unchecked-double (lambda (x) (let fnrec2006 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-double)))
+  (def-var! "clojure.core" "unchecked-double" (letrec ((unchecked-double (lambda (x) (let fnrec2030 ((x x)) (jolt-invoke (var-deref "clojure.core" "double") x))))) unchecked-double)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "transduce" (letrec ((transduce (case-lambda ((xform f coll) (let fnrec2007 ((xform xform) (f f) (coll coll)) (jolt-invoke transduce xform f (jolt-invoke f) coll))) ((xform f init coll) (let fnrec2008 ((xform xform) (f f) (init init) (coll coll)) (let* ((xf (jolt-invoke xform f))) (jolt-invoke xf (jolt-reduce xf init coll)))))))) transduce)))
+  (def-var! "clojure.core" "transduce" (letrec ((transduce (case-lambda ((xform f coll) (let fnrec2031 ((xform xform) (f f) (coll coll)) (jolt-invoke transduce xform f (jolt-invoke f) coll))) ((xform f init coll) (let fnrec2032 ((xform xform) (f f) (init init) (coll coll)) (let* ((xf (jolt-invoke xform f))) (jolt-invoke xf (jolt-reduce xf init coll)))))))) transduce)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "eduction" (letrec ((eduction (lambda args (let fnrec2009 ((args (list->cseq args))) (let* ((coll (jolt-last args)) (xforms (jolt-invoke (var-deref "clojure.core" "butlast") args))) (if (jolt-truthy? xforms) (let* ((_a$2010 jolt-into) (_a$2011 (jolt-vector)) (_a$2012 (jolt-apply (var-deref "clojure.core" "comp") xforms)) (_a$2013 coll)) (jolt-invoke _a$2010 _a$2011 _a$2012 _a$2013)) (jolt-into (jolt-vector) coll))))))) eduction)))
+  (def-var! "clojure.core" "eduction" (letrec ((eduction (lambda args (let fnrec2033 ((args (list->cseq args))) (let* ((coll (jolt-last args)) (xforms (jolt-invoke (var-deref "clojure.core" "butlast") args))) (if (jolt-truthy? xforms) (let* ((_a$2034 jolt-into) (_a$2035 (jolt-vector)) (_a$2036 (jolt-apply (var-deref "clojure.core" "comp") xforms)) (_a$2037 coll)) (jolt-invoke _a$2034 _a$2035 _a$2036 _a$2037)) (jolt-into (jolt-vector) coll))))))) eduction)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "->Eduction" (letrec ((->Eduction (lambda (xform coll) (let fnrec2014 ((xform xform) (coll coll)) (jolt-invoke jolt-into (jolt-vector) xform coll))))) ->Eduction)))
+  (def-var! "clojure.core" "->Eduction" (letrec ((->Eduction (lambda (xform coll) (let fnrec2038 ((xform xform) (coll coll)) (jolt-invoke jolt-into (jolt-vector) xform coll))))) ->Eduction)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "enumeration-seq" (letrec ((enumeration-seq (lambda (e) (let fnrec2015 ((e e)) (jolt-seq e))))) enumeration-seq)))
+  (def-var! "clojure.core" "enumeration-seq" (letrec ((enumeration-seq (lambda (e) (let fnrec2039 ((e e)) (jolt-seq e))))) enumeration-seq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "iterator-seq" (letrec ((iterator-seq (lambda (i) (let fnrec2016 ((i i)) (jolt-seq i))))) iterator-seq)))
+  (def-var! "clojure.core" "iterator-seq" (letrec ((iterator-seq (lambda (i) (let fnrec2040 ((i i)) (jolt-seq i))))) iterator-seq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "promise" (letrec ((promise (lambda () (let fnrec2017 () (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))))) promise)))
+  (def-var! "clojure.core" "promise" (letrec ((promise (lambda () (let fnrec2041 () (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))))) promise)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "deliver" (letrec ((deliver (lambda (p v) (let fnrec2018 ((p p) (v v)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") p v) p))))) deliver)))
+  (def-var! "clojure.core" "deliver" (letrec ((deliver (lambda (p v) (let fnrec2042 ((p p) (v v)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") p v) p))))) deliver)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "bean" (letrec ((bean (lambda (x) (let fnrec2019 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) x (jolt-hash-map)))))) bean)))
+  (def-var! "clojure.core" "bean" (letrec ((bean (lambda (x) (let fnrec2043 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) x (jolt-hash-map)))))) bean)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "uri?" (letrec ((uri? (lambda (x) (let fnrec2020 ((x x)) #f)))) uri?)))
+  (def-var! "clojure.core" "uri?" (letrec ((uri? (lambda (x) (let fnrec2044 ((x x)) #f)))) uri?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "clojure.core" "special-syms" (let* ((_o$2021 (jolt-symbol #f "if")) (_o$2022 (jolt-symbol #f "do")) (_o$2023 (jolt-symbol #f "let*")) (_o$2024 (jolt-symbol #f "fn*")) (_o$2025 (jolt-symbol #f "quote")) (_o$2026 (jolt-symbol #f "var")) (_o$2027 (jolt-symbol #f "def")) (_o$2028 (jolt-symbol #f "loop*")) (_o$2029 (jolt-symbol #f "recur")) (_o$2030 (jolt-symbol #f "throw")) (_o$2031 (jolt-symbol #f "try")) (_o$2032 (jolt-symbol #f "catch")) (_o$2033 (jolt-symbol #f "finally")) (_o$2034 (jolt-symbol #f "new")) (_o$2035 (jolt-symbol #f "set!")) (_o$2036 (jolt-symbol #f ".")) (_o$2037 (jolt-symbol #f "monitor-enter")) (_o$2038 (jolt-symbol #f "monitor-exit"))) (jolt-hash-set _o$2021 _o$2022 _o$2023 _o$2024 _o$2025 _o$2026 _o$2027 _o$2028 _o$2029 _o$2030 _o$2031 _o$2032 _o$2033 _o$2034 _o$2035 _o$2036 _o$2037 _o$2038)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "clojure.core" "special-syms" (let* ((_o$2045 (jolt-symbol #f "if")) (_o$2046 (jolt-symbol #f "do")) (_o$2047 (jolt-symbol #f "let*")) (_o$2048 (jolt-symbol #f "fn*")) (_o$2049 (jolt-symbol #f "quote")) (_o$2050 (jolt-symbol #f "var")) (_o$2051 (jolt-symbol #f "def")) (_o$2052 (jolt-symbol #f "loop*")) (_o$2053 (jolt-symbol #f "recur")) (_o$2054 (jolt-symbol #f "throw")) (_o$2055 (jolt-symbol #f "try")) (_o$2056 (jolt-symbol #f "catch")) (_o$2057 (jolt-symbol #f "finally")) (_o$2058 (jolt-symbol #f "new")) (_o$2059 (jolt-symbol #f "set!")) (_o$2060 (jolt-symbol #f ".")) (_o$2061 (jolt-symbol #f "monitor-enter")) (_o$2062 (jolt-symbol #f "monitor-exit"))) (jolt-hash-set _o$2045 _o$2046 _o$2047 _o$2048 _o$2049 _o$2050 _o$2051 _o$2052 _o$2053 _o$2054 _o$2055 _o$2056 _o$2057 _o$2058 _o$2059 _o$2060 _o$2061 _o$2062)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "special-symbol?" (letrec ((special-symbol? (lambda (s) (let fnrec2039 ((s s)) (jolt-contains? (var-deref "clojure.core" "special-syms") s))))) special-symbol?)))
+  (def-var! "clojure.core" "special-symbol?" (letrec ((special-symbol? (lambda (s) (let fnrec2063 ((s s)) (jolt-contains? (var-deref "clojure.core" "special-syms") s))))) special-symbol?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "proxy-mappings" (letrec ((proxy-mappings (lambda (p) (let fnrec2040 ((p p)) (jolt-hash-map))))) proxy-mappings)))
+  (def-var! "clojure.core" "proxy-mappings" (letrec ((proxy-mappings (lambda (p) (let fnrec2064 ((p p)) (jolt-hash-map))))) proxy-mappings)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "proxy-call-with-super" (letrec ((proxy-call-with-super (lambda (f p meth) (let fnrec2041 ((f f) (p p) (meth meth)) (jolt-invoke f))))) proxy-call-with-super)))
+  (def-var! "clojure.core" "proxy-call-with-super" (letrec ((proxy-call-with-super (lambda (f p meth) (let fnrec2065 ((f f) (p p) (meth meth)) (jolt-invoke f))))) proxy-call-with-super)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "init-proxy" (letrec ((init-proxy (lambda (p mappings) (let fnrec2042 ((p p) (mappings mappings)) p)))) init-proxy)))
+  (def-var! "clojure.core" "init-proxy" (letrec ((init-proxy (lambda (p mappings) (let fnrec2066 ((p p) (mappings mappings)) p)))) init-proxy)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "update-proxy" (letrec ((update-proxy (lambda (p mappings) (let fnrec2043 ((p p) (mappings mappings)) p)))) update-proxy)))
+  (def-var! "clojure.core" "update-proxy" (letrec ((update-proxy (lambda (p mappings) (let fnrec2067 ((p p) (mappings mappings)) p)))) update-proxy)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "proxy-super" (letrec ((proxy-super (lambda args (let fnrec2044 ((args (list->cseq args))) (jolt-throw "proxy-super: JVM proxies are not supported in Jolt"))))) proxy-super)))
+  (def-var! "clojure.core" "proxy-super" (letrec ((proxy-super (lambda args (let fnrec2068 ((args (list->cseq args))) (jolt-throw "proxy-super: JVM proxies are not supported in Jolt"))))) proxy-super)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "construct-proxy" (letrec ((construct-proxy (lambda (c . args) (let fnrec2045 ((c c) (args (list->cseq args))) (jolt-throw "construct-proxy: not supported in Jolt"))))) construct-proxy)))
+  (def-var! "clojure.core" "construct-proxy" (letrec ((construct-proxy (lambda (c . args) (let fnrec2069 ((c c) (args (list->cseq args))) (jolt-throw "construct-proxy: not supported in Jolt"))))) construct-proxy)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "get-proxy-class" (letrec ((get-proxy-class (lambda interfaces (let fnrec2046 ((interfaces (list->cseq interfaces))) (jolt-throw "get-proxy-class: not supported in Jolt"))))) get-proxy-class)))
+  (def-var! "clojure.core" "get-proxy-class" (letrec ((get-proxy-class (lambda interfaces (let fnrec2070 ((interfaces (list->cseq interfaces))) (jolt-throw "get-proxy-class: not supported in Jolt"))))) get-proxy-class)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sfield" (letrec ((sfield (lambda (sc k) (let fnrec359 ((sc sc) (k k)) (jolt-invoke (var-deref "jolt.host" "ref-get") sc k))))) sfield)))
+  (def-var! "clojure.core" "sfield" (letrec ((sfield (lambda (sc k) (let fnrec383 ((sc sc) (k k)) (jolt-invoke (var-deref "jolt.host" "ref-get") sc k))))) sfield)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "fn->cmp" (letrec ((fn->cmp (lambda (f) (let fnrec360 ((f f)) (lambda (a b) (let fnrec361 ((a a) (b b)) (let* ((r (jolt-invoke f a b))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") r)) r (if (jolt-truthy? r) -1 (if (jolt-truthy? (jolt-invoke f b a)) 1 0)))))))))) fn->cmp)))
+  (def-var! "clojure.core" "fn->cmp" (letrec ((fn->cmp (lambda (f) (let fnrec384 ((f f)) (lambda (a b) (let fnrec385 ((a a) (b b)) (let* ((r (jolt-invoke f a b))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") r)) r (if (jolt-truthy? r) -1 (if (jolt-truthy? (jolt-invoke f b a)) 1 0)))))))))) fn->cmp)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "the-cmp" (letrec ((the-cmp (lambda (sc) (let fnrec362 ((sc sc)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "sfield") sc (keyword #f "cmp")))) (if (jolt-truthy? or__14__auto) or__14__auto (var-deref "clojure.core" "compare"))))))) the-cmp)))
+  (def-var! "clojure.core" "the-cmp" (letrec ((the-cmp (lambda (sc) (let fnrec386 ((sc sc)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "sfield") sc (keyword #f "cmp")))) (if (jolt-truthy? or__14__auto) or__14__auto (var-deref "clojure.core" "compare"))))))) the-cmp)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nd-key" (letrec ((nd-key (lambda (n) (let fnrec363 ((n n)) (jolt-nth n 1))))) nd-key)))
+  (def-var! "clojure.core" "nd-key" (letrec ((nd-key (lambda (n) (let fnrec387 ((n n)) (jolt-nth n 1))))) nd-key)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nd-val" (letrec ((nd-val (lambda (n) (let fnrec364 ((n n)) (jolt-nth n 2))))) nd-val)))
+  (def-var! "clojure.core" "nd-val" (letrec ((nd-val (lambda (n) (let fnrec388 ((n n)) (jolt-nth n 2))))) nd-val)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nd-left" (letrec ((nd-left (lambda (n) (let fnrec365 ((n n)) (jolt-nth n 3))))) nd-left)))
+  (def-var! "clojure.core" "nd-left" (letrec ((nd-left (lambda (n) (let fnrec389 ((n n)) (jolt-nth n 3))))) nd-left)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "nd-right" (letrec ((nd-right (lambda (n) (let fnrec366 ((n n)) (jolt-nth n 4))))) nd-right)))
+  (def-var! "clojure.core" "nd-right" (letrec ((nd-right (lambda (n) (let fnrec390 ((n n)) (jolt-nth n 4))))) nd-right)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "red?" (letrec ((red? (lambda (n) (let fnrec367 ((n n)) (let* ((and__13__auto n)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "identical?") (keyword #f "red") (jolt-nth n 0)) and__13__auto)))))) red?)))
+  (def-var! "clojure.core" "red?" (letrec ((red? (lambda (n) (let fnrec391 ((n n)) (let* ((and__13__auto n)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "identical?") (keyword #f "red") (jolt-nth n 0)) and__13__auto)))))) red?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "black?" (letrec ((black? (lambda (n) (let fnrec368 ((n n)) (let* ((and__13__auto n)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "identical?") (keyword #f "black") (jolt-nth n 0)) and__13__auto)))))) black?)))
+  (def-var! "clojure.core" "black?" (letrec ((black? (lambda (n) (let fnrec392 ((n n)) (let* ((and__13__auto n)) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "identical?") (keyword #f "black") (jolt-nth n 0)) and__13__auto)))))) black?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "mk-red" (letrec ((mk-red (lambda (k v l r) (let fnrec369 ((k k) (v v) (l l) (r r)) (let* ((_o$370 (keyword #f "red")) (_o$371 k) (_o$372 v) (_o$373 l) (_o$374 r)) (jolt-vector _o$370 _o$371 _o$372 _o$373 _o$374)))))) mk-red)))
+  (def-var! "clojure.core" "mk-red" (letrec ((mk-red (lambda (k v l r) (let fnrec393 ((k k) (v v) (l l) (r r)) (let* ((_o$394 (keyword #f "red")) (_o$395 k) (_o$396 v) (_o$397 l) (_o$398 r)) (jolt-vector _o$394 _o$395 _o$396 _o$397 _o$398)))))) mk-red)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "mk-black" (letrec ((mk-black (lambda (k v l r) (let fnrec375 ((k k) (v v) (l l) (r r)) (let* ((_o$376 (keyword #f "black")) (_o$377 k) (_o$378 v) (_o$379 l) (_o$380 r)) (jolt-vector _o$376 _o$377 _o$378 _o$379 _o$380)))))) mk-black)))
+  (def-var! "clojure.core" "mk-black" (letrec ((mk-black (lambda (k v l r) (let fnrec399 ((k k) (v v) (l l) (r r)) (let* ((_o$400 (keyword #f "black")) (_o$401 k) (_o$402 v) (_o$403 l) (_o$404 r)) (jolt-vector _o$400 _o$401 _o$402 _o$403 _o$404)))))) mk-black)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "blacken" (letrec ((blacken (lambda (n) (let fnrec381 ((n n)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") n)) (let* ((_o$382 (keyword #f "black")) (_o$383 (jolt-invoke (var-deref "clojure.core" "nd-key") n)) (_o$384 (jolt-invoke (var-deref "clojure.core" "nd-val") n)) (_o$385 (jolt-invoke (var-deref "clojure.core" "nd-left") n)) (_o$386 (jolt-invoke (var-deref "clojure.core" "nd-right") n))) (jolt-vector _o$382 _o$383 _o$384 _o$385 _o$386)) n))))) blacken)))
+  (def-var! "clojure.core" "blacken" (letrec ((blacken (lambda (n) (let fnrec405 ((n n)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") n)) (let* ((_o$406 (keyword #f "black")) (_o$407 (jolt-invoke (var-deref "clojure.core" "nd-key") n)) (_o$408 (jolt-invoke (var-deref "clojure.core" "nd-val") n)) (_o$409 (jolt-invoke (var-deref "clojure.core" "nd-left") n)) (_o$410 (jolt-invoke (var-deref "clojure.core" "nd-right") n))) (jolt-vector _o$406 _o$407 _o$408 _o$409 _o$410)) n))))) blacken)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "redden" (letrec ((redden (lambda (n) (let fnrec387 ((n n)) (let* ((_o$388 (keyword #f "red")) (_o$389 (jolt-invoke (var-deref "clojure.core" "nd-key") n)) (_o$390 (jolt-invoke (var-deref "clojure.core" "nd-val") n)) (_o$391 (jolt-invoke (var-deref "clojure.core" "nd-left") n)) (_o$392 (jolt-invoke (var-deref "clojure.core" "nd-right") n))) (jolt-vector _o$388 _o$389 _o$390 _o$391 _o$392)))))) redden)))
+  (def-var! "clojure.core" "redden" (letrec ((redden (lambda (n) (let fnrec411 ((n n)) (let* ((_o$412 (keyword #f "red")) (_o$413 (jolt-invoke (var-deref "clojure.core" "nd-key") n)) (_o$414 (jolt-invoke (var-deref "clojure.core" "nd-val") n)) (_o$415 (jolt-invoke (var-deref "clojure.core" "nd-left") n)) (_o$416 (jolt-invoke (var-deref "clojure.core" "nd-right") n))) (jolt-vector _o$412 _o$413 _o$414 _o$415 _o$416)))))) redden)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "replace-node" (letrec ((replace-node (lambda (n k v l r) (let fnrec393 ((n n) (k k) (v v) (l l) (r r)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") n)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v l r) (jolt-invoke (var-deref "clojure.core" "mk-black") k v l r)))))) replace-node)))
+  (def-var! "clojure.core" "replace-node" (letrec ((replace-node (lambda (n k v l r) (let fnrec417 ((n n) (k k) (v v) (l l) (r r)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") n)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v l r) (jolt-invoke (var-deref "clojure.core" "mk-black") k v l r)))))) replace-node)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ins-balance-left" (letrec ((ins-balance-left (lambda (ins parent) (let fnrec394 ((ins ins) (parent parent)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((l (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (r (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") l)) (let* ((_a$400 (var-deref "clojure.core" "mk-red")) (_a$401 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$402 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$403 (jolt-invoke (var-deref "clojure.core" "blacken") l)) (_a$404 (let* ((_a$395 (var-deref "clojure.core" "mk-black")) (_a$396 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$397 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$398 r) (_a$399 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$395 _a$396 _a$397 _a$398 _a$399)))) (jolt-invoke _a$400 _a$401 _a$402 _a$403 _a$404)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") r)) (let* ((_a$415 (var-deref "clojure.core" "mk-red")) (_a$416 (jolt-invoke (var-deref "clojure.core" "nd-key") r)) (_a$417 (jolt-invoke (var-deref "clojure.core" "nd-val") r)) (_a$418 (let* ((_a$405 (var-deref "clojure.core" "mk-black")) (_a$406 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$407 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$408 l) (_a$409 (jolt-invoke (var-deref "clojure.core" "nd-left") r))) (jolt-invoke _a$405 _a$406 _a$407 _a$408 _a$409))) (_a$419 (let* ((_a$410 (var-deref "clojure.core" "mk-black")) (_a$411 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$412 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$413 (jolt-invoke (var-deref "clojure.core" "nd-right") r)) (_a$414 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$410 _a$411 _a$412 _a$413 _a$414)))) (jolt-invoke _a$415 _a$416 _a$417 _a$418 _a$419)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$420 (var-deref "clojure.core" "mk-black")) (_a$421 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$422 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$423 ins) (_a$424 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$420 _a$421 _a$422 _a$423 _a$424)) jolt-nil)))) (let* ((_a$425 (var-deref "clojure.core" "mk-black")) (_a$426 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$427 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$428 ins) (_a$429 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$425 _a$426 _a$427 _a$428 _a$429))))))) ins-balance-left)))
+  (def-var! "clojure.core" "ins-balance-left" (letrec ((ins-balance-left (lambda (ins parent) (let fnrec418 ((ins ins) (parent parent)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((l (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (r (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") l)) (let* ((_a$424 (var-deref "clojure.core" "mk-red")) (_a$425 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$426 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$427 (jolt-invoke (var-deref "clojure.core" "blacken") l)) (_a$428 (let* ((_a$419 (var-deref "clojure.core" "mk-black")) (_a$420 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$421 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$422 r) (_a$423 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$419 _a$420 _a$421 _a$422 _a$423)))) (jolt-invoke _a$424 _a$425 _a$426 _a$427 _a$428)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") r)) (let* ((_a$439 (var-deref "clojure.core" "mk-red")) (_a$440 (jolt-invoke (var-deref "clojure.core" "nd-key") r)) (_a$441 (jolt-invoke (var-deref "clojure.core" "nd-val") r)) (_a$442 (let* ((_a$429 (var-deref "clojure.core" "mk-black")) (_a$430 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$431 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$432 l) (_a$433 (jolt-invoke (var-deref "clojure.core" "nd-left") r))) (jolt-invoke _a$429 _a$430 _a$431 _a$432 _a$433))) (_a$443 (let* ((_a$434 (var-deref "clojure.core" "mk-black")) (_a$435 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$436 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$437 (jolt-invoke (var-deref "clojure.core" "nd-right") r)) (_a$438 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$434 _a$435 _a$436 _a$437 _a$438)))) (jolt-invoke _a$439 _a$440 _a$441 _a$442 _a$443)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$444 (var-deref "clojure.core" "mk-black")) (_a$445 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$446 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$447 ins) (_a$448 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$444 _a$445 _a$446 _a$447 _a$448)) jolt-nil)))) (let* ((_a$449 (var-deref "clojure.core" "mk-black")) (_a$450 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$451 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$452 ins) (_a$453 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$449 _a$450 _a$451 _a$452 _a$453))))))) ins-balance-left)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ins-balance-right" (letrec ((ins-balance-right (lambda (ins parent) (let fnrec430 ((ins ins) (parent parent)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((l (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (r (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") r)) (let* ((_a$436 (var-deref "clojure.core" "mk-red")) (_a$437 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$438 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$439 (let* ((_a$431 (var-deref "clojure.core" "mk-black")) (_a$432 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$433 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$434 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$435 l)) (jolt-invoke _a$431 _a$432 _a$433 _a$434 _a$435))) (_a$440 (jolt-invoke (var-deref "clojure.core" "blacken") r))) (jolt-invoke _a$436 _a$437 _a$438 _a$439 _a$440)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") l)) (let* ((_a$451 (var-deref "clojure.core" "mk-red")) (_a$452 (jolt-invoke (var-deref "clojure.core" "nd-key") l)) (_a$453 (jolt-invoke (var-deref "clojure.core" "nd-val") l)) (_a$454 (let* ((_a$441 (var-deref "clojure.core" "mk-black")) (_a$442 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$443 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$444 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$445 (jolt-invoke (var-deref "clojure.core" "nd-left") l))) (jolt-invoke _a$441 _a$442 _a$443 _a$444 _a$445))) (_a$455 (let* ((_a$446 (var-deref "clojure.core" "mk-black")) (_a$447 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$448 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$449 (jolt-invoke (var-deref "clojure.core" "nd-right") l)) (_a$450 r)) (jolt-invoke _a$446 _a$447 _a$448 _a$449 _a$450)))) (jolt-invoke _a$451 _a$452 _a$453 _a$454 _a$455)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$456 (var-deref "clojure.core" "mk-black")) (_a$457 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$458 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$459 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$460 ins)) (jolt-invoke _a$456 _a$457 _a$458 _a$459 _a$460)) jolt-nil)))) (let* ((_a$461 (var-deref "clojure.core" "mk-black")) (_a$462 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$463 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$464 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$465 ins)) (jolt-invoke _a$461 _a$462 _a$463 _a$464 _a$465))))))) ins-balance-right)))
+  (def-var! "clojure.core" "ins-balance-right" (letrec ((ins-balance-right (lambda (ins parent) (let fnrec454 ((ins ins) (parent parent)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((l (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (r (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") r)) (let* ((_a$460 (var-deref "clojure.core" "mk-red")) (_a$461 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$462 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$463 (let* ((_a$455 (var-deref "clojure.core" "mk-black")) (_a$456 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$457 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$458 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$459 l)) (jolt-invoke _a$455 _a$456 _a$457 _a$458 _a$459))) (_a$464 (jolt-invoke (var-deref "clojure.core" "blacken") r))) (jolt-invoke _a$460 _a$461 _a$462 _a$463 _a$464)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") l)) (let* ((_a$475 (var-deref "clojure.core" "mk-red")) (_a$476 (jolt-invoke (var-deref "clojure.core" "nd-key") l)) (_a$477 (jolt-invoke (var-deref "clojure.core" "nd-val") l)) (_a$478 (let* ((_a$465 (var-deref "clojure.core" "mk-black")) (_a$466 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$467 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$468 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$469 (jolt-invoke (var-deref "clojure.core" "nd-left") l))) (jolt-invoke _a$465 _a$466 _a$467 _a$468 _a$469))) (_a$479 (let* ((_a$470 (var-deref "clojure.core" "mk-black")) (_a$471 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$472 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$473 (jolt-invoke (var-deref "clojure.core" "nd-right") l)) (_a$474 r)) (jolt-invoke _a$470 _a$471 _a$472 _a$473 _a$474)))) (jolt-invoke _a$475 _a$476 _a$477 _a$478 _a$479)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$480 (var-deref "clojure.core" "mk-black")) (_a$481 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$482 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$483 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$484 ins)) (jolt-invoke _a$480 _a$481 _a$482 _a$483 _a$484)) jolt-nil)))) (let* ((_a$485 (var-deref "clojure.core" "mk-black")) (_a$486 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$487 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$488 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$489 ins)) (jolt-invoke _a$485 _a$486 _a$487 _a$488 _a$489))))))) ins-balance-right)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "add-left" (letrec ((add-left (lambda (parent ins) (let fnrec466 ((parent parent) (ins ins)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") parent)) (let* ((_a$467 (var-deref "clojure.core" "mk-red")) (_a$468 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$469 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$470 ins) (_a$471 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$467 _a$468 _a$469 _a$470 _a$471)) (jolt-invoke (var-deref "clojure.core" "ins-balance-left") ins parent)))))) add-left)))
+  (def-var! "clojure.core" "add-left" (letrec ((add-left (lambda (parent ins) (let fnrec490 ((parent parent) (ins ins)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") parent)) (let* ((_a$491 (var-deref "clojure.core" "mk-red")) (_a$492 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$493 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$494 ins) (_a$495 (jolt-invoke (var-deref "clojure.core" "nd-right") parent))) (jolt-invoke _a$491 _a$492 _a$493 _a$494 _a$495)) (jolt-invoke (var-deref "clojure.core" "ins-balance-left") ins parent)))))) add-left)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "add-right" (letrec ((add-right (lambda (parent ins) (let fnrec472 ((parent parent) (ins ins)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") parent)) (let* ((_a$473 (var-deref "clojure.core" "mk-red")) (_a$474 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$475 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$476 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$477 ins)) (jolt-invoke _a$473 _a$474 _a$475 _a$476 _a$477)) (jolt-invoke (var-deref "clojure.core" "ins-balance-right") ins parent)))))) add-right)))
+  (def-var! "clojure.core" "add-right" (letrec ((add-right (lambda (parent ins) (let fnrec496 ((parent parent) (ins ins)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") parent)) (let* ((_a$497 (var-deref "clojure.core" "mk-red")) (_a$498 (jolt-invoke (var-deref "clojure.core" "nd-key") parent)) (_a$499 (jolt-invoke (var-deref "clojure.core" "nd-val") parent)) (_a$500 (jolt-invoke (var-deref "clojure.core" "nd-left") parent)) (_a$501 ins)) (jolt-invoke _a$497 _a$498 _a$499 _a$500 _a$501)) (jolt-invoke (var-deref "clojure.core" "ins-balance-right") ins parent)))))) add-right)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-ins" (letrec ((tree-ins (lambda (cmp tree k v) (let fnrec478 ((cmp cmp) (tree tree) (k k) (v v)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") tree)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v jolt-nil jolt-nil) (if (jolt-neg? (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") tree))) (jolt-invoke (var-deref "clojure.core" "add-left") tree (jolt-invoke tree-ins cmp (jolt-invoke (var-deref "clojure.core" "nd-left") tree) k v)) (jolt-invoke (var-deref "clojure.core" "add-right") tree (jolt-invoke tree-ins cmp (jolt-invoke (var-deref "clojure.core" "nd-right") tree) k v)))))))) tree-ins)))
+  (def-var! "clojure.core" "tree-ins" (letrec ((tree-ins (lambda (cmp tree k v) (let fnrec502 ((cmp cmp) (tree tree) (k k) (v v)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") tree)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v jolt-nil jolt-nil) (if (jolt-neg? (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") tree))) (jolt-invoke (var-deref "clojure.core" "add-left") tree (jolt-invoke tree-ins cmp (jolt-invoke (var-deref "clojure.core" "nd-left") tree) k v)) (jolt-invoke (var-deref "clojure.core" "add-right") tree (jolt-invoke tree-ins cmp (jolt-invoke (var-deref "clojure.core" "nd-right") tree) k v)))))))) tree-ins)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-replace" (letrec ((tree-replace (lambda (cmp tree k v) (let fnrec479 ((cmp cmp) (tree tree) (k k) (v v)) (let* ((c (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") tree)))) (if (jolt-zero? c) (let* ((_a$480 (var-deref "clojure.core" "replace-node")) (_a$481 tree) (_a$482 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$483 v) (_a$484 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$485 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$480 _a$481 _a$482 _a$483 _a$484 _a$485)) (if (jolt-neg? c) (let* ((_a$486 (var-deref "clojure.core" "replace-node")) (_a$487 tree) (_a$488 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$489 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$490 (jolt-invoke tree-replace cmp (jolt-invoke (var-deref "clojure.core" "nd-left") tree) k v)) (_a$491 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$486 _a$487 _a$488 _a$489 _a$490 _a$491)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$492 (var-deref "clojure.core" "replace-node")) (_a$493 tree) (_a$494 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$495 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$496 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$497 (jolt-invoke tree-replace cmp (jolt-invoke (var-deref "clojure.core" "nd-right") tree) k v))) (jolt-invoke _a$492 _a$493 _a$494 _a$495 _a$496 _a$497)) jolt-nil)))))))) tree-replace)))
+  (def-var! "clojure.core" "tree-replace" (letrec ((tree-replace (lambda (cmp tree k v) (let fnrec503 ((cmp cmp) (tree tree) (k k) (v v)) (let* ((c (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") tree)))) (if (jolt-zero? c) (let* ((_a$504 (var-deref "clojure.core" "replace-node")) (_a$505 tree) (_a$506 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$507 v) (_a$508 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$509 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$504 _a$505 _a$506 _a$507 _a$508 _a$509)) (if (jolt-neg? c) (let* ((_a$510 (var-deref "clojure.core" "replace-node")) (_a$511 tree) (_a$512 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$513 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$514 (jolt-invoke tree-replace cmp (jolt-invoke (var-deref "clojure.core" "nd-left") tree) k v)) (_a$515 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$510 _a$511 _a$512 _a$513 _a$514 _a$515)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$516 (var-deref "clojure.core" "replace-node")) (_a$517 tree) (_a$518 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$519 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$520 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$521 (jolt-invoke tree-replace cmp (jolt-invoke (var-deref "clojure.core" "nd-right") tree) k v))) (jolt-invoke _a$516 _a$517 _a$518 _a$519 _a$520 _a$521)) jolt-nil)))))))) tree-replace)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-lookup" (letrec ((tree-lookup (lambda (tree cmp k) (let fnrec498 ((tree tree) (cmp cmp) (k k)) (let* ((t tree)) (let loop499 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") t)) jolt-nil (let* ((c (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") t)))) (if (jolt-zero? c) t (if (jolt-neg? c) (loop499 (jolt-invoke (var-deref "clojure.core" "nd-left") t)) (if (jolt-truthy? (keyword #f "else")) (loop499 (jolt-invoke (var-deref "clojure.core" "nd-right") t)) jolt-nil))))))))))) tree-lookup)))
+  (def-var! "clojure.core" "tree-lookup" (letrec ((tree-lookup (lambda (tree cmp k) (let fnrec522 ((tree tree) (cmp cmp) (k k)) (let* ((t tree)) (let loop523 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") t)) jolt-nil (let* ((c (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") t)))) (if (jolt-zero? c) t (if (jolt-neg? c) (loop523 (jolt-invoke (var-deref "clojure.core" "nd-left") t)) (if (jolt-truthy? (keyword #f "else")) (loop523 (jolt-invoke (var-deref "clojure.core" "nd-right") t)) jolt-nil))))))))))) tree-lookup)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "balance-left" (letrec ((balance-left (lambda (k v ins right) (let fnrec500 ((k k) (v v) (ins ins) (right right)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((il (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (ir (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") il)) (let* ((_a$501 (var-deref "clojure.core" "mk-red")) (_a$502 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$503 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$504 (jolt-invoke (var-deref "clojure.core" "blacken") il)) (_a$505 (jolt-invoke (var-deref "clojure.core" "mk-black") k v ir right))) (jolt-invoke _a$501 _a$502 _a$503 _a$504 _a$505)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ir)) (let* ((_a$511 (var-deref "clojure.core" "mk-red")) (_a$512 (jolt-invoke (var-deref "clojure.core" "nd-key") ir)) (_a$513 (jolt-invoke (var-deref "clojure.core" "nd-val") ir)) (_a$514 (let* ((_a$506 (var-deref "clojure.core" "mk-black")) (_a$507 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$508 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$509 il) (_a$510 (jolt-invoke (var-deref "clojure.core" "nd-left") ir))) (jolt-invoke _a$506 _a$507 _a$508 _a$509 _a$510))) (_a$515 (jolt-invoke (var-deref "clojure.core" "mk-black") k v (jolt-invoke (var-deref "clojure.core" "nd-right") ir) right))) (jolt-invoke _a$511 _a$512 _a$513 _a$514 _a$515)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "mk-black") k v ins right) jolt-nil)))) (jolt-invoke (var-deref "clojure.core" "mk-black") k v ins right)))))) balance-left)))
+  (def-var! "clojure.core" "balance-left" (letrec ((balance-left (lambda (k v ins right) (let fnrec524 ((k k) (v v) (ins ins) (right right)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((il (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (ir (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") il)) (let* ((_a$525 (var-deref "clojure.core" "mk-red")) (_a$526 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$527 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$528 (jolt-invoke (var-deref "clojure.core" "blacken") il)) (_a$529 (jolt-invoke (var-deref "clojure.core" "mk-black") k v ir right))) (jolt-invoke _a$525 _a$526 _a$527 _a$528 _a$529)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ir)) (let* ((_a$535 (var-deref "clojure.core" "mk-red")) (_a$536 (jolt-invoke (var-deref "clojure.core" "nd-key") ir)) (_a$537 (jolt-invoke (var-deref "clojure.core" "nd-val") ir)) (_a$538 (let* ((_a$530 (var-deref "clojure.core" "mk-black")) (_a$531 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$532 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$533 il) (_a$534 (jolt-invoke (var-deref "clojure.core" "nd-left") ir))) (jolt-invoke _a$530 _a$531 _a$532 _a$533 _a$534))) (_a$539 (jolt-invoke (var-deref "clojure.core" "mk-black") k v (jolt-invoke (var-deref "clojure.core" "nd-right") ir) right))) (jolt-invoke _a$535 _a$536 _a$537 _a$538 _a$539)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "mk-black") k v ins right) jolt-nil)))) (jolt-invoke (var-deref "clojure.core" "mk-black") k v ins right)))))) balance-left)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "balance-right" (letrec ((balance-right (lambda (k v left ins) (let fnrec516 ((k k) (v v) (left left) (ins ins)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((il (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (ir (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ir)) (let* ((_a$517 (var-deref "clojure.core" "mk-red")) (_a$518 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$519 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$520 (jolt-invoke (var-deref "clojure.core" "mk-black") k v left il)) (_a$521 (jolt-invoke (var-deref "clojure.core" "blacken") ir))) (jolt-invoke _a$517 _a$518 _a$519 _a$520 _a$521)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") il)) (let* ((_a$527 (var-deref "clojure.core" "mk-red")) (_a$528 (jolt-invoke (var-deref "clojure.core" "nd-key") il)) (_a$529 (jolt-invoke (var-deref "clojure.core" "nd-val") il)) (_a$530 (jolt-invoke (var-deref "clojure.core" "mk-black") k v left (jolt-invoke (var-deref "clojure.core" "nd-left") il))) (_a$531 (let* ((_a$522 (var-deref "clojure.core" "mk-black")) (_a$523 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$524 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$525 (jolt-invoke (var-deref "clojure.core" "nd-right") il)) (_a$526 ir)) (jolt-invoke _a$522 _a$523 _a$524 _a$525 _a$526)))) (jolt-invoke _a$527 _a$528 _a$529 _a$530 _a$531)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "mk-black") k v left ins) jolt-nil)))) (jolt-invoke (var-deref "clojure.core" "mk-black") k v left ins)))))) balance-right)))
+  (def-var! "clojure.core" "balance-right" (letrec ((balance-right (lambda (k v left ins) (let fnrec540 ((k k) (v v) (left left) (ins ins)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ins)) (let* ((il (jolt-invoke (var-deref "clojure.core" "nd-left") ins)) (ir (jolt-invoke (var-deref "clojure.core" "nd-right") ins))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") ir)) (let* ((_a$541 (var-deref "clojure.core" "mk-red")) (_a$542 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$543 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$544 (jolt-invoke (var-deref "clojure.core" "mk-black") k v left il)) (_a$545 (jolt-invoke (var-deref "clojure.core" "blacken") ir))) (jolt-invoke _a$541 _a$542 _a$543 _a$544 _a$545)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") il)) (let* ((_a$551 (var-deref "clojure.core" "mk-red")) (_a$552 (jolt-invoke (var-deref "clojure.core" "nd-key") il)) (_a$553 (jolt-invoke (var-deref "clojure.core" "nd-val") il)) (_a$554 (jolt-invoke (var-deref "clojure.core" "mk-black") k v left (jolt-invoke (var-deref "clojure.core" "nd-left") il))) (_a$555 (let* ((_a$546 (var-deref "clojure.core" "mk-black")) (_a$547 (jolt-invoke (var-deref "clojure.core" "nd-key") ins)) (_a$548 (jolt-invoke (var-deref "clojure.core" "nd-val") ins)) (_a$549 (jolt-invoke (var-deref "clojure.core" "nd-right") il)) (_a$550 ir)) (jolt-invoke _a$546 _a$547 _a$548 _a$549 _a$550)))) (jolt-invoke _a$551 _a$552 _a$553 _a$554 _a$555)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "mk-black") k v left ins) jolt-nil)))) (jolt-invoke (var-deref "clojure.core" "mk-black") k v left ins)))))) balance-right)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "balance-left-del" (letrec ((balance-left-del (lambda (k v del right) (let fnrec532 ((k k) (v v) (del del) (right right)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") del)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v (jolt-invoke (var-deref "clojure.core" "blacken") del) right) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") right)) (jolt-invoke (var-deref "clojure.core" "balance-right") k v del (jolt-invoke (var-deref "clojure.core" "redden") right)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "red?") right))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-left") right)) and__13__auto))) (let* ((_a$538 (var-deref "clojure.core" "mk-red")) (_a$539 (jolt-invoke (var-deref "clojure.core" "nd-key") (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$540 (jolt-invoke (var-deref "clojure.core" "nd-val") (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$541 (jolt-invoke (var-deref "clojure.core" "mk-black") k v del (jolt-invoke (var-deref "clojure.core" "nd-left") (jolt-invoke (var-deref "clojure.core" "nd-left") right)))) (_a$542 (let* ((_a$533 (var-deref "clojure.core" "balance-right")) (_a$534 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$535 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$536 (jolt-invoke (var-deref "clojure.core" "nd-right") (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$537 (jolt-invoke (var-deref "clojure.core" "redden") (jolt-invoke (var-deref "clojure.core" "nd-right") right)))) (jolt-invoke _a$533 _a$534 _a$535 _a$536 _a$537)))) (jolt-invoke _a$538 _a$539 _a$540 _a$541 _a$542)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-ex-info "red-black tree invariant violation" (jolt-hash-map))) jolt-nil)))))))) balance-left-del)))
+  (def-var! "clojure.core" "balance-left-del" (letrec ((balance-left-del (lambda (k v del right) (let fnrec556 ((k k) (v v) (del del) (right right)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") del)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v (jolt-invoke (var-deref "clojure.core" "blacken") del) right) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") right)) (jolt-invoke (var-deref "clojure.core" "balance-right") k v del (jolt-invoke (var-deref "clojure.core" "redden") right)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "red?") right))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-left") right)) and__13__auto))) (let* ((_a$562 (var-deref "clojure.core" "mk-red")) (_a$563 (jolt-invoke (var-deref "clojure.core" "nd-key") (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$564 (jolt-invoke (var-deref "clojure.core" "nd-val") (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$565 (jolt-invoke (var-deref "clojure.core" "mk-black") k v del (jolt-invoke (var-deref "clojure.core" "nd-left") (jolt-invoke (var-deref "clojure.core" "nd-left") right)))) (_a$566 (let* ((_a$557 (var-deref "clojure.core" "balance-right")) (_a$558 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$559 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$560 (jolt-invoke (var-deref "clojure.core" "nd-right") (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$561 (jolt-invoke (var-deref "clojure.core" "redden") (jolt-invoke (var-deref "clojure.core" "nd-right") right)))) (jolt-invoke _a$557 _a$558 _a$559 _a$560 _a$561)))) (jolt-invoke _a$562 _a$563 _a$564 _a$565 _a$566)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-ex-info "red-black tree invariant violation" (jolt-hash-map))) jolt-nil)))))))) balance-left-del)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "balance-right-del" (letrec ((balance-right-del (lambda (k v left del) (let fnrec543 ((k k) (v v) (left left) (del del)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") del)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v left (jolt-invoke (var-deref "clojure.core" "blacken") del)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") left)) (jolt-invoke (var-deref "clojure.core" "balance-left") k v (jolt-invoke (var-deref "clojure.core" "redden") left) del) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "red?") left))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-right") left)) and__13__auto))) (let* ((_a$549 (var-deref "clojure.core" "mk-red")) (_a$550 (jolt-invoke (var-deref "clojure.core" "nd-key") (jolt-invoke (var-deref "clojure.core" "nd-right") left))) (_a$551 (jolt-invoke (var-deref "clojure.core" "nd-val") (jolt-invoke (var-deref "clojure.core" "nd-right") left))) (_a$552 (let* ((_a$544 (var-deref "clojure.core" "balance-left")) (_a$545 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$546 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$547 (jolt-invoke (var-deref "clojure.core" "redden") (jolt-invoke (var-deref "clojure.core" "nd-left") left))) (_a$548 (jolt-invoke (var-deref "clojure.core" "nd-left") (jolt-invoke (var-deref "clojure.core" "nd-right") left)))) (jolt-invoke _a$544 _a$545 _a$546 _a$547 _a$548))) (_a$553 (jolt-invoke (var-deref "clojure.core" "mk-black") k v (jolt-invoke (var-deref "clojure.core" "nd-right") (jolt-invoke (var-deref "clojure.core" "nd-right") left)) del))) (jolt-invoke _a$549 _a$550 _a$551 _a$552 _a$553)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-ex-info "red-black tree invariant violation" (jolt-hash-map))) jolt-nil)))))))) balance-right-del)))
+  (def-var! "clojure.core" "balance-right-del" (letrec ((balance-right-del (lambda (k v left del) (let fnrec567 ((k k) (v v) (left left) (del del)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") del)) (jolt-invoke (var-deref "clojure.core" "mk-red") k v left (jolt-invoke (var-deref "clojure.core" "blacken") del)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") left)) (jolt-invoke (var-deref "clojure.core" "balance-left") k v (jolt-invoke (var-deref "clojure.core" "redden") left) del) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "red?") left))) (if (jolt-truthy? and__13__auto) (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-right") left)) and__13__auto))) (let* ((_a$573 (var-deref "clojure.core" "mk-red")) (_a$574 (jolt-invoke (var-deref "clojure.core" "nd-key") (jolt-invoke (var-deref "clojure.core" "nd-right") left))) (_a$575 (jolt-invoke (var-deref "clojure.core" "nd-val") (jolt-invoke (var-deref "clojure.core" "nd-right") left))) (_a$576 (let* ((_a$568 (var-deref "clojure.core" "balance-left")) (_a$569 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$570 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$571 (jolt-invoke (var-deref "clojure.core" "redden") (jolt-invoke (var-deref "clojure.core" "nd-left") left))) (_a$572 (jolt-invoke (var-deref "clojure.core" "nd-left") (jolt-invoke (var-deref "clojure.core" "nd-right") left)))) (jolt-invoke _a$568 _a$569 _a$570 _a$571 _a$572))) (_a$577 (jolt-invoke (var-deref "clojure.core" "mk-black") k v (jolt-invoke (var-deref "clojure.core" "nd-right") (jolt-invoke (var-deref "clojure.core" "nd-right") left)) del))) (jolt-invoke _a$573 _a$574 _a$575 _a$576 _a$577)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-ex-info "red-black tree invariant violation" (jolt-hash-map))) jolt-nil)))))))) balance-right-del)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-append" (letrec ((tree-append (lambda (left right) (let fnrec554 ((left left) (right right)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") left)) right (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") right)) left (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") left)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") right)) (let* ((app (let* ((_a$555 tree-append) (_a$556 (jolt-invoke (var-deref "clojure.core" "nd-right") left)) (_a$557 (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (jolt-invoke _a$555 _a$556 _a$557)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") app)) (let* ((_a$568 (var-deref "clojure.core" "mk-red")) (_a$569 (jolt-invoke (var-deref "clojure.core" "nd-key") app)) (_a$570 (jolt-invoke (var-deref "clojure.core" "nd-val") app)) (_a$571 (let* ((_a$558 (var-deref "clojure.core" "mk-red")) (_a$559 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$560 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$561 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$562 (jolt-invoke (var-deref "clojure.core" "nd-left") app))) (jolt-invoke _a$558 _a$559 _a$560 _a$561 _a$562))) (_a$572 (let* ((_a$563 (var-deref "clojure.core" "mk-red")) (_a$564 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$565 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$566 (jolt-invoke (var-deref "clojure.core" "nd-right") app)) (_a$567 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$563 _a$564 _a$565 _a$566 _a$567)))) (jolt-invoke _a$568 _a$569 _a$570 _a$571 _a$572)) (let* ((_a$578 (var-deref "clojure.core" "mk-red")) (_a$579 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$580 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$581 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$582 (let* ((_a$573 (var-deref "clojure.core" "mk-red")) (_a$574 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$575 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$576 app) (_a$577 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$573 _a$574 _a$575 _a$576 _a$577)))) (jolt-invoke _a$578 _a$579 _a$580 _a$581 _a$582)))) (let* ((_a$583 (var-deref "clojure.core" "mk-red")) (_a$584 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$585 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$586 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$587 (jolt-invoke tree-append (jolt-invoke (var-deref "clojure.core" "nd-right") left) right))) (jolt-invoke _a$583 _a$584 _a$585 _a$586 _a$587))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") right)) (let* ((_a$588 (var-deref "clojure.core" "mk-red")) (_a$589 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$590 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$591 (jolt-invoke tree-append left (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$592 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$588 _a$589 _a$590 _a$591 _a$592)) (if (jolt-truthy? (keyword #f "else")) (let* ((app (let* ((_a$593 tree-append) (_a$594 (jolt-invoke (var-deref "clojure.core" "nd-right") left)) (_a$595 (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (jolt-invoke _a$593 _a$594 _a$595)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") app)) (let* ((_a$606 (var-deref "clojure.core" "mk-red")) (_a$607 (jolt-invoke (var-deref "clojure.core" "nd-key") app)) (_a$608 (jolt-invoke (var-deref "clojure.core" "nd-val") app)) (_a$609 (let* ((_a$596 (var-deref "clojure.core" "mk-black")) (_a$597 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$598 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$599 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$600 (jolt-invoke (var-deref "clojure.core" "nd-left") app))) (jolt-invoke _a$596 _a$597 _a$598 _a$599 _a$600))) (_a$610 (let* ((_a$601 (var-deref "clojure.core" "mk-black")) (_a$602 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$603 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$604 (jolt-invoke (var-deref "clojure.core" "nd-right") app)) (_a$605 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$601 _a$602 _a$603 _a$604 _a$605)))) (jolt-invoke _a$606 _a$607 _a$608 _a$609 _a$610)) (let* ((_a$616 (var-deref "clojure.core" "balance-left-del")) (_a$617 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$618 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$619 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$620 (let* ((_a$611 (var-deref "clojure.core" "mk-black")) (_a$612 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$613 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$614 app) (_a$615 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$611 _a$612 _a$613 _a$614 _a$615)))) (jolt-invoke _a$616 _a$617 _a$618 _a$619 _a$620)))) jolt-nil))))))))) tree-append)))
+  (def-var! "clojure.core" "tree-append" (letrec ((tree-append (lambda (left right) (let fnrec578 ((left left) (right right)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") left)) right (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") right)) left (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") left)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") right)) (let* ((app (let* ((_a$579 tree-append) (_a$580 (jolt-invoke (var-deref "clojure.core" "nd-right") left)) (_a$581 (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (jolt-invoke _a$579 _a$580 _a$581)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") app)) (let* ((_a$592 (var-deref "clojure.core" "mk-red")) (_a$593 (jolt-invoke (var-deref "clojure.core" "nd-key") app)) (_a$594 (jolt-invoke (var-deref "clojure.core" "nd-val") app)) (_a$595 (let* ((_a$582 (var-deref "clojure.core" "mk-red")) (_a$583 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$584 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$585 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$586 (jolt-invoke (var-deref "clojure.core" "nd-left") app))) (jolt-invoke _a$582 _a$583 _a$584 _a$585 _a$586))) (_a$596 (let* ((_a$587 (var-deref "clojure.core" "mk-red")) (_a$588 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$589 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$590 (jolt-invoke (var-deref "clojure.core" "nd-right") app)) (_a$591 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$587 _a$588 _a$589 _a$590 _a$591)))) (jolt-invoke _a$592 _a$593 _a$594 _a$595 _a$596)) (let* ((_a$602 (var-deref "clojure.core" "mk-red")) (_a$603 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$604 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$605 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$606 (let* ((_a$597 (var-deref "clojure.core" "mk-red")) (_a$598 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$599 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$600 app) (_a$601 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$597 _a$598 _a$599 _a$600 _a$601)))) (jolt-invoke _a$602 _a$603 _a$604 _a$605 _a$606)))) (let* ((_a$607 (var-deref "clojure.core" "mk-red")) (_a$608 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$609 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$610 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$611 (jolt-invoke tree-append (jolt-invoke (var-deref "clojure.core" "nd-right") left) right))) (jolt-invoke _a$607 _a$608 _a$609 _a$610 _a$611))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") right)) (let* ((_a$612 (var-deref "clojure.core" "mk-red")) (_a$613 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$614 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$615 (jolt-invoke tree-append left (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (_a$616 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$612 _a$613 _a$614 _a$615 _a$616)) (if (jolt-truthy? (keyword #f "else")) (let* ((app (let* ((_a$617 tree-append) (_a$618 (jolt-invoke (var-deref "clojure.core" "nd-right") left)) (_a$619 (jolt-invoke (var-deref "clojure.core" "nd-left") right))) (jolt-invoke _a$617 _a$618 _a$619)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "red?") app)) (let* ((_a$630 (var-deref "clojure.core" "mk-red")) (_a$631 (jolt-invoke (var-deref "clojure.core" "nd-key") app)) (_a$632 (jolt-invoke (var-deref "clojure.core" "nd-val") app)) (_a$633 (let* ((_a$620 (var-deref "clojure.core" "mk-black")) (_a$621 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$622 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$623 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$624 (jolt-invoke (var-deref "clojure.core" "nd-left") app))) (jolt-invoke _a$620 _a$621 _a$622 _a$623 _a$624))) (_a$634 (let* ((_a$625 (var-deref "clojure.core" "mk-black")) (_a$626 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$627 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$628 (jolt-invoke (var-deref "clojure.core" "nd-right") app)) (_a$629 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$625 _a$626 _a$627 _a$628 _a$629)))) (jolt-invoke _a$630 _a$631 _a$632 _a$633 _a$634)) (let* ((_a$640 (var-deref "clojure.core" "balance-left-del")) (_a$641 (jolt-invoke (var-deref "clojure.core" "nd-key") left)) (_a$642 (jolt-invoke (var-deref "clojure.core" "nd-val") left)) (_a$643 (jolt-invoke (var-deref "clojure.core" "nd-left") left)) (_a$644 (let* ((_a$635 (var-deref "clojure.core" "mk-black")) (_a$636 (jolt-invoke (var-deref "clojure.core" "nd-key") right)) (_a$637 (jolt-invoke (var-deref "clojure.core" "nd-val") right)) (_a$638 app) (_a$639 (jolt-invoke (var-deref "clojure.core" "nd-right") right))) (jolt-invoke _a$635 _a$636 _a$637 _a$638 _a$639)))) (jolt-invoke _a$640 _a$641 _a$642 _a$643 _a$644)))) jolt-nil))))))))) tree-append)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-del" (letrec ((tree-del (lambda (cmp tree k) (let fnrec621 ((cmp cmp) (tree tree) (k k)) (let* ((c (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") tree)))) (if (jolt-zero? c) (let* ((_a$622 (var-deref "clojure.core" "tree-append")) (_a$623 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$624 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$622 _a$623 _a$624)) (if (jolt-neg? c) (let* ((del (jolt-invoke tree-del cmp (jolt-invoke (var-deref "clojure.core" "nd-left") tree) k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-left") tree))) (let* ((_a$625 (var-deref "clojure.core" "balance-left-del")) (_a$626 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$627 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$628 del) (_a$629 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$625 _a$626 _a$627 _a$628 _a$629)) (let* ((_a$630 (var-deref "clojure.core" "mk-red")) (_a$631 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$632 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$633 del) (_a$634 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$630 _a$631 _a$632 _a$633 _a$634)))) (if (jolt-truthy? (keyword #f "else")) (let* ((del (jolt-invoke tree-del cmp (jolt-invoke (var-deref "clojure.core" "nd-right") tree) k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (let* ((_a$635 (var-deref "clojure.core" "balance-right-del")) (_a$636 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$637 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$638 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$639 del)) (jolt-invoke _a$635 _a$636 _a$637 _a$638 _a$639)) (let* ((_a$640 (var-deref "clojure.core" "mk-red")) (_a$641 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$642 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$643 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$644 del)) (jolt-invoke _a$640 _a$641 _a$642 _a$643 _a$644)))) jolt-nil)))))))) tree-del)))
+  (def-var! "clojure.core" "tree-del" (letrec ((tree-del (lambda (cmp tree k) (let fnrec645 ((cmp cmp) (tree tree) (k k)) (let* ((c (jolt-invoke cmp k (jolt-invoke (var-deref "clojure.core" "nd-key") tree)))) (if (jolt-zero? c) (let* ((_a$646 (var-deref "clojure.core" "tree-append")) (_a$647 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$648 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$646 _a$647 _a$648)) (if (jolt-neg? c) (let* ((del (jolt-invoke tree-del cmp (jolt-invoke (var-deref "clojure.core" "nd-left") tree) k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-left") tree))) (let* ((_a$649 (var-deref "clojure.core" "balance-left-del")) (_a$650 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$651 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$652 del) (_a$653 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$649 _a$650 _a$651 _a$652 _a$653)) (let* ((_a$654 (var-deref "clojure.core" "mk-red")) (_a$655 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$656 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$657 del) (_a$658 (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (jolt-invoke _a$654 _a$655 _a$656 _a$657 _a$658)))) (if (jolt-truthy? (keyword #f "else")) (let* ((del (jolt-invoke tree-del cmp (jolt-invoke (var-deref "clojure.core" "nd-right") tree) k))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "black?") (jolt-invoke (var-deref "clojure.core" "nd-right") tree))) (let* ((_a$659 (var-deref "clojure.core" "balance-right-del")) (_a$660 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$661 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$662 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$663 del)) (jolt-invoke _a$659 _a$660 _a$661 _a$662 _a$663)) (let* ((_a$664 (var-deref "clojure.core" "mk-red")) (_a$665 (jolt-invoke (var-deref "clojure.core" "nd-key") tree)) (_a$666 (jolt-invoke (var-deref "clojure.core" "nd-val") tree)) (_a$667 (jolt-invoke (var-deref "clojure.core" "nd-left") tree)) (_a$668 del)) (jolt-invoke _a$664 _a$665 _a$666 _a$667 _a$668)))) jolt-nil)))))))) tree-del)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "tree-collect" (letrec ((tree-collect (lambda (t proj acc) (let fnrec645 ((t t) (proj proj) (acc acc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") t)) acc (let* ((_a$648 tree-collect) (_a$649 (jolt-invoke (var-deref "clojure.core" "nd-right") t)) (_a$650 proj) (_a$651 (let* ((_a$646 (jolt-invoke tree-collect (jolt-invoke (var-deref "clojure.core" "nd-left") t) proj acc)) (_a$647 (jolt-invoke proj t))) (jolt-conj _a$646 _a$647)))) (jolt-invoke _a$648 _a$649 _a$650 _a$651))))))) tree-collect)))
+  (def-var! "clojure.core" "tree-collect" (letrec ((tree-collect (lambda (t proj acc) (let fnrec669 ((t t) (proj proj) (acc acc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") t)) acc (let* ((_a$672 tree-collect) (_a$673 (jolt-invoke (var-deref "clojure.core" "nd-right") t)) (_a$674 proj) (_a$675 (let* ((_a$670 (jolt-invoke tree-collect (jolt-invoke (var-deref "clojure.core" "nd-left") t) proj acc)) (_a$671 (jolt-invoke proj t))) (jolt-conj _a$670 _a$671)))) (jolt-invoke _a$672 _a$673 _a$674 _a$675))))))) tree-collect)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "make-sorted" (letrec ((make-sorted (lambda (tag tree cnt cmp ops) (let fnrec652 ((tag tag) (tree tree) (cnt cnt) (cmp cmp) (ops ops)) (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "tagged-table") tag) (keyword #f "tree") tree) (keyword #f "cnt") cnt) (keyword #f "cmp") cmp) (keyword #f "ops") ops))))) make-sorted)))
+  (def-var! "clojure.core" "make-sorted" (letrec ((make-sorted (lambda (tag tree cnt cmp ops) (let fnrec676 ((tag tag) (tree tree) (cnt cnt) (cmp cmp) (ops ops)) (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "ref-put!") (jolt-invoke (var-deref "jolt.host" "tagged-table") tag) (keyword #f "tree") tree) (keyword #f "cnt") cnt) (keyword #f "cmp") cmp) (keyword #f "ops") ops))))) make-sorted)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sc-entries" (letrec ((sc-entries (lambda (sc proj) (let fnrec653 ((sc sc) (proj proj)) (let* ((_a$654 (var-deref "clojure.core" "tree-collect")) (_a$655 (jolt-invoke (var-deref "clojure.core" "sfield") sc (keyword #f "tree"))) (_a$656 proj) (_a$657 (jolt-vector))) (jolt-invoke _a$654 _a$655 _a$656 _a$657)))))) sc-entries)))
+  (def-var! "clojure.core" "sc-entries" (letrec ((sc-entries (lambda (sc proj) (let fnrec677 ((sc sc) (proj proj)) (let* ((_a$678 (var-deref "clojure.core" "tree-collect")) (_a$679 (jolt-invoke (var-deref "clojure.core" "sfield") sc (keyword #f "tree"))) (_a$680 proj) (_a$681 (jolt-vector))) (jolt-invoke _a$678 _a$679 _a$680 _a$681)))))) sc-entries)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "map-entry" (letrec ((map-entry (lambda (t) (let fnrec658 ((t t)) (let* ((_a$659 (var-deref "jolt.host" "map-entry")) (_a$660 (jolt-invoke (var-deref "clojure.core" "nd-key") t)) (_a$661 (jolt-invoke (var-deref "clojure.core" "nd-val") t))) (jolt-invoke _a$659 _a$660 _a$661)))))) map-entry)))
+  (def-var! "clojure.core" "map-entry" (letrec ((map-entry (lambda (t) (let fnrec682 ((t t)) (let* ((_a$683 (var-deref "jolt.host" "map-entry")) (_a$684 (jolt-invoke (var-deref "clojure.core" "nd-key") t)) (_a$685 (jolt-invoke (var-deref "clojure.core" "nd-val") t))) (jolt-invoke _a$683 _a$684 _a$685)))))) map-entry)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-get" (letrec ((sm-get (lambda (sm k not-found) (let fnrec662 ((sm sm) (k k) (not-found not-found)) (let* ((n (let* ((_a$663 (var-deref "clojure.core" "tree-lookup")) (_a$664 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree"))) (_a$665 (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (_a$666 k)) (jolt-invoke _a$663 _a$664 _a$665 _a$666)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") n)) not-found (jolt-invoke (var-deref "clojure.core" "nd-val") n))))))) sm-get)))
+  (def-var! "clojure.core" "sm-get" (letrec ((sm-get (lambda (sm k not-found) (let fnrec686 ((sm sm) (k k) (not-found not-found)) (let* ((n (let* ((_a$687 (var-deref "clojure.core" "tree-lookup")) (_a$688 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree"))) (_a$689 (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (_a$690 k)) (jolt-invoke _a$687 _a$688 _a$689 _a$690)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") n)) not-found (jolt-invoke (var-deref "clojure.core" "nd-val") n))))))) sm-get)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-assoc-1" (letrec ((sm-assoc-1 (lambda (sm k v) (let fnrec667 ((sm sm) (k k) (v v)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree"))) (node (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp k))) (if (jolt-truthy? (let* ((and__13__auto node)) (if (jolt-truthy? and__13__auto) (jolt= v (jolt-invoke (var-deref "clojure.core" "nd-val") node)) and__13__auto))) sm (if (jolt-truthy? node) (let* ((_a$668 (var-deref "clojure.core" "make-sorted")) (_a$669 (keyword "jolt" "sorted-map")) (_a$670 (jolt-invoke (var-deref "clojure.core" "tree-replace") cmp tree k v)) (_a$671 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt"))) (_a$672 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$673 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$668 _a$669 _a$670 _a$671 _a$672 _a$673)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$674 (var-deref "clojure.core" "make-sorted")) (_a$675 (keyword "jolt" "sorted-map")) (_a$676 (jolt-invoke (var-deref "clojure.core" "blacken") (jolt-invoke (var-deref "clojure.core" "tree-ins") cmp tree k v))) (_a$677 (jolt-inc (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt")))) (_a$678 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$679 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$674 _a$675 _a$676 _a$677 _a$678 _a$679)) jolt-nil)))))))) sm-assoc-1)))
+  (def-var! "clojure.core" "sm-assoc-1" (letrec ((sm-assoc-1 (lambda (sm k v) (let fnrec691 ((sm sm) (k k) (v v)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree"))) (node (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp k))) (if (jolt-truthy? (let* ((and__13__auto node)) (if (jolt-truthy? and__13__auto) (jolt= v (jolt-invoke (var-deref "clojure.core" "nd-val") node)) and__13__auto))) sm (if (jolt-truthy? node) (let* ((_a$692 (var-deref "clojure.core" "make-sorted")) (_a$693 (keyword "jolt" "sorted-map")) (_a$694 (jolt-invoke (var-deref "clojure.core" "tree-replace") cmp tree k v)) (_a$695 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt"))) (_a$696 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$697 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$692 _a$693 _a$694 _a$695 _a$696 _a$697)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$698 (var-deref "clojure.core" "make-sorted")) (_a$699 (keyword "jolt" "sorted-map")) (_a$700 (jolt-invoke (var-deref "clojure.core" "blacken") (jolt-invoke (var-deref "clojure.core" "tree-ins") cmp tree k v))) (_a$701 (jolt-inc (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt")))) (_a$702 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$703 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$698 _a$699 _a$700 _a$701 _a$702 _a$703)) jolt-nil)))))))) sm-assoc-1)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-assoc-many" (letrec ((sm-assoc-many (lambda (sm kvs) (let fnrec680 ((sm sm) (kvs kvs)) (let* ((n (jolt-count kvs))) (begin (if (jolt-odd? n) (jolt-throw (jolt-ex-info "sorted-map assoc expects an even number of key/values" (let* ((_o$681 (keyword #f "count")) (_o$682 n)) (jolt-hash-map _o$681 _o$682)))) jolt-nil) (let* ((m sm) (i 0)) (let loop683 ((m m) (i i)) (if (< i n) (let* ((_a$688 (let* ((_a$684 (var-deref "clojure.core" "sm-assoc-1")) (_a$685 m) (_a$686 (jolt-nth kvs i)) (_a$687 (jolt-nth kvs (jolt-inc i)))) (jolt-invoke _a$684 _a$685 _a$686 _a$687))) (_a$689 (+ i 2))) (loop683 _a$688 _a$689)) m))))))))) sm-assoc-many)))
+  (def-var! "clojure.core" "sm-assoc-many" (letrec ((sm-assoc-many (lambda (sm kvs) (let fnrec704 ((sm sm) (kvs kvs)) (let* ((n (jolt-count kvs))) (begin (if (jolt-odd? n) (jolt-throw (jolt-ex-info "sorted-map assoc expects an even number of key/values" (let* ((_o$705 (keyword #f "count")) (_o$706 n)) (jolt-hash-map _o$705 _o$706)))) jolt-nil) (let* ((m sm) (i 0)) (let loop707 ((m m) (i i)) (if (< i n) (let* ((_a$712 (let* ((_a$708 (var-deref "clojure.core" "sm-assoc-1")) (_a$709 m) (_a$710 (jolt-nth kvs i)) (_a$711 (jolt-nth kvs (jolt-inc i)))) (jolt-invoke _a$708 _a$709 _a$710 _a$711))) (_a$713 (+ i 2))) (loop707 _a$712 _a$713)) m))))))))) sm-assoc-many)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-dissoc-1" (letrec ((sm-dissoc-1 (lambda (sm k) (let fnrec690 ((sm sm) (k k)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp k))) sm (let* ((t (jolt-invoke (var-deref "clojure.core" "tree-del") cmp tree k))) (let* ((_a$691 (var-deref "clojure.core" "make-sorted")) (_a$692 (keyword "jolt" "sorted-map")) (_a$693 (if (jolt-truthy? t) (jolt-invoke (var-deref "clojure.core" "blacken") t) jolt-nil)) (_a$694 (jolt-dec (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt")))) (_a$695 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$696 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$691 _a$692 _a$693 _a$694 _a$695 _a$696))))))))) sm-dissoc-1)))
+  (def-var! "clojure.core" "sm-dissoc-1" (letrec ((sm-dissoc-1 (lambda (sm k) (let fnrec714 ((sm sm) (k k)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp k))) sm (let* ((t (jolt-invoke (var-deref "clojure.core" "tree-del") cmp tree k))) (let* ((_a$715 (var-deref "clojure.core" "make-sorted")) (_a$716 (keyword "jolt" "sorted-map")) (_a$717 (if (jolt-truthy? t) (jolt-invoke (var-deref "clojure.core" "blacken") t) jolt-nil)) (_a$718 (jolt-dec (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt")))) (_a$719 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$720 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$715 _a$716 _a$717 _a$718 _a$719 _a$720))))))))) sm-dissoc-1)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-dissoc-many" (letrec ((sm-dissoc-many (lambda (sm ks) (let fnrec697 ((sm sm) (ks ks)) (jolt-reduce (var-deref "clojure.core" "sm-dissoc-1") sm ks))))) sm-dissoc-many)))
+  (def-var! "clojure.core" "sm-dissoc-many" (letrec ((sm-dissoc-many (lambda (sm ks) (let fnrec721 ((sm sm) (ks ks)) (jolt-reduce (var-deref "clojure.core" "sm-dissoc-1") sm ks))))) sm-dissoc-many)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-conj-1" (letrec ((sm-conj-1 (lambda (sm x) (let fnrec698 ((sm sm) (x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) sm (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$704 (lambda (m e) (let fnrec699 ((m m) (e e)) (let* ((_a$700 (var-deref "clojure.core" "sm-assoc-1")) (_a$701 m) (_a$702 (jolt-first e)) (_a$703 (jolt-invoke (var-deref "clojure.core" "second") e))) (jolt-invoke _a$700 _a$701 _a$702 _a$703))))) (_a$705 sm) (_a$706 (jolt-seq x))) (jolt-reduce _a$704 _a$705 _a$706)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? and__13__auto) (jolt= 2 (jolt-count x)) and__13__auto))) (let* ((_a$707 (var-deref "clojure.core" "sm-assoc-1")) (_a$708 sm) (_a$709 (jolt-nth x 0)) (_a$710 (jolt-nth x 1))) (jolt-invoke _a$707 _a$708 _a$709 _a$710)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-ex-info "conj on a sorted-map requires a [key value] pair or a map" (jolt-hash-map))) jolt-nil)))))))) sm-conj-1)))
+  (def-var! "clojure.core" "sm-conj-1" (letrec ((sm-conj-1 (lambda (sm x) (let fnrec722 ((sm sm) (x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) sm (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$728 (lambda (m e) (let fnrec723 ((m m) (e e)) (let* ((_a$724 (var-deref "clojure.core" "sm-assoc-1")) (_a$725 m) (_a$726 (jolt-first e)) (_a$727 (jolt-invoke (var-deref "clojure.core" "second") e))) (jolt-invoke _a$724 _a$725 _a$726 _a$727))))) (_a$729 sm) (_a$730 (jolt-seq x))) (jolt-reduce _a$728 _a$729 _a$730)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "vector?") x))) (if (jolt-truthy? and__13__auto) (jolt= 2 (jolt-count x)) and__13__auto))) (let* ((_a$731 (var-deref "clojure.core" "sm-assoc-1")) (_a$732 sm) (_a$733 (jolt-nth x 0)) (_a$734 (jolt-nth x 1))) (jolt-invoke _a$731 _a$732 _a$733 _a$734)) (if (jolt-truthy? (keyword #f "else")) (jolt-throw (jolt-ex-info "conj on a sorted-map requires a [key value] pair or a map" (jolt-hash-map))) jolt-nil)))))))) sm-conj-1)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sm-conj-many" (letrec ((sm-conj-many (lambda (sm xs) (let fnrec711 ((sm sm) (xs xs)) (jolt-reduce (var-deref "clojure.core" "sm-conj-1") sm xs))))) sm-conj-many)))
+  (def-var! "clojure.core" "sm-conj-many" (letrec ((sm-conj-many (lambda (sm xs) (let fnrec735 ((sm sm) (xs xs)) (jolt-reduce (var-deref "clojure.core" "sm-conj-1") sm xs))))) sm-conj-many)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ss-get" (letrec ((ss-get (lambda (ss x not-found) (let fnrec712 ((ss ss) (x x) (not-found not-found)) (let* ((n (let* ((_a$713 (var-deref "clojure.core" "tree-lookup")) (_a$714 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree"))) (_a$715 (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (_a$716 x)) (jolt-invoke _a$713 _a$714 _a$715 _a$716)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") n)) not-found (jolt-invoke (var-deref "clojure.core" "nd-key") n))))))) ss-get)))
+  (def-var! "clojure.core" "ss-get" (letrec ((ss-get (lambda (ss x not-found) (let fnrec736 ((ss ss) (x x) (not-found not-found)) (let* ((n (let* ((_a$737 (var-deref "clojure.core" "tree-lookup")) (_a$738 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree"))) (_a$739 (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (_a$740 x)) (jolt-invoke _a$737 _a$738 _a$739 _a$740)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") n)) not-found (jolt-invoke (var-deref "clojure.core" "nd-key") n))))))) ss-get)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ss-conj-1" (letrec ((ss-conj-1 (lambda (ss x) (let fnrec717 ((ss ss) (x x)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp x)) ss (let* ((_a$718 (var-deref "clojure.core" "make-sorted")) (_a$719 (keyword "jolt" "sorted-set")) (_a$720 (jolt-invoke (var-deref "clojure.core" "blacken") (jolt-invoke (var-deref "clojure.core" "tree-ins") cmp tree x jolt-nil))) (_a$721 (jolt-inc (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cnt")))) (_a$722 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cmp"))) (_a$723 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "ops")))) (jolt-invoke _a$718 _a$719 _a$720 _a$721 _a$722 _a$723)))))))) ss-conj-1)))
+  (def-var! "clojure.core" "ss-conj-1" (letrec ((ss-conj-1 (lambda (ss x) (let fnrec741 ((ss ss) (x x)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp x)) ss (let* ((_a$742 (var-deref "clojure.core" "make-sorted")) (_a$743 (keyword "jolt" "sorted-set")) (_a$744 (jolt-invoke (var-deref "clojure.core" "blacken") (jolt-invoke (var-deref "clojure.core" "tree-ins") cmp tree x jolt-nil))) (_a$745 (jolt-inc (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cnt")))) (_a$746 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cmp"))) (_a$747 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "ops")))) (jolt-invoke _a$742 _a$743 _a$744 _a$745 _a$746 _a$747)))))))) ss-conj-1)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ss-conj-many" (letrec ((ss-conj-many (lambda (ss xs) (let fnrec724 ((ss ss) (xs xs)) (jolt-reduce (var-deref "clojure.core" "ss-conj-1") ss xs))))) ss-conj-many)))
+  (def-var! "clojure.core" "ss-conj-many" (letrec ((ss-conj-many (lambda (ss xs) (let fnrec748 ((ss ss) (xs xs)) (jolt-reduce (var-deref "clojure.core" "ss-conj-1") ss xs))))) ss-conj-many)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ss-disj-1" (letrec ((ss-disj-1 (lambda (ss x) (let fnrec725 ((ss ss) (x x)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp x))) ss (let* ((t (jolt-invoke (var-deref "clojure.core" "tree-del") cmp tree x))) (let* ((_a$726 (var-deref "clojure.core" "make-sorted")) (_a$727 (keyword "jolt" "sorted-set")) (_a$728 (if (jolt-truthy? t) (jolt-invoke (var-deref "clojure.core" "blacken") t) jolt-nil)) (_a$729 (jolt-dec (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cnt")))) (_a$730 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cmp"))) (_a$731 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "ops")))) (jolt-invoke _a$726 _a$727 _a$728 _a$729 _a$730 _a$731))))))))) ss-disj-1)))
+  (def-var! "clojure.core" "ss-disj-1" (letrec ((ss-disj-1 (lambda (ss x) (let fnrec749 ((ss ss) (x x)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (tree (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "tree-lookup") tree cmp x))) ss (let* ((t (jolt-invoke (var-deref "clojure.core" "tree-del") cmp tree x))) (let* ((_a$750 (var-deref "clojure.core" "make-sorted")) (_a$751 (keyword "jolt" "sorted-set")) (_a$752 (if (jolt-truthy? t) (jolt-invoke (var-deref "clojure.core" "blacken") t) jolt-nil)) (_a$753 (jolt-dec (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cnt")))) (_a$754 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cmp"))) (_a$755 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "ops")))) (jolt-invoke _a$750 _a$751 _a$752 _a$753 _a$754 _a$755))))))))) ss-disj-1)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "ss-disj-many" (letrec ((ss-disj-many (lambda (ss xs) (let fnrec732 ((ss ss) (xs xs)) (jolt-reduce (var-deref "clojure.core" "ss-disj-1") ss xs))))) ss-disj-many)))
+  (def-var! "clojure.core" "ss-disj-many" (letrec ((ss-disj-many (lambda (ss xs) (let fnrec756 ((ss ss) (xs xs)) (jolt-reduce (var-deref "clojure.core" "ss-disj-1") ss xs))))) ss-disj-many)))
 (guard (e (#t #f))
-  (def-var-with-meta! "clojure.core" "sm-ops" (let* ((_o$750 (keyword #f "count")) (_o$751 (lambda (sm) (let fnrec733 ((sm sm)) (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt"))))) (_o$752 (keyword #f "entries")) (_o$753 (lambda (sm) (let fnrec734 ((sm sm)) (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry"))))) (_o$754 (keyword #f "seq")) (_o$755 (lambda (sm) (let fnrec735 ((sm sm)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry")))))) (_o$756 (keyword #f "rseq")) (_o$757 (lambda (sm) (let fnrec736 ((sm sm)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry")))))))) (_o$758 (keyword #f "first")) (_o$759 (lambda (sm) (let fnrec737 ((sm sm)) (jolt-first (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry")))))) (_o$760 (keyword #f "get")) (_o$761 (var-deref "clojure.core" "sm-get")) (_o$762 (keyword #f "contains")) (_o$763 (lambda (sm k) (let fnrec738 ((sm sm) (k k)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (let* ((_a$739 (var-deref "clojure.core" "tree-lookup")) (_a$740 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree"))) (_a$741 (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (_a$742 k)) (jolt-invoke _a$739 _a$740 _a$741 _a$742))))))) (_o$764 (keyword #f "assoc")) (_o$765 (var-deref "clojure.core" "sm-assoc-many")) (_o$766 (keyword #f "dissoc")) (_o$767 (var-deref "clojure.core" "sm-dissoc-many")) (_o$768 (keyword #f "conj")) (_o$769 (var-deref "clojure.core" "sm-conj-many")) (_o$770 (keyword #f "empty")) (_o$771 (lambda (sm) (let fnrec743 ((sm sm)) (let* ((_a$744 (var-deref "clojure.core" "make-sorted")) (_a$745 (keyword "jolt" "sorted-map")) (_a$746 jolt-nil) (_a$747 0) (_a$748 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$749 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$744 _a$745 _a$746 _a$747 _a$748 _a$749)))))) (jolt-hash-map _o$750 _o$751 _o$752 _o$753 _o$754 _o$755 _o$756 _o$757 _o$758 _o$759 _o$760 _o$761 _o$762 _o$763 _o$764 _o$765 _o$766 _o$767 _o$768 _o$769 _o$770 _o$771)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "clojure.core" "sm-ops" (let* ((_o$774 (keyword #f "count")) (_o$775 (lambda (sm) (let fnrec757 ((sm sm)) (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cnt"))))) (_o$776 (keyword #f "entries")) (_o$777 (lambda (sm) (let fnrec758 ((sm sm)) (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry"))))) (_o$778 (keyword #f "seq")) (_o$779 (lambda (sm) (let fnrec759 ((sm sm)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry")))))) (_o$780 (keyword #f "rseq")) (_o$781 (lambda (sm) (let fnrec760 ((sm sm)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry")))))))) (_o$782 (keyword #f "first")) (_o$783 (lambda (sm) (let fnrec761 ((sm sm)) (jolt-first (jolt-invoke (var-deref "clojure.core" "sc-entries") sm (var-deref "clojure.core" "map-entry")))))) (_o$784 (keyword #f "get")) (_o$785 (var-deref "clojure.core" "sm-get")) (_o$786 (keyword #f "contains")) (_o$787 (lambda (sm k) (let fnrec762 ((sm sm) (k k)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (let* ((_a$763 (var-deref "clojure.core" "tree-lookup")) (_a$764 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "tree"))) (_a$765 (jolt-invoke (var-deref "clojure.core" "the-cmp") sm)) (_a$766 k)) (jolt-invoke _a$763 _a$764 _a$765 _a$766))))))) (_o$788 (keyword #f "assoc")) (_o$789 (var-deref "clojure.core" "sm-assoc-many")) (_o$790 (keyword #f "dissoc")) (_o$791 (var-deref "clojure.core" "sm-dissoc-many")) (_o$792 (keyword #f "conj")) (_o$793 (var-deref "clojure.core" "sm-conj-many")) (_o$794 (keyword #f "empty")) (_o$795 (lambda (sm) (let fnrec767 ((sm sm)) (let* ((_a$768 (var-deref "clojure.core" "make-sorted")) (_a$769 (keyword "jolt" "sorted-map")) (_a$770 jolt-nil) (_a$771 0) (_a$772 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "cmp"))) (_a$773 (jolt-invoke (var-deref "clojure.core" "sfield") sm (keyword #f "ops")))) (jolt-invoke _a$768 _a$769 _a$770 _a$771 _a$772 _a$773)))))) (jolt-hash-map _o$774 _o$775 _o$776 _o$777 _o$778 _o$779 _o$780 _o$781 _o$782 _o$783 _o$784 _o$785 _o$786 _o$787 _o$788 _o$789 _o$790 _o$791 _o$792 _o$793 _o$794 _o$795)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "clojure.core" "ss-ops" (let* ((_o$789 (keyword #f "count")) (_o$790 (lambda (ss) (let fnrec772 ((ss ss)) (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cnt"))))) (_o$791 (keyword #f "entries")) (_o$792 (lambda (ss) (let fnrec773 ((ss ss)) (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key"))))) (_o$793 (keyword #f "seq")) (_o$794 (lambda (ss) (let fnrec774 ((ss ss)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key")))))) (_o$795 (keyword #f "rseq")) (_o$796 (lambda (ss) (let fnrec775 ((ss ss)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key")))))))) (_o$797 (keyword #f "first")) (_o$798 (lambda (ss) (let fnrec776 ((ss ss)) (jolt-first (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key")))))) (_o$799 (keyword #f "get")) (_o$800 (var-deref "clojure.core" "ss-get")) (_o$801 (keyword #f "contains")) (_o$802 (lambda (ss x) (let fnrec777 ((ss ss) (x x)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (let* ((_a$778 (var-deref "clojure.core" "tree-lookup")) (_a$779 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree"))) (_a$780 (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (_a$781 x)) (jolt-invoke _a$778 _a$779 _a$780 _a$781))))))) (_o$803 (keyword #f "conj")) (_o$804 (var-deref "clojure.core" "ss-conj-many")) (_o$805 (keyword #f "disj")) (_o$806 (var-deref "clojure.core" "ss-disj-many")) (_o$807 (keyword #f "empty")) (_o$808 (lambda (ss) (let fnrec782 ((ss ss)) (let* ((_a$783 (var-deref "clojure.core" "make-sorted")) (_a$784 (keyword "jolt" "sorted-set")) (_a$785 jolt-nil) (_a$786 0) (_a$787 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cmp"))) (_a$788 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "ops")))) (jolt-invoke _a$783 _a$784 _a$785 _a$786 _a$787 _a$788)))))) (jolt-hash-map _o$789 _o$790 _o$791 _o$792 _o$793 _o$794 _o$795 _o$796 _o$797 _o$798 _o$799 _o$800 _o$801 _o$802 _o$803 _o$804 _o$805 _o$806 _o$807 _o$808)) (jolt-hash-map (keyword #f "private") #t)))
+  (def-var-with-meta! "clojure.core" "ss-ops" (let* ((_o$813 (keyword #f "count")) (_o$814 (lambda (ss) (let fnrec796 ((ss ss)) (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cnt"))))) (_o$815 (keyword #f "entries")) (_o$816 (lambda (ss) (let fnrec797 ((ss ss)) (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key"))))) (_o$817 (keyword #f "seq")) (_o$818 (lambda (ss) (let fnrec798 ((ss ss)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key")))))) (_o$819 (keyword #f "rseq")) (_o$820 (lambda (ss) (let fnrec799 ((ss ss)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key")))))))) (_o$821 (keyword #f "first")) (_o$822 (lambda (ss) (let fnrec800 ((ss ss)) (jolt-first (jolt-invoke (var-deref "clojure.core" "sc-entries") ss (var-deref "clojure.core" "nd-key")))))) (_o$823 (keyword #f "get")) (_o$824 (var-deref "clojure.core" "ss-get")) (_o$825 (keyword #f "contains")) (_o$826 (lambda (ss x) (let fnrec801 ((ss ss) (x x)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (let* ((_a$802 (var-deref "clojure.core" "tree-lookup")) (_a$803 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "tree"))) (_a$804 (jolt-invoke (var-deref "clojure.core" "the-cmp") ss)) (_a$805 x)) (jolt-invoke _a$802 _a$803 _a$804 _a$805))))))) (_o$827 (keyword #f "conj")) (_o$828 (var-deref "clojure.core" "ss-conj-many")) (_o$829 (keyword #f "disj")) (_o$830 (var-deref "clojure.core" "ss-disj-many")) (_o$831 (keyword #f "empty")) (_o$832 (lambda (ss) (let fnrec806 ((ss ss)) (let* ((_a$807 (var-deref "clojure.core" "make-sorted")) (_a$808 (keyword "jolt" "sorted-set")) (_a$809 jolt-nil) (_a$810 0) (_a$811 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "cmp"))) (_a$812 (jolt-invoke (var-deref "clojure.core" "sfield") ss (keyword #f "ops")))) (jolt-invoke _a$807 _a$808 _a$809 _a$810 _a$811 _a$812)))))) (jolt-hash-map _o$813 _o$814 _o$815 _o$816 _o$817 _o$818 _o$819 _o$820 _o$821 _o$822 _o$823 _o$824 _o$825 _o$826 _o$827 _o$828 _o$829 _o$830 _o$831 _o$832)) (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted-map" (letrec ((sorted-map (lambda kvs (let fnrec809 ((kvs (list->cseq kvs))) (let* ((_a$810 (var-deref "clojure.core" "sm-assoc-many")) (_a$811 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-map") jolt-nil 0 jolt-nil (var-deref "clojure.core" "sm-ops"))) (_a$812 (jolt-invoke (var-deref "clojure.core" "vec") kvs))) (jolt-invoke _a$810 _a$811 _a$812)))))) sorted-map)))
+  (def-var! "clojure.core" "sorted-map" (letrec ((sorted-map (lambda kvs (let fnrec833 ((kvs (list->cseq kvs))) (let* ((_a$834 (var-deref "clojure.core" "sm-assoc-many")) (_a$835 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-map") jolt-nil 0 jolt-nil (var-deref "clojure.core" "sm-ops"))) (_a$836 (jolt-invoke (var-deref "clojure.core" "vec") kvs))) (jolt-invoke _a$834 _a$835 _a$836)))))) sorted-map)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted-map-by" (letrec ((sorted-map-by (lambda (comparator . kvs) (let fnrec813 ((comparator comparator) (kvs (list->cseq kvs))) (let* ((_a$814 (var-deref "clojure.core" "sm-assoc-many")) (_a$815 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-map") jolt-nil 0 (jolt-invoke (var-deref "clojure.core" "fn->cmp") comparator) (var-deref "clojure.core" "sm-ops"))) (_a$816 (jolt-invoke (var-deref "clojure.core" "vec") kvs))) (jolt-invoke _a$814 _a$815 _a$816)))))) sorted-map-by)))
+  (def-var! "clojure.core" "sorted-map-by" (letrec ((sorted-map-by (lambda (comparator . kvs) (let fnrec837 ((comparator comparator) (kvs (list->cseq kvs))) (let* ((_a$838 (var-deref "clojure.core" "sm-assoc-many")) (_a$839 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-map") jolt-nil 0 (jolt-invoke (var-deref "clojure.core" "fn->cmp") comparator) (var-deref "clojure.core" "sm-ops"))) (_a$840 (jolt-invoke (var-deref "clojure.core" "vec") kvs))) (jolt-invoke _a$838 _a$839 _a$840)))))) sorted-map-by)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted-set" (letrec ((sorted-set (lambda xs (let fnrec817 ((xs (list->cseq xs))) (let* ((_a$818 (var-deref "clojure.core" "ss-conj-many")) (_a$819 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-set") jolt-nil 0 jolt-nil (var-deref "clojure.core" "ss-ops"))) (_a$820 (jolt-invoke (var-deref "clojure.core" "vec") xs))) (jolt-invoke _a$818 _a$819 _a$820)))))) sorted-set)))
+  (def-var! "clojure.core" "sorted-set" (letrec ((sorted-set (lambda xs (let fnrec841 ((xs (list->cseq xs))) (let* ((_a$842 (var-deref "clojure.core" "ss-conj-many")) (_a$843 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-set") jolt-nil 0 jolt-nil (var-deref "clojure.core" "ss-ops"))) (_a$844 (jolt-invoke (var-deref "clojure.core" "vec") xs))) (jolt-invoke _a$842 _a$843 _a$844)))))) sorted-set)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted-set-by" (letrec ((sorted-set-by (lambda (comparator . xs) (let fnrec821 ((comparator comparator) (xs (list->cseq xs))) (let* ((_a$822 (var-deref "clojure.core" "ss-conj-many")) (_a$823 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-set") jolt-nil 0 (jolt-invoke (var-deref "clojure.core" "fn->cmp") comparator) (var-deref "clojure.core" "ss-ops"))) (_a$824 (jolt-invoke (var-deref "clojure.core" "vec") xs))) (jolt-invoke _a$822 _a$823 _a$824)))))) sorted-set-by)))
+  (def-var! "clojure.core" "sorted-set-by" (letrec ((sorted-set-by (lambda (comparator . xs) (let fnrec845 ((comparator comparator) (xs (list->cseq xs))) (let* ((_a$846 (var-deref "clojure.core" "ss-conj-many")) (_a$847 (jolt-invoke (var-deref "clojure.core" "make-sorted") (keyword "jolt" "sorted-set") jolt-nil 0 (jolt-invoke (var-deref "clojure.core" "fn->cmp") comparator) (var-deref "clojure.core" "ss-ops"))) (_a$848 (jolt-invoke (var-deref "clojure.core" "vec") xs))) (jolt-invoke _a$846 _a$847 _a$848)))))) sorted-set-by)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted-map?" (letrec ((sorted-map? (lambda (x) (let fnrec825 ((x x)) (jolt= (keyword "jolt" "sorted-map") (jolt-invoke (var-deref "clojure.core" "sfield") x (keyword "jolt" "type"))))))) sorted-map?)))
+  (def-var! "clojure.core" "sorted-map?" (letrec ((sorted-map? (lambda (x) (let fnrec849 ((x x)) (jolt= (keyword "jolt" "sorted-map") (jolt-invoke (var-deref "clojure.core" "sfield") x (keyword "jolt" "type"))))))) sorted-map?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted-set?" (letrec ((sorted-set? (lambda (x) (let fnrec826 ((x x)) (jolt= (keyword "jolt" "sorted-set") (jolt-invoke (var-deref "clojure.core" "sfield") x (keyword "jolt" "type"))))))) sorted-set?)))
+  (def-var! "clojure.core" "sorted-set?" (letrec ((sorted-set? (lambda (x) (let fnrec850 ((x x)) (jolt= (keyword "jolt" "sorted-set") (jolt-invoke (var-deref "clojure.core" "sfield") x (keyword "jolt" "type"))))))) sorted-set?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sorted?" (letrec ((sorted? (lambda (x) (let fnrec827 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted-map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted-set?") x))))))) sorted?)))
+  (def-var! "clojure.core" "sorted?" (letrec ((sorted? (lambda (x) (let fnrec851 ((x x)) (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted-map?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "sorted-set?") x))))))) sorted?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sc-keyf" (letrec ((sc-keyf (lambda (sc) (let fnrec828 ((sc sc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted-map?") sc)) jolt-first jolt-identity))))) sc-keyf)))
+  (def-var! "clojure.core" "sc-keyf" (letrec ((sc-keyf (lambda (sc) (let fnrec852 ((sc sc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted-map?") sc)) jolt-first jolt-identity))))) sc-keyf)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sc-proj" (letrec ((sc-proj (lambda (sc) (let fnrec829 ((sc sc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted-map?") sc)) (var-deref "clojure.core" "map-entry") (var-deref "clojure.core" "nd-key")))))) sc-proj)))
+  (def-var! "clojure.core" "sc-proj" (letrec ((sc-proj (lambda (sc) (let fnrec853 ((sc sc)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "sorted-map?") sc)) (var-deref "clojure.core" "map-entry") (var-deref "clojure.core" "nd-key")))))) sc-proj)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "sub-filter" (letrec ((sub-filter (lambda (sc tests) (let fnrec830 ((sc sc) (tests tests)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") sc)) (keyf (jolt-invoke (var-deref "clojure.core" "sc-keyf") sc))) (let* ((_a$833 (var-deref "clojure.core" "filterv")) (_a$834 (lambda (e) (let fnrec831 ((e e)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (G__15) (let fnrec832 ((G__15 G__15)) (let* ((G__16 G__15) (test (jolt-nth G__16 0 jolt-nil)) (k (jolt-nth G__16 1 jolt-nil))) (jolt-invoke test (jolt-invoke cmp (jolt-invoke keyf e) k) 0)))) tests)))) (_a$835 (jolt-invoke (var-deref "clojure.core" "sc-entries") sc (jolt-invoke (var-deref "clojure.core" "sc-proj") sc)))) (jolt-invoke _a$833 _a$834 _a$835))))))) sub-filter)))
+  (def-var! "clojure.core" "sub-filter" (letrec ((sub-filter (lambda (sc tests) (let fnrec854 ((sc sc) (tests tests)) (let* ((cmp (jolt-invoke (var-deref "clojure.core" "the-cmp") sc)) (keyf (jolt-invoke (var-deref "clojure.core" "sc-keyf") sc))) (let* ((_a$857 (var-deref "clojure.core" "filterv")) (_a$858 (lambda (e) (let fnrec855 ((e e)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (G__15) (let fnrec856 ((G__15 G__15)) (let* ((G__16 G__15) (test (jolt-nth G__16 0 jolt-nil)) (k (jolt-nth G__16 1 jolt-nil))) (jolt-invoke test (jolt-invoke cmp (jolt-invoke keyf e) k) 0)))) tests)))) (_a$859 (jolt-invoke (var-deref "clojure.core" "sc-entries") sc (jolt-invoke (var-deref "clojure.core" "sc-proj") sc)))) (jolt-invoke _a$857 _a$858 _a$859))))))) sub-filter)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "subseq" (letrec ((subseq (case-lambda ((sc test k) (let fnrec836 ((sc sc) (test test) (k k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (jolt-vector (let* ((_o$837 test) (_o$838 k)) (jolt-vector _o$837 _o$838))))))) ((sc start-test start-k end-test end-k) (let fnrec839 ((sc sc) (start-test start-test) (start-k start-k) (end-test end-test) (end-k end-k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (let* ((_o$844 (let* ((_o$840 start-test) (_o$841 start-k)) (jolt-vector _o$840 _o$841))) (_o$845 (let* ((_o$842 end-test) (_o$843 end-k)) (jolt-vector _o$842 _o$843)))) (jolt-vector _o$844 _o$845))))))))) subseq)))
+  (def-var! "clojure.core" "subseq" (letrec ((subseq (case-lambda ((sc test k) (let fnrec860 ((sc sc) (test test) (k k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (jolt-vector (let* ((_o$861 test) (_o$862 k)) (jolt-vector _o$861 _o$862))))))) ((sc start-test start-k end-test end-k) (let fnrec863 ((sc sc) (start-test start-test) (start-k start-k) (end-test end-test) (end-k end-k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (let* ((_o$868 (let* ((_o$864 start-test) (_o$865 start-k)) (jolt-vector _o$864 _o$865))) (_o$869 (let* ((_o$866 end-test) (_o$867 end-k)) (jolt-vector _o$866 _o$867)))) (jolt-vector _o$868 _o$869))))))))) subseq)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "rsubseq" (letrec ((rsubseq (case-lambda ((sc test k) (let fnrec846 ((sc sc) (test test) (k k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (jolt-vector (let* ((_o$847 test) (_o$848 k)) (jolt-vector _o$847 _o$848))))))))) ((sc start-test start-k end-test end-k) (let fnrec849 ((sc sc) (start-test start-test) (start-k start-k) (end-test end-test) (end-k end-k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (let* ((_o$854 (let* ((_o$850 start-test) (_o$851 start-k)) (jolt-vector _o$850 _o$851))) (_o$855 (let* ((_o$852 end-test) (_o$853 end-k)) (jolt-vector _o$852 _o$853)))) (jolt-vector _o$854 _o$855))))))))))) rsubseq)))
+  (def-var! "clojure.core" "rsubseq" (letrec ((rsubseq (case-lambda ((sc test k) (let fnrec870 ((sc sc) (test test) (k k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (jolt-vector (let* ((_o$871 test) (_o$872 k)) (jolt-vector _o$871 _o$872))))))))) ((sc start-test start-k end-test end-k) (let fnrec873 ((sc sc) (start-test start-test) (start-k start-k) (end-test end-test) (end-k end-k)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "vec") (jolt-reverse (jolt-invoke (var-deref "clojure.core" "sub-filter") sc (let* ((_o$878 (let* ((_o$874 start-test) (_o$875 start-k)) (jolt-vector _o$874 _o$875))) (_o$879 (let* ((_o$876 end-test) (_o$877 end-k)) (jolt-vector _o$876 _o$877)))) (jolt-vector _o$878 _o$879))))))))))) rsubseq)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "comment"
-    (lambda body (let fnrec856 ((body (list->cseq body))) jolt-nil)))
+    (lambda body (let fnrec880 ((body (list->cseq body))) jolt-nil)))
   (mark-macro! "clojure.core" "comment"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-out-str"
-    (lambda body (let fnrec857 ((body (list->cseq body))) (let* ((_a$862 (var-deref "clojure.core" "__sqcat")) (_a$863 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__with-out-str"))) (_a$864 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$858 (var-deref "clojure.core" "__sqcat")) (_a$859 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$860 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$861 body)) (jolt-invoke _a$858 _a$859 _a$860 _a$861))))) (jolt-invoke _a$862 _a$863 _a$864)))))
+    (lambda body (let fnrec881 ((body (list->cseq body))) (let* ((_a$886 (var-deref "clojure.core" "__sqcat")) (_a$887 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__with-out-str"))) (_a$888 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$882 (var-deref "clojure.core" "__sqcat")) (_a$883 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$884 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$885 body)) (jolt-invoke _a$882 _a$883 _a$884 _a$885))))) (jolt-invoke _a$886 _a$887 _a$888)))))
   (mark-macro! "clojure.core" "with-out-str"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defmulti"
-    (lambda (name . args) (let fnrec865 ((name name) (args (list->cseq args))) (let* ((args (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first args))) (jolt-rest args) args)) (args (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") (jolt-first args)))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first args))) and__13__auto))) (jolt-rest args) args)) (dispatch (jolt-first args)) (opts (jolt-rest args))) (let* ((_a$869 (var-deref "clojure.core" "__sqcat")) (_a$870 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "defmulti-setup"))) (_a$871 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$866 (var-deref "clojure.core" "__sqcat")) (_a$867 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$868 (jolt-invoke (var-deref "clojure.core" "__sq1") name))) (jolt-invoke _a$866 _a$867 _a$868)))) (_a$872 (jolt-invoke (var-deref "clojure.core" "__sq1") dispatch)) (_a$873 opts)) (jolt-invoke _a$869 _a$870 _a$871 _a$872 _a$873))))))
+    (lambda (name . args) (let fnrec889 ((name name) (args (list->cseq args))) (let* ((args (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first args))) (jolt-rest args) args)) (args (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "map?") (jolt-first args)))) (if (jolt-truthy? and__13__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first args))) and__13__auto))) (jolt-rest args) args)) (dispatch (jolt-first args)) (opts (jolt-rest args))) (let* ((_a$893 (var-deref "clojure.core" "__sqcat")) (_a$894 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "defmulti-setup"))) (_a$895 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$890 (var-deref "clojure.core" "__sqcat")) (_a$891 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$892 (jolt-invoke (var-deref "clojure.core" "__sq1") name))) (jolt-invoke _a$890 _a$891 _a$892)))) (_a$896 (jolt-invoke (var-deref "clojure.core" "__sq1") dispatch)) (_a$897 opts)) (jolt-invoke _a$893 _a$894 _a$895 _a$896 _a$897))))))
   (mark-macro! "clojure.core" "defmulti"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defmethod"
-    (lambda (mm dispatch-val . fn-tail) (let fnrec874 ((mm mm) (dispatch-val dispatch-val) (fn-tail (list->cseq fn-tail))) (let* ((_a$878 (var-deref "clojure.core" "__sqcat")) (_a$879 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "defmethod-setup"))) (_a$880 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$875 (var-deref "clojure.core" "__sqcat")) (_a$876 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$877 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$875 _a$876 _a$877)))) (_a$881 (jolt-invoke (var-deref "clojure.core" "__sq1") dispatch-val)) (_a$882 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn")) fn-tail)))) (jolt-invoke _a$878 _a$879 _a$880 _a$881 _a$882)))))
+    (lambda (mm dispatch-val . fn-tail) (let fnrec898 ((mm mm) (dispatch-val dispatch-val) (fn-tail (list->cseq fn-tail))) (let* ((_a$902 (var-deref "clojure.core" "__sqcat")) (_a$903 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "defmethod-setup"))) (_a$904 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$899 (var-deref "clojure.core" "__sqcat")) (_a$900 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$901 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$899 _a$900 _a$901)))) (_a$905 (jolt-invoke (var-deref "clojure.core" "__sq1") dispatch-val)) (_a$906 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn")) fn-tail)))) (jolt-invoke _a$902 _a$903 _a$904 _a$905 _a$906)))))
   (mark-macro! "clojure.core" "defmethod"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "prefer-method"
-    (lambda (mm dval-a dval-b) (let fnrec883 ((mm mm) (dval-a dval-a) (dval-b dval-b)) (let* ((_a$887 (var-deref "clojure.core" "__sqcat")) (_a$888 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "prefer-method-setup"))) (_a$889 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$884 (var-deref "clojure.core" "__sqcat")) (_a$885 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$886 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$884 _a$885 _a$886)))) (_a$890 (jolt-invoke (var-deref "clojure.core" "__sq1") dval-a)) (_a$891 (jolt-invoke (var-deref "clojure.core" "__sq1") dval-b))) (jolt-invoke _a$887 _a$888 _a$889 _a$890 _a$891)))))
+    (lambda (mm dval-a dval-b) (let fnrec907 ((mm mm) (dval-a dval-a) (dval-b dval-b)) (let* ((_a$911 (var-deref "clojure.core" "__sqcat")) (_a$912 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "prefer-method-setup"))) (_a$913 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$908 (var-deref "clojure.core" "__sqcat")) (_a$909 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$910 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$908 _a$909 _a$910)))) (_a$914 (jolt-invoke (var-deref "clojure.core" "__sq1") dval-a)) (_a$915 (jolt-invoke (var-deref "clojure.core" "__sq1") dval-b))) (jolt-invoke _a$911 _a$912 _a$913 _a$914 _a$915)))))
   (mark-macro! "clojure.core" "prefer-method"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "remove-method"
-    (lambda (mm dval) (let fnrec892 ((mm mm) (dval dval)) (let* ((_a$896 (var-deref "clojure.core" "__sqcat")) (_a$897 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "remove-method-setup"))) (_a$898 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$893 (var-deref "clojure.core" "__sqcat")) (_a$894 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$895 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$893 _a$894 _a$895)))) (_a$899 (jolt-invoke (var-deref "clojure.core" "__sq1") dval))) (jolt-invoke _a$896 _a$897 _a$898 _a$899)))))
+    (lambda (mm dval) (let fnrec916 ((mm mm) (dval dval)) (let* ((_a$920 (var-deref "clojure.core" "__sqcat")) (_a$921 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "remove-method-setup"))) (_a$922 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$917 (var-deref "clojure.core" "__sqcat")) (_a$918 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$919 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$917 _a$918 _a$919)))) (_a$923 (jolt-invoke (var-deref "clojure.core" "__sq1") dval))) (jolt-invoke _a$920 _a$921 _a$922 _a$923)))))
   (mark-macro! "clojure.core" "remove-method"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "remove-all-methods"
-    (lambda (mm) (let fnrec900 ((mm mm)) (let* ((_a$904 (var-deref "clojure.core" "__sqcat")) (_a$905 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "remove-all-methods-setup"))) (_a$906 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$901 (var-deref "clojure.core" "__sqcat")) (_a$902 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$903 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$901 _a$902 _a$903))))) (jolt-invoke _a$904 _a$905 _a$906)))))
+    (lambda (mm) (let fnrec924 ((mm mm)) (let* ((_a$928 (var-deref "clojure.core" "__sqcat")) (_a$929 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "remove-all-methods-setup"))) (_a$930 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$925 (var-deref "clojure.core" "__sqcat")) (_a$926 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$927 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$925 _a$926 _a$927))))) (jolt-invoke _a$928 _a$929 _a$930)))))
   (mark-macro! "clojure.core" "remove-all-methods"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "get-method"
-    (lambda (mm dval) (let fnrec907 ((mm mm) (dval dval)) (let* ((_a$908 (var-deref "clojure.core" "__sqcat")) (_a$909 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get-method-setup"))) (_a$910 (jolt-invoke (var-deref "clojure.core" "__sq1") mm)) (_a$911 (jolt-invoke (var-deref "clojure.core" "__sq1") dval))) (jolt-invoke _a$908 _a$909 _a$910 _a$911)))))
+    (lambda (mm dval) (let fnrec931 ((mm mm) (dval dval)) (let* ((_a$932 (var-deref "clojure.core" "__sqcat")) (_a$933 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get-method-setup"))) (_a$934 (jolt-invoke (var-deref "clojure.core" "__sq1") mm)) (_a$935 (jolt-invoke (var-deref "clojure.core" "__sq1") dval))) (jolt-invoke _a$932 _a$933 _a$934 _a$935)))))
   (mark-macro! "clojure.core" "get-method"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "methods"
-    (lambda (mm) (let fnrec912 ((mm mm)) (let* ((_a$913 (var-deref "clojure.core" "__sqcat")) (_a$914 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "methods-setup"))) (_a$915 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$913 _a$914 _a$915)))))
+    (lambda (mm) (let fnrec936 ((mm mm)) (let* ((_a$937 (var-deref "clojure.core" "__sqcat")) (_a$938 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "methods-setup"))) (_a$939 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$937 _a$938 _a$939)))))
   (mark-macro! "clojure.core" "methods"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "prefers"
-    (lambda (mm) (let fnrec916 ((mm mm)) (let* ((_a$920 (var-deref "clojure.core" "__sqcat")) (_a$921 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "prefers-setup"))) (_a$922 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$917 (var-deref "clojure.core" "__sqcat")) (_a$918 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$919 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$917 _a$918 _a$919))))) (jolt-invoke _a$920 _a$921 _a$922)))))
+    (lambda (mm) (let fnrec940 ((mm mm)) (let* ((_a$944 (var-deref "clojure.core" "__sqcat")) (_a$945 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "prefers-setup"))) (_a$946 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$941 (var-deref "clojure.core" "__sqcat")) (_a$942 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$943 (jolt-invoke (var-deref "clojure.core" "__sq1") mm))) (jolt-invoke _a$941 _a$942 _a$943))))) (jolt-invoke _a$944 _a$945 _a$946)))))
   (mark-macro! "clojure.core" "prefers"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "instance?"
-    (lambda (t x) (let fnrec923 ((t t) (x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") t)) (let* ((_a$924 (var-deref "clojure.core" "__sqcat")) (_a$925 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "instance-check"))) (_a$926 (jolt-invoke (var-deref "clojure.core" "__sq1") t)) (_a$927 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$924 _a$925 _a$926 _a$927)) (let* ((_a$931 (var-deref "clojure.core" "__sqcat")) (_a$932 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "instance-check"))) (_a$933 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$928 (var-deref "clojure.core" "__sqcat")) (_a$929 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$930 (jolt-invoke (var-deref "clojure.core" "__sq1") t))) (jolt-invoke _a$928 _a$929 _a$930)))) (_a$934 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$931 _a$932 _a$933 _a$934))))))
+    (lambda (t x) (let fnrec947 ((t t) (x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") t)) (let* ((_a$948 (var-deref "clojure.core" "__sqcat")) (_a$949 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "instance-check"))) (_a$950 (jolt-invoke (var-deref "clojure.core" "__sq1") t)) (_a$951 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$948 _a$949 _a$950 _a$951)) (let* ((_a$955 (var-deref "clojure.core" "__sqcat")) (_a$956 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "instance-check"))) (_a$957 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$952 (var-deref "clojure.core" "__sqcat")) (_a$953 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$954 (jolt-invoke (var-deref "clojure.core" "__sq1") t))) (jolt-invoke _a$952 _a$953 _a$954)))) (_a$958 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$955 _a$956 _a$957 _a$958))))))
   (mark-macro! "clojure.core" "instance?"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "locking"
-    (lambda (x . body) (let fnrec935 ((x x) (body (list->cseq body))) (let* ((_a$936 (var-deref "clojure.core" "__sqcat")) (_a$937 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$938 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$939 body)) (jolt-invoke _a$936 _a$937 _a$938 _a$939)))))
+    (lambda (x . body) (let fnrec959 ((x x) (body (list->cseq body))) (let* ((_a$960 (var-deref "clojure.core" "__sqcat")) (_a$961 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$962 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$963 body)) (jolt-invoke _a$960 _a$961 _a$962 _a$963)))))
   (mark-macro! "clojure.core" "locking"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "time"
-    (lambda (expr) (let fnrec940 ((expr expr)) (let* ((_a$958 (var-deref "clojure.core" "__sqcat")) (_a$959 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$960 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$941 (var-deref "clojure.core" "__sqvec")) (_a$942 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "start__1__auto"))) (_a$943 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "current-time-ms"))))) (_a$944 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "ret__2__auto"))) (_a$945 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$941 _a$942 _a$943 _a$944 _a$945)))) (_a$961 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$955 (var-deref "clojure.core" "__sqcat")) (_a$956 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "println"))) (_a$957 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$950 (var-deref "clojure.core" "__sqcat")) (_a$951 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "str"))) (_a$952 (jolt-invoke (var-deref "clojure.core" "__sq1") "Elapsed time: ")) (_a$953 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$946 (var-deref "clojure.core" "__sqcat")) (_a$947 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "-"))) (_a$948 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "current-time-ms"))))) (_a$949 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "start__1__auto")))) (jolt-invoke _a$946 _a$947 _a$948 _a$949)))) (_a$954 (jolt-invoke (var-deref "clojure.core" "__sq1") " msecs"))) (jolt-invoke _a$950 _a$951 _a$952 _a$953 _a$954))))) (jolt-invoke _a$955 _a$956 _a$957)))) (_a$962 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "ret__2__auto")))) (jolt-invoke _a$958 _a$959 _a$960 _a$961 _a$962)))))
+    (lambda (expr) (let fnrec964 ((expr expr)) (let* ((_a$982 (var-deref "clojure.core" "__sqcat")) (_a$983 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$984 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$965 (var-deref "clojure.core" "__sqvec")) (_a$966 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "start__1__auto"))) (_a$967 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "current-time-ms"))))) (_a$968 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "ret__2__auto"))) (_a$969 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$965 _a$966 _a$967 _a$968 _a$969)))) (_a$985 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$979 (var-deref "clojure.core" "__sqcat")) (_a$980 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "println"))) (_a$981 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$974 (var-deref "clojure.core" "__sqcat")) (_a$975 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "str"))) (_a$976 (jolt-invoke (var-deref "clojure.core" "__sq1") "Elapsed time: ")) (_a$977 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$970 (var-deref "clojure.core" "__sqcat")) (_a$971 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "-"))) (_a$972 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "current-time-ms"))))) (_a$973 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "start__1__auto")))) (jolt-invoke _a$970 _a$971 _a$972 _a$973)))) (_a$978 (jolt-invoke (var-deref "clojure.core" "__sq1") " msecs"))) (jolt-invoke _a$974 _a$975 _a$976 _a$977 _a$978))))) (jolt-invoke _a$979 _a$980 _a$981)))) (_a$986 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "ret__2__auto")))) (jolt-invoke _a$982 _a$983 _a$984 _a$985 _a$986)))))
   (mark-macro! "clojure.core" "time"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-redefs"
-    (lambda (bindings . body) (let fnrec963 ((bindings bindings) (body (list->cseq body))) (let* ((pairs (let* ((_a$970 (lambda (acc p) (let fnrec964 ((acc acc) (p p)) (let* ((_a$968 (jolt-conj acc (let* ((_a$965 (var-deref "clojure.core" "__sqcat")) (_a$966 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "var"))) (_a$967 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first p)))) (jolt-invoke _a$965 _a$966 _a$967)))) (_a$969 (jolt-invoke (var-deref "clojure.core" "second") p))) (jolt-conj _a$968 _a$969))))) (_a$971 (jolt-vector)) (_a$972 (jolt-invoke (var-deref "clojure.core" "partition") 2 bindings))) (jolt-reduce _a$970 _a$971 _a$972)))) (let* ((_a$977 (var-deref "clojure.core" "__sqcat")) (_a$978 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "with-redefs-fn"))) (_a$979 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "hash-map")) pairs))) (_a$980 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$973 (var-deref "clojure.core" "__sqcat")) (_a$974 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$975 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$976 body)) (jolt-invoke _a$973 _a$974 _a$975 _a$976))))) (jolt-invoke _a$977 _a$978 _a$979 _a$980))))))
+    (lambda (bindings . body) (let fnrec987 ((bindings bindings) (body (list->cseq body))) (let* ((pairs (let* ((_a$994 (lambda (acc p) (let fnrec988 ((acc acc) (p p)) (let* ((_a$992 (jolt-conj acc (let* ((_a$989 (var-deref "clojure.core" "__sqcat")) (_a$990 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "var"))) (_a$991 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first p)))) (jolt-invoke _a$989 _a$990 _a$991)))) (_a$993 (jolt-invoke (var-deref "clojure.core" "second") p))) (jolt-conj _a$992 _a$993))))) (_a$995 (jolt-vector)) (_a$996 (jolt-invoke (var-deref "clojure.core" "partition") 2 bindings))) (jolt-reduce _a$994 _a$995 _a$996)))) (let* ((_a$1001 (var-deref "clojure.core" "__sqcat")) (_a$1002 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "with-redefs-fn"))) (_a$1003 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "hash-map")) pairs))) (_a$1004 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$997 (var-deref "clojure.core" "__sqcat")) (_a$998 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$999 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1000 body)) (jolt-invoke _a$997 _a$998 _a$999 _a$1000))))) (jolt-invoke _a$1001 _a$1002 _a$1003 _a$1004))))))
   (mark-macro! "clojure.core" "with-redefs"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-local-vars"
-    (lambda (bindings . body) (let fnrec981 ((bindings bindings) (body (list->cseq body))) (let* ((binds (let* ((_a$988 (lambda (acc p) (let fnrec982 ((acc acc) (p p)) (let* ((_a$986 (jolt-conj acc (jolt-first p))) (_a$987 (let* ((_a$983 (var-deref "clojure.core" "__sqcat")) (_a$984 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__local-var"))) (_a$985 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") p)))) (jolt-invoke _a$983 _a$984 _a$985)))) (jolt-conj _a$986 _a$987))))) (_a$989 (jolt-vector)) (_a$990 (jolt-invoke (var-deref "clojure.core" "partition") 2 bindings))) (jolt-reduce _a$988 _a$989 _a$990)))) (let* ((_a$991 (var-deref "clojure.core" "__sqcat")) (_a$992 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$993 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") binds))) (_a$994 body)) (jolt-invoke _a$991 _a$992 _a$993 _a$994))))))
+    (lambda (bindings . body) (let fnrec1005 ((bindings bindings) (body (list->cseq body))) (let* ((binds (let* ((_a$1012 (lambda (acc p) (let fnrec1006 ((acc acc) (p p)) (let* ((_a$1010 (jolt-conj acc (jolt-first p))) (_a$1011 (let* ((_a$1007 (var-deref "clojure.core" "__sqcat")) (_a$1008 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__local-var"))) (_a$1009 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") p)))) (jolt-invoke _a$1007 _a$1008 _a$1009)))) (jolt-conj _a$1010 _a$1011))))) (_a$1013 (jolt-vector)) (_a$1014 (jolt-invoke (var-deref "clojure.core" "partition") 2 bindings))) (jolt-reduce _a$1012 _a$1013 _a$1014)))) (let* ((_a$1015 (var-deref "clojure.core" "__sqcat")) (_a$1016 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1017 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") binds))) (_a$1018 body)) (jolt-invoke _a$1015 _a$1016 _a$1017 _a$1018))))))
   (mark-macro! "clojure.core" "with-local-vars"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-open"
-    (lambda (bindings . body) (let fnrec995 ((bindings bindings) (body (list->cseq body))) (if (jolt-zero? (jolt-count bindings)) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body) (let* ((_a$1013 (var-deref "clojure.core" "__sqcat")) (_a$1014 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1015 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$996 (var-deref "clojure.core" "__sqvec")) (_a$997 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first bindings))) (_a$998 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") bindings)))) (jolt-invoke _a$996 _a$997 _a$998)))) (_a$1016 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1009 (var-deref "clojure.core" "__sqcat")) (_a$1010 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "try"))) (_a$1011 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$999 (var-deref "clojure.core" "__sqcat")) (_a$1000 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "with-open"))) (_a$1001 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "vec") (jolt-drop 2 bindings)))) (_a$1002 body)) (jolt-invoke _a$999 _a$1000 _a$1001 _a$1002)))) (_a$1012 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1006 (var-deref "clojure.core" "__sqcat")) (_a$1007 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "finally"))) (_a$1008 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1003 (var-deref "clojure.core" "__sqcat")) (_a$1004 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__close"))) (_a$1005 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first bindings)))) (jolt-invoke _a$1003 _a$1004 _a$1005))))) (jolt-invoke _a$1006 _a$1007 _a$1008))))) (jolt-invoke _a$1009 _a$1010 _a$1011 _a$1012))))) (jolt-invoke _a$1013 _a$1014 _a$1015 _a$1016))))))
+    (lambda (bindings . body) (let fnrec1019 ((bindings bindings) (body (list->cseq body))) (if (jolt-zero? (jolt-count bindings)) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body) (let* ((_a$1037 (var-deref "clojure.core" "__sqcat")) (_a$1038 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1039 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1020 (var-deref "clojure.core" "__sqvec")) (_a$1021 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first bindings))) (_a$1022 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") bindings)))) (jolt-invoke _a$1020 _a$1021 _a$1022)))) (_a$1040 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1033 (var-deref "clojure.core" "__sqcat")) (_a$1034 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "try"))) (_a$1035 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1023 (var-deref "clojure.core" "__sqcat")) (_a$1024 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "with-open"))) (_a$1025 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "vec") (jolt-drop 2 bindings)))) (_a$1026 body)) (jolt-invoke _a$1023 _a$1024 _a$1025 _a$1026)))) (_a$1036 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1030 (var-deref "clojure.core" "__sqcat")) (_a$1031 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "finally"))) (_a$1032 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1027 (var-deref "clojure.core" "__sqcat")) (_a$1028 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__close"))) (_a$1029 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first bindings)))) (jolt-invoke _a$1027 _a$1028 _a$1029))))) (jolt-invoke _a$1030 _a$1031 _a$1032))))) (jolt-invoke _a$1033 _a$1034 _a$1035 _a$1036))))) (jolt-invoke _a$1037 _a$1038 _a$1039 _a$1040))))))
   (mark-macro! "clojure.core" "with-open"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-precision"
-    (lambda (precision . exprs) (let fnrec1017 ((precision precision) (exprs (list->cseq exprs))) (let* ((body (if (jolt= (keyword #f "rounding") (jolt-first exprs)) (jolt-drop 2 exprs) exprs))) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))))
+    (lambda (precision . exprs) (let fnrec1041 ((precision precision) (exprs (list->cseq exprs))) (let* ((body (if (jolt= (keyword #f "rounding") (jolt-first exprs)) (jolt-drop 2 exprs) exprs))) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body)))))
   (mark-macro! "clojure.core" "with-precision"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-bindings"
-    (lambda (binding-map . body) (let fnrec1018 ((binding-map binding-map) (body (list->cseq body))) (let* ((_a$1023 (var-deref "clojure.core" "__sqcat")) (_a$1024 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "with-bindings*"))) (_a$1025 (jolt-invoke (var-deref "clojure.core" "__sq1") binding-map)) (_a$1026 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1019 (var-deref "clojure.core" "__sqcat")) (_a$1020 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1021 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1022 body)) (jolt-invoke _a$1019 _a$1020 _a$1021 _a$1022))))) (jolt-invoke _a$1023 _a$1024 _a$1025 _a$1026)))))
+    (lambda (binding-map . body) (let fnrec1042 ((binding-map binding-map) (body (list->cseq body))) (let* ((_a$1047 (var-deref "clojure.core" "__sqcat")) (_a$1048 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "with-bindings*"))) (_a$1049 (jolt-invoke (var-deref "clojure.core" "__sq1") binding-map)) (_a$1050 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1043 (var-deref "clojure.core" "__sqcat")) (_a$1044 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1045 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1046 body)) (jolt-invoke _a$1043 _a$1044 _a$1045 _a$1046))))) (jolt-invoke _a$1047 _a$1048 _a$1049 _a$1050)))))
   (mark-macro! "clojure.core" "with-bindings"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "bound-fn"
-    (lambda fntail (let fnrec1027 ((fntail (list->cseq fntail))) (let* ((_a$1028 (var-deref "clojure.core" "__sqcat")) (_a$1029 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "bound-fn*"))) (_a$1030 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn")) fntail)))) (jolt-invoke _a$1028 _a$1029 _a$1030)))))
+    (lambda fntail (let fnrec1051 ((fntail (list->cseq fntail))) (let* ((_a$1052 (var-deref "clojure.core" "__sqcat")) (_a$1053 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "bound-fn*"))) (_a$1054 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn")) fntail)))) (jolt-invoke _a$1052 _a$1053 _a$1054)))))
   (mark-macro! "clojure.core" "bound-fn"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defonce"
-    (lambda (name expr) (let fnrec1031 ((name name) (expr expr)) (let* ((_a$1057 (var-deref "clojure.core" "__sqcat")) (_a$1058 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1059 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1038 (var-deref "clojure.core" "__sqvec")) (_a$1039 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto"))) (_a$1040 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1035 (var-deref "clojure.core" "__sqcat")) (_a$1036 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "resolve"))) (_a$1037 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1032 (var-deref "clojure.core" "__sqcat")) (_a$1033 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$1034 (jolt-invoke (var-deref "clojure.core" "__sq1") name))) (jolt-invoke _a$1032 _a$1033 _a$1034))))) (jolt-invoke _a$1035 _a$1036 _a$1037))))) (jolt-invoke _a$1038 _a$1039 _a$1040)))) (_a$1060 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1052 (var-deref "clojure.core" "__sqcat")) (_a$1053 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1054 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1044 (var-deref "clojure.core" "__sqcat")) (_a$1045 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "and"))) (_a$1046 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto"))) (_a$1047 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1041 (var-deref "clojure.core" "__sqcat")) (_a$1042 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "bound?"))) (_a$1043 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto")))) (jolt-invoke _a$1041 _a$1042 _a$1043))))) (jolt-invoke _a$1044 _a$1045 _a$1046 _a$1047)))) (_a$1055 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto"))) (_a$1056 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1048 (var-deref "clojure.core" "__sqcat")) (_a$1049 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1050 (jolt-invoke (var-deref "clojure.core" "__sq1") name)) (_a$1051 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$1048 _a$1049 _a$1050 _a$1051))))) (jolt-invoke _a$1052 _a$1053 _a$1054 _a$1055 _a$1056))))) (jolt-invoke _a$1057 _a$1058 _a$1059 _a$1060)))))
+    (lambda (name expr) (let fnrec1055 ((name name) (expr expr)) (let* ((_a$1081 (var-deref "clojure.core" "__sqcat")) (_a$1082 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1083 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1062 (var-deref "clojure.core" "__sqvec")) (_a$1063 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto"))) (_a$1064 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1059 (var-deref "clojure.core" "__sqcat")) (_a$1060 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "resolve"))) (_a$1061 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1056 (var-deref "clojure.core" "__sqcat")) (_a$1057 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$1058 (jolt-invoke (var-deref "clojure.core" "__sq1") name))) (jolt-invoke _a$1056 _a$1057 _a$1058))))) (jolt-invoke _a$1059 _a$1060 _a$1061))))) (jolt-invoke _a$1062 _a$1063 _a$1064)))) (_a$1084 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1076 (var-deref "clojure.core" "__sqcat")) (_a$1077 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1078 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1068 (var-deref "clojure.core" "__sqcat")) (_a$1069 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "and"))) (_a$1070 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto"))) (_a$1071 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1065 (var-deref "clojure.core" "__sqcat")) (_a$1066 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "bound?"))) (_a$1067 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto")))) (jolt-invoke _a$1065 _a$1066 _a$1067))))) (jolt-invoke _a$1068 _a$1069 _a$1070 _a$1071)))) (_a$1079 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "v__3__auto"))) (_a$1080 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1072 (var-deref "clojure.core" "__sqcat")) (_a$1073 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1074 (jolt-invoke (var-deref "clojure.core" "__sq1") name)) (_a$1075 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$1072 _a$1073 _a$1074 _a$1075))))) (jolt-invoke _a$1076 _a$1077 _a$1078 _a$1079 _a$1080))))) (jolt-invoke _a$1081 _a$1082 _a$1083 _a$1084)))))
   (mark-macro! "clojure.core" "defonce"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "if-not"
-    (lambda (test then . G__17) (let fnrec1061 ((test test) (then then) (G__17 (list->cseq G__17))) (let* ((G__18 G__17) (_else (jolt-nth G__18 0 jolt-nil))) (let* ((_a$1065 (var-deref "clojure.core" "__sqcat")) (_a$1066 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1067 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1062 (var-deref "clojure.core" "__sqcat")) (_a$1063 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "not"))) (_a$1064 (jolt-invoke (var-deref "clojure.core" "__sq1") test))) (jolt-invoke _a$1062 _a$1063 _a$1064)))) (_a$1068 (jolt-invoke (var-deref "clojure.core" "__sq1") then)) (_a$1069 (jolt-invoke (var-deref "clojure.core" "__sq1") _else))) (jolt-invoke _a$1065 _a$1066 _a$1067 _a$1068 _a$1069))))))
+    (lambda (test then . G__17) (let fnrec1085 ((test test) (then then) (G__17 (list->cseq G__17))) (let* ((G__18 G__17) (_else (jolt-nth G__18 0 jolt-nil))) (let* ((_a$1089 (var-deref "clojure.core" "__sqcat")) (_a$1090 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1091 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1086 (var-deref "clojure.core" "__sqcat")) (_a$1087 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "not"))) (_a$1088 (jolt-invoke (var-deref "clojure.core" "__sq1") test))) (jolt-invoke _a$1086 _a$1087 _a$1088)))) (_a$1092 (jolt-invoke (var-deref "clojure.core" "__sq1") then)) (_a$1093 (jolt-invoke (var-deref "clojure.core" "__sq1") _else))) (jolt-invoke _a$1089 _a$1090 _a$1091 _a$1092 _a$1093))))))
   (mark-macro! "clojure.core" "if-not"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "if-let"
-    (lambda (bindings then . G__19) (let fnrec1070 ((bindings bindings) (then then) (G__19 (list->cseq G__19))) (let* ((G__20 G__19) (_else (jolt-nth G__20 0 jolt-nil))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$1086 (var-deref "clojure.core" "__sqcat")) (_a$1087 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1088 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1071 (var-deref "clojure.core" "__sqvec")) (_a$1072 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__4__auto"))) (_a$1073 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$1071 _a$1072 _a$1073)))) (_a$1089 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1081 (var-deref "clojure.core" "__sqcat")) (_a$1082 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1083 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__4__auto"))) (_a$1084 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1077 (var-deref "clojure.core" "__sqcat")) (_a$1078 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1079 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1074 (var-deref "clojure.core" "__sqvec")) (_a$1075 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$1076 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__4__auto")))) (jolt-invoke _a$1074 _a$1075 _a$1076)))) (_a$1080 (jolt-invoke (var-deref "clojure.core" "__sq1") then))) (jolt-invoke _a$1077 _a$1078 _a$1079 _a$1080)))) (_a$1085 (jolt-invoke (var-deref "clojure.core" "__sq1") _else))) (jolt-invoke _a$1081 _a$1082 _a$1083 _a$1084 _a$1085))))) (jolt-invoke _a$1086 _a$1087 _a$1088 _a$1089)))))))
+    (lambda (bindings then . G__19) (let fnrec1094 ((bindings bindings) (then then) (G__19 (list->cseq G__19))) (let* ((G__20 G__19) (_else (jolt-nth G__20 0 jolt-nil))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$1110 (var-deref "clojure.core" "__sqcat")) (_a$1111 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1112 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1095 (var-deref "clojure.core" "__sqvec")) (_a$1096 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__4__auto"))) (_a$1097 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$1095 _a$1096 _a$1097)))) (_a$1113 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1105 (var-deref "clojure.core" "__sqcat")) (_a$1106 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1107 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__4__auto"))) (_a$1108 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1101 (var-deref "clojure.core" "__sqcat")) (_a$1102 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1103 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1098 (var-deref "clojure.core" "__sqvec")) (_a$1099 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$1100 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__4__auto")))) (jolt-invoke _a$1098 _a$1099 _a$1100)))) (_a$1104 (jolt-invoke (var-deref "clojure.core" "__sq1") then))) (jolt-invoke _a$1101 _a$1102 _a$1103 _a$1104)))) (_a$1109 (jolt-invoke (var-deref "clojure.core" "__sq1") _else))) (jolt-invoke _a$1105 _a$1106 _a$1107 _a$1108 _a$1109))))) (jolt-invoke _a$1110 _a$1111 _a$1112 _a$1113)))))))
   (mark-macro! "clojure.core" "if-let"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "if-some"
-    (lambda (bindings then . G__21) (let fnrec1090 ((bindings bindings) (then then) (G__21 (list->cseq G__21))) (let* ((G__22 G__21) (_else (jolt-nth G__22 0 jolt-nil))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$1109 (var-deref "clojure.core" "__sqcat")) (_a$1110 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1111 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1091 (var-deref "clojure.core" "__sqvec")) (_a$1092 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__5__auto"))) (_a$1093 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$1091 _a$1092 _a$1093)))) (_a$1112 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1104 (var-deref "clojure.core" "__sqcat")) (_a$1105 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1106 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1094 (var-deref "clojure.core" "__sqcat")) (_a$1095 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "some?"))) (_a$1096 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__5__auto")))) (jolt-invoke _a$1094 _a$1095 _a$1096)))) (_a$1107 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1100 (var-deref "clojure.core" "__sqcat")) (_a$1101 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1102 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1097 (var-deref "clojure.core" "__sqvec")) (_a$1098 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$1099 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__5__auto")))) (jolt-invoke _a$1097 _a$1098 _a$1099)))) (_a$1103 (jolt-invoke (var-deref "clojure.core" "__sq1") then))) (jolt-invoke _a$1100 _a$1101 _a$1102 _a$1103)))) (_a$1108 (jolt-invoke (var-deref "clojure.core" "__sq1") _else))) (jolt-invoke _a$1104 _a$1105 _a$1106 _a$1107 _a$1108))))) (jolt-invoke _a$1109 _a$1110 _a$1111 _a$1112)))))))
+    (lambda (bindings then . G__21) (let fnrec1114 ((bindings bindings) (then then) (G__21 (list->cseq G__21))) (let* ((G__22 G__21) (_else (jolt-nth G__22 0 jolt-nil))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$1133 (var-deref "clojure.core" "__sqcat")) (_a$1134 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1135 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1115 (var-deref "clojure.core" "__sqvec")) (_a$1116 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__5__auto"))) (_a$1117 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$1115 _a$1116 _a$1117)))) (_a$1136 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1128 (var-deref "clojure.core" "__sqcat")) (_a$1129 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1130 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1118 (var-deref "clojure.core" "__sqcat")) (_a$1119 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "some?"))) (_a$1120 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__5__auto")))) (jolt-invoke _a$1118 _a$1119 _a$1120)))) (_a$1131 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1124 (var-deref "clojure.core" "__sqcat")) (_a$1125 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1126 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1121 (var-deref "clojure.core" "__sqvec")) (_a$1122 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$1123 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__5__auto")))) (jolt-invoke _a$1121 _a$1122 _a$1123)))) (_a$1127 (jolt-invoke (var-deref "clojure.core" "__sq1") then))) (jolt-invoke _a$1124 _a$1125 _a$1126 _a$1127)))) (_a$1132 (jolt-invoke (var-deref "clojure.core" "__sq1") _else))) (jolt-invoke _a$1128 _a$1129 _a$1130 _a$1131 _a$1132))))) (jolt-invoke _a$1133 _a$1134 _a$1135 _a$1136)))))))
   (mark-macro! "clojure.core" "if-some"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "when-some"
-    (lambda (bindings . body) (let fnrec1113 ((bindings bindings) (body (list->cseq body))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$1132 (var-deref "clojure.core" "__sqcat")) (_a$1133 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1134 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1114 (var-deref "clojure.core" "__sqvec")) (_a$1115 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__6__auto"))) (_a$1116 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$1114 _a$1115 _a$1116)))) (_a$1135 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1127 (var-deref "clojure.core" "__sqcat")) (_a$1128 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1129 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1117 (var-deref "clojure.core" "__sqcat")) (_a$1118 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "some?"))) (_a$1119 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__6__auto")))) (jolt-invoke _a$1117 _a$1118 _a$1119)))) (_a$1130 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1123 (var-deref "clojure.core" "__sqcat")) (_a$1124 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1125 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1120 (var-deref "clojure.core" "__sqvec")) (_a$1121 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$1122 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__6__auto")))) (jolt-invoke _a$1120 _a$1121 _a$1122)))) (_a$1126 body)) (jolt-invoke _a$1123 _a$1124 _a$1125 _a$1126)))) (_a$1131 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$1127 _a$1128 _a$1129 _a$1130 _a$1131))))) (jolt-invoke _a$1132 _a$1133 _a$1134 _a$1135))))))
+    (lambda (bindings . body) (let fnrec1137 ((bindings bindings) (body (list->cseq body))) (let* ((form (jolt-invoke bindings 0)) (tst (jolt-invoke bindings 1))) (let* ((_a$1156 (var-deref "clojure.core" "__sqcat")) (_a$1157 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1158 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1138 (var-deref "clojure.core" "__sqvec")) (_a$1139 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__6__auto"))) (_a$1140 (jolt-invoke (var-deref "clojure.core" "__sq1") tst))) (jolt-invoke _a$1138 _a$1139 _a$1140)))) (_a$1159 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1151 (var-deref "clojure.core" "__sqcat")) (_a$1152 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1153 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1141 (var-deref "clojure.core" "__sqcat")) (_a$1142 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "some?"))) (_a$1143 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__6__auto")))) (jolt-invoke _a$1141 _a$1142 _a$1143)))) (_a$1154 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1147 (var-deref "clojure.core" "__sqcat")) (_a$1148 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1149 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1144 (var-deref "clojure.core" "__sqvec")) (_a$1145 (jolt-invoke (var-deref "clojure.core" "__sq1") form)) (_a$1146 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "temp__6__auto")))) (jolt-invoke _a$1144 _a$1145 _a$1146)))) (_a$1150 body)) (jolt-invoke _a$1147 _a$1148 _a$1149 _a$1150)))) (_a$1155 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil))) (jolt-invoke _a$1151 _a$1152 _a$1153 _a$1154 _a$1155))))) (jolt-invoke _a$1156 _a$1157 _a$1158 _a$1159))))))
   (mark-macro! "clojure.core" "when-some"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "while"
-    (lambda (test . body) (let fnrec1136 ((test test) (body (list->cseq body))) (let* ((_a$1142 (var-deref "clojure.core" "__sqcat")) (_a$1143 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "loop"))) (_a$1144 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1145 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1137 (var-deref "clojure.core" "__sqcat")) (_a$1138 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when"))) (_a$1139 (jolt-invoke (var-deref "clojure.core" "__sq1") test)) (_a$1140 body) (_a$1141 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "recur")))))) (jolt-invoke _a$1137 _a$1138 _a$1139 _a$1140 _a$1141))))) (jolt-invoke _a$1142 _a$1143 _a$1144 _a$1145)))))
+    (lambda (test . body) (let fnrec1160 ((test test) (body (list->cseq body))) (let* ((_a$1166 (var-deref "clojure.core" "__sqcat")) (_a$1167 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "loop"))) (_a$1168 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1169 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1161 (var-deref "clojure.core" "__sqcat")) (_a$1162 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when"))) (_a$1163 (jolt-invoke (var-deref "clojure.core" "__sq1") test)) (_a$1164 body) (_a$1165 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "recur")))))) (jolt-invoke _a$1161 _a$1162 _a$1163 _a$1164 _a$1165))))) (jolt-invoke _a$1166 _a$1167 _a$1168 _a$1169)))))
   (mark-macro! "clojure.core" "while"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "dotimes"
-    (lambda (bindings . body) (let fnrec1146 ((bindings bindings) (body (list->cseq body))) (let* ((i (jolt-invoke bindings 0)) (n (jolt-invoke bindings 1))) (let* ((_a$1172 (var-deref "clojure.core" "__sqcat")) (_a$1173 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1174 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1147 (var-deref "clojure.core" "__sqvec")) (_a$1148 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "n__7__auto"))) (_a$1149 (jolt-invoke (var-deref "clojure.core" "__sq1") n))) (jolt-invoke _a$1147 _a$1148 _a$1149)))) (_a$1175 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1168 (var-deref "clojure.core" "__sqcat")) (_a$1169 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "loop"))) (_a$1170 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1150 (var-deref "clojure.core" "__sqvec")) (_a$1151 (jolt-invoke (var-deref "clojure.core" "__sq1") i)) (_a$1152 (jolt-invoke (var-deref "clojure.core" "__sq1") 0))) (jolt-invoke _a$1150 _a$1151 _a$1152)))) (_a$1171 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1163 (var-deref "clojure.core" "__sqcat")) (_a$1164 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when"))) (_a$1165 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1153 (var-deref "clojure.core" "__sqcat")) (_a$1154 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "<"))) (_a$1155 (jolt-invoke (var-deref "clojure.core" "__sq1") i)) (_a$1156 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "n__7__auto")))) (jolt-invoke _a$1153 _a$1154 _a$1155 _a$1156)))) (_a$1166 body) (_a$1167 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1160 (var-deref "clojure.core" "__sqcat")) (_a$1161 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "recur"))) (_a$1162 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1157 (var-deref "clojure.core" "__sqcat")) (_a$1158 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "inc"))) (_a$1159 (jolt-invoke (var-deref "clojure.core" "__sq1") i))) (jolt-invoke _a$1157 _a$1158 _a$1159))))) (jolt-invoke _a$1160 _a$1161 _a$1162))))) (jolt-invoke _a$1163 _a$1164 _a$1165 _a$1166 _a$1167))))) (jolt-invoke _a$1168 _a$1169 _a$1170 _a$1171))))) (jolt-invoke _a$1172 _a$1173 _a$1174 _a$1175))))))
+    (lambda (bindings . body) (let fnrec1170 ((bindings bindings) (body (list->cseq body))) (let* ((i (jolt-invoke bindings 0)) (n (jolt-invoke bindings 1))) (let* ((_a$1196 (var-deref "clojure.core" "__sqcat")) (_a$1197 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1198 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1171 (var-deref "clojure.core" "__sqvec")) (_a$1172 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "n__7__auto"))) (_a$1173 (jolt-invoke (var-deref "clojure.core" "__sq1") n))) (jolt-invoke _a$1171 _a$1172 _a$1173)))) (_a$1199 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1192 (var-deref "clojure.core" "__sqcat")) (_a$1193 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "loop"))) (_a$1194 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1174 (var-deref "clojure.core" "__sqvec")) (_a$1175 (jolt-invoke (var-deref "clojure.core" "__sq1") i)) (_a$1176 (jolt-invoke (var-deref "clojure.core" "__sq1") 0))) (jolt-invoke _a$1174 _a$1175 _a$1176)))) (_a$1195 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1187 (var-deref "clojure.core" "__sqcat")) (_a$1188 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when"))) (_a$1189 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1177 (var-deref "clojure.core" "__sqcat")) (_a$1178 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "<"))) (_a$1179 (jolt-invoke (var-deref "clojure.core" "__sq1") i)) (_a$1180 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "n__7__auto")))) (jolt-invoke _a$1177 _a$1178 _a$1179 _a$1180)))) (_a$1190 body) (_a$1191 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1184 (var-deref "clojure.core" "__sqcat")) (_a$1185 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "recur"))) (_a$1186 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1181 (var-deref "clojure.core" "__sqcat")) (_a$1182 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "inc"))) (_a$1183 (jolt-invoke (var-deref "clojure.core" "__sq1") i))) (jolt-invoke _a$1181 _a$1182 _a$1183))))) (jolt-invoke _a$1184 _a$1185 _a$1186))))) (jolt-invoke _a$1187 _a$1188 _a$1189 _a$1190 _a$1191))))) (jolt-invoke _a$1192 _a$1193 _a$1194 _a$1195))))) (jolt-invoke _a$1196 _a$1197 _a$1198 _a$1199))))))
   (mark-macro! "clojure.core" "dotimes"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "fresh-sym" (letrec ((fresh-sym (lambda () (let fnrec1176 () (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym")))))))) fresh-sym)))
+  (def-var! "clojure.core" "fresh-sym" (letrec ((fresh-sym (lambda () (let fnrec1200 () (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "gensym")))))))) fresh-sym)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "when-first"
-    (lambda (bindings . body) (let fnrec1177 ((bindings bindings) (body (list->cseq body))) (let* ((x (jolt-invoke bindings 0)) (coll (jolt-invoke bindings 1))) (let* ((_a$1184 (var-deref "clojure.core" "__sqcat")) (_a$1185 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when-let"))) (_a$1186 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1181 (var-deref "clojure.core" "__sqvec")) (_a$1182 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1183 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1178 (var-deref "clojure.core" "__sqcat")) (_a$1179 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "first"))) (_a$1180 (jolt-invoke (var-deref "clojure.core" "__sq1") coll))) (jolt-invoke _a$1178 _a$1179 _a$1180))))) (jolt-invoke _a$1181 _a$1182 _a$1183)))) (_a$1187 body)) (jolt-invoke _a$1184 _a$1185 _a$1186 _a$1187))))))
+    (lambda (bindings . body) (let fnrec1201 ((bindings bindings) (body (list->cseq body))) (let* ((x (jolt-invoke bindings 0)) (coll (jolt-invoke bindings 1))) (let* ((_a$1208 (var-deref "clojure.core" "__sqcat")) (_a$1209 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when-let"))) (_a$1210 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1205 (var-deref "clojure.core" "__sqvec")) (_a$1206 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1207 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1202 (var-deref "clojure.core" "__sqcat")) (_a$1203 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "first"))) (_a$1204 (jolt-invoke (var-deref "clojure.core" "__sq1") coll))) (jolt-invoke _a$1202 _a$1203 _a$1204))))) (jolt-invoke _a$1205 _a$1206 _a$1207)))) (_a$1211 body)) (jolt-invoke _a$1208 _a$1209 _a$1210 _a$1211))))))
   (mark-macro! "clojure.core" "when-first"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "doto"
-    (lambda (x . forms) (let fnrec1188 ((x x) (forms (list->cseq forms))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (jolt-map (lambda (f) (let fnrec1189 ((f f)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") f)) (let* ((_a$1190 jolt-list) (_a$1191 (jolt-first f)) (_a$1192 g) (_a$1193 (jolt-rest f))) (jolt-apply _a$1190 _a$1191 _a$1192 _a$1193)) (jolt-list f g)))) forms))) (let* ((_a$1197 (var-deref "clojure.core" "__sqcat")) (_a$1198 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1199 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1194 (var-deref "clojure.core" "__sqvec")) (_a$1195 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1196 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$1194 _a$1195 _a$1196)))) (_a$1200 steps) (_a$1201 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1197 _a$1198 _a$1199 _a$1200 _a$1201))))))
+    (lambda (x . forms) (let fnrec1212 ((x x) (forms (list->cseq forms))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (jolt-map (lambda (f) (let fnrec1213 ((f f)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") f)) (let* ((_a$1214 jolt-list) (_a$1215 (jolt-first f)) (_a$1216 g) (_a$1217 (jolt-rest f))) (jolt-apply _a$1214 _a$1215 _a$1216 _a$1217)) (jolt-list f g)))) forms))) (let* ((_a$1221 (var-deref "clojure.core" "__sqcat")) (_a$1222 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1223 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1218 (var-deref "clojure.core" "__sqvec")) (_a$1219 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1220 (jolt-invoke (var-deref "clojure.core" "__sq1") x))) (jolt-invoke _a$1218 _a$1219 _a$1220)))) (_a$1224 steps) (_a$1225 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1221 _a$1222 _a$1223 _a$1224 _a$1225))))))
   (mark-macro! "clojure.core" "doto"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "thread-binds" (letrec ((thread-binds (lambda (g steps) (let fnrec1202 ((g g) (steps steps)) (let* ((_a$1204 (lambda (acc s) (let fnrec1203 ((acc acc) (s s)) (jolt-conj (jolt-conj acc g) s)))) (_a$1205 (jolt-vector)) (_a$1206 (jolt-invoke (var-deref "clojure.core" "butlast") steps))) (jolt-reduce _a$1204 _a$1205 _a$1206)))))) thread-binds)))
+  (def-var! "clojure.core" "thread-binds" (letrec ((thread-binds (lambda (g steps) (let fnrec1226 ((g g) (steps steps)) (let* ((_a$1228 (lambda (acc s) (let fnrec1227 ((acc acc) (s s)) (jolt-conj (jolt-conj acc g) s)))) (_a$1229 (jolt-vector)) (_a$1230 (jolt-invoke (var-deref "clojure.core" "butlast") steps))) (jolt-reduce _a$1228 _a$1229 _a$1230)))))) thread-binds)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "as->"
-    (lambda (expr name . forms) (let fnrec1207 ((expr expr) (name name) (forms (list->cseq forms))) (let* ((pairs (let* ((_a$1209 (lambda (acc f) (let fnrec1208 ((acc acc) (f f)) (jolt-conj (jolt-conj acc name) f)))) (_a$1210 (jolt-vector)) (_a$1211 (jolt-invoke (var-deref "clojure.core" "butlast") forms))) (jolt-reduce _a$1209 _a$1210 _a$1211)))) (let* ((_a$1216 (var-deref "clojure.core" "__sqcat")) (_a$1217 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1218 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1212 (var-deref "clojure.core" "__sqvec")) (_a$1213 (jolt-invoke (var-deref "clojure.core" "__sq1") name)) (_a$1214 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1215 pairs)) (jolt-invoke _a$1212 _a$1213 _a$1214 _a$1215)))) (_a$1219 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? forms) name (jolt-last forms))))) (jolt-invoke _a$1216 _a$1217 _a$1218 _a$1219))))))
+    (lambda (expr name . forms) (let fnrec1231 ((expr expr) (name name) (forms (list->cseq forms))) (let* ((pairs (let* ((_a$1233 (lambda (acc f) (let fnrec1232 ((acc acc) (f f)) (jolt-conj (jolt-conj acc name) f)))) (_a$1234 (jolt-vector)) (_a$1235 (jolt-invoke (var-deref "clojure.core" "butlast") forms))) (jolt-reduce _a$1233 _a$1234 _a$1235)))) (let* ((_a$1240 (var-deref "clojure.core" "__sqcat")) (_a$1241 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1242 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1236 (var-deref "clojure.core" "__sqvec")) (_a$1237 (jolt-invoke (var-deref "clojure.core" "__sq1") name)) (_a$1238 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1239 pairs)) (jolt-invoke _a$1236 _a$1237 _a$1238 _a$1239)))) (_a$1243 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? forms) name (jolt-last forms))))) (jolt-invoke _a$1240 _a$1241 _a$1242 _a$1243))))))
   (mark-macro! "clojure.core" "as->"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "some->"
-    (lambda (expr . forms) (let fnrec1220 ((expr expr) (forms (list->cseq forms))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (jolt-map (lambda (f) (let fnrec1221 ((f f)) (let* ((_a$1229 (var-deref "clojure.core" "__sqcat")) (_a$1230 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1231 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1222 (var-deref "clojure.core" "__sqcat")) (_a$1223 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nil?"))) (_a$1224 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1222 _a$1223 _a$1224)))) (_a$1232 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil)) (_a$1233 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1225 (var-deref "clojure.core" "__sqcat")) (_a$1226 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->"))) (_a$1227 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1228 (jolt-invoke (var-deref "clojure.core" "__sq1") f))) (jolt-invoke _a$1225 _a$1226 _a$1227 _a$1228))))) (jolt-invoke _a$1229 _a$1230 _a$1231 _a$1232 _a$1233)))) forms))) (let* ((_a$1238 (var-deref "clojure.core" "__sqcat")) (_a$1239 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1240 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1234 (var-deref "clojure.core" "__sqvec")) (_a$1235 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1236 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1237 (jolt-invoke (var-deref "clojure.core" "thread-binds") g steps))) (jolt-invoke _a$1234 _a$1235 _a$1236 _a$1237)))) (_a$1241 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? steps) g (jolt-last steps))))) (jolt-invoke _a$1238 _a$1239 _a$1240 _a$1241))))))
+    (lambda (expr . forms) (let fnrec1244 ((expr expr) (forms (list->cseq forms))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (jolt-map (lambda (f) (let fnrec1245 ((f f)) (let* ((_a$1253 (var-deref "clojure.core" "__sqcat")) (_a$1254 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1255 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1246 (var-deref "clojure.core" "__sqcat")) (_a$1247 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nil?"))) (_a$1248 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1246 _a$1247 _a$1248)))) (_a$1256 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil)) (_a$1257 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1249 (var-deref "clojure.core" "__sqcat")) (_a$1250 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->"))) (_a$1251 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1252 (jolt-invoke (var-deref "clojure.core" "__sq1") f))) (jolt-invoke _a$1249 _a$1250 _a$1251 _a$1252))))) (jolt-invoke _a$1253 _a$1254 _a$1255 _a$1256 _a$1257)))) forms))) (let* ((_a$1262 (var-deref "clojure.core" "__sqcat")) (_a$1263 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1264 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1258 (var-deref "clojure.core" "__sqvec")) (_a$1259 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1260 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1261 (jolt-invoke (var-deref "clojure.core" "thread-binds") g steps))) (jolt-invoke _a$1258 _a$1259 _a$1260 _a$1261)))) (_a$1265 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? steps) g (jolt-last steps))))) (jolt-invoke _a$1262 _a$1263 _a$1264 _a$1265))))))
   (mark-macro! "clojure.core" "some->"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "some->>"
-    (lambda (expr . forms) (let fnrec1242 ((expr expr) (forms (list->cseq forms))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (jolt-map (lambda (f) (let fnrec1243 ((f f)) (let* ((_a$1251 (var-deref "clojure.core" "__sqcat")) (_a$1252 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1253 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1244 (var-deref "clojure.core" "__sqcat")) (_a$1245 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nil?"))) (_a$1246 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1244 _a$1245 _a$1246)))) (_a$1254 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil)) (_a$1255 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1247 (var-deref "clojure.core" "__sqcat")) (_a$1248 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->>"))) (_a$1249 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1250 (jolt-invoke (var-deref "clojure.core" "__sq1") f))) (jolt-invoke _a$1247 _a$1248 _a$1249 _a$1250))))) (jolt-invoke _a$1251 _a$1252 _a$1253 _a$1254 _a$1255)))) forms))) (let* ((_a$1260 (var-deref "clojure.core" "__sqcat")) (_a$1261 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1262 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1256 (var-deref "clojure.core" "__sqvec")) (_a$1257 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1258 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1259 (jolt-invoke (var-deref "clojure.core" "thread-binds") g steps))) (jolt-invoke _a$1256 _a$1257 _a$1258 _a$1259)))) (_a$1263 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? steps) g (jolt-last steps))))) (jolt-invoke _a$1260 _a$1261 _a$1262 _a$1263))))))
+    (lambda (expr . forms) (let fnrec1266 ((expr expr) (forms (list->cseq forms))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (jolt-map (lambda (f) (let fnrec1267 ((f f)) (let* ((_a$1275 (var-deref "clojure.core" "__sqcat")) (_a$1276 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1277 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1268 (var-deref "clojure.core" "__sqcat")) (_a$1269 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "nil?"))) (_a$1270 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1268 _a$1269 _a$1270)))) (_a$1278 (jolt-invoke (var-deref "clojure.core" "__sq1") jolt-nil)) (_a$1279 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1271 (var-deref "clojure.core" "__sqcat")) (_a$1272 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->>"))) (_a$1273 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1274 (jolt-invoke (var-deref "clojure.core" "__sq1") f))) (jolt-invoke _a$1271 _a$1272 _a$1273 _a$1274))))) (jolt-invoke _a$1275 _a$1276 _a$1277 _a$1278 _a$1279)))) forms))) (let* ((_a$1284 (var-deref "clojure.core" "__sqcat")) (_a$1285 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1286 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1280 (var-deref "clojure.core" "__sqvec")) (_a$1281 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1282 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1283 (jolt-invoke (var-deref "clojure.core" "thread-binds") g steps))) (jolt-invoke _a$1280 _a$1281 _a$1282 _a$1283)))) (_a$1287 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? steps) g (jolt-last steps))))) (jolt-invoke _a$1284 _a$1285 _a$1286 _a$1287))))))
   (mark-macro! "clojure.core" "some->>"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "cond->>"
-    (lambda (expr . clauses) (let fnrec1264 ((expr expr) (clauses (list->cseq clauses))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (let* ((_a$1275 (lambda (pair) (let fnrec1265 ((pair pair)) (let* ((_a$1270 (var-deref "clojure.core" "__sqcat")) (_a$1271 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1272 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first pair))) (_a$1273 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1266 (var-deref "clojure.core" "__sqcat")) (_a$1267 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->>"))) (_a$1268 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1269 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") pair)))) (jolt-invoke _a$1266 _a$1267 _a$1268 _a$1269)))) (_a$1274 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1270 _a$1271 _a$1272 _a$1273 _a$1274))))) (_a$1276 (jolt-invoke (var-deref "clojure.core" "partition") 2 clauses))) (jolt-map _a$1275 _a$1276)))) (let* ((_a$1281 (var-deref "clojure.core" "__sqcat")) (_a$1282 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1283 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1277 (var-deref "clojure.core" "__sqvec")) (_a$1278 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1279 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1280 (jolt-invoke (var-deref "clojure.core" "thread-binds") g steps))) (jolt-invoke _a$1277 _a$1278 _a$1279 _a$1280)))) (_a$1284 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? steps) g (jolt-last steps))))) (jolt-invoke _a$1281 _a$1282 _a$1283 _a$1284))))))
+    (lambda (expr . clauses) (let fnrec1288 ((expr expr) (clauses (list->cseq clauses))) (let* ((g (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (steps (let* ((_a$1299 (lambda (pair) (let fnrec1289 ((pair pair)) (let* ((_a$1294 (var-deref "clojure.core" "__sqcat")) (_a$1295 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1296 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first pair))) (_a$1297 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1290 (var-deref "clojure.core" "__sqcat")) (_a$1291 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "->>"))) (_a$1292 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1293 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") pair)))) (jolt-invoke _a$1290 _a$1291 _a$1292 _a$1293)))) (_a$1298 (jolt-invoke (var-deref "clojure.core" "__sq1") g))) (jolt-invoke _a$1294 _a$1295 _a$1296 _a$1297 _a$1298))))) (_a$1300 (jolt-invoke (var-deref "clojure.core" "partition") 2 clauses))) (jolt-map _a$1299 _a$1300)))) (let* ((_a$1305 (var-deref "clojure.core" "__sqcat")) (_a$1306 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1307 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1301 (var-deref "clojure.core" "__sqvec")) (_a$1302 (jolt-invoke (var-deref "clojure.core" "__sq1") g)) (_a$1303 (jolt-invoke (var-deref "clojure.core" "__sq1") expr)) (_a$1304 (jolt-invoke (var-deref "clojure.core" "thread-binds") g steps))) (jolt-invoke _a$1301 _a$1302 _a$1303 _a$1304)))) (_a$1308 (jolt-invoke (var-deref "clojure.core" "__sq1") (if (jolt-empty? steps) g (jolt-last steps))))) (jolt-invoke _a$1305 _a$1306 _a$1307 _a$1308))))))
   (mark-macro! "clojure.core" "cond->>"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "assert"
-    (lambda (x . G__23) (let fnrec1285 ((x x) (G__23 (list->cseq G__23))) (let* ((G__24 G__23) (message (jolt-nth G__24 0 jolt-nil))) (let* ((msg (if (jolt-truthy? message) message (jolt-invoke (var-deref "clojure.core" "str") "Assert failed: " (jolt-invoke (var-deref "clojure.core" "pr-str") x))))) (let* ((_a$1293 (var-deref "clojure.core" "__sqcat")) (_a$1294 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when-not"))) (_a$1295 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1296 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1290 (var-deref "clojure.core" "__sqcat")) (_a$1291 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "throw"))) (_a$1292 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1286 (var-deref "clojure.core" "__sqcat")) (_a$1287 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "ex-info"))) (_a$1288 (jolt-invoke (var-deref "clojure.core" "__sq1") msg)) (_a$1289 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$1286 _a$1287 _a$1288 _a$1289))))) (jolt-invoke _a$1290 _a$1291 _a$1292))))) (jolt-invoke _a$1293 _a$1294 _a$1295 _a$1296)))))))
+    (lambda (x . G__23) (let fnrec1309 ((x x) (G__23 (list->cseq G__23))) (let* ((G__24 G__23) (message (jolt-nth G__24 0 jolt-nil))) (let* ((msg (if (jolt-truthy? message) message (jolt-invoke (var-deref "clojure.core" "str") "Assert failed: " (jolt-invoke (var-deref "clojure.core" "pr-str") x))))) (let* ((_a$1317 (var-deref "clojure.core" "__sqcat")) (_a$1318 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "when-not"))) (_a$1319 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1320 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1314 (var-deref "clojure.core" "__sqcat")) (_a$1315 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "throw"))) (_a$1316 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1310 (var-deref "clojure.core" "__sqcat")) (_a$1311 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "ex-info"))) (_a$1312 (jolt-invoke (var-deref "clojure.core" "__sq1") msg)) (_a$1313 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$1310 _a$1311 _a$1312 _a$1313))))) (jolt-invoke _a$1314 _a$1315 _a$1316))))) (jolt-invoke _a$1317 _a$1318 _a$1319 _a$1320)))))))
   (mark-macro! "clojure.core" "assert"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "pvalues"
-    (lambda exprs (let fnrec1297 ((exprs (list->cseq exprs))) (let* ((_a$1303 (var-deref "clojure.core" "__sqcat")) (_a$1304 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "pcalls"))) (_a$1305 (jolt-map (lambda (e) (let fnrec1298 ((e e)) (let* ((_a$1299 (var-deref "clojure.core" "__sqcat")) (_a$1300 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1301 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1302 (jolt-invoke (var-deref "clojure.core" "__sq1") e))) (jolt-invoke _a$1299 _a$1300 _a$1301 _a$1302)))) exprs))) (jolt-invoke _a$1303 _a$1304 _a$1305)))))
+    (lambda exprs (let fnrec1321 ((exprs (list->cseq exprs))) (let* ((_a$1327 (var-deref "clojure.core" "__sqcat")) (_a$1328 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "pcalls"))) (_a$1329 (jolt-map (lambda (e) (let fnrec1322 ((e e)) (let* ((_a$1323 (var-deref "clojure.core" "__sqcat")) (_a$1324 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1325 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1326 (jolt-invoke (var-deref "clojure.core" "__sq1") e))) (jolt-invoke _a$1323 _a$1324 _a$1325 _a$1326)))) exprs))) (jolt-invoke _a$1327 _a$1328 _a$1329)))))
   (mark-macro! "clojure.core" "pvalues"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "delay"
-    (lambda body (let fnrec1306 ((body (list->cseq body))) (let* ((_a$1311 (var-deref "clojure.core" "__sqcat")) (_a$1312 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-delay"))) (_a$1313 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1307 (var-deref "clojure.core" "__sqcat")) (_a$1308 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1309 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1310 body)) (jolt-invoke _a$1307 _a$1308 _a$1309 _a$1310))))) (jolt-invoke _a$1311 _a$1312 _a$1313)))))
+    (lambda body (let fnrec1330 ((body (list->cseq body))) (let* ((_a$1335 (var-deref "clojure.core" "__sqcat")) (_a$1336 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-delay"))) (_a$1337 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1331 (var-deref "clojure.core" "__sqcat")) (_a$1332 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1333 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1334 body)) (jolt-invoke _a$1331 _a$1332 _a$1333 _a$1334))))) (jolt-invoke _a$1335 _a$1336 _a$1337)))))
   (mark-macro! "clojure.core" "delay"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "future"
-    (lambda body (let fnrec1314 ((body (list->cseq body))) (let* ((_a$1319 (var-deref "clojure.core" "__sqcat")) (_a$1320 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "future-call"))) (_a$1321 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1315 (var-deref "clojure.core" "__sqcat")) (_a$1316 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1317 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1318 body)) (jolt-invoke _a$1315 _a$1316 _a$1317 _a$1318))))) (jolt-invoke _a$1319 _a$1320 _a$1321)))))
+    (lambda body (let fnrec1338 ((body (list->cseq body))) (let* ((_a$1343 (var-deref "clojure.core" "__sqcat")) (_a$1344 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "future-call"))) (_a$1345 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1339 (var-deref "clojure.core" "__sqcat")) (_a$1340 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1341 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec")))) (_a$1342 body)) (jolt-invoke _a$1339 _a$1340 _a$1341 _a$1342))))) (jolt-invoke _a$1343 _a$1344 _a$1345)))))
   (mark-macro! "clojure.core" "future"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "binding"
-    (lambda (bindings . body) (let fnrec1322 ((bindings bindings) (body (list->cseq body))) (let* ((pairs (let* ((_a$1329 (lambda (acc p) (let fnrec1323 ((acc acc) (p p)) (let* ((_a$1327 (jolt-conj acc (let* ((_a$1324 (var-deref "clojure.core" "__sqcat")) (_a$1325 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "var"))) (_a$1326 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first p)))) (jolt-invoke _a$1324 _a$1325 _a$1326)))) (_a$1328 (jolt-invoke (var-deref "clojure.core" "second") p))) (jolt-conj _a$1327 _a$1328))))) (_a$1330 (jolt-vector)) (_a$1331 (jolt-invoke (var-deref "clojure.core" "partition") 2 bindings))) (jolt-reduce _a$1329 _a$1330 _a$1331)))) (let* ((_a$1345 (var-deref "clojure.core" "__sqcat")) (_a$1346 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$1347 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1332 (var-deref "clojure.core" "__sqvec")) (_a$1333 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "frame__8__auto"))) (_a$1334 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "array-map")) pairs)))) (jolt-invoke _a$1332 _a$1333 _a$1334)))) (_a$1348 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1335 (var-deref "clojure.core" "__sqcat")) (_a$1336 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "push-thread-bindings"))) (_a$1337 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "frame__8__auto")))) (jolt-invoke _a$1335 _a$1336 _a$1337)))) (_a$1349 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1341 (var-deref "clojure.core" "__sqcat")) (_a$1342 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "try"))) (_a$1343 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body))) (_a$1344 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1338 (var-deref "clojure.core" "__sqcat")) (_a$1339 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "finally"))) (_a$1340 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "pop-thread-bindings")))))) (jolt-invoke _a$1338 _a$1339 _a$1340))))) (jolt-invoke _a$1341 _a$1342 _a$1343 _a$1344))))) (jolt-invoke _a$1345 _a$1346 _a$1347 _a$1348 _a$1349))))))
+    (lambda (bindings . body) (let fnrec1346 ((bindings bindings) (body (list->cseq body))) (let* ((pairs (let* ((_a$1353 (lambda (acc p) (let fnrec1347 ((acc acc) (p p)) (let* ((_a$1351 (jolt-conj acc (let* ((_a$1348 (var-deref "clojure.core" "__sqcat")) (_a$1349 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "var"))) (_a$1350 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first p)))) (jolt-invoke _a$1348 _a$1349 _a$1350)))) (_a$1352 (jolt-invoke (var-deref "clojure.core" "second") p))) (jolt-conj _a$1351 _a$1352))))) (_a$1354 (jolt-vector)) (_a$1355 (jolt-invoke (var-deref "clojure.core" "partition") 2 bindings))) (jolt-reduce _a$1353 _a$1354 _a$1355)))) (let* ((_a$1369 (var-deref "clojure.core" "__sqcat")) (_a$1370 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "let*"))) (_a$1371 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1356 (var-deref "clojure.core" "__sqvec")) (_a$1357 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "frame__8__auto"))) (_a$1358 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "array-map")) pairs)))) (jolt-invoke _a$1356 _a$1357 _a$1358)))) (_a$1372 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1359 (var-deref "clojure.core" "__sqcat")) (_a$1360 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "push-thread-bindings"))) (_a$1361 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "frame__8__auto")))) (jolt-invoke _a$1359 _a$1360 _a$1361)))) (_a$1373 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1365 (var-deref "clojure.core" "__sqcat")) (_a$1366 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "try"))) (_a$1367 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) body))) (_a$1368 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1362 (var-deref "clojure.core" "__sqcat")) (_a$1363 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "finally"))) (_a$1364 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "pop-thread-bindings")))))) (jolt-invoke _a$1362 _a$1363 _a$1364))))) (jolt-invoke _a$1365 _a$1366 _a$1367 _a$1368))))) (jolt-invoke _a$1369 _a$1370 _a$1371 _a$1372 _a$1373))))))
   (mark-macro! "clojure.core" "binding"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "condp"
-    (lambda (pred expr . clauses) (let fnrec1350 ((pred pred) (expr expr) (clauses (list->cseq clauses))) (let* ((gp (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (ge (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (emit (letrec ((emit (lambda (args) (let fnrec1351 ((args args)) (let* ((n (if (jolt= (keyword #f ">>") (jolt-invoke (var-deref "clojure.core" "second") args)) 3 2)) (clause (jolt-take n args)) (more (jolt-drop n args)) (cn (jolt-count clause))) (if (jolt= 0 cn) (let* ((_a$1360 (var-deref "clojure.core" "__sqcat")) (_a$1361 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "throw"))) (_a$1362 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1356 (var-deref "clojure.core" "__sqcat")) (_a$1357 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "ex-info"))) (_a$1358 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1352 (var-deref "clojure.core" "__sqcat")) (_a$1353 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "str"))) (_a$1354 (jolt-invoke (var-deref "clojure.core" "__sq1") "No matching clause: ")) (_a$1355 (jolt-invoke (var-deref "clojure.core" "__sq1") ge))) (jolt-invoke _a$1352 _a$1353 _a$1354 _a$1355)))) (_a$1359 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$1356 _a$1357 _a$1358 _a$1359))))) (jolt-invoke _a$1360 _a$1361 _a$1362)) (if (jolt= 1 cn) (jolt-first clause) (if (jolt= 2 cn) (let* ((_a$1367 (var-deref "clojure.core" "__sqcat")) (_a$1368 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1369 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1363 (var-deref "clojure.core" "__sqcat")) (_a$1364 (jolt-invoke (var-deref "clojure.core" "__sq1") gp)) (_a$1365 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first clause))) (_a$1366 (jolt-invoke (var-deref "clojure.core" "__sq1") ge))) (jolt-invoke _a$1363 _a$1364 _a$1365 _a$1366)))) (_a$1370 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") clause))) (_a$1371 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke emit more)))) (jolt-invoke _a$1367 _a$1368 _a$1369 _a$1370 _a$1371)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$1382 (var-deref "clojure.core" "__sqcat")) (_a$1383 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "if-let"))) (_a$1384 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1376 (var-deref "clojure.core" "__sqvec")) (_a$1377 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "p__9__auto"))) (_a$1378 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1372 (var-deref "clojure.core" "__sqcat")) (_a$1373 (jolt-invoke (var-deref "clojure.core" "__sq1") gp)) (_a$1374 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first clause))) (_a$1375 (jolt-invoke (var-deref "clojure.core" "__sq1") ge))) (jolt-invoke _a$1372 _a$1373 _a$1374 _a$1375))))) (jolt-invoke _a$1376 _a$1377 _a$1378)))) (_a$1385 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1379 (var-deref "clojure.core" "__sqcat")) (_a$1380 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth clause 2))) (_a$1381 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "p__9__auto")))) (jolt-invoke _a$1379 _a$1380 _a$1381)))) (_a$1386 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke emit more)))) (jolt-invoke _a$1382 _a$1383 _a$1384 _a$1385 _a$1386)) jolt-nil))))))))) emit))) (let* ((_a$1392 (var-deref "clojure.core" "__sqcat")) (_a$1393 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1394 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1387 (var-deref "clojure.core" "__sqvec")) (_a$1388 (jolt-invoke (var-deref "clojure.core" "__sq1") gp)) (_a$1389 (jolt-invoke (var-deref "clojure.core" "__sq1") pred)) (_a$1390 (jolt-invoke (var-deref "clojure.core" "__sq1") ge)) (_a$1391 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$1387 _a$1388 _a$1389 _a$1390 _a$1391)))) (_a$1395 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke emit clauses)))) (jolt-invoke _a$1392 _a$1393 _a$1394 _a$1395))))))
+    (lambda (pred expr . clauses) (let fnrec1374 ((pred pred) (expr expr) (clauses (list->cseq clauses))) (let* ((gp (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (ge (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (emit (letrec ((emit (lambda (args) (let fnrec1375 ((args args)) (let* ((n (if (jolt= (keyword #f ">>") (jolt-invoke (var-deref "clojure.core" "second") args)) 3 2)) (clause (jolt-take n args)) (more (jolt-drop n args)) (cn (jolt-count clause))) (if (jolt= 0 cn) (let* ((_a$1384 (var-deref "clojure.core" "__sqcat")) (_a$1385 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "throw"))) (_a$1386 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1380 (var-deref "clojure.core" "__sqcat")) (_a$1381 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "ex-info"))) (_a$1382 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1376 (var-deref "clojure.core" "__sqcat")) (_a$1377 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "str"))) (_a$1378 (jolt-invoke (var-deref "clojure.core" "__sq1") "No matching clause: ")) (_a$1379 (jolt-invoke (var-deref "clojure.core" "__sq1") ge))) (jolt-invoke _a$1376 _a$1377 _a$1378 _a$1379)))) (_a$1383 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$1380 _a$1381 _a$1382 _a$1383))))) (jolt-invoke _a$1384 _a$1385 _a$1386)) (if (jolt= 1 cn) (jolt-first clause) (if (jolt= 2 cn) (let* ((_a$1391 (var-deref "clojure.core" "__sqcat")) (_a$1392 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "if"))) (_a$1393 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1387 (var-deref "clojure.core" "__sqcat")) (_a$1388 (jolt-invoke (var-deref "clojure.core" "__sq1") gp)) (_a$1389 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first clause))) (_a$1390 (jolt-invoke (var-deref "clojure.core" "__sq1") ge))) (jolt-invoke _a$1387 _a$1388 _a$1389 _a$1390)))) (_a$1394 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "second") clause))) (_a$1395 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke emit more)))) (jolt-invoke _a$1391 _a$1392 _a$1393 _a$1394 _a$1395)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$1406 (var-deref "clojure.core" "__sqcat")) (_a$1407 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "if-let"))) (_a$1408 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1400 (var-deref "clojure.core" "__sqvec")) (_a$1401 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "p__9__auto"))) (_a$1402 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1396 (var-deref "clojure.core" "__sqcat")) (_a$1397 (jolt-invoke (var-deref "clojure.core" "__sq1") gp)) (_a$1398 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first clause))) (_a$1399 (jolt-invoke (var-deref "clojure.core" "__sq1") ge))) (jolt-invoke _a$1396 _a$1397 _a$1398 _a$1399))))) (jolt-invoke _a$1400 _a$1401 _a$1402)))) (_a$1409 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1403 (var-deref "clojure.core" "__sqcat")) (_a$1404 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth clause 2))) (_a$1405 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "p__9__auto")))) (jolt-invoke _a$1403 _a$1404 _a$1405)))) (_a$1410 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke emit more)))) (jolt-invoke _a$1406 _a$1407 _a$1408 _a$1409 _a$1410)) jolt-nil))))))))) emit))) (let* ((_a$1416 (var-deref "clojure.core" "__sqcat")) (_a$1417 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1418 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1411 (var-deref "clojure.core" "__sqvec")) (_a$1412 (jolt-invoke (var-deref "clojure.core" "__sq1") gp)) (_a$1413 (jolt-invoke (var-deref "clojure.core" "__sq1") pred)) (_a$1414 (jolt-invoke (var-deref "clojure.core" "__sq1") ge)) (_a$1415 (jolt-invoke (var-deref "clojure.core" "__sq1") expr))) (jolt-invoke _a$1411 _a$1412 _a$1413 _a$1414 _a$1415)))) (_a$1419 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke emit clauses)))) (jolt-invoke _a$1416 _a$1417 _a$1418 _a$1419))))))
   (mark-macro! "clojure.core" "condp"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "group-by-head" (letrec ((group-by-head (lambda (items) (let fnrec1396 ((items items)) (let* ((_a$1400 (lambda (acc x) (let fnrec1397 ((acc acc) (x x)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") x)))) (jolt-conj acc (jolt-vector x)) (let* ((_a$1398 (jolt-pop acc)) (_a$1399 (jolt-conj (jolt-peek acc) x))) (jolt-conj _a$1398 _a$1399)))))) (_a$1401 (jolt-vector)) (_a$1402 items)) (jolt-reduce _a$1400 _a$1401 _a$1402)))))) group-by-head)))
+  (def-var! "clojure.core" "group-by-head" (letrec ((group-by-head (lambda (items) (let fnrec1420 ((items items)) (let* ((_a$1424 (lambda (acc x) (let fnrec1421 ((acc acc) (x x)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "symbol?") x))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") x)))) (jolt-conj acc (jolt-vector x)) (let* ((_a$1422 (jolt-pop acc)) (_a$1423 (jolt-conj (jolt-peek acc) x))) (jolt-conj _a$1422 _a$1423)))))) (_a$1425 (jolt-vector)) (_a$1426 items)) (jolt-reduce _a$1424 _a$1425 _a$1426)))))) group-by-head)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "deftype"
-    (lambda (tname fields . body) (let fnrec1403 ((tname tname) (fields fields) (body (list->cseq body))) (let* ((unwrap (lambda (x) (let fnrec1404 ((x x)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "seq?") x))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first x)))) (if (jolt-truthy? and__13__auto) (jolt= "with-meta" (jolt-invoke (var-deref "clojure.core" "name") (jolt-first x))) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "second") x) x)))) (tname (jolt-invoke unwrap tname)) (fields (jolt-map unwrap fields)) (arrow (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "->" (jolt-invoke (var-deref "clojure.core" "name") tname)))) (field-kws (jolt-map (lambda (f) (let fnrec1405 ((f f)) (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f)))) fields)) (field-tags (jolt-map (lambda (f) (let fnrec1406 ((f f)) (let* ((mt (jolt-invoke (var-deref "clojure.core" "meta") f))) (if (jolt-truthy? (let* ((and__13__auto mt)) (if (jolt-truthy? and__13__auto) (jolt-get mt (keyword #f "tag")) and__13__auto))) (jolt-get mt (keyword #f "tag")) (if (jolt-truthy? (let* ((and__13__auto mt)) (if (jolt-truthy? and__13__auto) (jolt-get mt (keyword #f "num")) and__13__auto))) "num" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))) fields)) (field-muts (jolt-map (lambda (f) (let fnrec1407 ((f f)) (let* ((mt (jolt-invoke (var-deref "clojure.core" "meta") f))) (if (jolt-truthy? (let* ((and__13__auto mt)) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt-get mt (keyword #f "unsynchronized-mutable")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-get mt (keyword #f "volatile-mutable")))) and__13__auto))) #t #f)))) fields)) (mutable-syms (jolt-map jolt-first (jolt-filter (var-deref "clojure.core" "second") (jolt-map jolt-vector fields field-muts)))) (mutable? (lambda (s) (let fnrec1408 ((s s)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-invoke (var-deref "clojure.core" "some") (lambda (m) (let fnrec1409 ((m m)) (jolt= m s))) mutable-syms))))) (rewrite-set (letrec ((rw (lambda (inst form) (let fnrec1410 ((inst inst) (form form)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "seq?") form))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-seq form))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first form)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "set!" (jolt-invoke (var-deref "clojure.core" "name") (jolt-first form))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-invoke (var-deref "clojure.core" "second") form)))) (if (jolt-truthy? and__13__auto) (jolt-invoke mutable? (jolt-invoke (var-deref "clojure.core" "second") form)) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto))) (let* ((_a$1411 (jolt-symbol #f "set!")) (_a$1412 (jolt-list (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") ".-" (jolt-invoke (var-deref "clojure.core" "name") (jolt-invoke (var-deref "clojure.core" "second") form)))) inst)) (_a$1413 (jolt-invoke rw inst (jolt-nth form 2)))) (jolt-list _a$1411 _a$1412 _a$1413)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-map (lambda (x) (let fnrec1414 ((x x)) (jolt-invoke rw inst x))) form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (x) (let fnrec1415 ((x x)) (jolt-invoke rw inst x))) form) (if (jolt-truthy? (keyword #f "else")) form jolt-nil)))))))) rw)) (impl (lambda (proto specs) (let fnrec1416 ((proto proto) (specs specs)) (let* ((_a$1442 (var-deref "clojure.core" "__sqcat")) (_a$1443 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1444 (jolt-map (lambda (spec) (let fnrec1417 ((spec spec)) (let* ((argv (jolt-nth spec 1)) (inst (jolt-first argv)) (binds (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (f) (let fnrec1418 ((f f)) (let* ((_o$1423 f) (_o$1424 (let* ((_a$1419 (var-deref "clojure.core" "__sqcat")) (_a$1420 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$1421 (jolt-invoke (var-deref "clojure.core" "__sq1") inst)) (_a$1422 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f))))) (jolt-invoke _a$1419 _a$1420 _a$1421 _a$1422)))) (jolt-vector _o$1423 _o$1424)))) fields))) (mbody (let* ((_a$1426 (lambda (bf) (let fnrec1425 ((bf bf)) (jolt-invoke rewrite-set inst bf)))) (_a$1427 (jolt-drop 2 spec))) (jolt-map _a$1426 _a$1427)))) (let* ((_a$1436 (var-deref "clojure.core" "__sqcat")) (_a$1437 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-inline-method"))) (_a$1438 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") tname))) (_a$1439 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") proto))) (_a$1440 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first spec)))) (_a$1441 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1432 (var-deref "clojure.core" "__sqcat")) (_a$1433 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1434 (jolt-invoke (var-deref "clojure.core" "__sq1") argv)) (_a$1435 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1428 (var-deref "clojure.core" "__sqcat")) (_a$1429 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1430 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") binds))) (_a$1431 mbody)) (jolt-invoke _a$1428 _a$1429 _a$1430 _a$1431))))) (jolt-invoke _a$1432 _a$1433 _a$1434 _a$1435))))) (jolt-invoke _a$1436 _a$1437 _a$1438 _a$1439 _a$1440 _a$1441))))) specs))) (jolt-invoke _a$1442 _a$1443 _a$1444)))))) (let* ((_a$1468 (var-deref "clojure.core" "__sqcat")) (_a$1469 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1470 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1454 (var-deref "clojure.core" "__sqcat")) (_a$1455 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1456 (jolt-invoke (var-deref "clojure.core" "__sq1") tname)) (_a$1457 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1448 (var-deref "clojure.core" "__sqcat")) (_a$1449 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-deftype-ctor"))) (_a$1450 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1445 (var-deref "clojure.core" "__sqcat")) (_a$1446 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$1447 (jolt-invoke (var-deref "clojure.core" "__sq1") tname))) (jolt-invoke _a$1445 _a$1446 _a$1447)))) (_a$1451 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") field-kws))) (_a$1452 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") field-tags))) (_a$1453 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") field-muts)))) (jolt-invoke _a$1448 _a$1449 _a$1450 _a$1451 _a$1452 _a$1453))))) (jolt-invoke _a$1454 _a$1455 _a$1456 _a$1457)))) (_a$1471 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1458 (var-deref "clojure.core" "__sqcat")) (_a$1459 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1460 (jolt-invoke (var-deref "clojure.core" "__sq1") arrow)) (_a$1461 (jolt-invoke (var-deref "clojure.core" "__sq1") tname))) (jolt-invoke _a$1458 _a$1459 _a$1460 _a$1461)))) (_a$1472 (let* ((_a$1466 (lambda (g) (let fnrec1462 ((g g)) (let* ((_a$1463 impl) (_a$1464 (jolt-first g)) (_a$1465 (jolt-rest g))) (jolt-invoke _a$1463 _a$1464 _a$1465))))) (_a$1467 (jolt-invoke (var-deref "clojure.core" "group-by-head") body))) (jolt-map _a$1466 _a$1467))) (_a$1473 (jolt-invoke (var-deref "clojure.core" "__sq1") tname))) (jolt-invoke _a$1468 _a$1469 _a$1470 _a$1471 _a$1472 _a$1473))))))
+    (lambda (tname fields . body) (let fnrec1427 ((tname tname) (fields fields) (body (list->cseq body))) (let* ((unwrap (lambda (x) (let fnrec1428 ((x x)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "seq?") x))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first x)))) (if (jolt-truthy? and__13__auto) (jolt= "with-meta" (jolt-invoke (var-deref "clojure.core" "name") (jolt-first x))) and__13__auto)) and__13__auto))) (jolt-invoke (var-deref "clojure.core" "second") x) x)))) (tname (jolt-invoke unwrap tname)) (fields (jolt-map unwrap fields)) (arrow (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "->" (jolt-invoke (var-deref "clojure.core" "name") tname)))) (field-kws (jolt-map (lambda (f) (let fnrec1429 ((f f)) (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f)))) fields)) (field-tags (jolt-map (lambda (f) (let fnrec1430 ((f f)) (let* ((mt (jolt-invoke (var-deref "clojure.core" "meta") f))) (if (jolt-truthy? (let* ((and__13__auto mt)) (if (jolt-truthy? and__13__auto) (jolt-get mt (keyword #f "tag")) and__13__auto))) (jolt-get mt (keyword #f "tag")) (if (jolt-truthy? (let* ((and__13__auto mt)) (if (jolt-truthy? and__13__auto) (jolt-get mt (keyword #f "num")) and__13__auto))) "num" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))) fields)) (field-muts (jolt-map (lambda (f) (let fnrec1431 ((f f)) (let* ((mt (jolt-invoke (var-deref "clojure.core" "meta") f))) (if (jolt-truthy? (let* ((and__13__auto mt)) (if (jolt-truthy? and__13__auto) (let* ((or__14__auto (jolt-get mt (keyword #f "unsynchronized-mutable")))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-get mt (keyword #f "volatile-mutable")))) and__13__auto))) #t #f)))) fields)) (mutable-syms (jolt-map jolt-first (jolt-filter (var-deref "clojure.core" "second") (jolt-map jolt-vector fields field-muts)))) (mutable? (lambda (s) (let fnrec1432 ((s s)) (jolt-invoke (var-deref "clojure.core" "boolean") (jolt-invoke (var-deref "clojure.core" "some") (lambda (m) (let fnrec1433 ((m m)) (jolt= m s))) mutable-syms))))) (rewrite-set (letrec ((rw (lambda (inst form) (let fnrec1434 ((inst inst) (form form)) (if (jolt-truthy? (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "seq?") form))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-seq form))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-first form)))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt= "set!" (jolt-invoke (var-deref "clojure.core" "name") (jolt-first form))))) (if (jolt-truthy? and__13__auto) (let* ((and__13__auto (jolt-invoke (var-deref "clojure.core" "symbol?") (jolt-invoke (var-deref "clojure.core" "second") form)))) (if (jolt-truthy? and__13__auto) (jolt-invoke mutable? (jolt-invoke (var-deref "clojure.core" "second") form)) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto)) and__13__auto))) (let* ((_a$1435 (jolt-symbol #f "set!")) (_a$1436 (jolt-list (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") ".-" (jolt-invoke (var-deref "clojure.core" "name") (jolt-invoke (var-deref "clojure.core" "second") form)))) inst)) (_a$1437 (jolt-invoke rw inst (jolt-nth form 2)))) (jolt-list _a$1435 _a$1436 _a$1437)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-map (lambda (x) (let fnrec1438 ((x x)) (jolt-invoke rw inst x))) form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (x) (let fnrec1439 ((x x)) (jolt-invoke rw inst x))) form) (if (jolt-truthy? (keyword #f "else")) form jolt-nil)))))))) rw)) (impl (lambda (proto specs) (let fnrec1440 ((proto proto) (specs specs)) (let* ((_a$1466 (var-deref "clojure.core" "__sqcat")) (_a$1467 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1468 (jolt-map (lambda (spec) (let fnrec1441 ((spec spec)) (let* ((argv (jolt-nth spec 1)) (inst (jolt-first argv)) (binds (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (f) (let fnrec1442 ((f f)) (let* ((_o$1447 f) (_o$1448 (let* ((_a$1443 (var-deref "clojure.core" "__sqcat")) (_a$1444 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$1445 (jolt-invoke (var-deref "clojure.core" "__sq1") inst)) (_a$1446 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f))))) (jolt-invoke _a$1443 _a$1444 _a$1445 _a$1446)))) (jolt-vector _o$1447 _o$1448)))) fields))) (mbody (let* ((_a$1450 (lambda (bf) (let fnrec1449 ((bf bf)) (jolt-invoke rewrite-set inst bf)))) (_a$1451 (jolt-drop 2 spec))) (jolt-map _a$1450 _a$1451)))) (let* ((_a$1460 (var-deref "clojure.core" "__sqcat")) (_a$1461 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-inline-method"))) (_a$1462 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") tname))) (_a$1463 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") proto))) (_a$1464 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first spec)))) (_a$1465 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1456 (var-deref "clojure.core" "__sqcat")) (_a$1457 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1458 (jolt-invoke (var-deref "clojure.core" "__sq1") argv)) (_a$1459 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1452 (var-deref "clojure.core" "__sqcat")) (_a$1453 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1454 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") binds))) (_a$1455 mbody)) (jolt-invoke _a$1452 _a$1453 _a$1454 _a$1455))))) (jolt-invoke _a$1456 _a$1457 _a$1458 _a$1459))))) (jolt-invoke _a$1460 _a$1461 _a$1462 _a$1463 _a$1464 _a$1465))))) specs))) (jolt-invoke _a$1466 _a$1467 _a$1468)))))) (let* ((_a$1492 (var-deref "clojure.core" "__sqcat")) (_a$1493 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1494 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1478 (var-deref "clojure.core" "__sqcat")) (_a$1479 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1480 (jolt-invoke (var-deref "clojure.core" "__sq1") tname)) (_a$1481 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1472 (var-deref "clojure.core" "__sqcat")) (_a$1473 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-deftype-ctor"))) (_a$1474 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1469 (var-deref "clojure.core" "__sqcat")) (_a$1470 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$1471 (jolt-invoke (var-deref "clojure.core" "__sq1") tname))) (jolt-invoke _a$1469 _a$1470 _a$1471)))) (_a$1475 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") field-kws))) (_a$1476 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") field-tags))) (_a$1477 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") field-muts)))) (jolt-invoke _a$1472 _a$1473 _a$1474 _a$1475 _a$1476 _a$1477))))) (jolt-invoke _a$1478 _a$1479 _a$1480 _a$1481)))) (_a$1495 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1482 (var-deref "clojure.core" "__sqcat")) (_a$1483 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1484 (jolt-invoke (var-deref "clojure.core" "__sq1") arrow)) (_a$1485 (jolt-invoke (var-deref "clojure.core" "__sq1") tname))) (jolt-invoke _a$1482 _a$1483 _a$1484 _a$1485)))) (_a$1496 (let* ((_a$1490 (lambda (g) (let fnrec1486 ((g g)) (let* ((_a$1487 impl) (_a$1488 (jolt-first g)) (_a$1489 (jolt-rest g))) (jolt-invoke _a$1487 _a$1488 _a$1489))))) (_a$1491 (jolt-invoke (var-deref "clojure.core" "group-by-head") body))) (jolt-map _a$1490 _a$1491))) (_a$1497 (jolt-invoke (var-deref "clojure.core" "__sq1") tname))) (jolt-invoke _a$1492 _a$1493 _a$1494 _a$1495 _a$1496 _a$1497))))))
   (mark-macro! "clojure.core" "deftype"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defprotocol"
-    (lambda (pname . sigs) (let fnrec1474 ((pname pname) (sigs (list->cseq sigs))) (let* ((sigs (let* ((s sigs)) (let loop1475 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first s))) (loop1475 (jolt-rest s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-first s))) (loop1475 (jolt-rest (jolt-rest s))) (if (jolt-truthy? (keyword #f "else")) s jolt-nil)))))) (methods (let* ((_a$1482 (lambda (m sig) (let fnrec1476 ((m m) (sig sig)) (let* ((_a$1479 m) (_a$1480 (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first sig)))) (_a$1481 (let* ((_o$1477 (keyword #f "name")) (_o$1478 (jolt-invoke (var-deref "clojure.core" "name") (jolt-first sig)))) (jolt-hash-map _o$1477 _o$1478)))) (jolt-assoc _a$1479 _a$1480 _a$1481))))) (_a$1483 (jolt-hash-map)) (_a$1484 sigs)) (jolt-reduce _a$1482 _a$1483 _a$1484)))) (let* ((_a$1517 (var-deref "clojure.core" "__sqcat")) (_a$1518 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1519 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1489 (var-deref "clojure.core" "__sqcat")) (_a$1490 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1491 (jolt-invoke (var-deref "clojure.core" "__sq1") pname)) (_a$1492 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1485 (var-deref "clojure.core" "__sqcat")) (_a$1486 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-protocol"))) (_a$1487 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") pname))) (_a$1488 (jolt-invoke (var-deref "clojure.core" "__sq1") methods))) (jolt-invoke _a$1485 _a$1486 _a$1487 _a$1488))))) (jolt-invoke _a$1489 _a$1490 _a$1491 _a$1492)))) (_a$1520 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1494 (var-deref "clojure.core" "__sqcat")) (_a$1495 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-protocol-methods!"))) (_a$1496 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") pname))) (_a$1497 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-map (lambda (s) (let fnrec1493 ((s s)) (jolt-invoke (var-deref "clojure.core" "name") (jolt-first s)))) sigs))))) (jolt-invoke _a$1494 _a$1495 _a$1496 _a$1497)))) (_a$1521 (jolt-map (lambda (sig) (let fnrec1498 ((sig sig)) (let* ((_a$1513 (var-deref "clojure.core" "__sqcat")) (_a$1514 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1515 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first sig))) (_a$1516 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1509 (var-deref "clojure.core" "__sqcat")) (_a$1510 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$1511 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1499 (var-deref "clojure.core" "__sqvec")) (_a$1500 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "this__11__auto"))) (_a$1501 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "&"))) (_a$1502 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "rest__10__auto")))) (jolt-invoke _a$1499 _a$1500 _a$1501 _a$1502)))) (_a$1512 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1503 (var-deref "clojure.core" "__sqcat")) (_a$1504 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "protocol-dispatch"))) (_a$1505 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") pname))) (_a$1506 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first sig)))) (_a$1507 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "this__11__auto"))) (_a$1508 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "rest__10__auto")))) (jolt-invoke _a$1503 _a$1504 _a$1505 _a$1506 _a$1507 _a$1508))))) (jolt-invoke _a$1509 _a$1510 _a$1511 _a$1512))))) (jolt-invoke _a$1513 _a$1514 _a$1515 _a$1516)))) sigs))) (jolt-invoke _a$1517 _a$1518 _a$1519 _a$1520 _a$1521))))))
+    (lambda (pname . sigs) (let fnrec1498 ((pname pname) (sigs (list->cseq sigs))) (let* ((sigs (let* ((s sigs)) (let loop1499 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first s))) (loop1499 (jolt-rest s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-first s))) (loop1499 (jolt-rest (jolt-rest s))) (if (jolt-truthy? (keyword #f "else")) s jolt-nil)))))) (methods (let* ((_a$1506 (lambda (m sig) (let fnrec1500 ((m m) (sig sig)) (let* ((_a$1503 m) (_a$1504 (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first sig)))) (_a$1505 (let* ((_o$1501 (keyword #f "name")) (_o$1502 (jolt-invoke (var-deref "clojure.core" "name") (jolt-first sig)))) (jolt-hash-map _o$1501 _o$1502)))) (jolt-assoc _a$1503 _a$1504 _a$1505))))) (_a$1507 (jolt-hash-map)) (_a$1508 sigs)) (jolt-reduce _a$1506 _a$1507 _a$1508)))) (let* ((_a$1541 (var-deref "clojure.core" "__sqcat")) (_a$1542 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1543 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1513 (var-deref "clojure.core" "__sqcat")) (_a$1514 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1515 (jolt-invoke (var-deref "clojure.core" "__sq1") pname)) (_a$1516 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1509 (var-deref "clojure.core" "__sqcat")) (_a$1510 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-protocol"))) (_a$1511 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") pname))) (_a$1512 (jolt-invoke (var-deref "clojure.core" "__sq1") methods))) (jolt-invoke _a$1509 _a$1510 _a$1511 _a$1512))))) (jolt-invoke _a$1513 _a$1514 _a$1515 _a$1516)))) (_a$1544 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1518 (var-deref "clojure.core" "__sqcat")) (_a$1519 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-protocol-methods!"))) (_a$1520 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") pname))) (_a$1521 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-map (lambda (s) (let fnrec1517 ((s s)) (jolt-invoke (var-deref "clojure.core" "name") (jolt-first s)))) sigs))))) (jolt-invoke _a$1518 _a$1519 _a$1520 _a$1521)))) (_a$1545 (jolt-map (lambda (sig) (let fnrec1522 ((sig sig)) (let* ((_a$1537 (var-deref "clojure.core" "__sqcat")) (_a$1538 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1539 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first sig))) (_a$1540 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1533 (var-deref "clojure.core" "__sqcat")) (_a$1534 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$1535 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1523 (var-deref "clojure.core" "__sqvec")) (_a$1524 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "this__11__auto"))) (_a$1525 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "&"))) (_a$1526 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "rest__10__auto")))) (jolt-invoke _a$1523 _a$1524 _a$1525 _a$1526)))) (_a$1536 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1527 (var-deref "clojure.core" "__sqcat")) (_a$1528 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "protocol-dispatch"))) (_a$1529 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") pname))) (_a$1530 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first sig)))) (_a$1531 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "this__11__auto"))) (_a$1532 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "rest__10__auto")))) (jolt-invoke _a$1527 _a$1528 _a$1529 _a$1530 _a$1531 _a$1532))))) (jolt-invoke _a$1533 _a$1534 _a$1535 _a$1536))))) (jolt-invoke _a$1537 _a$1538 _a$1539 _a$1540)))) sigs))) (jolt-invoke _a$1541 _a$1542 _a$1543 _a$1544 _a$1545))))))
   (mark-macro! "clojure.core" "defprotocol"))
 (guard (e (#t #f))
   (def-var! "clojure.core" ".."
-    (lambda (x form . more) (let fnrec1522 ((x x) (form form) (more (list->cseq more))) (let* ((step (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (let* ((_a$1523 (var-deref "clojure.core" "__sqcat")) (_a$1524 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "."))) (_a$1525 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1526 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first form))) (_a$1527 (jolt-rest form))) (jolt-invoke _a$1523 _a$1524 _a$1525 _a$1526 _a$1527)) (let* ((_a$1528 (var-deref "clojure.core" "__sqcat")) (_a$1529 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "."))) (_a$1530 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1531 (jolt-invoke (var-deref "clojure.core" "__sq1") form))) (jolt-invoke _a$1528 _a$1529 _a$1530 _a$1531))))) (if (jolt-truthy? (jolt-seq more)) (let* ((_a$1532 (var-deref "clojure.core" "__sqcat")) (_a$1533 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" ".."))) (_a$1534 (jolt-invoke (var-deref "clojure.core" "__sq1") step)) (_a$1535 more)) (jolt-invoke _a$1532 _a$1533 _a$1534 _a$1535)) step)))))
+    (lambda (x form . more) (let fnrec1546 ((x x) (form form) (more (list->cseq more))) (let* ((step (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (let* ((_a$1547 (var-deref "clojure.core" "__sqcat")) (_a$1548 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "."))) (_a$1549 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1550 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first form))) (_a$1551 (jolt-rest form))) (jolt-invoke _a$1547 _a$1548 _a$1549 _a$1550 _a$1551)) (let* ((_a$1552 (var-deref "clojure.core" "__sqcat")) (_a$1553 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "."))) (_a$1554 (jolt-invoke (var-deref "clojure.core" "__sq1") x)) (_a$1555 (jolt-invoke (var-deref "clojure.core" "__sq1") form))) (jolt-invoke _a$1552 _a$1553 _a$1554 _a$1555))))) (if (jolt-truthy? (jolt-seq more)) (let* ((_a$1556 (var-deref "clojure.core" "__sqcat")) (_a$1557 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" ".."))) (_a$1558 (jolt-invoke (var-deref "clojure.core" "__sq1") step)) (_a$1559 more)) (jolt-invoke _a$1556 _a$1557 _a$1558 _a$1559)) step)))))
   (mark-macro! "clojure.core" ".."))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "extends?" (letrec ((extends? (lambda (protocol atype) (let fnrec1536 ((protocol protocol) (atype atype)) (let* ((want (jolt-invoke (var-deref "clojure.core" "name") atype)) (dotted (jolt-invoke (var-deref "clojure.core" "str") "." want)) (dlen (jolt-count dotted))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((_a$1538 (var-deref "clojure.core" "some")) (_a$1539 (lambda (t) (let fnrec1537 ((t t)) (let* ((tn (jolt-invoke (var-deref "clojure.core" "name") t))) (let* ((or__14__auto (jolt= tn want))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (> (jolt-count tn) dlen))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-invoke (var-deref "clojure.core" "subs") tn (- (jolt-count tn) dlen)) dotted) and__13__auto)))))))) (_a$1540 (jolt-invoke (var-deref "clojure.core" "extenders") protocol))) (jolt-invoke _a$1538 _a$1539 _a$1540)))))))) extends?)))
+  (def-var! "clojure.core" "extends?" (letrec ((extends? (lambda (protocol atype) (let fnrec1560 ((protocol protocol) (atype atype)) (let* ((want (jolt-invoke (var-deref "clojure.core" "name") atype)) (dotted (jolt-invoke (var-deref "clojure.core" "str") "." want)) (dlen (jolt-count dotted))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((_a$1562 (var-deref "clojure.core" "some")) (_a$1563 (lambda (t) (let fnrec1561 ((t t)) (let* ((tn (jolt-invoke (var-deref "clojure.core" "name") t))) (let* ((or__14__auto (jolt= tn want))) (if (jolt-truthy? or__14__auto) or__14__auto (let* ((and__13__auto (> (jolt-count tn) dlen))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-invoke (var-deref "clojure.core" "subs") tn (- (jolt-count tn) dlen)) dotted) and__13__auto)))))))) (_a$1564 (jolt-invoke (var-deref "clojure.core" "extenders") protocol))) (jolt-invoke _a$1562 _a$1563 _a$1564)))))))) extends?)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "extend" (letrec ((extend (lambda (atype . proto+mmaps) (let fnrec1541 ((atype atype) (proto+mmaps (list->cseq proto+mmaps))) (let* ((s (jolt-seq proto+mmaps))) (let loop1542 ((s s)) (if (jolt-truthy? s) (begin (let* ((proto (jolt-first s)) (mmap (jolt-invoke (var-deref "clojure.core" "second") s)) (pname (jolt-invoke (var-deref "clojure.core" "name") (jolt-get proto (keyword #f "name"))))) (begin (jolt-count (jolt-map (lambda (G__25) (let fnrec1543 ((G__25 G__25)) (let* ((G__26 G__25) (k (jolt-nth G__26 0 jolt-nil)) (f (jolt-nth G__26 1 jolt-nil))) (begin (let* ((_a$1544 (var-deref "clojure.core" "register-method")) (_a$1545 (jolt-invoke (var-deref "clojure.core" "name") atype)) (_a$1546 pname) (_a$1547 (jolt-invoke (var-deref "clojure.core" "name") k)) (_a$1548 f)) (jolt-invoke _a$1544 _a$1545 _a$1546 _a$1547 _a$1548)) jolt-nil)))) mmap)) jolt-nil)) (loop1542 (jolt-invoke (var-deref "clojure.core" "nnext") s))) jolt-nil))))))) extend)))
+  (def-var! "clojure.core" "extend" (letrec ((extend (lambda (atype . proto+mmaps) (let fnrec1565 ((atype atype) (proto+mmaps (list->cseq proto+mmaps))) (let* ((s (jolt-seq proto+mmaps))) (let loop1566 ((s s)) (if (jolt-truthy? s) (begin (let* ((proto (jolt-first s)) (mmap (jolt-invoke (var-deref "clojure.core" "second") s)) (pname (jolt-invoke (var-deref "clojure.core" "name") (jolt-get proto (keyword #f "name"))))) (begin (jolt-count (jolt-map (lambda (G__25) (let fnrec1567 ((G__25 G__25)) (let* ((G__26 G__25) (k (jolt-nth G__26 0 jolt-nil)) (f (jolt-nth G__26 1 jolt-nil))) (begin (let* ((_a$1568 (var-deref "clojure.core" "register-method")) (_a$1569 (jolt-invoke (var-deref "clojure.core" "name") atype)) (_a$1570 pname) (_a$1571 (jolt-invoke (var-deref "clojure.core" "name") k)) (_a$1572 f)) (jolt-invoke _a$1568 _a$1569 _a$1570 _a$1571 _a$1572)) jolt-nil)))) mmap)) jolt-nil)) (loop1566 (jolt-invoke (var-deref "clojure.core" "nnext") s))) jolt-nil))))))) extend)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "extend-type"
-    (lambda (tsym . body) (let fnrec1549 ((tsym tsym) (body (list->cseq body))) (let* ((tname (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") tsym)) "nil" (jolt-invoke (var-deref "clojure.core" "name") tsym)))) (let* ((items (jolt-seq body)) (proto jolt-nil) (forms (jolt-vector))) (let loop1550 ((items items) (proto proto) (forms forms)) (if (jolt-empty? items) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) forms) (let* ((x (jolt-first items))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") x)) (let* ((_a$1551 (jolt-rest items)) (_a$1552 (jolt-invoke (var-deref "clojure.core" "name") x)) (_a$1553 forms)) (loop1550 _a$1551 _a$1552 _a$1553)) (let* ((_a$1564 (jolt-rest items)) (_a$1565 proto) (_a$1566 (jolt-conj forms (let* ((_a$1558 (var-deref "clojure.core" "__sqcat")) (_a$1559 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-method"))) (_a$1560 (jolt-invoke (var-deref "clojure.core" "__sq1") tname)) (_a$1561 (jolt-invoke (var-deref "clojure.core" "__sq1") proto)) (_a$1562 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first x)))) (_a$1563 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1554 (var-deref "clojure.core" "__sqcat")) (_a$1555 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1556 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth x 1))) (_a$1557 (jolt-drop 2 x))) (jolt-invoke _a$1554 _a$1555 _a$1556 _a$1557))))) (jolt-invoke _a$1558 _a$1559 _a$1560 _a$1561 _a$1562 _a$1563))))) (loop1550 _a$1564 _a$1565 _a$1566)))))))))))
+    (lambda (tsym . body) (let fnrec1573 ((tsym tsym) (body (list->cseq body))) (let* ((tname (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") tsym)) "nil" (jolt-invoke (var-deref "clojure.core" "name") tsym)))) (let* ((items (jolt-seq body)) (proto jolt-nil) (forms (jolt-vector))) (let loop1574 ((items items) (proto proto) (forms forms)) (if (jolt-empty? items) (jolt-invoke (var-deref "clojure.core" "__sqcat") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do")) forms) (let* ((x (jolt-first items))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") x)) (let* ((_a$1575 (jolt-rest items)) (_a$1576 (jolt-invoke (var-deref "clojure.core" "name") x)) (_a$1577 forms)) (loop1574 _a$1575 _a$1576 _a$1577)) (let* ((_a$1588 (jolt-rest items)) (_a$1589 proto) (_a$1590 (jolt-conj forms (let* ((_a$1582 (var-deref "clojure.core" "__sqcat")) (_a$1583 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-method"))) (_a$1584 (jolt-invoke (var-deref "clojure.core" "__sq1") tname)) (_a$1585 (jolt-invoke (var-deref "clojure.core" "__sq1") proto)) (_a$1586 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first x)))) (_a$1587 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1578 (var-deref "clojure.core" "__sqcat")) (_a$1579 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1580 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth x 1))) (_a$1581 (jolt-drop 2 x))) (jolt-invoke _a$1578 _a$1579 _a$1580 _a$1581))))) (jolt-invoke _a$1582 _a$1583 _a$1584 _a$1585 _a$1586 _a$1587))))) (loop1574 _a$1588 _a$1589 _a$1590)))))))))))
   (mark-macro! "clojure.core" "extend-type"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "extend-protocol"
-    (lambda (psym . type-impls) (let fnrec1567 ((psym psym) (type-impls (list->cseq type-impls))) (let* ((_a$1576 (var-deref "clojure.core" "__sqcat")) (_a$1577 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1578 (let* ((_a$1574 (lambda (g) (let fnrec1568 ((g g)) (let* ((_a$1569 (var-deref "clojure.core" "__sqcat")) (_a$1570 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "extend-type"))) (_a$1571 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first g))) (_a$1572 (jolt-invoke (var-deref "clojure.core" "__sq1") psym)) (_a$1573 (jolt-rest g))) (jolt-invoke _a$1569 _a$1570 _a$1571 _a$1572 _a$1573))))) (_a$1575 (jolt-invoke (var-deref "clojure.core" "group-by-head") type-impls))) (jolt-map _a$1574 _a$1575)))) (jolt-invoke _a$1576 _a$1577 _a$1578)))))
+    (lambda (psym . type-impls) (let fnrec1591 ((psym psym) (type-impls (list->cseq type-impls))) (let* ((_a$1600 (var-deref "clojure.core" "__sqcat")) (_a$1601 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1602 (let* ((_a$1598 (lambda (g) (let fnrec1592 ((g g)) (let* ((_a$1593 (var-deref "clojure.core" "__sqcat")) (_a$1594 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "extend-type"))) (_a$1595 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-first g))) (_a$1596 (jolt-invoke (var-deref "clojure.core" "__sq1") psym)) (_a$1597 (jolt-rest g))) (jolt-invoke _a$1593 _a$1594 _a$1595 _a$1596 _a$1597))))) (_a$1599 (jolt-invoke (var-deref "clojure.core" "group-by-head") type-impls))) (jolt-map _a$1598 _a$1599)))) (jolt-invoke _a$1600 _a$1601 _a$1602)))))
   (mark-macro! "clojure.core" "extend-protocol"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "proxy"
-    (lambda args (let fnrec1579 ((args (list->cseq args))) jolt-nil)))
+    (lambda args (let fnrec1603 ((args (list->cseq args))) jolt-nil)))
   (mark-macro! "clojure.core" "proxy"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "definterface"
-    (lambda (name-sym . body) (let fnrec1580 ((name-sym name-sym) (body (list->cseq body))) (let* ((_a$1588 (var-deref "clojure.core" "__sqcat")) (_a$1589 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1590 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1581 (var-deref "clojure.core" "__sqcat")) (_a$1582 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1583 (jolt-invoke (var-deref "clojure.core" "__sq1") name-sym)) (_a$1584 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$1581 _a$1582 _a$1583 _a$1584)))) (_a$1591 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1585 (var-deref "clojure.core" "__sqcat")) (_a$1586 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$1587 (jolt-invoke (var-deref "clojure.core" "__sq1") name-sym))) (jolt-invoke _a$1585 _a$1586 _a$1587))))) (jolt-invoke _a$1588 _a$1589 _a$1590 _a$1591)))))
+    (lambda (name-sym . body) (let fnrec1604 ((name-sym name-sym) (body (list->cseq body))) (let* ((_a$1612 (var-deref "clojure.core" "__sqcat")) (_a$1613 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1614 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1605 (var-deref "clojure.core" "__sqcat")) (_a$1606 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1607 (jolt-invoke (var-deref "clojure.core" "__sq1") name-sym)) (_a$1608 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqmap"))))) (jolt-invoke _a$1605 _a$1606 _a$1607 _a$1608)))) (_a$1615 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1609 (var-deref "clojure.core" "__sqcat")) (_a$1610 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "quote"))) (_a$1611 (jolt-invoke (var-deref "clojure.core" "__sq1") name-sym))) (jolt-invoke _a$1609 _a$1610 _a$1611))))) (jolt-invoke _a$1612 _a$1613 _a$1614 _a$1615)))))
   (mark-macro! "clojure.core" "definterface"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "reify"
-    (lambda forms (let fnrec1592 ((forms (list->cseq forms))) (let* ((items (jolt-seq forms)) (protos (jolt-vector)) (methods (jolt-hash-map))) (let loop1593 ((items items) (protos protos) (methods methods)) (if (jolt-empty? items) (let* ((_a$1594 (var-deref "clojure.core" "__sqcat")) (_a$1595 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-reified"))) (_a$1596 (jolt-invoke (var-deref "clojure.core" "__sq1") methods)) (_a$1597 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-map (var-deref "clojure.core" "name") protos)))) (jolt-invoke _a$1594 _a$1595 _a$1596 _a$1597)) (let* ((x (jolt-first items))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") x)) (let* ((_a$1598 (jolt-rest items)) (_a$1599 (jolt-conj protos x)) (_a$1600 methods)) (loop1593 _a$1598 _a$1599 _a$1600)) (let* ((_a$1608 (jolt-rest items)) (_a$1609 protos) (_a$1610 (let* ((_a$1605 methods) (_a$1606 (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first x)))) (_a$1607 (let* ((_a$1601 (var-deref "clojure.core" "__sqcat")) (_a$1602 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1603 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth x 1))) (_a$1604 (jolt-drop 2 x))) (jolt-invoke _a$1601 _a$1602 _a$1603 _a$1604)))) (jolt-assoc _a$1605 _a$1606 _a$1607)))) (loop1593 _a$1608 _a$1609 _a$1610))))))))))
+    (lambda forms (let fnrec1616 ((forms (list->cseq forms))) (let* ((items (jolt-seq forms)) (protos (jolt-vector)) (methods (jolt-hash-map))) (let loop1617 ((items items) (protos protos) (methods methods)) (if (jolt-empty? items) (let* ((_a$1618 (var-deref "clojure.core" "__sqcat")) (_a$1619 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "make-reified"))) (_a$1620 (jolt-invoke (var-deref "clojure.core" "__sq1") methods)) (_a$1621 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-map (var-deref "clojure.core" "name") protos)))) (jolt-invoke _a$1618 _a$1619 _a$1620 _a$1621)) (let* ((x (jolt-first items))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "symbol?") x)) (let* ((_a$1622 (jolt-rest items)) (_a$1623 (jolt-conj protos x)) (_a$1624 methods)) (loop1617 _a$1622 _a$1623 _a$1624)) (let* ((_a$1632 (jolt-rest items)) (_a$1633 protos) (_a$1634 (let* ((_a$1629 methods) (_a$1630 (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first x)))) (_a$1631 (let* ((_a$1625 (var-deref "clojure.core" "__sqcat")) (_a$1626 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1627 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-nth x 1))) (_a$1628 (jolt-drop 2 x))) (jolt-invoke _a$1625 _a$1626 _a$1627 _a$1628)))) (jolt-assoc _a$1629 _a$1630 _a$1631)))) (loop1617 _a$1632 _a$1633 _a$1634))))))))))
   (mark-macro! "clojure.core" "reify"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "defrecord"
-    (lambda (name-sym fields . body) (let fnrec1611 ((name-sym name-sym) (fields fields) (body (list->cseq body))) (let* ((tn (jolt-invoke (var-deref "clojure.core" "name") name-sym)) (arrow (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "->" tn))) (mapf (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "map->" tn))) (m (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (impl (lambda (proto specs) (let fnrec1612 ((proto proto) (specs specs)) (let* ((_a$1635 (var-deref "clojure.core" "__sqcat")) (_a$1636 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1637 (jolt-map (lambda (spec) (let fnrec1613 ((spec spec)) (let* ((argv (jolt-nth spec 1)) (inst (jolt-first argv)) (hinted (jolt-assoc argv 0 (jolt-invoke (var-deref "clojure.core" "vary-meta") inst jolt-assoc (keyword #f "tag") (jolt-invoke (var-deref "clojure.core" "name") name-sym)))) (binds (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (f) (let fnrec1614 ((f f)) (let* ((_o$1619 f) (_o$1620 (let* ((_a$1615 (var-deref "clojure.core" "__sqcat")) (_a$1616 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$1617 (jolt-invoke (var-deref "clojure.core" "__sq1") inst)) (_a$1618 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f))))) (jolt-invoke _a$1615 _a$1616 _a$1617 _a$1618)))) (jolt-vector _o$1619 _o$1620)))) fields)))) (let* ((_a$1629 (var-deref "clojure.core" "__sqcat")) (_a$1630 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-inline-method"))) (_a$1631 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") name-sym))) (_a$1632 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") proto))) (_a$1633 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first spec)))) (_a$1634 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1625 (var-deref "clojure.core" "__sqcat")) (_a$1626 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1627 (jolt-invoke (var-deref "clojure.core" "__sq1") hinted)) (_a$1628 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1621 (var-deref "clojure.core" "__sqcat")) (_a$1622 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1623 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") binds))) (_a$1624 (jolt-drop 2 spec))) (jolt-invoke _a$1621 _a$1622 _a$1623 _a$1624))))) (jolt-invoke _a$1625 _a$1626 _a$1627 _a$1628))))) (jolt-invoke _a$1629 _a$1630 _a$1631 _a$1632 _a$1633 _a$1634))))) specs))) (jolt-invoke _a$1635 _a$1636 _a$1637)))))) (let* ((_a$1664 (var-deref "clojure.core" "__sqcat")) (_a$1665 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1666 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1638 (var-deref "clojure.core" "__sqcat")) (_a$1639 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "deftype"))) (_a$1640 (jolt-invoke (var-deref "clojure.core" "__sq1") name-sym)) (_a$1641 (jolt-invoke (var-deref "clojure.core" "__sq1") fields))) (jolt-invoke _a$1638 _a$1639 _a$1640 _a$1641)))) (_a$1667 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1654 (var-deref "clojure.core" "__sqcat")) (_a$1655 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1656 (jolt-invoke (var-deref "clojure.core" "__sq1") mapf)) (_a$1657 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1650 (var-deref "clojure.core" "__sqcat")) (_a$1651 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$1652 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") m)))) (_a$1653 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1647 (var-deref "clojure.core" "__sqcat")) (_a$1648 (jolt-invoke (var-deref "clojure.core" "__sq1") arrow)) (_a$1649 (jolt-map (lambda (f) (let fnrec1642 ((f f)) (let* ((_a$1643 (var-deref "clojure.core" "__sqcat")) (_a$1644 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$1645 (jolt-invoke (var-deref "clojure.core" "__sq1") m)) (_a$1646 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f))))) (jolt-invoke _a$1643 _a$1644 _a$1645 _a$1646)))) fields))) (jolt-invoke _a$1647 _a$1648 _a$1649))))) (jolt-invoke _a$1650 _a$1651 _a$1652 _a$1653))))) (jolt-invoke _a$1654 _a$1655 _a$1656 _a$1657)))) (_a$1668 (let* ((_a$1662 (lambda (g) (let fnrec1658 ((g g)) (let* ((_a$1659 impl) (_a$1660 (jolt-first g)) (_a$1661 (jolt-rest g))) (jolt-invoke _a$1659 _a$1660 _a$1661))))) (_a$1663 (jolt-invoke (var-deref "clojure.core" "group-by-head") body))) (jolt-map _a$1662 _a$1663)))) (jolt-invoke _a$1664 _a$1665 _a$1666 _a$1667 _a$1668))))))
+    (lambda (name-sym fields . body) (let fnrec1635 ((name-sym name-sym) (fields fields) (body (list->cseq body))) (let* ((tn (jolt-invoke (var-deref "clojure.core" "name") name-sym)) (arrow (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "->" tn))) (mapf (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "map->" tn))) (m (jolt-invoke (var-deref "clojure.core" "fresh-sym"))) (impl (lambda (proto specs) (let fnrec1636 ((proto proto) (specs specs)) (let* ((_a$1659 (var-deref "clojure.core" "__sqcat")) (_a$1660 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1661 (jolt-map (lambda (spec) (let fnrec1637 ((spec spec)) (let* ((argv (jolt-nth spec 1)) (inst (jolt-first argv)) (hinted (jolt-assoc argv 0 (jolt-invoke (var-deref "clojure.core" "vary-meta") inst jolt-assoc (keyword #f "tag") (jolt-invoke (var-deref "clojure.core" "name") name-sym)))) (binds (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (f) (let fnrec1638 ((f f)) (let* ((_o$1643 f) (_o$1644 (let* ((_a$1639 (var-deref "clojure.core" "__sqcat")) (_a$1640 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$1641 (jolt-invoke (var-deref "clojure.core" "__sq1") inst)) (_a$1642 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f))))) (jolt-invoke _a$1639 _a$1640 _a$1641 _a$1642)))) (jolt-vector _o$1643 _o$1644)))) fields)))) (let* ((_a$1653 (var-deref "clojure.core" "__sqcat")) (_a$1654 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "register-inline-method"))) (_a$1655 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") name-sym))) (_a$1656 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") proto))) (_a$1657 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "name") (jolt-first spec)))) (_a$1658 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1649 (var-deref "clojure.core" "__sqcat")) (_a$1650 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1651 (jolt-invoke (var-deref "clojure.core" "__sq1") hinted)) (_a$1652 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1645 (var-deref "clojure.core" "__sqcat")) (_a$1646 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "let"))) (_a$1647 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") binds))) (_a$1648 (jolt-drop 2 spec))) (jolt-invoke _a$1645 _a$1646 _a$1647 _a$1648))))) (jolt-invoke _a$1649 _a$1650 _a$1651 _a$1652))))) (jolt-invoke _a$1653 _a$1654 _a$1655 _a$1656 _a$1657 _a$1658))))) specs))) (jolt-invoke _a$1659 _a$1660 _a$1661)))))) (let* ((_a$1688 (var-deref "clojure.core" "__sqcat")) (_a$1689 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$1690 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1662 (var-deref "clojure.core" "__sqcat")) (_a$1663 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "deftype"))) (_a$1664 (jolt-invoke (var-deref "clojure.core" "__sq1") name-sym)) (_a$1665 (jolt-invoke (var-deref "clojure.core" "__sq1") fields))) (jolt-invoke _a$1662 _a$1663 _a$1664 _a$1665)))) (_a$1691 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1678 (var-deref "clojure.core" "__sqcat")) (_a$1679 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "def"))) (_a$1680 (jolt-invoke (var-deref "clojure.core" "__sq1") mapf)) (_a$1681 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1674 (var-deref "clojure.core" "__sqcat")) (_a$1675 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "fn*"))) (_a$1676 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") m)))) (_a$1677 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1671 (var-deref "clojure.core" "__sqcat")) (_a$1672 (jolt-invoke (var-deref "clojure.core" "__sq1") arrow)) (_a$1673 (jolt-map (lambda (f) (let fnrec1666 ((f f)) (let* ((_a$1667 (var-deref "clojure.core" "__sqcat")) (_a$1668 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "get"))) (_a$1669 (jolt-invoke (var-deref "clojure.core" "__sq1") m)) (_a$1670 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "keyword") (jolt-invoke (var-deref "clojure.core" "name") f))))) (jolt-invoke _a$1667 _a$1668 _a$1669 _a$1670)))) fields))) (jolt-invoke _a$1671 _a$1672 _a$1673))))) (jolt-invoke _a$1674 _a$1675 _a$1676 _a$1677))))) (jolt-invoke _a$1678 _a$1679 _a$1680 _a$1681)))) (_a$1692 (let* ((_a$1686 (lambda (g) (let fnrec1682 ((g g)) (let* ((_a$1683 impl) (_a$1684 (jolt-first g)) (_a$1685 (jolt-rest g))) (jolt-invoke _a$1683 _a$1684 _a$1685))))) (_a$1687 (jolt-invoke (var-deref "clojure.core" "group-by-head") body))) (jolt-map _a$1686 _a$1687)))) (jolt-invoke _a$1688 _a$1689 _a$1690 _a$1691 _a$1692))))))
   (mark-macro! "clojure.core" "defrecord"))
 (guard (e (#t #f))
   (def-var! "clojure.core" "memfn"
-    (lambda (method-name . args) (let fnrec1669 ((method-name method-name) (args (list->cseq args))) (let* ((_a$1674 (var-deref "clojure.core" "__sqcat")) (_a$1675 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1676 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "target__12__auto")) args))) (_a$1677 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1670 (var-deref "clojure.core" "__sqcat")) (_a$1671 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "." (jolt-invoke (var-deref "clojure.core" "name") method-name))))) (_a$1672 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "target__12__auto"))) (_a$1673 args)) (jolt-invoke _a$1670 _a$1671 _a$1672 _a$1673))))) (jolt-invoke _a$1674 _a$1675 _a$1676 _a$1677)))))
+    (lambda (method-name . args) (let fnrec1693 ((method-name method-name) (args (list->cseq args))) (let* ((_a$1698 (var-deref "clojure.core" "__sqcat")) (_a$1699 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "fn"))) (_a$1700 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "__sqvec") (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "target__12__auto")) args))) (_a$1701 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$1694 (var-deref "clojure.core" "__sqcat")) (_a$1695 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-invoke (var-deref "clojure.core" "symbol") (jolt-invoke (var-deref "clojure.core" "str") "." (jolt-invoke (var-deref "clojure.core" "name") method-name))))) (_a$1696 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "target__12__auto"))) (_a$1697 args)) (jolt-invoke _a$1694 _a$1695 _a$1696 _a$1697))))) (jolt-invoke _a$1698 _a$1699 _a$1700 _a$1701)))))
   (mark-macro! "clojure.core" "memfn"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "distinct" (letrec ((distinct (case-lambda (() (let fnrec174 () (lambda (rf) (let fnrec175 ((rf rf)) (let* ((seen (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-hash-set)))) (case-lambda (() (let fnrec176 () (jolt-invoke rf))) ((result) (let fnrec177 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec178 ((result result) (input input)) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") seen) input) result (begin (jolt-invoke (var-deref "clojure.core" "vswap!") seen jolt-conj input) (jolt-invoke rf result input))))))))))) ((coll) (let fnrec179 ((coll coll)) (let* ((step (letrec ((step (lambda (xs seen) (let fnrec180 ((xs xs) (seen seen)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec181 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-invoke (lambda (G__13 seen) (let fnrec182 ((G__13 G__13) (seen seen)) (let* ((G__14 G__13) (f (jolt-nth G__14 0 jolt-nil)) (xs G__14)) (let* ((temp__15__auto (jolt-seq xs))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (if (jolt-contains? seen f) (fnrec182 (jolt-rest s) seen) (jolt-cons f (let* ((_a$183 step) (_a$184 (jolt-rest s)) (_a$185 (jolt-conj seen f))) (jolt-invoke _a$183 _a$184 _a$185))))) jolt-nil))))) xs seen))))))))) step))) (jolt-invoke step coll (jolt-hash-set)))))))) distinct)))
+  (def-var! "clojure.core" "distinct" (letrec ((distinct (case-lambda (() (let fnrec198 () (lambda (rf) (let fnrec199 ((rf rf)) (let* ((seen (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-hash-set)))) (case-lambda (() (let fnrec200 () (jolt-invoke rf))) ((result) (let fnrec201 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec202 ((result result) (input input)) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") seen) input) result (begin (jolt-invoke (var-deref "clojure.core" "vswap!") seen jolt-conj input) (jolt-invoke rf result input))))))))))) ((coll) (let fnrec203 ((coll coll)) (let* ((step (letrec ((step (lambda (xs seen) (let fnrec204 ((xs xs) (seen seen)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec205 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-invoke (lambda (G__13 seen) (let fnrec206 ((G__13 G__13) (seen seen)) (let* ((G__14 G__13) (f (jolt-nth G__14 0 jolt-nil)) (xs G__14)) (let* ((temp__15__auto (jolt-seq xs))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (if (jolt-contains? seen f) (fnrec206 (jolt-rest s) seen) (jolt-cons f (let* ((_a$207 step) (_a$208 (jolt-rest s)) (_a$209 (jolt-conj seen f))) (jolt-invoke _a$207 _a$208 _a$209))))) jolt-nil))))) xs seen))))))))) step))) (jolt-invoke step coll (jolt-hash-set)))))))) distinct)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "keep" (letrec ((keep (case-lambda ((f) (let fnrec186 ((f f)) (lambda (rf) (let fnrec187 ((rf rf)) (case-lambda (() (let fnrec188 () (jolt-invoke rf))) ((result) (let fnrec189 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec190 ((result result) (input input)) (let* ((v (jolt-invoke f input))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) result (jolt-invoke rf result v)))))))))) ((f coll) (let fnrec191 ((f f) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec192 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((x (jolt-invoke f (jolt-first s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) (jolt-invoke keep f (jolt-rest s)) (jolt-cons x (jolt-invoke keep f (jolt-rest s)))))) jolt-nil))))))))))) keep)))
+  (def-var! "clojure.core" "keep" (letrec ((keep (case-lambda ((f) (let fnrec210 ((f f)) (lambda (rf) (let fnrec211 ((rf rf)) (case-lambda (() (let fnrec212 () (jolt-invoke rf))) ((result) (let fnrec213 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec214 ((result result) (input input)) (let* ((v (jolt-invoke f input))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) result (jolt-invoke rf result v)))))))))) ((f coll) (let fnrec215 ((f f) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec216 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((x (jolt-invoke f (jolt-first s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) (jolt-invoke keep f (jolt-rest s)) (jolt-cons x (jolt-invoke keep f (jolt-rest s)))))) jolt-nil))))))))))) keep)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "keep-indexed" (letrec ((keep-indexed (case-lambda ((f) (let fnrec193 ((f f)) (lambda (rf) (let fnrec194 ((rf rf)) (let* ((ia (jolt-invoke (var-deref "clojure.core" "volatile!") -1))) (case-lambda (() (let fnrec195 () (jolt-invoke rf))) ((result) (let fnrec196 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec197 ((result result) (input input)) (let* ((i (jolt-invoke (var-deref "clojure.core" "vswap!") ia jolt-inc)) (v (jolt-invoke f i input))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) result (jolt-invoke rf result v))))))))))) ((f coll) (let fnrec198 ((f f) (coll coll)) (letrec* ((keepi (letrec ((keepi (lambda (idx coll) (let fnrec199 ((idx idx) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec200 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((x (jolt-invoke f idx (jolt-first s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) (let* ((_a$201 keepi) (_a$202 (jolt-inc idx)) (_a$203 (jolt-rest s))) (jolt-invoke _a$201 _a$202 _a$203)) (jolt-cons x (let* ((_a$204 keepi) (_a$205 (jolt-inc idx)) (_a$206 (jolt-rest s))) (jolt-invoke _a$204 _a$205 _a$206)))))) jolt-nil)))))))))) keepi))) (jolt-invoke keepi 0 coll))))))) keep-indexed)))
+  (def-var! "clojure.core" "keep-indexed" (letrec ((keep-indexed (case-lambda ((f) (let fnrec217 ((f f)) (lambda (rf) (let fnrec218 ((rf rf)) (let* ((ia (jolt-invoke (var-deref "clojure.core" "volatile!") -1))) (case-lambda (() (let fnrec219 () (jolt-invoke rf))) ((result) (let fnrec220 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec221 ((result result) (input input)) (let* ((i (jolt-invoke (var-deref "clojure.core" "vswap!") ia jolt-inc)) (v (jolt-invoke f i input))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) result (jolt-invoke rf result v))))))))))) ((f coll) (let fnrec222 ((f f) (coll coll)) (letrec* ((keepi (letrec ((keepi (lambda (idx coll) (let fnrec223 ((idx idx) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec224 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((x (jolt-invoke f idx (jolt-first s)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") x)) (let* ((_a$225 keepi) (_a$226 (jolt-inc idx)) (_a$227 (jolt-rest s))) (jolt-invoke _a$225 _a$226 _a$227)) (jolt-cons x (let* ((_a$228 keepi) (_a$229 (jolt-inc idx)) (_a$230 (jolt-rest s))) (jolt-invoke _a$228 _a$229 _a$230)))))) jolt-nil)))))))))) keepi))) (jolt-invoke keepi 0 coll))))))) keep-indexed)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "map-indexed" (letrec ((map-indexed (case-lambda ((f) (let fnrec207 ((f f)) (lambda (rf) (let fnrec208 ((rf rf)) (let* ((i (jolt-invoke (var-deref "clojure.core" "volatile!") -1))) (case-lambda (() (let fnrec209 () (jolt-invoke rf))) ((result) (let fnrec210 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec211 ((result result) (input input)) (jolt-invoke rf result (jolt-invoke f (jolt-invoke (var-deref "clojure.core" "vswap!") i jolt-inc) input)))))))))) ((f coll) (let fnrec212 ((f f) (coll coll)) (letrec* ((mapi (letrec ((mapi (lambda (idx coll) (let fnrec213 ((idx idx) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec214 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$218 (jolt-invoke f idx (jolt-first s))) (_a$219 (let* ((_a$215 mapi) (_a$216 (jolt-inc idx)) (_a$217 (jolt-rest s))) (jolt-invoke _a$215 _a$216 _a$217)))) (jolt-cons _a$218 _a$219))) jolt-nil)))))))))) mapi))) (jolt-invoke mapi 0 coll))))))) map-indexed)))
+  (def-var! "clojure.core" "map-indexed" (letrec ((map-indexed (case-lambda ((f) (let fnrec231 ((f f)) (lambda (rf) (let fnrec232 ((rf rf)) (let* ((i (jolt-invoke (var-deref "clojure.core" "volatile!") -1))) (case-lambda (() (let fnrec233 () (jolt-invoke rf))) ((result) (let fnrec234 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec235 ((result result) (input input)) (jolt-invoke rf result (jolt-invoke f (jolt-invoke (var-deref "clojure.core" "vswap!") i jolt-inc) input)))))))))) ((f coll) (let fnrec236 ((f f) (coll coll)) (letrec* ((mapi (letrec ((mapi (lambda (idx coll) (let fnrec237 ((idx idx) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec238 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$242 (jolt-invoke f idx (jolt-first s))) (_a$243 (let* ((_a$239 mapi) (_a$240 (jolt-inc idx)) (_a$241 (jolt-rest s))) (jolt-invoke _a$239 _a$240 _a$241)))) (jolt-cons _a$242 _a$243))) jolt-nil)))))))))) mapi))) (jolt-invoke mapi 0 coll))))))) map-indexed)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "cycle" (letrec ((cycle (lambda (coll) (let fnrec220 ((coll coll)) (if (jolt-truthy? (jolt-seq coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec221 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-concat coll (jolt-invoke cycle coll)))))) (jolt-list )))))) cycle)))
+  (def-var! "clojure.core" "cycle" (letrec ((cycle (lambda (coll) (let fnrec244 ((coll coll)) (if (jolt-truthy? (jolt-seq coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec245 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-concat coll (jolt-invoke cycle coll)))))) (jolt-list )))))) cycle)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "repeatedly" (letrec ((repeatedly (case-lambda ((f) (let fnrec222 ((f f)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec223 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((_a$224 (jolt-invoke f)) (_a$225 (jolt-invoke repeatedly f))) (jolt-cons _a$224 _a$225)))))))) ((n f) (let fnrec226 ((n n) (f f)) (jolt-take n (jolt-invoke repeatedly f))))))) repeatedly)))
+  (def-var! "clojure.core" "repeatedly" (letrec ((repeatedly (case-lambda ((f) (let fnrec246 ((f f)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec247 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((_a$248 (jolt-invoke f)) (_a$249 (jolt-invoke repeatedly f))) (jolt-cons _a$248 _a$249)))))))) ((n f) (let fnrec250 ((n n) (f f)) (jolt-take n (jolt-invoke repeatedly f))))))) repeatedly)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "repeat" (letrec ((repeat (case-lambda ((x) (let fnrec227 ((x x)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec228 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke repeat x)))))))) ((n x) (let fnrec229 ((n n) (x x)) (jolt-take n (jolt-invoke repeat x))))))) repeat)))
+  (def-var! "clojure.core" "repeat" (letrec ((repeat (case-lambda ((x) (let fnrec251 ((x x)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec252 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke repeat x)))))))) ((n x) (let fnrec253 ((n n) (x x)) (jolt-take n (jolt-invoke repeat x))))))) repeat)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "iterate" (letrec ((iterate (lambda (f x) (let fnrec230 ((f f) (x x)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec231 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke iterate f (jolt-invoke f x))))))))))) iterate)))
+  (def-var! "clojure.core" "iterate" (letrec ((iterate (lambda (f x) (let fnrec254 ((f f) (x x)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec255 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (jolt-cons x (jolt-invoke iterate f (jolt-invoke f x))))))))))) iterate)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "partition-all" (letrec ((partition-all (case-lambda ((n) (let fnrec232 ((n n)) (lambda (rf) (let fnrec233 ((rf rf)) (let* ((a (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector)))) (case-lambda (() (let fnrec234 () (jolt-invoke rf))) ((result) (let fnrec235 ((result result)) (let* ((result (if (jolt-zero? (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") a))) result (let* ((v (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") a (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result v))))))) (jolt-invoke rf result)))) ((result input) (let fnrec236 ((result result) (input input)) (begin (jolt-invoke (var-deref "clojure.core" "vswap!") a jolt-conj input) (if (jolt= n (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((v (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") a (jolt-vector)) (jolt-invoke rf result v))) result)))))))))) ((n coll) (let fnrec237 ((n n) (coll coll)) (letrec* ((go (letrec ((go (lambda (s) (let fnrec238 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec239 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (if (jolt-truthy? (jolt-seq s)) (let* ((i 0) (chunk (jolt-vector)) (cur s)) (let loop240 ((i i) (chunk chunk) (cur cur)) (if (jolt-truthy? (let* ((and__13__auto (< i n))) (if (jolt-truthy? and__13__auto) (jolt-seq cur) and__13__auto))) (let* ((_a$241 (jolt-inc i)) (_a$242 (jolt-conj chunk (jolt-first cur))) (_a$243 (jolt-rest cur))) (loop240 _a$241 _a$242 _a$243)) (jolt-cons chunk (jolt-invoke go cur))))) jolt-nil))))))))) go))) (jolt-invoke go coll)))) ((n step coll) (let fnrec244 ((n n) (step step) (coll coll)) (letrec* ((go (letrec ((go (lambda (s) (let fnrec245 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec246 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (if (jolt-truthy? (jolt-seq s)) (let* ((_a$247 (jolt-take n s)) (_a$248 (jolt-invoke go (jolt-invoke (var-deref "clojure.core" "nthrest") s step)))) (jolt-cons _a$247 _a$248)) jolt-nil))))))))) go))) (jolt-invoke go coll))))))) partition-all)))
+  (def-var! "clojure.core" "partition-all" (letrec ((partition-all (case-lambda ((n) (let fnrec256 ((n n)) (lambda (rf) (let fnrec257 ((rf rf)) (let* ((a (jolt-invoke (var-deref "clojure.core" "volatile!") (jolt-vector)))) (case-lambda (() (let fnrec258 () (jolt-invoke rf))) ((result) (let fnrec259 ((result result)) (let* ((result (if (jolt-zero? (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") a))) result (let* ((v (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") a (jolt-vector)) (jolt-invoke (var-deref "clojure.core" "unreduced") (jolt-invoke rf result v))))))) (jolt-invoke rf result)))) ((result input) (let fnrec260 ((result result) (input input)) (begin (jolt-invoke (var-deref "clojure.core" "vswap!") a jolt-conj input) (if (jolt= n (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") a))) (let* ((v (jolt-invoke (var-deref "clojure.core" "deref") a))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") a (jolt-vector)) (jolt-invoke rf result v))) result)))))))))) ((n coll) (let fnrec261 ((n n) (coll coll)) (letrec* ((go (letrec ((go (lambda (s) (let fnrec262 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec263 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (if (jolt-truthy? (jolt-seq s)) (let* ((i 0) (chunk (jolt-vector)) (cur s)) (let loop264 ((i i) (chunk chunk) (cur cur)) (if (jolt-truthy? (let* ((and__13__auto (< i n))) (if (jolt-truthy? and__13__auto) (jolt-seq cur) and__13__auto))) (let* ((_a$265 (jolt-inc i)) (_a$266 (jolt-conj chunk (jolt-first cur))) (_a$267 (jolt-rest cur))) (loop264 _a$265 _a$266 _a$267)) (jolt-cons chunk (jolt-invoke go cur))))) jolt-nil))))))))) go))) (jolt-invoke go coll)))) ((n step coll) (let fnrec268 ((n n) (step step) (coll coll)) (letrec* ((go (letrec ((go (lambda (s) (let fnrec269 ((s s)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec270 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (if (jolt-truthy? (jolt-seq s)) (let* ((_a$271 (jolt-take n s)) (_a$272 (jolt-invoke go (jolt-invoke (var-deref "clojure.core" "nthrest") s step)))) (jolt-cons _a$271 _a$272)) jolt-nil))))))))) go))) (jolt-invoke go coll))))))) partition-all)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "interpose" (letrec ((interpose (case-lambda ((sep) (let fnrec249 ((sep sep)) (lambda (rf) (let fnrec250 ((rf rf)) (let* ((started (jolt-invoke (var-deref "clojure.core" "volatile!") #f))) (case-lambda (() (let fnrec251 () (jolt-invoke rf))) ((result) (let fnrec252 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec253 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") started)) (let* ((sepr (jolt-invoke rf result sep))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") sepr)) sepr (jolt-invoke rf sepr input))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") started #t) (jolt-invoke rf result input))))))))))) ((sep coll) (let fnrec254 ((sep sep) (coll coll)) (jolt-drop 1 (jolt-invoke (var-deref "clojure.core" "interleave") (jolt-invoke (var-deref "clojure.core" "repeat") sep) coll))))))) interpose)))
+  (def-var! "clojure.core" "interpose" (letrec ((interpose (case-lambda ((sep) (let fnrec273 ((sep sep)) (lambda (rf) (let fnrec274 ((rf rf)) (let* ((started (jolt-invoke (var-deref "clojure.core" "volatile!") #f))) (case-lambda (() (let fnrec275 () (jolt-invoke rf))) ((result) (let fnrec276 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec277 ((result result) (input input)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") started)) (let* ((sepr (jolt-invoke rf result sep))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "reduced?") sepr)) sepr (jolt-invoke rf sepr input))) (begin (jolt-invoke (var-deref "clojure.core" "vreset!") started #t) (jolt-invoke rf result input))))))))))) ((sep coll) (let fnrec278 ((sep sep) (coll coll)) (jolt-drop 1 (jolt-invoke (var-deref "clojure.core" "interleave") (jolt-invoke (var-deref "clojure.core" "repeat") sep) coll))))))) interpose)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "take-nth" (letrec ((take-nth (case-lambda ((n) (let fnrec255 ((n n)) (lambda (rf) (let fnrec256 ((rf rf)) (let* ((iv (jolt-invoke (var-deref "clojure.core" "volatile!") -1))) (case-lambda (() (let fnrec257 () (jolt-invoke rf))) ((result) (let fnrec258 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec259 ((result result) (input input)) (let* ((i (jolt-invoke (var-deref "clojure.core" "vswap!") iv jolt-inc))) (if (jolt-zero? (remainder i n)) (jolt-invoke rf result input) result)))))))))) ((n coll) (let fnrec260 ((n n) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec261 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$262 (jolt-first s)) (_a$263 (jolt-invoke take-nth n (jolt-drop n s)))) (jolt-cons _a$262 _a$263))) jolt-nil))))))))))) take-nth)))
+  (def-var! "clojure.core" "take-nth" (letrec ((take-nth (case-lambda ((n) (let fnrec279 ((n n)) (lambda (rf) (let fnrec280 ((rf rf)) (let* ((iv (jolt-invoke (var-deref "clojure.core" "volatile!") -1))) (case-lambda (() (let fnrec281 () (jolt-invoke rf))) ((result) (let fnrec282 ((result result)) (jolt-invoke rf result))) ((result input) (let fnrec283 ((result result) (input input)) (let* ((i (jolt-invoke (var-deref "clojure.core" "vswap!") iv jolt-inc))) (if (jolt-zero? (remainder i n)) (jolt-invoke rf result input) result)))))))))) ((n coll) (let fnrec284 ((n n) (coll coll)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec285 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((temp__15__auto (jolt-seq coll))) (if (jolt-truthy? temp__15__auto) (let* ((s temp__15__auto)) (let* ((_a$286 (jolt-first s)) (_a$287 (jolt-invoke take-nth n (jolt-drop n s)))) (jolt-cons _a$286 _a$287))) jolt-nil))))))))))) take-nth)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pmap" (letrec ((pmap (case-lambda ((f coll) (let fnrec264 ((f f) (coll coll)) (jolt-map (var-deref "clojure.core" "deref") (jolt-invoke (var-deref "clojure.core" "doall") (jolt-map (lambda (x) (let fnrec265 ((x x)) (jolt-invoke (var-deref "clojure.core" "future-call") (lambda () (let fnrec266 () (jolt-invoke f x)))))) coll))))) ((f coll . colls) (let fnrec267 ((f f) (coll coll) (colls (list->cseq colls))) (let* ((_a$269 pmap) (_a$270 (lambda (xs) (let fnrec268 ((xs xs)) (jolt-apply f xs)))) (_a$271 (jolt-apply jolt-map jolt-vector coll colls))) (jolt-invoke _a$269 _a$270 _a$271))))))) pmap)))
+  (def-var! "clojure.core" "pmap" (letrec ((pmap (case-lambda ((f coll) (let fnrec288 ((f f) (coll coll)) (jolt-map (var-deref "clojure.core" "deref") (jolt-invoke (var-deref "clojure.core" "doall") (jolt-map (lambda (x) (let fnrec289 ((x x)) (jolt-invoke (var-deref "clojure.core" "future-call") (lambda () (let fnrec290 () (jolt-invoke f x)))))) coll))))) ((f coll . colls) (let fnrec291 ((f f) (coll coll) (colls (list->cseq colls))) (let* ((_a$293 pmap) (_a$294 (lambda (xs) (let fnrec292 ((xs xs)) (jolt-apply f xs)))) (_a$295 (jolt-apply jolt-map jolt-vector coll colls))) (jolt-invoke _a$293 _a$294 _a$295))))))) pmap)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "pcalls" (letrec ((pcalls (lambda fns (let fnrec272 ((fns (list->cseq fns))) (jolt-invoke (var-deref "clojure.core" "pmap") (lambda (f) (let fnrec273 ((f f)) (jolt-invoke f))) fns))))) pcalls)))
+  (def-var! "clojure.core" "pcalls" (letrec ((pcalls (lambda fns (let fnrec296 ((fns (list->cseq fns))) (jolt-invoke (var-deref "clojure.core" "pmap") (lambda (f) (let fnrec297 ((f f)) (jolt-invoke f))) fns))))) pcalls)))
 (guard (e (#t #f))
   (def-var-with-meta! "clojure.core" "reader-eof" (keyword "jolt" "reader-eof") (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (begin (def-var! "clojure.core" "IReader" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IReader" (let* ((_o$280 (keyword #f "-read+string")) (_o$281 (let* ((_o$274 (keyword #f "name")) (_o$275 "-read+string")) (jolt-hash-map _o$274 _o$275))) (_o$282 (keyword #f "-read-line")) (_o$283 (let* ((_o$276 (keyword #f "name")) (_o$277 "-read-line")) (jolt-hash-map _o$276 _o$277))) (_o$284 (keyword #f "-read-form")) (_o$285 (let* ((_o$278 (keyword #f "name")) (_o$279 "-read-form")) (jolt-hash-map _o$278 _o$279)))) (jolt-hash-map _o$280 _o$281 _o$282 _o$283 _o$284 _o$285)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IReader" (let* ((_o$286 "-read-line") (_o$287 "-read-form") (_o$288 "-read+string")) (jolt-vector _o$286 _o$287 _o$288))) (def-var! "clojure.core" "-read-line" (lambda (this__11__auto . rest__10__auto) (let fnrec289 ((this__11__auto this__11__auto) (rest__10__auto (list->cseq rest__10__auto))) (jolt-invoke (var-deref "clojure.core" "protocol-dispatch") "IReader" "-read-line" this__11__auto rest__10__auto)))) (def-var! "clojure.core" "-read-form" (lambda (this__11__auto . rest__10__auto) (let fnrec290 ((this__11__auto this__11__auto) (rest__10__auto (list->cseq rest__10__auto))) (jolt-invoke (var-deref "clojure.core" "protocol-dispatch") "IReader" "-read-form" this__11__auto rest__10__auto)))) (def-var! "clojure.core" "-read+string" (lambda (this__11__auto . rest__10__auto) (let fnrec291 ((this__11__auto this__11__auto) (rest__10__auto (list->cseq rest__10__auto))) (jolt-invoke (var-deref "clojure.core" "protocol-dispatch") "IReader" "-read+string" this__11__auto rest__10__auto))))))
+  (begin (def-var! "clojure.core" "IReader" (jolt-invoke (var-deref "clojure.core" "make-protocol") "IReader" (let* ((_o$304 (keyword #f "-read+string")) (_o$305 (let* ((_o$298 (keyword #f "name")) (_o$299 "-read+string")) (jolt-hash-map _o$298 _o$299))) (_o$306 (keyword #f "-read-line")) (_o$307 (let* ((_o$300 (keyword #f "name")) (_o$301 "-read-line")) (jolt-hash-map _o$300 _o$301))) (_o$308 (keyword #f "-read-form")) (_o$309 (let* ((_o$302 (keyword #f "name")) (_o$303 "-read-form")) (jolt-hash-map _o$302 _o$303)))) (jolt-hash-map _o$304 _o$305 _o$306 _o$307 _o$308 _o$309)))) (jolt-invoke (var-deref "clojure.core" "register-protocol-methods!") "IReader" (let* ((_o$310 "-read-line") (_o$311 "-read-form") (_o$312 "-read+string")) (jolt-vector _o$310 _o$311 _o$312))) (def-var! "clojure.core" "-read-line" (lambda (this__11__auto . rest__10__auto) (let fnrec313 ((this__11__auto this__11__auto) (rest__10__auto (list->cseq rest__10__auto))) (jolt-invoke (var-deref "clojure.core" "protocol-dispatch") "IReader" "-read-line" this__11__auto rest__10__auto)))) (def-var! "clojure.core" "-read-form" (lambda (this__11__auto . rest__10__auto) (let fnrec314 ((this__11__auto this__11__auto) (rest__10__auto (list->cseq rest__10__auto))) (jolt-invoke (var-deref "clojure.core" "protocol-dispatch") "IReader" "-read-form" this__11__auto rest__10__auto)))) (def-var! "clojure.core" "-read+string" (lambda (this__11__auto . rest__10__auto) (let fnrec315 ((this__11__auto this__11__auto) (rest__10__auto (list->cseq rest__10__auto))) (jolt-invoke (var-deref "clojure.core" "protocol-dispatch") "IReader" "-read+string" this__11__auto rest__10__auto))))))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "__string-reader" (letrec ((__string-reader (lambda (s) (let fnrec292 ((s s)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "atom") s))) (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$302 (keyword #f "-read+string")) (_o$303 (lambda (_ eof-error? eof-value) (let fnrec293 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") buf)) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$294 eof-value) (_o$295 "")) (jolt-vector _o$294 _o$295))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (let* ((_o$298 (jolt-nth r 0)) (_o$299 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$296 (jolt-count s)) (_a$297 (jolt-count (jolt-nth r 1)))) (- _a$296 _a$297))))) (jolt-vector _o$298 _o$299)))))))) (_o$304 (keyword #f "-read-line")) (_o$305 (lambda (_) (let fnrec300 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") buf))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") i)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) jolt-nil))))) (_o$306 (keyword #f "-read-form")) (_o$307 (lambda (_) (let fnrec301 ((_ _)) (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") buf)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (jolt-nth r 0)))))))) (jolt-hash-map _o$302 _o$303 _o$304 _o$305 _o$306 _o$307)) "IReader")))))) __string-reader)))
+  (def-var! "clojure.core" "__string-reader" (letrec ((__string-reader (lambda (s) (let fnrec316 ((s s)) (let* ((buf (jolt-invoke (var-deref "clojure.core" "atom") s))) (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$326 (keyword #f "-read+string")) (_o$327 (lambda (_ eof-error? eof-value) (let fnrec317 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") buf)) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$318 eof-value) (_o$319 "")) (jolt-vector _o$318 _o$319))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (let* ((_o$322 (jolt-nth r 0)) (_o$323 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$320 (jolt-count s)) (_a$321 (jolt-count (jolt-nth r 1)))) (- _a$320 _a$321))))) (jolt-vector _o$322 _o$323)))))))) (_o$328 (keyword #f "-read-line")) (_o$329 (lambda (_) (let fnrec324 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") buf))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") i)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) jolt-nil))))) (_o$330 (keyword #f "-read-form")) (_o$331 (lambda (_) (let fnrec325 ((_ _)) (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") buf)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "reset!") buf (jolt-nth r 1)) (jolt-nth r 0)))))))) (jolt-hash-map _o$326 _o$327 _o$328 _o$329 _o$330 _o$331)) "IReader")))))) __string-reader)))
 (guard (e (#t #f))
   (def-var-with-meta! "clojure.core" "stdin-buf" (jolt-invoke (var-deref "clojure.core" "atom") "") (jolt-hash-map (keyword #f "private") #t)))
 (guard (e (#t #f))
-  (def-var-with-meta! "clojure.core" "*in*" (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$321 (keyword #f "-read+string")) (_o$322 (lambda (_ eof-error? eof-value) (let fnrec308 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* () (let loop309 () (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") line)) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$310 eof-value) (_o$311 "")) (jolt-vector _o$310 _o$311))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec312 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop309 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (let* ((_o$315 (jolt-nth r 0)) (_o$316 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$313 (jolt-count s)) (_a$314 (jolt-count (jolt-nth r 1)))) (- _a$313 _a$314))))) (jolt-vector _o$315 _o$316)))))))))) (_o$323 (keyword #f "-read-line")) (_o$324 (lambda (_) (let fnrec317 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf")))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") i)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) (jolt-invoke (var-deref "clojure.core" "__stdin-read-line"))))))) (_o$325 (keyword #f "-read-form")) (_o$326 (lambda (_) (let fnrec318 ((_ _)) (let* () (let loop319 () (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") line)) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec320 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop319 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (jolt-nth r 0)))))))))) (jolt-hash-map _o$321 _o$322 _o$323 _o$324 _o$325 _o$326)) "IReader") (jolt-hash-map (keyword #f "dynamic") #t)))
+  (def-var-with-meta! "clojure.core" "*in*" (jolt-invoke (var-deref "clojure.core" "make-reified") (let* ((_o$345 (keyword #f "-read+string")) (_o$346 (lambda (_ eof-error? eof-value) (let fnrec332 ((_ _) (eof-error? eof-error?) (eof-value eof-value)) (let* () (let loop333 () (let* ((s (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))) (r (jolt-invoke (var-deref "clojure.core" "__parse-next") s))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") line)) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) (let* ((_o$334 eof-value) (_o$335 "")) (jolt-vector _o$334 _o$335))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec336 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop333 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (let* ((_o$339 (jolt-nth r 0)) (_o$340 (jolt-invoke (var-deref "clojure.core" "subs") s 0 (let* ((_a$337 (jolt-count s)) (_a$338 (jolt-count (jolt-nth r 1)))) (- _a$337 _a$338))))) (jolt-vector _o$339 _o$340)))))))))) (_o$347 (keyword #f "-read-line")) (_o$348 (lambda (_) (let fnrec341 ((_ _)) (let* ((cur (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf")))) (if (jolt-pos? (jolt-count cur)) (let* ((i (jolt-invoke (var-deref "clojure.core" "str-find") "\n" cur))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") i)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") "") cur) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-invoke (var-deref "clojure.core" "subs") cur (jolt-inc i))) (jolt-invoke (var-deref "clojure.core" "subs") cur 0 i)))) (jolt-invoke (var-deref "clojure.core" "__stdin-read-line"))))))) (_o$349 (keyword #f "-read-form")) (_o$350 (lambda (_) (let fnrec342 ((_ _)) (let* () (let loop343 () (let* ((r (jolt-invoke (var-deref "clojure.core" "__parse-next") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "clojure.core" "stdin-buf"))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") r)) (let* ((line (jolt-invoke (var-deref "clojure.core" "__stdin-read-line")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") line)) (var-deref "clojure.core" "reader-eof") (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "clojure.core" "stdin-buf") (lambda (b) (let fnrec344 ((b b)) (jolt-invoke (var-deref "clojure.core" "str") b line "\n")))) (loop343 )))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "clojure.core" "stdin-buf") (jolt-nth r 1)) (jolt-nth r 0)))))))))) (jolt-hash-map _o$345 _o$346 _o$347 _o$348 _o$349 _o$350)) "IReader") (jolt-hash-map (keyword #f "dynamic") #t)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "read-line" (letrec ((read-line (lambda () (let fnrec327 () (jolt-invoke (var-deref "clojure.core" "-read-line") (var-deref "clojure.core" "*in*")))))) read-line)))
+  (def-var! "clojure.core" "read-line" (letrec ((read-line (lambda () (let fnrec351 () (jolt-invoke (var-deref "clojure.core" "-read-line") (var-deref "clojure.core" "*in*")))))) read-line)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "read" (letrec ((read (case-lambda (() (let fnrec328 () (jolt-invoke read (var-deref "clojure.core" "*in*")))) ((stream) (let fnrec329 ((stream stream)) (let* ((v (jolt-invoke (var-deref "clojure.core" "-read-form") stream))) (if (jolt= v (var-deref "clojure.core" "reader-eof")) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) v)))) ((stream eof-error? eof-value) (let fnrec330 ((stream stream) (eof-error? eof-error?) (eof-value eof-value)) (let* ((v (jolt-invoke (var-deref "clojure.core" "-read-form") stream))) (if (jolt= v (var-deref "clojure.core" "reader-eof")) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) eof-value) v))))))) read)))
+  (def-var! "clojure.core" "read" (letrec ((read (case-lambda (() (let fnrec352 () (jolt-invoke read (var-deref "clojure.core" "*in*")))) ((stream) (let fnrec353 ((stream stream)) (let* ((v (jolt-invoke (var-deref "clojure.core" "-read-form") stream))) (if (jolt= v (var-deref "clojure.core" "reader-eof")) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) v)))) ((stream eof-error? eof-value) (let fnrec354 ((stream stream) (eof-error? eof-error?) (eof-value eof-value)) (let* ((v (jolt-invoke (var-deref "clojure.core" "-read-form") stream))) (if (jolt= v (var-deref "clojure.core" "reader-eof")) (if (jolt-truthy? eof-error?) (jolt-throw (jolt-ex-info "EOF while reading" (jolt-hash-map))) eof-value) v))))))) read)))
 (guard (e (#t #f))
   (def-var! "clojure.core" "with-in-str"
-    (lambda (s . body) (let fnrec331 ((s s) (body (list->cseq body))) (let* ((_a$338 (var-deref "clojure.core" "__sqcat")) (_a$339 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "binding"))) (_a$340 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$335 (var-deref "clojure.core" "__sqvec")) (_a$336 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*in*"))) (_a$337 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$332 (var-deref "clojure.core" "__sqcat")) (_a$333 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__string-reader"))) (_a$334 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$332 _a$333 _a$334))))) (jolt-invoke _a$335 _a$336 _a$337)))) (_a$341 body)) (jolt-invoke _a$338 _a$339 _a$340 _a$341)))))
+    (lambda (s . body) (let fnrec355 ((s s) (body (list->cseq body))) (let* ((_a$362 (var-deref "clojure.core" "__sqcat")) (_a$363 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "binding"))) (_a$364 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$359 (var-deref "clojure.core" "__sqvec")) (_a$360 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "*in*"))) (_a$361 (jolt-invoke (var-deref "clojure.core" "__sq1") (let* ((_a$356 (var-deref "clojure.core" "__sqcat")) (_a$357 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol "clojure.core" "__string-reader"))) (_a$358 (jolt-invoke (var-deref "clojure.core" "__sq1") s))) (jolt-invoke _a$356 _a$357 _a$358))))) (jolt-invoke _a$359 _a$360 _a$361)))) (_a$365 body)) (jolt-invoke _a$362 _a$363 _a$364 _a$365)))))
   (mark-macro! "clojure.core" "with-in-str"))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "read+string" (letrec ((read+string (case-lambda (() (let fnrec342 () (jolt-invoke read+string (var-deref "clojure.core" "*in*")))) ((stream) (let fnrec343 ((stream stream)) (jolt-invoke read+string stream #t jolt-nil))) ((stream eof-error? eof-value) (let fnrec344 ((stream stream) (eof-error? eof-error?) (eof-value eof-value)) (jolt-invoke (var-deref "clojure.core" "-read+string") stream eof-error? eof-value)))))) read+string)))
+  (def-var! "clojure.core" "read+string" (letrec ((read+string (case-lambda (() (let fnrec366 () (jolt-invoke read+string (var-deref "clojure.core" "*in*")))) ((stream) (let fnrec367 ((stream stream)) (jolt-invoke read+string stream #t jolt-nil))) ((stream eof-error? eof-value) (let fnrec368 ((stream stream) (eof-error? eof-error?) (eof-value eof-value)) (jolt-invoke (var-deref "clojure.core" "-read+string") stream eof-error? eof-value)))))) read+string)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "line-seq" (letrec ((line-seq (lambda (rdr) (let fnrec345 ((rdr rdr)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") rdr)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "str-split") "\n" rdr)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec346 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((line (jolt-invoke (var-deref "clojure.core" "-read-line") rdr))) (if (jolt-truthy? line) (jolt-cons line (jolt-invoke line-seq rdr)) jolt-nil))))))))))) line-seq)))
+  (def-var! "clojure.core" "line-seq" (letrec ((line-seq (lambda (rdr) (let fnrec369 ((rdr rdr)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") rdr)) (jolt-seq (jolt-invoke (var-deref "clojure.core" "str-split") "\n" rdr)) (jolt-invoke (var-deref "clojure.core" "make-lazy-seq") (lambda () (let fnrec370 () (jolt-invoke (var-deref "clojure.core" "coll->cells") (let* ((line (jolt-invoke (var-deref "clojure.core" "-read-line") rdr))) (if (jolt-truthy? line) (jolt-cons line (jolt-invoke line-seq rdr)) jolt-nil))))))))))) line-seq)))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmulti-setup") (jolt-symbol #f "print-method") (lambda (x writer) (let fnrec347 ((x x) (writer writer)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") x) (keyword #f "type")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") t)) t (jolt-invoke (var-deref "clojure.core" "type") x)))))))
+  (jolt-invoke (var-deref "clojure.core" "defmulti-setup") (jolt-symbol #f "print-method") (lambda (x writer) (let fnrec371 ((x x) (writer writer)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") x) (keyword #f "type")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") t)) t (jolt-invoke (var-deref "clojure.core" "type") x)))))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword #f "default") (lambda (o w) (let fnrec348 ((o o) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "__pr-str1") o))) jolt-nil)))))
+  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword #f "default") (lambda (o w) (let fnrec372 ((o o) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "__pr-str1") o))) jolt-nil)))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmulti-setup") (jolt-symbol #f "print-dup") (lambda (x writer) (let fnrec349 ((x x) (writer writer)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") x) (keyword #f "type")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") t)) t (jolt-invoke (var-deref "clojure.core" "type") x)))))))
+  (jolt-invoke (var-deref "clojure.core" "defmulti-setup") (jolt-symbol #f "print-dup") (lambda (x writer) (let fnrec373 ((x x) (writer writer)) (let* ((t (jolt-get (jolt-invoke (var-deref "clojure.core" "meta") x) (keyword #f "type")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") t)) t (jolt-invoke (var-deref "clojure.core" "type") x)))))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-dup") (keyword #f "default") (lambda (o w) (let fnrec350 ((o o) (w w)) (jolt-invoke (var-deref "clojure.core" "print-method") o w)))))
+  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-dup") (keyword #f "default") (lambda (o w) (let fnrec374 ((o o) (w w)) (jolt-invoke (var-deref "clojure.core" "print-method") o w)))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "uuid") (lambda (u w) (let fnrec351 ((u u) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "#uuid \"" (jolt-get u (keyword #f "str")) "\""))) jolt-nil)))))
+  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "uuid") (lambda (u w) (let fnrec375 ((u u) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "#uuid \"" (jolt-get u (keyword #f "str")) "\""))) jolt-nil)))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "regex") (lambda (re w) (let fnrec352 ((re re) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "#\"" (jolt-get re (keyword #f "source")) "\""))) jolt-nil)))))
+  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "regex") (lambda (re w) (let fnrec376 ((re re) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "#\"" (jolt-get re (keyword #f "source")) "\""))) jolt-nil)))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "transient") (lambda (t w) (let fnrec353 ((t t) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "#<transient " (jolt-invoke (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "ref-get") t (keyword #f "kind"))) ">"))) jolt-nil)))))
+  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "transient") (lambda (t w) (let fnrec377 ((t t) (w w)) (begin (record-method-dispatch w "write" (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "#<transient " (jolt-invoke (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "ref-get") t (keyword #f "kind"))) ">"))) jolt-nil)))))
 (guard (e (#t #f))
-  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "chan") (lambda (c w) (let fnrec354 ((c c) (w w)) (begin (record-method-dispatch w "write" (jolt-vector "#<channel>")) jolt-nil)))))
+  (jolt-invoke (var-deref "clojure.core" "defmethod-setup") (jolt-symbol #f "print-method") (keyword "jolt" "chan") (lambda (c w) (let fnrec378 ((c c) (w w)) (begin (record-method-dispatch w "write" (jolt-vector "#<channel>")) jolt-nil)))))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "agent" (letrec ((agent (lambda (state . _opts) (let fnrec355 ((state state) (_opts (list->cseq _opts))) (jolt-invoke (var-deref "clojure.core" "atom") state))))) agent)))
+  (def-var! "clojure.core" "agent" (letrec ((agent (lambda (state . _opts) (let fnrec379 ((state state) (_opts (list->cseq _opts))) (jolt-invoke (var-deref "clojure.core" "atom") state))))) agent)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "send-off" (letrec ((send-off (lambda (a f . args) (let fnrec356 ((a a) (f f) (args (list->cseq args))) (begin (jolt-apply (var-deref "clojure.core" "swap!") a f args) a))))) send-off)))
+  (def-var! "clojure.core" "send-off" (letrec ((send-off (lambda (a f . args) (let fnrec380 ((a a) (f f) (args (list->cseq args))) (begin (jolt-apply (var-deref "clojure.core" "swap!") a f args) a))))) send-off)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "send" (letrec ((send (lambda (a f . args) (let fnrec357 ((a a) (f f) (args (list->cseq args))) (begin (jolt-apply (var-deref "clojure.core" "swap!") a f args) a))))) send)))
+  (def-var! "clojure.core" "send" (letrec ((send (lambda (a f . args) (let fnrec381 ((a a) (f f) (args (list->cseq args))) (begin (jolt-apply (var-deref "clojure.core" "swap!") a f args) a))))) send)))
 (guard (e (#t #f))
-  (def-var! "clojure.core" "agent-error" (letrec ((agent-error (lambda (_a) (let fnrec358 ((_a _a)) jolt-nil)))) agent-error)))
+  (def-var! "clojure.core" "agent-error" (letrec ((agent-error (lambda (_a) (let fnrec382 ((_a _a)) jolt-nil)))) agent-error)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "blank?" (letrec ((blank? (lambda (s) (let fnrec101 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") s)) #t (jolt= 0 (jolt-count (jolt-invoke (var-deref "clojure.core" "str-trim") s)))))))) blank?)))
+  (def-var! "clojure.string" "blank?" (letrec ((blank? (lambda (s) (let fnrec113 ((s s)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") s)) #t (jolt= 0 (jolt-count (jolt-invoke (var-deref "clojure.core" "str-trim") s)))))))) blank?)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "capitalize" (letrec ((capitalize (lambda (s) (let fnrec102 ((s s)) (if (< 1 (jolt-count s)) (let* ((_a$103 (var-deref "clojure.core" "str")) (_a$104 (jolt-invoke (var-deref "clojure.core" "str-upper") (jolt-invoke (var-deref "clojure.core" "subs") s 0 1))) (_a$105 (jolt-invoke (var-deref "clojure.core" "str-lower") (jolt-invoke (var-deref "clojure.core" "subs") s 1)))) (jolt-invoke _a$103 _a$104 _a$105)) (jolt-invoke (var-deref "clojure.core" "str-upper") s)))))) capitalize)))
+  (def-var! "clojure.string" "capitalize" (letrec ((capitalize (lambda (s) (let fnrec114 ((s s)) (if (< 1 (jolt-count s)) (let* ((_a$115 (var-deref "clojure.core" "str")) (_a$116 (jolt-invoke (var-deref "clojure.core" "str-upper") (jolt-invoke (var-deref "clojure.core" "subs") s 0 1))) (_a$117 (jolt-invoke (var-deref "clojure.core" "str-lower") (jolt-invoke (var-deref "clojure.core" "subs") s 1)))) (jolt-invoke _a$115 _a$116 _a$117)) (jolt-invoke (var-deref "clojure.core" "str-upper") s)))))) capitalize)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "lower-case" (letrec ((lower-case (lambda (s) (let fnrec106 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-lower") s))))) lower-case)))
+  (def-var! "clojure.string" "lower-case" (letrec ((lower-case (lambda (s) (let fnrec118 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-lower") s))))) lower-case)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "upper-case" (letrec ((upper-case (lambda (s) (let fnrec107 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-upper") s))))) upper-case)))
+  (def-var! "clojure.string" "upper-case" (letrec ((upper-case (lambda (s) (let fnrec119 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-upper") s))))) upper-case)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "includes?" (letrec ((includes? (lambda (s substr) (let fnrec108 ((s s) (substr substr)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "str-find") substr s))))))) includes?)))
+  (def-var! "clojure.string" "includes?" (letrec ((includes? (lambda (s substr) (let fnrec120 ((s s) (substr substr)) (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "clojure.core" "str-find") substr s))))))) includes?)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "join" (letrec ((join (case-lambda ((coll) (let fnrec109 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "str-join") coll))) ((separator coll) (let fnrec110 ((separator separator) (coll coll)) (jolt-invoke (var-deref "clojure.core" "str-join") coll separator)))))) join)))
+  (def-var! "clojure.string" "join" (letrec ((join (case-lambda ((coll) (let fnrec121 ((coll coll)) (jolt-invoke (var-deref "clojure.core" "str-join") coll))) ((separator coll) (let fnrec122 ((separator separator) (coll coll)) (jolt-invoke (var-deref "clojure.core" "str-join") coll separator)))))) join)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "replace" (letrec ((replace (lambda (s match replacement) (let fnrec111 ((s s) (match match) (replacement replacement)) (jolt-invoke (var-deref "clojure.core" "str-replace-all") match replacement s))))) replace)))
+  (def-var! "clojure.string" "replace" (letrec ((replace (lambda (s match replacement) (let fnrec123 ((s s) (match match) (replacement replacement)) (jolt-invoke (var-deref "clojure.core" "str-replace-all") match replacement s))))) replace)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "replace-first" (letrec ((replace-first (lambda (s match replacement) (let fnrec112 ((s s) (match match) (replacement replacement)) (jolt-invoke (var-deref "clojure.core" "str-replace") match replacement s))))) replace-first)))
+  (def-var! "clojure.string" "replace-first" (letrec ((replace-first (lambda (s match replacement) (let fnrec124 ((s s) (match match) (replacement replacement)) (jolt-invoke (var-deref "clojure.core" "str-replace") match replacement s))))) replace-first)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "reverse" (letrec ((reverse (lambda (s) (let fnrec113 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-reverse-b") s))))) reverse)))
+  (def-var! "clojure.string" "reverse" (letrec ((reverse (lambda (s) (let fnrec125 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-reverse-b") s))))) reverse)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "str-reverse" (letrec ((str-reverse (lambda (s) (let fnrec114 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-reverse-b") s))))) str-reverse)))
+  (def-var! "clojure.string" "str-reverse" (letrec ((str-reverse (lambda (s) (let fnrec126 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-reverse-b") s))))) str-reverse)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "split" (letrec ((split (case-lambda ((s re) (let fnrec115 ((s s) (re re)) (jolt-invoke split s re 0))) ((s re limit) (let fnrec116 ((s s) (re re) (limit limit)) (let* ((parts (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "str-split") re s (if (jolt-pos? limit) limit jolt-nil))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-zero? limit))) (if (jolt-truthy? and__13__auto) (> (jolt-count parts) 1) and__13__auto))) (let* ((v parts)) (let loop117 ((v v)) (if (jolt-truthy? (let* ((and__13__auto (jolt-seq v))) (if (jolt-truthy? and__13__auto) (jolt= "" (jolt-peek v)) and__13__auto))) (loop117 (jolt-pop v)) v))) parts))))))) split)))
+  (def-var! "clojure.string" "split" (letrec ((split (case-lambda ((s re) (let fnrec127 ((s s) (re re)) (jolt-invoke split s re 0))) ((s re limit) (let fnrec128 ((s s) (re re) (limit limit)) (let* ((parts (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "str-split") re s (if (jolt-pos? limit) limit jolt-nil))))) (if (jolt-truthy? (let* ((and__13__auto (jolt-zero? limit))) (if (jolt-truthy? and__13__auto) (> (jolt-count parts) 1) and__13__auto))) (let* ((v parts)) (let loop129 ((v v)) (if (jolt-truthy? (let* ((and__13__auto (jolt-seq v))) (if (jolt-truthy? and__13__auto) (jolt= "" (jolt-peek v)) and__13__auto))) (loop129 (jolt-pop v)) v))) parts))))))) split)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "split-lines" (letrec ((split-lines (lambda (s) (let fnrec118 ((s s)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "str-split") (jolt-regex "\\r?\\n") s)))))) split-lines)))
+  (def-var! "clojure.string" "split-lines" (letrec ((split-lines (lambda (s) (let fnrec130 ((s s)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "str-split") (jolt-regex "\\r?\\n") s)))))) split-lines)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "starts-with?" (letrec ((starts-with? (lambda (s substr) (let fnrec119 ((s s) (substr substr)) (let* ((slen (jolt-count s)) (slen2 (jolt-count substr))) (let* ((and__13__auto (>= slen slen2))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-invoke (var-deref "clojure.core" "subs") s 0 slen2) substr) and__13__auto))))))) starts-with?)))
+  (def-var! "clojure.string" "starts-with?" (letrec ((starts-with? (lambda (s substr) (let fnrec131 ((s s) (substr substr)) (let* ((slen (jolt-count s)) (slen2 (jolt-count substr))) (let* ((and__13__auto (>= slen slen2))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-invoke (var-deref "clojure.core" "subs") s 0 slen2) substr) and__13__auto))))))) starts-with?)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "ends-with?" (letrec ((ends-with? (lambda (s substr) (let fnrec120 ((s s) (substr substr)) (let* ((slen (jolt-count s)) (slen2 (jolt-count substr))) (let* ((and__13__auto (>= slen slen2))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-invoke (var-deref "clojure.core" "subs") s (- slen slen2)) substr) and__13__auto))))))) ends-with?)))
+  (def-var! "clojure.string" "ends-with?" (letrec ((ends-with? (lambda (s substr) (let fnrec132 ((s s) (substr substr)) (let* ((slen (jolt-count s)) (slen2 (jolt-count substr))) (let* ((and__13__auto (>= slen slen2))) (if (jolt-truthy? and__13__auto) (jolt= (jolt-invoke (var-deref "clojure.core" "subs") s (- slen slen2)) substr) and__13__auto))))))) ends-with?)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "trim" (letrec ((trim (lambda (s) (let fnrec121 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-trim") s))))) trim)))
+  (def-var! "clojure.string" "trim" (letrec ((trim (lambda (s) (let fnrec133 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-trim") s))))) trim)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "triml" (letrec ((triml (lambda (s) (let fnrec122 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-triml") s))))) triml)))
+  (def-var! "clojure.string" "triml" (letrec ((triml (lambda (s) (let fnrec134 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-triml") s))))) triml)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "trimr" (letrec ((trimr (lambda (s) (let fnrec123 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-trimr") s))))) trimr)))
+  (def-var! "clojure.string" "trimr" (letrec ((trimr (lambda (s) (let fnrec135 ((s s)) (jolt-invoke (var-deref "clojure.core" "str-trimr") s))))) trimr)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "escape" (letrec ((escape (lambda (s cmap) (let fnrec124 ((s s) (cmap cmap)) (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (ch) (let fnrec125 ((ch ch)) (let* ((temp__4__auto (jolt-invoke cmap ch))) (if (jolt-truthy? temp__4__auto) (let* ((rep temp__4__auto)) rep) (jolt-invoke (var-deref "clojure.core" "str") ch))))) s)))))) escape)))
+  (def-var! "clojure.string" "escape" (letrec ((escape (lambda (s cmap) (let fnrec136 ((s s) (cmap cmap)) (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (ch) (let fnrec137 ((ch ch)) (let* ((temp__4__auto (jolt-invoke cmap ch))) (if (jolt-truthy? temp__4__auto) (let* ((rep temp__4__auto)) rep) (jolt-invoke (var-deref "clojure.core" "str") ch))))) s)))))) escape)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "index-of" (letrec ((index-of (case-lambda ((s value) (let fnrec126 ((s s) (value value)) (jolt-invoke (var-deref "clojure.core" "str-find") value s))) ((s value from) (let fnrec127 ((s s) (value value) (from from)) (let* ((idx (jolt-invoke (var-deref "clojure.core" "str-find") value (jolt-invoke (var-deref "clojure.core" "subs") s from)))) (if (jolt-truthy? idx) (+ from idx) jolt-nil))))))) index-of)))
+  (def-var! "clojure.string" "index-of" (letrec ((index-of (case-lambda ((s value) (let fnrec138 ((s s) (value value)) (jolt-invoke (var-deref "clojure.core" "str-find") value s))) ((s value from) (let fnrec139 ((s s) (value value) (from from)) (let* ((idx (jolt-invoke (var-deref "clojure.core" "str-find") value (jolt-invoke (var-deref "clojure.core" "subs") s from)))) (if (jolt-truthy? idx) (+ from idx) jolt-nil))))))) index-of)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "last-index-of" (letrec ((last-index-of (case-lambda ((s value) (let fnrec128 ((s s) (value value)) (let* ((r (jolt-invoke (var-deref "clojure.core" "str-reverse-b") s)) (sval (jolt-invoke (var-deref "clojure.core" "str-reverse-b") value)) (idx (jolt-invoke (var-deref "clojure.core" "str-find") sval r))) (if (jolt-truthy? idx) (let* ((_a$129 (jolt-count s)) (_a$130 (+ idx (jolt-count value)))) (- _a$129 _a$130)) jolt-nil)))) ((s value from) (let fnrec131 ((s s) (value value) (from from)) (let* ((sub (jolt-invoke (var-deref "clojure.core" "subs") s 0 from)) (r (jolt-invoke (var-deref "clojure.core" "str-reverse-b") sub)) (sval (jolt-invoke (var-deref "clojure.core" "str-reverse-b") value)) (idx (jolt-invoke (var-deref "clojure.core" "str-find") sval r))) (if (jolt-truthy? idx) (- from (+ idx (jolt-count value))) jolt-nil))))))) last-index-of)))
+  (def-var! "clojure.string" "last-index-of" (letrec ((last-index-of (case-lambda ((s value) (let fnrec140 ((s s) (value value)) (let* ((r (jolt-invoke (var-deref "clojure.core" "str-reverse-b") s)) (sval (jolt-invoke (var-deref "clojure.core" "str-reverse-b") value)) (idx (jolt-invoke (var-deref "clojure.core" "str-find") sval r))) (if (jolt-truthy? idx) (let* ((_a$141 (jolt-count s)) (_a$142 (+ idx (jolt-count value)))) (- _a$141 _a$142)) jolt-nil)))) ((s value from) (let fnrec143 ((s s) (value value) (from from)) (let* ((sub (jolt-invoke (var-deref "clojure.core" "subs") s 0 from)) (r (jolt-invoke (var-deref "clojure.core" "str-reverse-b") sub)) (sval (jolt-invoke (var-deref "clojure.core" "str-reverse-b") value)) (idx (jolt-invoke (var-deref "clojure.core" "str-find") sval r))) (if (jolt-truthy? idx) (- from (+ idx (jolt-count value))) jolt-nil))))))) last-index-of)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "re-quote-replacement" (letrec ((re-quote-replacement (lambda (replacement) (let fnrec132 ((replacement replacement)) (jolt-apply (var-deref "clojure.core" "str") (let* ((_a$134 (lambda (ch) (let fnrec133 ((ch ch)) (let* ((c (jolt-invoke (var-deref "clojure.core" "str") ch))) (if (jolt-truthy? (let* ((or__14__auto (jolt= c "\\"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= c "$")))) (jolt-invoke (var-deref "clojure.core" "str") "\\" c) c))))) (_a$135 (jolt-seq replacement))) (jolt-map _a$134 _a$135))))))) re-quote-replacement)))
+  (def-var! "clojure.string" "re-quote-replacement" (letrec ((re-quote-replacement (lambda (replacement) (let fnrec144 ((replacement replacement)) (jolt-apply (var-deref "clojure.core" "str") (let* ((_a$146 (lambda (ch) (let fnrec145 ((ch ch)) (let* ((c (jolt-invoke (var-deref "clojure.core" "str") ch))) (if (jolt-truthy? (let* ((or__14__auto (jolt= c "\\"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= c "$")))) (jolt-invoke (var-deref "clojure.core" "str") "\\" c) c))))) (_a$147 (jolt-seq replacement))) (jolt-map _a$146 _a$147))))))) re-quote-replacement)))
 (guard (e (#t #f))
-  (def-var! "clojure.string" "trim-newline" (letrec ((trim-newline (lambda (s) (let fnrec136 ((s s)) (let* ((index (jolt-count s))) (let loop137 ((index index)) (if (jolt-zero? index) "" (let* ((c (jolt-invoke (var-deref "clojure.core" "subs") s (jolt-dec index) index))) (if (jolt-truthy? (let* ((or__14__auto (jolt= c "\n"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= c "\r")))) (loop137 (jolt-dec index)) (jolt-invoke (var-deref "clojure.core" "subs") s 0 index)))))))))) trim-newline)))
+  (def-var! "clojure.string" "trim-newline" (letrec ((trim-newline (lambda (s) (let fnrec148 ((s s)) (let* ((index (jolt-count s))) (let loop149 ((index index)) (if (jolt-zero? index) "" (let* ((c (jolt-invoke (var-deref "clojure.core" "subs") s (jolt-dec index) index))) (if (jolt-truthy? (let* ((or__14__auto (jolt= c "\n"))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt= c "\r")))) (loop149 (jolt-dec index)) (jolt-invoke (var-deref "clojure.core" "subs") s 0 index)))))))))) trim-newline)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "walk" (letrec ((walk (lambda (inner outer form) (let fnrec138 ((inner inner) (outer outer) (form form)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke outer (jolt-invoke (var-deref "clojure.core" "vec") (jolt-map inner form))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "record?") form)) (jolt-invoke outer (jolt-reduce (lambda (r x) (let fnrec139 ((r r) (x x)) (jolt-conj r (jolt-invoke inner x)))) form form)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke outer (let* ((_a$140 (jolt-invoke (var-deref "clojure.core" "empty") form)) (_a$141 (jolt-map inner form))) (jolt-into _a$140 _a$141))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "list?") form)) (jolt-invoke outer (jolt-apply jolt-list (jolt-map inner form))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke outer (jolt-map inner form)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke outer form) jolt-nil)))))))))) walk)))
+  (def-var! "clojure.walk" "walk" (letrec ((walk (lambda (inner outer form) (let fnrec150 ((inner inner) (outer outer) (form form)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke outer (let* ((_a$151 (var-deref "clojure.core" "with-meta")) (_a$152 (jolt-invoke (var-deref "clojure.core" "vec") (jolt-map inner form))) (_a$153 (jolt-invoke (var-deref "clojure.core" "meta") form))) (jolt-invoke _a$151 _a$152 _a$153))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "record?") form)) (jolt-invoke outer (jolt-reduce (lambda (r x) (let fnrec154 ((r r) (x x)) (jolt-conj r (jolt-invoke inner x)))) form form)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke outer (let* ((_a$157 (var-deref "clojure.core" "with-meta")) (_a$158 (let* ((_a$155 (jolt-invoke (var-deref "clojure.core" "empty") form)) (_a$156 (jolt-map inner form))) (jolt-into _a$155 _a$156))) (_a$159 (jolt-invoke (var-deref "clojure.core" "meta") form))) (jolt-invoke _a$157 _a$158 _a$159))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "list?") form)) (jolt-invoke outer (let* ((_a$160 (var-deref "clojure.core" "with-meta")) (_a$161 (jolt-apply jolt-list (jolt-map inner form))) (_a$162 (jolt-invoke (var-deref "clojure.core" "meta") form))) (jolt-invoke _a$160 _a$161 _a$162))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke outer (let* ((_a$163 (var-deref "clojure.core" "with-meta")) (_a$164 (jolt-map inner form)) (_a$165 (jolt-invoke (var-deref "clojure.core" "meta") form))) (jolt-invoke _a$163 _a$164 _a$165))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke outer form) jolt-nil)))))))))) walk)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "postwalk" (letrec ((postwalk (lambda (f form) (let fnrec142 ((f f) (form form)) (jolt-invoke (var-deref "clojure.walk" "walk") (jolt-invoke (var-deref "clojure.core" "partial") postwalk f) f form))))) postwalk)))
+  (def-var! "clojure.walk" "postwalk" (letrec ((postwalk (lambda (f form) (let fnrec166 ((f f) (form form)) (jolt-invoke (var-deref "clojure.walk" "walk") (jolt-invoke (var-deref "clojure.core" "partial") postwalk f) f form))))) postwalk)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "prewalk" (letrec ((prewalk (lambda (f form) (let fnrec143 ((f f) (form form)) (let* ((_a$144 (var-deref "clojure.walk" "walk")) (_a$145 (jolt-invoke (var-deref "clojure.core" "partial") prewalk f)) (_a$146 jolt-identity) (_a$147 (jolt-invoke f form))) (jolt-invoke _a$144 _a$145 _a$146 _a$147)))))) prewalk)))
+  (def-var! "clojure.walk" "prewalk" (letrec ((prewalk (lambda (f form) (let fnrec167 ((f f) (form form)) (let* ((_a$168 (var-deref "clojure.walk" "walk")) (_a$169 (jolt-invoke (var-deref "clojure.core" "partial") prewalk f)) (_a$170 jolt-identity) (_a$171 (jolt-invoke f form))) (jolt-invoke _a$168 _a$169 _a$170 _a$171)))))) prewalk)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "postwalk-demo" (letrec ((postwalk-demo (lambda (form) (let fnrec148 ((form form)) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec149 ((x x)) (begin (jolt-invoke (var-deref "clojure.core" "print") "Walked: ") (jolt-invoke (var-deref "clojure.core" "prn") x) x))) form))))) postwalk-demo)))
+  (def-var! "clojure.walk" "postwalk-demo" (letrec ((postwalk-demo (lambda (form) (let fnrec172 ((form form)) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec173 ((x x)) (begin (jolt-invoke (var-deref "clojure.core" "print") "Walked: ") (jolt-invoke (var-deref "clojure.core" "prn") x) x))) form))))) postwalk-demo)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "prewalk-demo" (letrec ((prewalk-demo (lambda (form) (let fnrec150 ((form form)) (jolt-invoke (var-deref "clojure.walk" "prewalk") (lambda (x) (let fnrec151 ((x x)) (begin (jolt-invoke (var-deref "clojure.core" "print") "Walked: ") (jolt-invoke (var-deref "clojure.core" "prn") x) x))) form))))) prewalk-demo)))
+  (def-var! "clojure.walk" "prewalk-demo" (letrec ((prewalk-demo (lambda (form) (let fnrec174 ((form form)) (jolt-invoke (var-deref "clojure.walk" "prewalk") (lambda (x) (let fnrec175 ((x x)) (begin (jolt-invoke (var-deref "clojure.core" "print") "Walked: ") (jolt-invoke (var-deref "clojure.core" "prn") x) x))) form))))) prewalk-demo)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "postwalk-replace" (letrec ((postwalk-replace (lambda (smap form) (let fnrec152 ((smap smap) (form form)) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec153 ((x x)) (if (jolt-contains? smap x) (jolt-get smap x) x))) form))))) postwalk-replace)))
+  (def-var! "clojure.walk" "postwalk-replace" (letrec ((postwalk-replace (lambda (smap form) (let fnrec176 ((smap smap) (form form)) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec177 ((x x)) (if (jolt-contains? smap x) (jolt-get smap x) x))) form))))) postwalk-replace)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "prewalk-replace" (letrec ((prewalk-replace (lambda (smap form) (let fnrec154 ((smap smap) (form form)) (jolt-invoke (var-deref "clojure.walk" "prewalk") (lambda (x) (let fnrec155 ((x x)) (if (jolt-contains? smap x) (jolt-get smap x) x))) form))))) prewalk-replace)))
+  (def-var! "clojure.walk" "prewalk-replace" (letrec ((prewalk-replace (lambda (smap form) (let fnrec178 ((smap smap) (form form)) (jolt-invoke (var-deref "clojure.walk" "prewalk") (lambda (x) (let fnrec179 ((x x)) (if (jolt-contains? smap x) (jolt-get smap x) x))) form))))) prewalk-replace)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "keywordize-keys" (letrec ((keywordize-keys (lambda (m) (let fnrec156 ((m m)) (let* ((f (lambda (G__9) (let fnrec157 ((G__9 G__9)) (let* ((G__10 G__9) (k (jolt-nth G__10 0 jolt-nil)) (v (jolt-nth G__10 1 jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") k)) (let* ((_o$158 (jolt-invoke (var-deref "clojure.core" "keyword") k)) (_o$159 v)) (jolt-vector _o$158 _o$159)) (let* ((_o$160 k) (_o$161 v)) (jolt-vector _o$160 _o$161)))))))) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec162 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$163 (jolt-hash-map)) (_a$164 (jolt-map f x))) (jolt-into _a$163 _a$164)) x))) m)))))) keywordize-keys)))
+  (def-var! "clojure.walk" "keywordize-keys" (letrec ((keywordize-keys (lambda (m) (let fnrec180 ((m m)) (let* ((f (lambda (G__9) (let fnrec181 ((G__9 G__9)) (let* ((G__10 G__9) (k (jolt-nth G__10 0 jolt-nil)) (v (jolt-nth G__10 1 jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") k)) (let* ((_o$182 (jolt-invoke (var-deref "clojure.core" "keyword") k)) (_o$183 v)) (jolt-vector _o$182 _o$183)) (let* ((_o$184 k) (_o$185 v)) (jolt-vector _o$184 _o$185)))))))) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec186 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$187 (jolt-hash-map)) (_a$188 (jolt-map f x))) (jolt-into _a$187 _a$188)) x))) m)))))) keywordize-keys)))
 (guard (e (#t #f))
-  (def-var! "clojure.walk" "stringify-keys" (letrec ((stringify-keys (lambda (m) (let fnrec165 ((m m)) (let* ((f (lambda (G__11) (let fnrec166 ((G__11 G__11)) (let* ((G__12 G__11) (k (jolt-nth G__12 0 jolt-nil)) (v (jolt-nth G__12 1 jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") k)) (let* ((_o$167 (jolt-invoke (var-deref "clojure.core" "name") k)) (_o$168 v)) (jolt-vector _o$167 _o$168)) (let* ((_o$169 k) (_o$170 v)) (jolt-vector _o$169 _o$170)))))))) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec171 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$172 (jolt-hash-map)) (_a$173 (jolt-map f x))) (jolt-into _a$172 _a$173)) x))) m)))))) stringify-keys)))
+  (def-var! "clojure.walk" "stringify-keys" (letrec ((stringify-keys (lambda (m) (let fnrec189 ((m m)) (let* ((f (lambda (G__11) (let fnrec190 ((G__11 G__11)) (let* ((G__12 G__11) (k (jolt-nth G__12 0 jolt-nil)) (v (jolt-nth G__12 1 jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") k)) (let* ((_o$191 (jolt-invoke (var-deref "clojure.core" "name") k)) (_o$192 v)) (jolt-vector _o$191 _o$192)) (let* ((_o$193 k) (_o$194 v)) (jolt-vector _o$193 _o$194)))))))) (jolt-invoke (var-deref "clojure.walk" "postwalk") (lambda (x) (let fnrec195 ((x x)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$196 (jolt-hash-map)) (_a$197 (jolt-map f x))) (jolt-into _a$196 _a$197)) x))) m)))))) stringify-keys)))
 (guard (e (#t #f))
   (def-var! "clojure.template" "apply-template" (letrec ((apply-template (lambda (argv expr _values) (let fnrec73 ((argv argv) (expr expr) (_values _values)) (begin (if (jolt-not (jolt-invoke (var-deref "clojure.core" "vector?") argv)) (jolt-throw (jolt-ex-info "Assert failed: (vector? argv)" (jolt-hash-map))) jolt-nil) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "clojure.core" "symbol?") argv)) (jolt-throw (jolt-ex-info "Assert failed: (every? symbol? argv)" (jolt-hash-map))) jolt-nil) (jolt-invoke (var-deref "clojure.walk" "postwalk-replace") (jolt-invoke (var-deref "clojure.core" "zipmap") argv _values) expr)))))) apply-template)))
 (guard (e (#t #f))
@@ -1057,15 +1057,15 @@
     (lambda (argv expr . _values) (let fnrec74 ((argv argv) (expr expr) (_values (list->cseq _values))) (let* ((c (jolt-count argv))) (let* ((_a$78 (var-deref "clojure.core" "__sqcat")) (_a$79 (jolt-invoke (var-deref "clojure.core" "__sq1") (jolt-symbol #f "do"))) (_a$80 (let* ((_a$76 (lambda (a) (let fnrec75 ((a a)) (jolt-invoke (var-deref "clojure.template" "apply-template") argv expr a)))) (_a$77 (jolt-invoke (var-deref "clojure.core" "partition") c _values))) (jolt-map _a$76 _a$77)))) (jolt-invoke _a$78 _a$79 _a$80))))))
   (mark-macro! "clojure.template" "do-template"))
 (guard (e (#t #f))
-  (def-var! "clojure.edn" "edn->value" (letrec ((edn->value (lambda (opts x) (let fnrec81 ((opts opts) (x x)) (if (jolt= (keyword "jolt" "set") (jolt-get x (keyword "jolt" "type"))) (jolt-invoke (var-deref "clojure.core" "set") (let* ((_a$83 (lambda (v) (let fnrec82 ((v v)) (jolt-invoke edn->value opts v)))) (_a$84 (jolt-get x (keyword #f "value")))) (jolt-map _a$83 _a$84))) (if (jolt= (keyword "jolt" "tagged") (jolt-get x (keyword "jolt" "type"))) (let* ((tag (jolt-get x (keyword #f "tag"))) (v (jolt-invoke edn->value opts (jolt-get x (keyword #f "form")))) (tag-sym (let* ((n (jolt-invoke (var-deref "clojure.core" "name") tag))) (jolt-invoke (var-deref "clojure.core" "symbol") (if (jolt= "#" (jolt-invoke (var-deref "clojure.core" "subs") n 0 1)) (jolt-invoke (var-deref "clojure.core" "subs") n 1) n)))) (custom (jolt-get (jolt-get opts (keyword #f "readers")) tag-sym))) (if (jolt-truthy? custom) (jolt-invoke custom v) (if (jolt-truthy? (jolt-get opts (keyword #f "default"))) (jolt-invoke (jolt-get opts (keyword #f "default")) tag-sym v) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "__read-tagged") tag v) jolt-nil)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$88 (jolt-hash-map)) (_a$89 (jolt-map (lambda (e) (let fnrec85 ((e e)) (let* ((_o$86 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "key") e))) (_o$87 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "val") e)))) (jolt-vector _o$86 _o$87)))) x))) (jolt-into _a$88 _a$89)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") x)) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (v) (let fnrec90 ((v v)) (jolt-invoke edn->value opts v))) x) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") x)) (jolt-map (lambda (v) (let fnrec91 ((v v)) (jolt-invoke edn->value opts v))) x) (if (jolt-truthy? (keyword #f "else")) x jolt-nil)))))))))) edn->value)))
+  (def-var! "clojure.edn" "edn->value" (letrec ((edn->value (lambda (opts x) (let fnrec81 ((opts opts) (x x)) (if (jolt= (keyword "jolt" "set") (jolt-get x (keyword "jolt" "type"))) (let* ((_a$85 (var-deref "clojure.core" "with-meta")) (_a$86 (jolt-invoke (var-deref "clojure.core" "set") (let* ((_a$83 (lambda (v) (let fnrec82 ((v v)) (jolt-invoke edn->value opts v)))) (_a$84 (jolt-get x (keyword #f "value")))) (jolt-map _a$83 _a$84)))) (_a$87 (jolt-invoke (var-deref "clojure.core" "meta") x))) (jolt-invoke _a$85 _a$86 _a$87)) (if (jolt= (keyword "jolt" "tagged") (jolt-get x (keyword "jolt" "type"))) (let* ((tag (jolt-get x (keyword #f "tag"))) (v (jolt-invoke edn->value opts (jolt-get x (keyword #f "form")))) (tag-sym (let* ((n (jolt-invoke (var-deref "clojure.core" "name") tag))) (jolt-invoke (var-deref "clojure.core" "symbol") (if (jolt= "#" (jolt-invoke (var-deref "clojure.core" "subs") n 0 1)) (jolt-invoke (var-deref "clojure.core" "subs") n 1) n)))) (custom (jolt-get (jolt-get opts (keyword #f "readers")) tag-sym))) (if (jolt-truthy? custom) (jolt-invoke custom v) (if (jolt-truthy? (jolt-get opts (keyword #f "default"))) (jolt-invoke (jolt-get opts (keyword #f "default")) tag-sym v) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "__read-tagged") tag v) jolt-nil)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") x)) (let* ((_a$93 (var-deref "clojure.core" "with-meta")) (_a$94 (let* ((_a$91 (jolt-hash-map)) (_a$92 (jolt-map (lambda (e) (let fnrec88 ((e e)) (let* ((_o$89 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "key") e))) (_o$90 (jolt-invoke edn->value opts (jolt-invoke (var-deref "clojure.core" "val") e)))) (jolt-vector _o$89 _o$90)))) x))) (jolt-into _a$91 _a$92))) (_a$95 (jolt-invoke (var-deref "clojure.core" "meta") x))) (jolt-invoke _a$93 _a$94 _a$95)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") x)) (let* ((_a$97 (var-deref "clojure.core" "with-meta")) (_a$98 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (v) (let fnrec96 ((v v)) (jolt-invoke edn->value opts v))) x)) (_a$99 (jolt-invoke (var-deref "clojure.core" "meta") x))) (jolt-invoke _a$97 _a$98 _a$99)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") x)) (let* ((_a$101 (var-deref "clojure.core" "with-meta")) (_a$102 (jolt-map (lambda (v) (let fnrec100 ((v v)) (jolt-invoke edn->value opts v))) x)) (_a$103 (jolt-invoke (var-deref "clojure.core" "meta") x))) (jolt-invoke _a$101 _a$102 _a$103)) (if (jolt-truthy? (keyword #f "else")) x jolt-nil)))))))))) edn->value)))
 (guard (e (#t #f))
-  (def-var! "clojure.edn" "read-edn" (letrec ((read-edn (lambda (opts s) (let fnrec92 ((opts opts) (s s)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") s))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.string" "blank?") s)))) (jolt-get opts (keyword #f "eof") jolt-nil) (jolt-invoke (var-deref "clojure.edn" "edn->value") opts (jolt-invoke (var-deref "clojure.core" "read-string") s))))))) read-edn)))
+  (def-var! "clojure.edn" "read-edn" (letrec ((read-edn (lambda (opts s) (let fnrec104 ((opts opts) (s s)) (if (jolt-truthy? (let* ((or__14__auto (jolt-invoke (var-deref "clojure.core" "nil?") s))) (if (jolt-truthy? or__14__auto) or__14__auto (jolt-invoke (var-deref "clojure.string" "blank?") s)))) (jolt-get opts (keyword #f "eof") jolt-nil) (jolt-invoke (var-deref "clojure.edn" "edn->value") opts (jolt-invoke (var-deref "clojure.core" "read-string") s))))))) read-edn)))
 (guard (e (#t #f))
-  (def-var! "clojure.edn" "read-string" (letrec ((read-string (case-lambda ((s) (let fnrec93 ((s s)) (jolt-invoke (var-deref "clojure.edn" "read-edn") (jolt-hash-map) s))) ((opts s) (let fnrec94 ((opts opts) (s s)) (jolt-invoke (var-deref "clojure.edn" "read-edn") opts s)))))) read-string)))
+  (def-var! "clojure.edn" "read-string" (letrec ((read-string (case-lambda ((s) (let fnrec105 ((s s)) (jolt-invoke (var-deref "clojure.edn" "read-edn") (jolt-hash-map) s))) ((opts s) (let fnrec106 ((opts opts) (s s)) (jolt-invoke (var-deref "clojure.edn" "read-edn") opts s)))))) read-string)))
 (guard (e (#t #f))
-  (def-var! "clojure.edn" "drain-reader" (letrec ((drain-reader (lambda (reader) (let fnrec95 ((reader reader)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (c (record-method-dispatch reader "read" (jolt-vector)))) (let loop96 ((acc acc) (c c)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "==") -1 c)) (jolt-apply (var-deref "clojure.core" "str") (jolt-map (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "persistent!") acc))) (let* ((_a$97 (jolt-invoke (var-deref "clojure.core" "conj!") acc c)) (_a$98 (record-method-dispatch reader "read" (jolt-vector)))) (loop96 _a$97 _a$98))))))))) drain-reader)))
+  (def-var! "clojure.edn" "drain-reader" (letrec ((drain-reader (lambda (reader) (let fnrec107 ((reader reader)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "transient") (jolt-vector))) (c (record-method-dispatch reader "read" (jolt-vector)))) (let loop108 ((acc acc) (c c)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "==") -1 c)) (jolt-apply (var-deref "clojure.core" "str") (jolt-map (var-deref "clojure.core" "char") (jolt-invoke (var-deref "clojure.core" "persistent!") acc))) (let* ((_a$109 (jolt-invoke (var-deref "clojure.core" "conj!") acc c)) (_a$110 (record-method-dispatch reader "read" (jolt-vector)))) (loop108 _a$109 _a$110))))))))) drain-reader)))
 (guard (e (#t #f))
-  (def-var! "clojure.edn" "read" (letrec ((read (case-lambda ((reader) (let fnrec99 ((reader reader)) (jolt-invoke read (jolt-hash-map) reader))) ((opts reader) (let fnrec100 ((opts opts) (reader reader)) (jolt-invoke (var-deref "clojure.edn" "read-edn") opts (jolt-invoke (var-deref "clojure.edn" "drain-reader") reader))))))) read)))
+  (def-var! "clojure.edn" "read" (letrec ((read (case-lambda ((reader) (let fnrec111 ((reader reader)) (jolt-invoke read (jolt-hash-map) reader))) ((opts reader) (let fnrec112 ((opts opts) (reader reader)) (jolt-invoke (var-deref "clojure.edn" "read-edn") opts (jolt-invoke (var-deref "clojure.edn" "drain-reader") reader))))))) read)))
 (guard (e (#t #f))
   (def-var! "clojure.set" "union" (letrec ((union (case-lambda ((s1) (let fnrec1 ((s1 s1)) s1)) ((s1 s2) (let fnrec2 ((s1 s1) (s2 s2)) (jolt-reduce jolt-conj s2 s1)))))) union)))
 (guard (e (#t #f))
diff --git a/jolt-core/jolt/analyzer.clj b/jolt-core/jolt/analyzer.clj
index 0a1ead9..bd247e6 100644
--- a/jolt-core/jolt/analyzer.clj
+++ b/jolt-core/jolt/analyzer.clj
@@ -26,7 +26,7 @@
                                form-bigdec? form-bigdec-source
                                form-ns-value? form-ns-value-name
                                form-macro? form-expand-1 resolve-global
-                               form-sym-meta host-intern! form-syntax-quote-lower
+                               form-sym-meta form-coll-meta host-intern! form-syntax-quote-lower
                                record-type? record-ctor-key form-position late-bind?
                                resolve-class-hint]]))
 
@@ -590,17 +590,31 @@
                   p (form-position form)]
               (if p (assoc n :pos p) n)))))))
 
+;; A vector/map/set literal carrying reader metadata (^:foo {…}, ^{:tag :int} [1])
+;; keeps it as a runtime value: wrap the collection node in (with-meta coll meta).
+;; The metadata is itself a form (its values may be expressions, ^{:a (f)}), so
+;; analyze it. nil meta passes the node through. Arglist vectors never reach here —
+;; analyze-arity reads their items directly — so a ^Type [args] hint is not wrapped.
+(defn- with-coll-meta [ctx form env node]
+  (let [m (form-coll-meta form)]
+    (if (nil? m)
+      node
+      (invoke (var-ref "clojure.core" "with-meta") [node (analyze ctx m env)]))))
+
 (defn analyze
   ([ctx form] (analyze ctx form (empty-env)))
   ([ctx form env]
    (cond
      (form-literal? form) (const form)
      (form-sym? form) (analyze-symbol ctx form env)
-     (form-vec? form) (vector-node (mapv #(analyze ctx % env) (form-vec-items form)))
-     (form-map? form) (map-node (mapv (fn [p] [(analyze ctx (first p) env)
-                                              (analyze ctx (second p) env)])
-                                     (form-map-pairs form)))
-     (form-set? form) (set-node (mapv #(analyze ctx % env) (form-set-items form)))
+     (form-vec? form) (with-coll-meta ctx form env
+                        (vector-node (mapv #(analyze ctx % env) (form-vec-items form))))
+     (form-map? form) (with-coll-meta ctx form env
+                        (map-node (mapv (fn [p] [(analyze ctx (first p) env)
+                                                 (analyze ctx (second p) env)])
+                                        (form-map-pairs form))))
+     (form-set? form) (with-coll-meta ctx form env
+                        (set-node (mapv #(analyze ctx % env) (form-set-items form))))
      (form-list? form) (analyze-list ctx form env)
      ;; regex literal #"…" -> a :regex IR node (leaf). The Chez back end emits a
      ;; jolt-regex value over the vendored irregex.
diff --git a/stdlib/clojure/edn.clj b/stdlib/clojure/edn.clj
index 66c4f9c..e23f885 100644
--- a/stdlib/clojure/edn.clj
+++ b/stdlib/clojure/edn.clj
@@ -8,12 +8,15 @@
 ;; The reader yields set literals as a FORM ({:jolt/type :jolt/set :value [...]})
 ;; rather than a constructed set, so build the actual values, recursing into
 ;; maps/vectors/lists. (Lists stay lists — EDN never evaluates them as code.)
+;; Re-attach the source value's metadata to each rebuilt collection — read-string
+;; preserves reader metadata (^:ref […]) but this rebuild would otherwise drop it,
+;; which a metadata-driven config lib (aero/integrant) relies on.
 (defn- edn->value [opts x]
   (cond
     ;; Reader FORMS are detected by :jolt/type tag, never by map? — strict map?
     ;; (correctly) excludes tagged structs, so the old (and (map? x) ...) guard
     ;; would skip them.
-    (= :jolt/set (get x :jolt/type)) (set (map (fn [v] (edn->value opts v)) (get x :value)))
+    (= :jolt/set (get x :jolt/type)) (with-meta (set (map (fn [v] (edn->value opts v)) (get x :value))) (meta x))
     ;; Tagged elements: a reader from the :readers opt wins, then the built-in
     ;; data readers (#uuid/#inst + registered); an unknown tag falls to the
     ;; :default opt fn (called with tag and value, as in Clojure) or throws.
@@ -31,9 +34,9 @@
           (get opts :default) ((get opts :default) tag-sym v)
           :else (__read-tagged tag v)))
     (map? x)
-      (into {} (map (fn [e] [(edn->value opts (key e)) (edn->value opts (val e))]) x))
-    (vector? x) (mapv (fn [v] (edn->value opts v)) x)
-    (seq? x) (map (fn [v] (edn->value opts v)) x)
+      (with-meta (into {} (map (fn [e] [(edn->value opts (key e)) (edn->value opts (val e))]) x)) (meta x))
+    (vector? x) (with-meta (mapv (fn [v] (edn->value opts v)) x) (meta x))
+    (seq? x) (with-meta (map (fn [v] (edn->value opts v)) x) (meta x))
     :else x))
 
 ;; Private helper, NOT named read-string: an unqualified (read-string …) call
diff --git a/stdlib/clojure/walk.clj b/stdlib/clojure/walk.clj
index bd9a9aa..fb143e7 100644
--- a/stdlib/clojure/walk.clj
+++ b/stdlib/clojure/walk.clj
@@ -5,19 +5,21 @@
   [inner outer form]
   (cond
     ; vectors/maps first so seq? can't swallow them (a vector is not seq? on
-    ; jolt, but keep the concrete branches authoritative)
-    (vector? form) (outer (vec (map inner form)))
+    ; jolt, but keep the concrete branches authoritative). Re-attach the form's
+    ; metadata to the rebuilt collection, as Clojure does — a metadata-driven walk
+    ; (aero/spec) needs ^:ref and friends to survive the rebuild.
+    (vector? form) (outer (with-meta (vec (map inner form)) (meta form)))
     ; a record is also map?, but (empty record) yields a plain map — rebuild by
     ; conj-ing the walked entries back onto the original so the record TYPE
     ; survives. Type-dispatched walks depend on it (e.g. integrant resolves
     ; #ig/ref by detecting its Ref record while postwalking the config).
     (record? form) (outer (reduce (fn [r x] (conj r (inner x))) form form))
-    (map? form) (outer (into (empty form) (map inner form)))
+    (map? form) (outer (with-meta (into (empty form) (map inner form)) (meta form)))
     ; lists rebuild as lists, other seqs (incl. macro/template output: cons/
     ; concat/lazy-seq) walk too — without this, postwalk-replace silently no-op'd
     ; a quoted list, breaking clojure.template/apply-template
-    (list? form) (outer (apply list (map inner form)))
-    (seq? form) (outer (map inner form))
+    (list? form) (outer (with-meta (apply list (map inner form)) (meta form)))
+    (seq? form) (outer (with-meta (map inner form) (meta form)))
     :else (outer form)))
 
 (defn postwalk

From d19310cb7e030b4492f4a223a1e10622cea70743 Mon Sep 17 00:00:00 2001
From: Yogthos <yogthos@gmail.com>
Date: Wed, 24 Jun 2026 12:04:36 -0400
Subject: [PATCH 14/14] corpus: metadata round-trip rows

---
 test/chez/corpus.edn | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/test/chez/corpus.edn b/test/chez/corpus.edn
index 888dc01..e0519d1 100644
--- a/test/chez/corpus.edn
+++ b/test/chez/corpus.edn
@@ -1046,6 +1046,23 @@
   {:suite "metadata / type hints" :label "type hint in destructure" :expected "3" :actual "(let [{:keys [^long a]} {:a 3}] a)"}
   {:suite "metadata / type hints" :label "symbol hint -> :tag" :expected "\"String\"" :actual "(:tag (meta (read-string \"^String x\")))"}
   {:suite "metadata / type hints" :label "keyword hint -> true" :expected "true" :actual "(:foo (meta (read-string \"^:foo x\")))"}
+  {:suite "metadata / read data metadata" :label "vector data meta" :expected "{:ref true}" :actual "(meta (read-string \"^:ref [:greeting]\"))"}
+  {:suite "metadata / read data metadata" :label "map data meta" :expected "{:k 1}" :actual "(meta (read-string \"^{:k 1} {:a 2}\"))"}
+  {:suite "metadata / read data metadata" :label "set data meta" :expected "{:s true}" :actual "(meta (read-string \"^:s #{1 2}\"))"}
+  {:suite "metadata / read data metadata" :label "nested vector data meta" :expected "{:x true}" :actual "(meta (second (read-string \"[1 ^:x {:a 2}]\")))"}
+  {:suite "metadata / read data metadata" :label "collection value unchanged" :expected "[:greeting]" :actual "(read-string \"^:ref [:greeting]\")"}
+  {:suite "metadata / coll literal in code keeps meta" :label "vector literal meta" :expected "{:foo true}" :actual "(meta ^:foo [1 2])"}
+  {:suite "metadata / coll literal in code keeps meta" :label "map literal meta with expr" :expected "{:a 3}" :actual "(meta ^{:a (+ 1 2)} [1])"}
+  {:suite "metadata / coll literal in code keeps meta" :label "map literal value-eval order" :expected "[1 2]" :actual "(let [a (atom [])] ^:t {(do (swap! a conj 1) :a) 1 (do (swap! a conj 2) :b) 2} @a)"}
+  {:suite "metadata / *print-meta*" :label "pr-str prefixes ^meta" :expected "\"^{:ref true} [:g]\"" :actual "(binding [*print-meta* true] (pr-str (with-meta [:g] {:ref true})))"}
+  {:suite "metadata / *print-meta*" :label "off by default" :expected "\"[:g]\"" :actual "(pr-str (with-meta [:g] {:ref true}))"}
+  {:suite "metadata / *print-meta*" :label "symbol meta prefixed" :expected "\"^{:k 1} x\"" :actual "(binding [*print-meta* true] (pr-str (with-meta (quote x) {:k 1})))"}
+  {:suite "metadata / *print-meta*" :label "print then read round-trips" :expected "{:ref true}" :actual "(meta (read-string (binding [*print-meta* true] (pr-str (with-meta [:g] {:ref true})))))"}
+  {:suite "metadata / clojure.walk preserves meta" :label "postwalk keeps vector meta" :expected "{:ref true}" :actual "(do (require (quote [clojure.walk :as w])) (meta (w/postwalk identity (with-meta [:b] {:ref true}))))"}
+  {:suite "metadata / clojure.walk preserves meta" :label "postwalk keeps map meta" :expected "{:m 1}" :actual "(do (require (quote [clojure.walk :as w])) (meta (w/postwalk identity (with-meta {:a 2} {:m 1}))))"}
+  {:suite "metadata / clojure.edn preserves meta" :label "edn vector meta" :expected "{:ref true}" :actual "(do (require (quote [clojure.edn :as e1])) (meta (e1/read-string \"^:ref [:greeting]\")))"}
+  {:suite "metadata / clojure.edn preserves meta" :label "edn map meta" :expected "{:m true}" :actual "(do (require (quote [clojure.edn :as e1])) (meta (e1/read-string \"^:m {:a 1}\")))"}
+  {:suite "metadata / clojure.edn preserves meta" :label "edn set meta" :expected "{:s true}" :actual "(do (require (quote [clojure.edn :as e1])) (meta (e1/read-string \"^:s #{1}\")))"}
   {:suite "metadata / def metadata" :label "^:dynamic var binds" :expected "9" :actual "(do (def ^:dynamic *d* 1) (binding [*d* 9] *d*))"}
   {:suite "metadata / def metadata" :label "^:private on var" :expected "true" :actual "(do (def ^:private pv 1) (:private (meta (var pv))))"}
   {:suite "metadata / def metadata" :label "^Type tag on var" :expected "java.lang.String" :actual "(do (def ^String tv \"a\") (:tag (meta (var tv))))"}