diff --git a/Makefile b/Makefile
index 1c9587c..d96ca47 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@
 # build step. `make test` is the full gate. `make remint` rebuilds the seed after a
 # source change.
 
-.PHONY: test ci values corpus unit smoke buildsmoke selfhost sci certify ffi transient infer wp devirt fieldread numwp directlink numeric inline shakesmoke remint
+.PHONY: test ci values corpus unit smoke buildsmoke selfhost sci certify ffi transient infer wp devirt fieldread numwp fieldnum directlink numeric inline shakesmoke remint
 
 # Full gate (dev machine). Includes the self-host byte-fixpoint, which only holds
 # on the same Chez that minted the seed.
@@ -15,7 +15,7 @@ test: selfhost ci
 # lockfile) — it RUNS correctly on any Chez, but `selfhost` rebuilds it and a
 # different Chez version may emit byte-different (gensym/order) output, so the
 # byte-fixpoint is a dev-machine check, not a CI one (jolt-8479).
-ci: values corpus unit smoke buildsmoke sci ffi transient infer wp devirt fieldread numwp directlink numeric inline certify
+ci: values corpus unit smoke buildsmoke sci ffi transient infer wp devirt fieldread numwp fieldnum directlink numeric inline certify
 	@echo "OK: CI gates passed"
 
 # Self-host fixpoint: bootstrap.ss rebuild == checked-in seed.
@@ -86,6 +86,12 @@ fieldread:
 numwp:
 	@chez --script host/chez/run-numwp.ss
 
+# Double record fields: a ^double-tagged field reads back as a flonum (coerced at
+# construction and set!), so hintless arithmetic over those fields unboxes to fl-ops;
+# an untagged field stays generic.
+fieldnum:
+	@chez --script host/chez/run-fieldnum.ss
+
 # Direct-linking emission: a closed-world build binds top-level app defs to jv$
 # Scheme bindings and routes app->app calls/refs to them, skipping var-deref +
 # jolt-invoke; ^:dynamic/^:redef and nested defs opt out.
diff --git a/host/chez/records.ss b/host/chez/records.ss
index 437f227..95aeb1c 100644
--- a/host/chez/records.ss
+++ b/host/chez/records.ss
@@ -48,10 +48,17 @@
 (define chez-record-shapes-tbl (make-hashtable string-hash string=?))
 ;; method var-key "ns/method" -> (cons proto-name method-name).
 (define chez-protocol-methods-tbl (make-hashtable string-hash string=?))
+;; type-tag "ns.Name" -> #(bool ...) marking which fields are ^double, so the ctor
+;; and set! coerce them to flonums (JVM primitive-field semantics, and what makes
+;; reading the field back as :double sound for fl-ops).
+(define chez-record-dbl-tbl (make-hashtable string-hash string=?))
+(define (chez-double-tag? t) (and (string? t) (string=? t "double")))
 
 (define (register-record-shape! ctor-key field-kws field-tags type-tag)
   (hashtable-set! chez-record-shapes-tbl ctor-key
-                  (vector field-kws field-tags type-tag)))
+                  (vector field-kws field-tags type-tag))
+  (hashtable-set! chez-record-dbl-tbl type-tag
+                  (list->vector (map chez-double-tag? field-tags))))
 
 ;; simple name of a dotted/slashed string: the segment after the last . or /.
 (define (chez-shape-simple-name s)
@@ -67,6 +74,7 @@
 (define (chez-resolve-field-tag tag by-name)
   (cond ((or (not tag) (jolt-nil-t? tag)) jolt-nil)
         ((string=? tag "num") "num")
+        ((string=? tag "double") "double")   ; a ^double field reads back as a flonum
         (else (let ((ck (hashtable-ref by-name (chez-shape-simple-name tag) #f)))
                 (if ck ck jolt-nil)))))
 
@@ -163,7 +171,13 @@
 (define (jolt-set-field! inst k v)
   (if (jrec? inst)
       (let ((i (jrec-field-index inst k)))
-        (if i (begin (vector-set! (jrec-vals inst) i v) v)
+        (if i (let* ((flags (hashtable-ref chez-record-dbl-tbl (jrec-tag inst) #f))
+                     ;; a ^double field stays a flonum across set!, like the ctor —
+                     ;; keeps a later field read sound to unbox.
+                     (v2 (if (and flags (fx< i (vector-length flags)) (vector-ref flags i)
+                                  (number? v) (not (flonum? v)))
+                             (exact->inexact v) v)))
+                (vector-set! (jrec-vals inst) i v2) v2)
             (error #f "set! of an unknown field" k)))
       (error #f "set! of a field on a non-record" inst)))
 (define (jrec-ext=? ea eb)
@@ -431,6 +445,10 @@
   (let* ((tag (string-append (chez-current-ns) "." (symbol-t-name name-sym)))
          (kws (seq->list field-kws))
          (field-tags (if (pair? rest-args) (seq->list (car rest-args)) '()))
+         ;; which fields are ^double — coerced to a flonum on construction (JVM
+         ;; primitive-field parity), so reading them back is a genuine flonum.
+         (dbl-flags (list->vector (map chez-double-tag? field-tags)))
+         (ndbl (vector-length dbl-flags))
          (desc (make-jrdesc tag kws))
          (nf (length kws))
          (ctor (lambda args
@@ -439,7 +457,12 @@
                  (let ((v (make-vector nf jolt-nil)))
                    (let loop ((as args) (i 0))
                      (if (or (null? as) (= i nf)) (make-jrec desc v jolt-nil)
-                         (begin (vector-set! v i (car as)) (loop (cdr as) (+ i 1)))))))))
+                         (let ((a (car as)))
+                           (vector-set! v i
+                                        (if (and (fx< i ndbl) (vector-ref dbl-flags i)
+                                                 (number? a) (not (flonum? a)))
+                                            (exact->inexact a) a))
+                           (loop (cdr as) (+ i 1)))))))))
     ;; Register the ctor globally by simple class name (like StringBuilder) so
     ;; (Name. …) interop resolves ns-agnostically: a deftype used across files works
     ;; even when the runtime current ns is the caller's, not the defining ns
diff --git a/host/chez/run-fieldnum.ss b/host/chez/run-fieldnum.ss
new file mode 100644
index 0000000..e51091e
--- /dev/null
+++ b/host/chez/run-fieldnum.ss
@@ -0,0 +1,73 @@
+;; run-fieldnum.ss — ^double record field reads unbox to fl-ops (jolt-evr9 R2).
+;;
+;; A record field tagged ^double reads back as a flonum (:double in the lattice),
+;; so hintless arithmetic over those fields — (* (:x a) (:x b)) — lowers to fl-ops,
+;; the same machinery as a ^double param. Two halves pinned here: (1) the ctor
+;; coerces a ^double field to a flonum at construction (JVM parity, and what makes
+;; the fl-op sound), and (2) field-field arithmetic over a record param (typed by
+;; the whole-program fixpoint) emits fl*.
+;;
+;;   chez --script host/chez/run-fieldnum.ss
+(import (chezscheme))
+(load "host/chez/rt.ss")
+(set-chez-ns! "clojure.core")
+(load "host/chez/seed/prelude.ss")
+(load "host/chez/post-prelude.ss")
+(set-chez-ns! "user")
+(load "host/chez/host-contract.ss")
+(load "host/chez/seed/image.ss")
+(load "host/chez/compile-eval.ss")
+
+(define analyze              (var-deref "jolt.analyzer" "analyze"))
+(define set-record-shapes!   (var-deref "jolt.passes.types" "set-record-shapes!"))
+(define set-protocol-methods! (var-deref "jolt.passes.types" "set-protocol-methods!"))
+(define wp-infer!            (var-deref "jolt.passes.types" "wp-infer!"))
+(define run-passes           (var-deref "jolt.passes" "run-passes"))
+(define emit                 (var-deref "jolt.backend-scheme" "emit"))
+
+(define (anode src) (analyze (make-analyze-ctx "user") (jolt-ce-read src)))
+(define (evals src) (jolt-compile-eval (string-append "(do " src ")") "user"))
+(define (contains-sub? s sub)
+  (let ((n (string-length s)) (m (string-length sub)))
+    (let loop ((i 0))
+      (cond ((> (+ i m) n) #f)
+            ((string=? (substring s i (+ i m)) sub) #t)
+            (else (loop (+ i 1)))))))
+
+(define fails 0) (define total 0)
+(define (check label actual expected)
+  (set! total (+ total 1))
+  (unless (equal? actual expected)
+    (set! fails (+ fails 1))
+    (printf "  FAIL ~a: got ~s expected ~s\n" label actual expected)))
+
+;; a record with ^double fields; the ctor must coerce an integer arg to a flonum.
+(evals "(defrecord V [^double x ^double y])")
+(check "ctor coerces ^double field to flonum" (flonum? (evals "(:x (->V 1 2))")) #t)
+(check "coerced field value matches" (evals "(:x (->V 1 2))") 1.0)
+(check "a flonum arg passes through" (evals "(:y (->V 1.5 2.5))") 2.5)
+
+;; dot is hintless; its caller passes V instances, so the fixpoint types a/b as V
+;; records, the ^double fields read :double, and the field-field arithmetic unboxes.
+(define dot  (anode "(def dot (fn [a b] (+ (* (:x a) (:x b)) (* (:y a) (:y b)))))"))
+(define used (anode "(def used (fn [] (dot (->V 1.0 2.0) (->V 3.0 4.0))))"))
+(set-record-shapes! (chez-record-shapes-map))
+(set-protocol-methods! (jolt-hash-map))
+(wp-infer! (jolt-vector dot used))
+(set-optimize! #t)
+(define dot-emit (emit (run-passes dot (make-analyze-ctx "user"))))
+(check "field-field arithmetic unboxes to fl*" (contains-sub? dot-emit "fl*") #t)
+(check "field-field arithmetic unboxes to fl+" (contains-sub? dot-emit "fl+") #t)
+
+;; an UNTAGGED field stays generic — no fl-op (the read is :any, not :double).
+(evals "(defrecord W [p q])")
+(define dotw (anode "(def dotw (fn [a b] (* (:p a) (:p b))))"))
+(define usew (anode "(def usew (fn [] (dotw (->W 1.0 2.0) (->W 3.0 4.0))))"))
+(set-record-shapes! (chez-record-shapes-map))
+(wp-infer! (jolt-vector dotw usew))
+(check "untagged field stays generic (no fl*)"
+       (contains-sub? (emit (run-passes dotw (make-analyze-ctx "user"))) "fl*") #f)
+
+(if (= fails 0)
+    (begin (printf "fieldnum gate: ~a/~a passed\n" total total) (exit 0))
+    (begin (printf "fieldnum gate: ~a/~a passed (~a failed)\n" (- total fails) total fails) (exit 1)))
diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss
index b7ce50b..64a6480 100644
--- a/host/chez/seed/image.ss
+++ b/host/chez/seed/image.ss
@@ -1,271 +1,271 @@
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7501 ((v v)) (let* ((_o$7502 (keyword #f "op")) (_o$7503 (keyword #f "const")) (_o$7504 (keyword #f "val")) (_o$7505 v)) (jolt-hash-map _o$7502 _o$7503 _o$7504 _o$7505)))))) const)))
+  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7503 ((v v)) (let* ((_o$7504 (keyword #f "op")) (_o$7505 (keyword #f "const")) (_o$7506 (keyword #f "val")) (_o$7507 v)) (jolt-hash-map _o$7504 _o$7505 _o$7506 _o$7507)))))) const)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7506 ((name name)) (let* ((_o$7507 (keyword #f "op")) (_o$7508 (keyword #f "local")) (_o$7509 (keyword #f "name")) (_o$7510 name)) (jolt-hash-map _o$7507 _o$7508 _o$7509 _o$7510)))))) local)))
+  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7508 ((name name)) (let* ((_o$7509 (keyword #f "op")) (_o$7510 (keyword #f "local")) (_o$7511 (keyword #f "name")) (_o$7512 name)) (jolt-hash-map _o$7509 _o$7510 _o$7511 _o$7512)))))) local)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7511 ((ns ns) (name name)) (let* ((_o$7512 (keyword #f "op")) (_o$7513 (keyword #f "var")) (_o$7514 (keyword #f "ns")) (_o$7515 ns) (_o$7516 (keyword #f "name")) (_o$7517 name)) (jolt-hash-map _o$7512 _o$7513 _o$7514 _o$7515 _o$7516 _o$7517)))))) var-ref)))
+  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7513 ((ns ns) (name name)) (let* ((_o$7514 (keyword #f "op")) (_o$7515 (keyword #f "var")) (_o$7516 (keyword #f "ns")) (_o$7517 ns) (_o$7518 (keyword #f "name")) (_o$7519 name)) (jolt-hash-map _o$7514 _o$7515 _o$7516 _o$7517 _o$7518 _o$7519)))))) var-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7518 ((ns ns) (name name)) (let* ((_o$7519 (keyword #f "op")) (_o$7520 (keyword #f "the-var")) (_o$7521 (keyword #f "ns")) (_o$7522 ns) (_o$7523 (keyword #f "name")) (_o$7524 name)) (jolt-hash-map _o$7519 _o$7520 _o$7521 _o$7522 _o$7523 _o$7524)))))) the-var)))
+  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7520 ((ns ns) (name name)) (let* ((_o$7521 (keyword #f "op")) (_o$7522 (keyword #f "the-var")) (_o$7523 (keyword #f "ns")) (_o$7524 ns) (_o$7525 (keyword #f "name")) (_o$7526 name)) (jolt-hash-map _o$7521 _o$7522 _o$7523 _o$7524 _o$7525 _o$7526)))))) the-var)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7525 ((name name)) (let* ((_o$7526 (keyword #f "op")) (_o$7527 (keyword #f "host")) (_o$7528 (keyword #f "name")) (_o$7529 name)) (jolt-hash-map _o$7526 _o$7527 _o$7528 _o$7529)))))) host-ref)))
+  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7527 ((name name)) (let* ((_o$7528 (keyword #f "op")) (_o$7529 (keyword #f "host")) (_o$7530 (keyword #f "name")) (_o$7531 name)) (jolt-hash-map _o$7528 _o$7529 _o$7530 _o$7531)))))) host-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7530 ((class class) (member member)) (let* ((_o$7531 (keyword #f "op")) (_o$7532 (keyword #f "host-static")) (_o$7533 (keyword #f "class")) (_o$7534 class) (_o$7535 (keyword #f "member")) (_o$7536 member)) (jolt-hash-map _o$7531 _o$7532 _o$7533 _o$7534 _o$7535 _o$7536)))))) host-static)))
+  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7532 ((class class) (member member)) (let* ((_o$7533 (keyword #f "op")) (_o$7534 (keyword #f "host-static")) (_o$7535 (keyword #f "class")) (_o$7536 class) (_o$7537 (keyword #f "member")) (_o$7538 member)) (jolt-hash-map _o$7533 _o$7534 _o$7535 _o$7536 _o$7537 _o$7538)))))) host-static)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7537 ((class class) (args args)) (let* ((_o$7538 (keyword #f "op")) (_o$7539 (keyword #f "host-new")) (_o$7540 (keyword #f "class")) (_o$7541 class) (_o$7542 (keyword #f "args")) (_o$7543 args)) (jolt-hash-map _o$7538 _o$7539 _o$7540 _o$7541 _o$7542 _o$7543)))))) host-new)))
+  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7539 ((class class) (args args)) (let* ((_o$7540 (keyword #f "op")) (_o$7541 (keyword #f "host-new")) (_o$7542 (keyword #f "class")) (_o$7543 class) (_o$7544 (keyword #f "args")) (_o$7545 args)) (jolt-hash-map _o$7540 _o$7541 _o$7542 _o$7543 _o$7544 _o$7545)))))) host-new)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7544 ((test test) (then then) (_else _else)) (let* ((_o$7545 (keyword #f "op")) (_o$7546 (keyword #f "if")) (_o$7547 (keyword #f "test")) (_o$7548 test) (_o$7549 (keyword #f "then")) (_o$7550 then) (_o$7551 (keyword #f "else")) (_o$7552 _else)) (jolt-hash-map _o$7545 _o$7546 _o$7547 _o$7548 _o$7549 _o$7550 _o$7551 _o$7552)))))) if-node)))
+  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7546 ((test test) (then then) (_else _else)) (let* ((_o$7547 (keyword #f "op")) (_o$7548 (keyword #f "if")) (_o$7549 (keyword #f "test")) (_o$7550 test) (_o$7551 (keyword #f "then")) (_o$7552 then) (_o$7553 (keyword #f "else")) (_o$7554 _else)) (jolt-hash-map _o$7547 _o$7548 _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554)))))) if-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7553 ((statements statements) (ret ret)) (let* ((_o$7554 (keyword #f "op")) (_o$7555 (keyword #f "do")) (_o$7556 (keyword #f "statements")) (_o$7557 statements) (_o$7558 (keyword #f "ret")) (_o$7559 ret)) (jolt-hash-map _o$7554 _o$7555 _o$7556 _o$7557 _o$7558 _o$7559)))))) do-node)))
+  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7555 ((statements statements) (ret ret)) (let* ((_o$7556 (keyword #f "op")) (_o$7557 (keyword #f "do")) (_o$7558 (keyword #f "statements")) (_o$7559 statements) (_o$7560 (keyword #f "ret")) (_o$7561 ret)) (jolt-hash-map _o$7556 _o$7557 _o$7558 _o$7559 _o$7560 _o$7561)))))) do-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7560 ((f f) (args args)) (let* ((_o$7561 (keyword #f "op")) (_o$7562 (keyword #f "invoke")) (_o$7563 (keyword #f "fn")) (_o$7564 f) (_o$7565 (keyword #f "args")) (_o$7566 args)) (jolt-hash-map _o$7561 _o$7562 _o$7563 _o$7564 _o$7565 _o$7566)))))) invoke)))
+  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7562 ((f f) (args args)) (let* ((_o$7563 (keyword #f "op")) (_o$7564 (keyword #f "invoke")) (_o$7565 (keyword #f "fn")) (_o$7566 f) (_o$7567 (keyword #f "args")) (_o$7568 args)) (jolt-hash-map _o$7563 _o$7564 _o$7565 _o$7566 _o$7567 _o$7568)))))) invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7567 ((ns ns) (name name) (init init)) (let* ((_o$7568 (keyword #f "op")) (_o$7569 (keyword #f "def")) (_o$7570 (keyword #f "ns")) (_o$7571 ns) (_o$7572 (keyword #f "name")) (_o$7573 name) (_o$7574 (keyword #f "init")) (_o$7575 init)) (jolt-hash-map _o$7568 _o$7569 _o$7570 _o$7571 _o$7572 _o$7573 _o$7574 _o$7575)))) ((ns name init meta) (let fnrec7576 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7577 (keyword #f "op")) (_o$7578 (keyword #f "def")) (_o$7579 (keyword #f "ns")) (_o$7580 ns) (_o$7581 (keyword #f "name")) (_o$7582 name) (_o$7583 (keyword #f "init")) (_o$7584 init) (_o$7585 (keyword #f "meta")) (_o$7586 meta)) (jolt-hash-map _o$7577 _o$7578 _o$7579 _o$7580 _o$7581 _o$7582 _o$7583 _o$7584 _o$7585 _o$7586)) (let* ((_o$7587 (keyword #f "op")) (_o$7588 (keyword #f "def")) (_o$7589 (keyword #f "ns")) (_o$7590 ns) (_o$7591 (keyword #f "name")) (_o$7592 name) (_o$7593 (keyword #f "init")) (_o$7594 init)) (jolt-hash-map _o$7587 _o$7588 _o$7589 _o$7590 _o$7591 _o$7592 _o$7593 _o$7594)))))))) def-node)))
+  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7569 ((ns ns) (name name) (init init)) (let* ((_o$7570 (keyword #f "op")) (_o$7571 (keyword #f "def")) (_o$7572 (keyword #f "ns")) (_o$7573 ns) (_o$7574 (keyword #f "name")) (_o$7575 name) (_o$7576 (keyword #f "init")) (_o$7577 init)) (jolt-hash-map _o$7570 _o$7571 _o$7572 _o$7573 _o$7574 _o$7575 _o$7576 _o$7577)))) ((ns name init meta) (let fnrec7578 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7579 (keyword #f "op")) (_o$7580 (keyword #f "def")) (_o$7581 (keyword #f "ns")) (_o$7582 ns) (_o$7583 (keyword #f "name")) (_o$7584 name) (_o$7585 (keyword #f "init")) (_o$7586 init) (_o$7587 (keyword #f "meta")) (_o$7588 meta)) (jolt-hash-map _o$7579 _o$7580 _o$7581 _o$7582 _o$7583 _o$7584 _o$7585 _o$7586 _o$7587 _o$7588)) (let* ((_o$7589 (keyword #f "op")) (_o$7590 (keyword #f "def")) (_o$7591 (keyword #f "ns")) (_o$7592 ns) (_o$7593 (keyword #f "name")) (_o$7594 name) (_o$7595 (keyword #f "init")) (_o$7596 init)) (jolt-hash-map _o$7589 _o$7590 _o$7591 _o$7592 _o$7593 _o$7594 _o$7595 _o$7596)))))))) def-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7595 ((bindings bindings) (body body)) (let* ((_o$7596 (keyword #f "op")) (_o$7597 (keyword #f "let")) (_o$7598 (keyword #f "bindings")) (_o$7599 bindings) (_o$7600 (keyword #f "body")) (_o$7601 body)) (jolt-hash-map _o$7596 _o$7597 _o$7598 _o$7599 _o$7600 _o$7601)))))) let-node)))
+  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7597 ((bindings bindings) (body body)) (let* ((_o$7598 (keyword #f "op")) (_o$7599 (keyword #f "let")) (_o$7600 (keyword #f "bindings")) (_o$7601 bindings) (_o$7602 (keyword #f "body")) (_o$7603 body)) (jolt-hash-map _o$7598 _o$7599 _o$7600 _o$7601 _o$7602 _o$7603)))))) let-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7602 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7603 (keyword #f "op")) (_o$7604 (keyword #f "fn")) (_o$7605 (keyword #f "name")) (_o$7606 name) (_o$7607 (keyword #f "arities")) (_o$7608 arities)) (jolt-hash-map _o$7603 _o$7604 _o$7605 _o$7606 _o$7607 _o$7608)) (let* ((_o$7609 (keyword #f "op")) (_o$7610 (keyword #f "fn")) (_o$7611 (keyword #f "arities")) (_o$7612 arities)) (jolt-hash-map _o$7609 _o$7610 _o$7611 _o$7612))))))) fn-node)))
+  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7604 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7605 (keyword #f "op")) (_o$7606 (keyword #f "fn")) (_o$7607 (keyword #f "name")) (_o$7608 name) (_o$7609 (keyword #f "arities")) (_o$7610 arities)) (jolt-hash-map _o$7605 _o$7606 _o$7607 _o$7608 _o$7609 _o$7610)) (let* ((_o$7611 (keyword #f "op")) (_o$7612 (keyword #f "fn")) (_o$7613 (keyword #f "arities")) (_o$7614 arities)) (jolt-hash-map _o$7611 _o$7612 _o$7613 _o$7614))))))) fn-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7613 ((items items)) (let* ((_o$7614 (keyword #f "op")) (_o$7615 (keyword #f "vector")) (_o$7616 (keyword #f "items")) (_o$7617 items)) (jolt-hash-map _o$7614 _o$7615 _o$7616 _o$7617)))))) vector-node)))
+  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7615 ((items items)) (let* ((_o$7616 (keyword #f "op")) (_o$7617 (keyword #f "vector")) (_o$7618 (keyword #f "items")) (_o$7619 items)) (jolt-hash-map _o$7616 _o$7617 _o$7618 _o$7619)))))) vector-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7618 ((pairs pairs)) (let* ((_o$7619 (keyword #f "op")) (_o$7620 (keyword #f "map")) (_o$7621 (keyword #f "pairs")) (_o$7622 pairs)) (jolt-hash-map _o$7619 _o$7620 _o$7621 _o$7622)))))) map-node)))
+  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7620 ((pairs pairs)) (let* ((_o$7621 (keyword #f "op")) (_o$7622 (keyword #f "map")) (_o$7623 (keyword #f "pairs")) (_o$7624 pairs)) (jolt-hash-map _o$7621 _o$7622 _o$7623 _o$7624)))))) map-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7623 ((items items)) (let* ((_o$7624 (keyword #f "op")) (_o$7625 (keyword #f "set")) (_o$7626 (keyword #f "items")) (_o$7627 items)) (jolt-hash-map _o$7624 _o$7625 _o$7626 _o$7627)))))) set-node)))
+  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7625 ((items items)) (let* ((_o$7626 (keyword #f "op")) (_o$7627 (keyword #f "set")) (_o$7628 (keyword #f "items")) (_o$7629 items)) (jolt-hash-map _o$7626 _o$7627 _o$7628 _o$7629)))))) set-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7628 ((form form)) (let* ((_o$7629 (keyword #f "op")) (_o$7630 (keyword #f "quote")) (_o$7631 (keyword #f "form")) (_o$7632 form)) (jolt-hash-map _o$7629 _o$7630 _o$7631 _o$7632)))))) quote-node)))
+  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7630 ((form form)) (let* ((_o$7631 (keyword #f "op")) (_o$7632 (keyword #f "quote")) (_o$7633 (keyword #f "form")) (_o$7634 form)) (jolt-hash-map _o$7631 _o$7632 _o$7633 _o$7634)))))) quote-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7633 ((expr expr)) (let* ((_o$7634 (keyword #f "op")) (_o$7635 (keyword #f "throw")) (_o$7636 (keyword #f "expr")) (_o$7637 expr)) (jolt-hash-map _o$7634 _o$7635 _o$7636 _o$7637)))))) throw-node)))
+  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7635 ((expr expr)) (let* ((_o$7636 (keyword #f "op")) (_o$7637 (keyword #f "throw")) (_o$7638 (keyword #f "expr")) (_o$7639 expr)) (jolt-hash-map _o$7636 _o$7637 _o$7638 _o$7639)))))) throw-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7638 ((kind kind) (expr expr)) (let* ((_o$7639 (keyword #f "op")) (_o$7640 (keyword #f "coerce")) (_o$7641 (keyword #f "kind")) (_o$7642 kind) (_o$7643 (keyword #f "expr")) (_o$7644 expr)) (jolt-hash-map _o$7639 _o$7640 _o$7641 _o$7642 _o$7643 _o$7644)))))) coerce-node)))
+  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7640 ((kind kind) (expr expr)) (let* ((_o$7641 (keyword #f "op")) (_o$7642 (keyword #f "coerce")) (_o$7643 (keyword #f "kind")) (_o$7644 kind) (_o$7645 (keyword #f "expr")) (_o$7646 expr)) (jolt-hash-map _o$7641 _o$7642 _o$7643 _o$7644 _o$7645 _o$7646)))))) coerce-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec7645 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7646 node) (_a$7647 (keyword #f "test")) (_a$7648 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7649 (keyword #f "then")) (_a$7650 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7651 (keyword #f "else")) (_a$7652 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7646 _a$7647 _a$7648 _a$7649 _a$7650 _a$7651 _a$7652)) (if (jolt= op (keyword #f "do")) (let* ((_a$7653 node) (_a$7654 (keyword #f "statements")) (_a$7655 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7656 (keyword #f "ret")) (_a$7657 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7653 _a$7654 _a$7655 _a$7656 _a$7657)) (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$7658 node) (_a$7659 (keyword #f "obj")) (_a$7660 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7661 (keyword #f "val")) (_a$7662 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7658 _a$7659 _a$7660 _a$7661 _a$7662)) (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$7663 node) (_a$7664 (keyword #f "fn")) (_a$7665 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7666 (keyword #f "args")) (_a$7667 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7663 _a$7664 _a$7665 _a$7666 _a$7667)) (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$7671 (var-deref "clojure.core" "mapv")) (_a$7672 (lambda (pr) (let fnrec7668 ((pr pr)) (let* ((_o$7669 (jolt-invoke f (jolt-nth pr 0))) (_o$7670 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7669 _o$7670))))) (_a$7673 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7671 _a$7672 _a$7673))) (if (jolt= op (keyword #f "let")) (let* ((_a$7680 node) (_a$7681 (keyword #f "bindings")) (_a$7682 (let* ((_a$7677 (var-deref "clojure.core" "mapv")) (_a$7678 (lambda (b) (let fnrec7674 ((b b)) (let* ((_o$7675 (jolt-nth b 0)) (_o$7676 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7675 _o$7676))))) (_a$7679 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7677 _a$7678 _a$7679))) (_a$7683 (keyword #f "body")) (_a$7684 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7680 _a$7681 _a$7682 _a$7683 _a$7684)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7691 node) (_a$7692 (keyword #f "bindings")) (_a$7693 (let* ((_a$7688 (var-deref "clojure.core" "mapv")) (_a$7689 (lambda (b) (let fnrec7685 ((b b)) (let* ((_o$7686 (jolt-nth b 0)) (_o$7687 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7686 _o$7687))))) (_a$7690 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7688 _a$7689 _a$7690))) (_a$7694 (keyword #f "body")) (_a$7695 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7691 _a$7692 _a$7693 _a$7694 _a$7695)) (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$7697 (var-deref "clojure.core" "mapv")) (_a$7698 (lambda (a) (let fnrec7696 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7699 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7697 _a$7698 _a$7699))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$7700 node) (_a$7701 (keyword #f "target")) (_a$7702 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7703 (keyword #f "args")) (_a$7704 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7700 _a$7701 _a$7702 _a$7703 _a$7704)) (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 fnrec7647 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7648 node) (_a$7649 (keyword #f "test")) (_a$7650 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7651 (keyword #f "then")) (_a$7652 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7653 (keyword #f "else")) (_a$7654 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7648 _a$7649 _a$7650 _a$7651 _a$7652 _a$7653 _a$7654)) (if (jolt= op (keyword #f "do")) (let* ((_a$7655 node) (_a$7656 (keyword #f "statements")) (_a$7657 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7658 (keyword #f "ret")) (_a$7659 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7655 _a$7656 _a$7657 _a$7658 _a$7659)) (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$7660 node) (_a$7661 (keyword #f "obj")) (_a$7662 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7663 (keyword #f "val")) (_a$7664 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7660 _a$7661 _a$7662 _a$7663 _a$7664)) (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$7665 node) (_a$7666 (keyword #f "fn")) (_a$7667 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7668 (keyword #f "args")) (_a$7669 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7665 _a$7666 _a$7667 _a$7668 _a$7669)) (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$7673 (var-deref "clojure.core" "mapv")) (_a$7674 (lambda (pr) (let fnrec7670 ((pr pr)) (let* ((_o$7671 (jolt-invoke f (jolt-nth pr 0))) (_o$7672 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7671 _o$7672))))) (_a$7675 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7673 _a$7674 _a$7675))) (if (jolt= op (keyword #f "let")) (let* ((_a$7682 node) (_a$7683 (keyword #f "bindings")) (_a$7684 (let* ((_a$7679 (var-deref "clojure.core" "mapv")) (_a$7680 (lambda (b) (let fnrec7676 ((b b)) (let* ((_o$7677 (jolt-nth b 0)) (_o$7678 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7677 _o$7678))))) (_a$7681 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7679 _a$7680 _a$7681))) (_a$7685 (keyword #f "body")) (_a$7686 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7682 _a$7683 _a$7684 _a$7685 _a$7686)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7693 node) (_a$7694 (keyword #f "bindings")) (_a$7695 (let* ((_a$7690 (var-deref "clojure.core" "mapv")) (_a$7691 (lambda (b) (let fnrec7687 ((b b)) (let* ((_o$7688 (jolt-nth b 0)) (_o$7689 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7688 _o$7689))))) (_a$7692 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7690 _a$7691 _a$7692))) (_a$7696 (keyword #f "body")) (_a$7697 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7693 _a$7694 _a$7695 _a$7696 _a$7697)) (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$7699 (var-deref "clojure.core" "mapv")) (_a$7700 (lambda (a) (let fnrec7698 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7701 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7699 _a$7700 _a$7701))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$7702 node) (_a$7703 (keyword #f "target")) (_a$7704 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7705 (keyword #f "args")) (_a$7706 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7702 _a$7703 _a$7704 _a$7705 _a$7706)) (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 fnrec7705 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7709 f) (_a$7710 (let* ((_a$7706 f) (_a$7707 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7708 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7706 _a$7707 _a$7708))) (_a$7711 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7709 _a$7710 _a$7711)) (if (jolt= op (keyword #f "do")) (let* ((_a$7712 f) (_a$7713 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7714 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7712 _a$7713 _a$7714)) (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$7715 f) (_a$7716 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7717 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7715 _a$7716 _a$7717)) (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$7718 f) (_a$7719 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7720 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7718 _a$7719 _a$7720)) (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$7725 (lambda (a pr) (let fnrec7721 ((a a) (pr pr)) (let* ((_a$7722 f) (_a$7723 (jolt-invoke f a (jolt-nth pr 0))) (_a$7724 (jolt-nth pr 1))) (jolt-invoke _a$7722 _a$7723 _a$7724))))) (_a$7726 acc) (_a$7727 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7725 _a$7726 _a$7727)) (if (jolt= op (keyword #f "let")) (let* ((_a$7732 f) (_a$7733 (let* ((_a$7729 (lambda (a b) (let fnrec7728 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7730 acc) (_a$7731 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7729 _a$7730 _a$7731))) (_a$7734 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7732 _a$7733 _a$7734)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7739 f) (_a$7740 (let* ((_a$7736 (lambda (a b) (let fnrec7735 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7737 acc) (_a$7738 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7736 _a$7737 _a$7738))) (_a$7741 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7739 _a$7740 _a$7741)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7743 (lambda (a ar) (let fnrec7742 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7744 acc) (_a$7745 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7743 _a$7744 _a$7745)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$7746 f) (_a$7747 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7748 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7746 _a$7747 _a$7748)) (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 fnrec7707 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7711 f) (_a$7712 (let* ((_a$7708 f) (_a$7709 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7710 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7708 _a$7709 _a$7710))) (_a$7713 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7711 _a$7712 _a$7713)) (if (jolt= op (keyword #f "do")) (let* ((_a$7714 f) (_a$7715 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7716 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7714 _a$7715 _a$7716)) (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$7717 f) (_a$7718 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7719 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7717 _a$7718 _a$7719)) (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$7720 f) (_a$7721 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7722 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7720 _a$7721 _a$7722)) (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$7727 (lambda (a pr) (let fnrec7723 ((a a) (pr pr)) (let* ((_a$7724 f) (_a$7725 (jolt-invoke f a (jolt-nth pr 0))) (_a$7726 (jolt-nth pr 1))) (jolt-invoke _a$7724 _a$7725 _a$7726))))) (_a$7728 acc) (_a$7729 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7727 _a$7728 _a$7729)) (if (jolt= op (keyword #f "let")) (let* ((_a$7734 f) (_a$7735 (let* ((_a$7731 (lambda (a b) (let fnrec7730 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7732 acc) (_a$7733 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7731 _a$7732 _a$7733))) (_a$7736 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7734 _a$7735 _a$7736)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7741 f) (_a$7742 (let* ((_a$7738 (lambda (a b) (let fnrec7737 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7739 acc) (_a$7740 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7738 _a$7739 _a$7740))) (_a$7743 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7741 _a$7742 _a$7743)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7745 (lambda (a ar) (let fnrec7744 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7746 acc) (_a$7747 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7745 _a$7746 _a$7747)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$7748 f) (_a$7749 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7750 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7748 _a$7749 _a$7750)) (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$7749 "quote") (_o$7750 "if") (_o$7751 "do") (_o$7752 "def") (_o$7753 "fn*") (_o$7754 "let*") (_o$7755 "loop*") (_o$7756 "recur") (_o$7757 "throw") (_o$7758 "try") (_o$7759 "syntax-quote") (_o$7760 "var") (_o$7761 "letfn") (_o$7762 "set!") (_o$7763 "defmacro")) (jolt-hash-set _o$7749 _o$7750 _o$7751 _o$7752 _o$7753 _o$7754 _o$7755 _o$7756 _o$7757 _o$7758 _o$7759 _o$7760 _o$7761 _o$7762 _o$7763)) (let* ((_o$7764 (keyword #f "private")) (_o$7765 #t)) (jolt-hash-map _o$7764 _o$7765))))
+  (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$7751 "quote") (_o$7752 "if") (_o$7753 "do") (_o$7754 "def") (_o$7755 "fn*") (_o$7756 "let*") (_o$7757 "loop*") (_o$7758 "recur") (_o$7759 "throw") (_o$7760 "try") (_o$7761 "syntax-quote") (_o$7762 "var") (_o$7763 "letfn") (_o$7764 "set!") (_o$7765 "defmacro")) (jolt-hash-set _o$7751 _o$7752 _o$7753 _o$7754 _o$7755 _o$7756 _o$7757 _o$7758 _o$7759 _o$7760 _o$7761 _o$7762 _o$7763 _o$7764 _o$7765)) (let* ((_o$7766 (keyword #f "private")) (_o$7767 #t)) (jolt-hash-map _o$7766 _o$7767))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7766 ((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 fnrec7768 ((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) (let* ((_o$7767 (keyword #f "private")) (_o$7768 #t)) (jolt-hash-map _o$7767 _o$7768))))
+  (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7769 (keyword #f "private")) (_o$7770 #t)) (jolt-hash-map _o$7769 _o$7770))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7769 ((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 fnrec7771 ((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 fnrec7770 () (let* ((_o$7771 (keyword #f "locals")) (_o$7772 (jolt-hash-set)) (_o$7773 (keyword #f "hints")) (_o$7774 (jolt-hash-map))) (jolt-hash-map _o$7771 _o$7772 _o$7773 _o$7774)))))) empty-env)))
+  (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7772 () (let* ((_o$7773 (keyword #f "locals")) (_o$7774 (jolt-hash-set)) (_o$7775 (keyword #f "hints")) (_o$7776 (jolt-hash-map))) (jolt-hash-map _o$7773 _o$7774 _o$7775 _o$7776)))))) empty-env)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7775 ((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 fnrec7777 ((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 fnrec7776 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7777 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals)))
+  (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7778 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7779 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7778 ((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 fnrec7780 ((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 fnrec7779 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-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__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of)))
+  (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7781 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-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__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__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 fnrec7780 ((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 fnrec7782 ((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 fnrec7781 ((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 fnrec7783 ((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 fnrec7782 ((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 fnrec7784 ((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 fnrec7783 ((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 fnrec7785 ((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 fnrec7784 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$7786 (var-deref "clojure.core" "mapv")) (_a$7787 (lambda (a) (let fnrec7785 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7788 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7786 _a$7787 _a$7788))) node))))) with-ret-nhint)))
+  (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7786 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$7788 (var-deref "clojure.core" "mapv")) (_a$7789 (lambda (a) (let fnrec7787 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7790 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7788 _a$7789 _a$7790))) node))))) with-ret-nhint)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7789 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7790 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ 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$7791 (var-deref "jolt.ir" "do-node")) (_a$7792 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7793 (jolt-peek v))) (jolt-invoke _a$7791 _a$7792 _a$7793)) jolt-nil)))))))) analyze-seq)))
+  (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7791 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7792 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ 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$7793 (var-deref "jolt.ir" "do-node")) (_a$7794 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7795 (jolt-peek v))) (jolt-invoke _a$7793 _a$7794 _a$7795)) jolt-nil)))))))) analyze-seq)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7794 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7795 ((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$7802 (+ i 2)) (_a$7803 (let* ((_a$7796 (var-deref "jolt.analyzer" "add-hint")) (_a$7797 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7798 nm) (_a$7799 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7796 _a$7797 _a$7798 _a$7799))) (_a$7804 (jolt-conj pairs (let* ((_o$7800 nm) (_o$7801 init)) (jolt-vector _o$7800 _o$7801))))) (loop7795 _a$7802 _a$7803 _a$7804))))) (let* ((_o$7805 pairs) (_o$7806 env)) (jolt-vector _o$7805 _o$7806))))))))) analyze-bindings)))
+  (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7796 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7797 ((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$7804 (+ i 2)) (_a$7805 (let* ((_a$7798 (var-deref "jolt.analyzer" "add-hint")) (_a$7799 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7800 nm) (_a$7801 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7798 _a$7799 _a$7800 _a$7801))) (_a$7806 (jolt-conj pairs (let* ((_o$7802 nm) (_o$7803 init)) (jolt-vector _o$7802 _o$7803))))) (loop7797 _a$7804 _a$7805 _a$7806))))) (let* ((_o$7807 pairs) (_o$7808 env)) (jolt-vector _o$7807 _o$7808))))))))) analyze-bindings)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7807 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7808 ((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$7809 (+ i 2)) (_a$7810 fixed) (_a$7811 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7812 hints) (_a$7813 phints) (_a$7814 nhints)) (loop7808 _a$7809 _a$7810 _a$7811 _a$7812 _a$7813 _a$7814)))) (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$7821 (jolt-inc i)) (_a$7822 (jolt-conj fixed nm)) (_a$7823 rest-name) (_a$7824 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7815 nm) (_o$7816 h)) (jolt-vector _o$7815 _o$7816))) hints)) (_a$7825 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7817 nm) (_o$7818 ph)) (jolt-vector _o$7817 _o$7818))) phints)) (_a$7826 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7819 nm) (_o$7820 nh)) (jolt-vector _o$7819 _o$7820))) nhints))) (loop7808 _a$7821 _a$7822 _a$7823 _a$7824 _a$7825 _a$7826)))))) (let* ((_o$7827 (keyword #f "fixed")) (_o$7828 fixed) (_o$7829 (keyword #f "rest")) (_o$7830 rest-name) (_o$7831 (keyword #f "hints")) (_o$7832 hints) (_o$7833 (keyword #f "phints")) (_o$7834 phints) (_o$7835 (keyword #f "nhints")) (_o$7836 nhints)) (jolt-hash-map _o$7827 _o$7828 _o$7829 _o$7830 _o$7831 _o$7832 _o$7833 _o$7834 _o$7835 _o$7836))))))))) parse-params)))
+  (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7809 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7810 ((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$7811 (+ i 2)) (_a$7812 fixed) (_a$7813 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7814 hints) (_a$7815 phints) (_a$7816 nhints)) (loop7810 _a$7811 _a$7812 _a$7813 _a$7814 _a$7815 _a$7816)))) (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$7823 (jolt-inc i)) (_a$7824 (jolt-conj fixed nm)) (_a$7825 rest-name) (_a$7826 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7817 nm) (_o$7818 h)) (jolt-vector _o$7817 _o$7818))) hints)) (_a$7827 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7819 nm) (_o$7820 ph)) (jolt-vector _o$7819 _o$7820))) phints)) (_a$7828 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7821 nm) (_o$7822 nh)) (jolt-vector _o$7821 _o$7822))) nhints))) (loop7810 _a$7823 _a$7824 _a$7825 _a$7826 _a$7827 _a$7828)))))) (let* ((_o$7829 (keyword #f "fixed")) (_o$7830 fixed) (_o$7831 (keyword #f "rest")) (_o$7832 rest-name) (_o$7833 (keyword #f "hints")) (_o$7834 hints) (_o$7835 (keyword #f "phints")) (_o$7836 phints) (_o$7837 (keyword #f "nhints")) (_o$7838 nhints)) (jolt-hash-map _o$7829 _o$7830 _o$7831 _o$7832 _o$7833 _o$7834 _o$7835 _o$7836 _o$7837 _o$7838))))))))) parse-params)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7837 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7838 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7839 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7839 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7840 (jolt-inc i)) (_a$7841 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7838 _a$7840 _a$7841))) out)))))))) uniquify-params)))
+  (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7839 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7840 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7841 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7841 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7842 (jolt-inc i)) (_a$7843 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7840 _a$7842 _a$7843))) out)))))))) uniquify-params)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7842 ((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$7843 (var-deref "clojure.core" "str")) (_a$7844 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7845 "/") (_a$7846 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7847 "--")) (jolt-invoke _a$7843 _a$7844 _a$7845 _a$7846 _a$7847)))) (names (let* ((G__142 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__143 (if (jolt-truthy? rst) (jolt-conj G__142 rst) G__142))) (let* ((G__144 (if (jolt-truthy? fn-name) (jolt-conj G__143 fn-name) G__143))) G__144)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7853 (lambda (e pr) (let fnrec7848 ((e e) (pr pr)) (let* ((_a$7849 (var-deref "jolt.analyzer" "add-hint")) (_a$7850 e) (_a$7851 (jolt-nth pr 0)) (_a$7852 (jolt-nth pr 1))) (jolt-invoke _a$7849 _a$7850 _a$7851 _a$7852))))) (_a$7854 env0) (_a$7855 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7853 _a$7854 _a$7855))) (arity (let* ((_o$7856 (keyword #f "params")) (_o$7857 fixed) (_o$7858 (keyword #f "recur-name")) (_o$7859 rname) (_o$7860 (keyword #f "body")) (_o$7861 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7856 _o$7857 _o$7858 _o$7859 _o$7860 _o$7861))) (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 fnrec7844 ((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$7845 (var-deref "clojure.core" "str")) (_a$7846 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7847 "/") (_a$7848 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7849 "--")) (jolt-invoke _a$7845 _a$7846 _a$7847 _a$7848 _a$7849)))) (names (let* ((G__142 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__143 (if (jolt-truthy? rst) (jolt-conj G__142 rst) G__142))) (let* ((G__144 (if (jolt-truthy? fn-name) (jolt-conj G__143 fn-name) G__143))) G__144)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7855 (lambda (e pr) (let fnrec7850 ((e e) (pr pr)) (let* ((_a$7851 (var-deref "jolt.analyzer" "add-hint")) (_a$7852 e) (_a$7853 (jolt-nth pr 0)) (_a$7854 (jolt-nth pr 1))) (jolt-invoke _a$7851 _a$7852 _a$7853 _a$7854))))) (_a$7856 env0) (_a$7857 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7855 _a$7856 _a$7857))) (arity (let* ((_o$7858 (keyword #f "params")) (_o$7859 fixed) (_o$7860 (keyword #f "recur-name")) (_o$7861 rname) (_o$7862 (keyword #f "body")) (_o$7863 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7858 _o$7859 _o$7860 _o$7861 _o$7862 _o$7863))) (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 fnrec7862 ((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__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta)))
+  (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7864 ((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__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__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 fnrec7863 ((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 fnrec7864 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7865 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7866 ctx) (_a$7867 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7868 (jolt-rest cl)) (_a$7869 env) (_a$7870 fn-name)) (jolt-invoke _a$7865 _a$7866 _a$7867 _a$7868 _a$7869 _a$7870))))) 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 fnrec7865 ((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 fnrec7866 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7867 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7868 ctx) (_a$7869 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7870 (jolt-rest cl)) (_a$7871 env) (_a$7872 fn-name)) (jolt-invoke _a$7867 _a$7868 _a$7869 _a$7870 _a$7871 _a$7872))))) 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-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7871 "Throwable") (_o$7872 "java.lang.Throwable") (_o$7873 "Object") (_o$7874 "java.lang.Object")) (jolt-hash-set _o$7871 _o$7872 _o$7873 _o$7874)) (let* ((_o$7875 (keyword #f "private")) (_o$7876 #t)) (jolt-hash-map _o$7875 _o$7876))))
+  (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7873 "Throwable") (_o$7874 "java.lang.Throwable") (_o$7875 "Object") (_o$7876 "java.lang.Object")) (jolt-hash-set _o$7873 _o$7874 _o$7875 _o$7876)) (let* ((_o$7877 (keyword #f "private")) (_o$7878 #t)) (jolt-hash-map _o$7877 _o$7878))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7877 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec7878 ((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__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__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 (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__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" "swap!") catches jolt-conj 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$7879 (keyword #f "op")) (_o$7880 (keyword #f "try")) (_o$7881 (keyword #f "body")) (_o$7882 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7879 _o$7880 _o$7881 _o$7882))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$7887 (lambda (_else cl) (let fnrec7883 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$7884 (jolt-symbol #f "or")) (_a$7885 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7886 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7884 _a$7885 _a$7886)) letform _else)))))) (_a$7888 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7889 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7887 _a$7888 _a$7889)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7890 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7891 ctx) (_a$7892 (jolt-list dispatch)) (_a$7893 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7890 _a$7891 _a$7892 _a$7893)))) 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 fnrec7879 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec7880 ((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__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__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 (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__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" "swap!") catches jolt-conj 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$7881 (keyword #f "op")) (_o$7882 (keyword #f "try")) (_o$7883 (keyword #f "body")) (_o$7884 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7881 _o$7882 _o$7883 _o$7884))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$7889 (lambda (_else cl) (let fnrec7885 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$7886 (jolt-symbol #f "or")) (_a$7887 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7888 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7886 _a$7887 _a$7888)) letform _else)))))) (_a$7890 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7891 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7889 _a$7890 _a$7891)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7892 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7893 ctx) (_a$7894 (jolt-list dispatch)) (_a$7895 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7892 _a$7893 _a$7894 _a$7895)))) 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 fnrec7894 ((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__92_) (let fnrec7895 ((p__92_ p__92_)) (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__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7896 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7897 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7898 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7897 _o$7898))))) specs))) (let* ((_o$7899 (keyword #f "op")) (_o$7900 (keyword #f "let")) (_o$7901 (keyword #f "letrec")) (_o$7902 #t) (_o$7903 (keyword #f "bindings")) (_o$7904 binds) (_o$7905 (keyword #f "body")) (_o$7906 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7899 _o$7900 _o$7901 _o$7902 _o$7903 _o$7904 _o$7905 _o$7906))))))) analyze-letfn)))
+  (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec7896 ((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__92_) (let fnrec7897 ((p__92_ p__92_)) (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__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7898 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7899 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7900 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7899 _o$7900))))) specs))) (let* ((_o$7901 (keyword #f "op")) (_o$7902 (keyword #f "let")) (_o$7903 (keyword #f "letrec")) (_o$7904 #t) (_o$7905 (keyword #f "bindings")) (_o$7906 binds) (_o$7907 (keyword #f "body")) (_o$7908 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7901 _o$7902 _o$7903 _o$7904 _o$7905 _o$7906 _o$7907 _o$7908))))))) analyze-letfn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7907 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?)))
+  (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7909 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7908 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7912 (var-deref "clojure.core" "mapv")) (_a$7913 (lambda (p) (let fnrec7909 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7910 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7911 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$7910 _o$7911)))))) (_a$7914 (jolt-seq base))) (jolt-invoke _a$7912 _a$7913 _a$7914))) jolt-nil))))) def-meta-expr)))
+  (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7910 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7914 (var-deref "clojure.core" "mapv")) (_a$7915 (lambda (p) (let fnrec7911 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7912 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7913 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$7912 _o$7913)))))) (_a$7916 (jolt-seq base))) (jolt-invoke _a$7914 _a$7915 _a$7916))) jolt-nil))))) def-meta-expr)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7915 ((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$7916 (keyword #f "op")) (_o$7917 (keyword #f "def")) (_o$7918 (keyword #f "ns")) (_o$7919 cur) (_o$7920 (keyword #f "name")) (_o$7921 nm) (_o$7922 (keyword #f "no-init")) (_o$7923 #t)) (jolt-hash-map _o$7916 _o$7917 _o$7918 _o$7919 _o$7920 _o$7921 _o$7922 _o$7923)))) (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__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__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) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$7924 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7925 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7926 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7924 _a$7925 _a$7926)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def)))
+  (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7917 ((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$7918 (keyword #f "op")) (_o$7919 (keyword #f "def")) (_o$7920 (keyword #f "ns")) (_o$7921 cur) (_o$7922 (keyword #f "name")) (_o$7923 nm) (_o$7924 (keyword #f "no-init")) (_o$7925 #t)) (jolt-hash-map _o$7918 _o$7919 _o$7920 _o$7921 _o$7922 _o$7923 _o$7924 _o$7925)))) (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__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__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) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$7926 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7927 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7928 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7926 _a$7927 _a$7928)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec7927 ((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__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$7928 (keyword #f "op")) (_o$7929 (keyword #f "set-field")) (_o$7930 (keyword #f "obj")) (_o$7931 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7932 (keyword #f "field")) (_o$7933 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7934 (keyword #f "val")) (_o$7935 val-node)) (jolt-hash-map _o$7928 _o$7929 _o$7930 _o$7931 _o$7932 _o$7933 _o$7934 _o$7935)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$7939 (var-deref "jolt.ir" "invoke")) (_a$7940 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7941 (let* ((_o$7936 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$7937 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7938 val-node)) (jolt-vector _o$7936 _o$7937 _o$7938)))) (jolt-invoke _a$7939 _a$7940 _a$7941)) (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$7945 (keyword #f "op")) (_o$7946 (keyword #f "set-var")) (_o$7947 (keyword #f "the-var")) (_o$7948 (let* ((_a$7942 (var-deref "jolt.ir" "the-var")) (_a$7943 (jolt-get r (keyword #f "ns"))) (_a$7944 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7942 _a$7943 _a$7944))) (_o$7949 (keyword #f "val")) (_o$7950 val-node)) (jolt-hash-map _o$7945 _o$7946 _o$7947 _o$7948 _o$7949 _o$7950))))) (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 fnrec7929 ((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__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$7930 (keyword #f "op")) (_o$7931 (keyword #f "set-field")) (_o$7932 (keyword #f "obj")) (_o$7933 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7934 (keyword #f "field")) (_o$7935 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7936 (keyword #f "val")) (_o$7937 val-node)) (jolt-hash-map _o$7930 _o$7931 _o$7932 _o$7933 _o$7934 _o$7935 _o$7936 _o$7937)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$7941 (var-deref "jolt.ir" "invoke")) (_a$7942 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7943 (let* ((_o$7938 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$7939 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7940 val-node)) (jolt-vector _o$7938 _o$7939 _o$7940)))) (jolt-invoke _a$7941 _a$7942 _a$7943)) (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$7947 (keyword #f "op")) (_o$7948 (keyword #f "set-var")) (_o$7949 (keyword #f "the-var")) (_o$7950 (let* ((_a$7944 (var-deref "jolt.ir" "the-var")) (_a$7945 (jolt-get r (keyword #f "ns"))) (_a$7946 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7944 _a$7945 _a$7946))) (_o$7951 (keyword #f "val")) (_o$7952 val-node)) (jolt-hash-map _o$7947 _o$7948 _o$7949 _o$7950 _o$7951 _o$7952))))) (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 fnrec7951 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__145 op)) (if (jolt= G__145 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__145 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__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$7952 (var-deref "jolt.ir" "if-node")) (_a$7953 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7954 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7955 (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$7952 _a$7953 _a$7954 _a$7955))) (if (jolt= G__145 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__145 "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__145 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__145 "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$7960 (var-deref "jolt.ir" "let-node")) (_a$7961 (jolt-first r)) (_a$7962 (let* ((_a$7956 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7957 ctx) (_a$7958 (jolt-drop 2 items)) (_a$7959 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7956 _a$7957 _a$7958 _a$7959)))) (jolt-invoke _a$7960 _a$7961 _a$7962))) (if (jolt= G__145 "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$7963 (keyword #f "op")) (_o$7964 (keyword #f "loop")) (_o$7965 (keyword #f "recur-name")) (_o$7966 rname) (_o$7967 (keyword #f "bindings")) (_o$7968 (jolt-first r)) (_o$7969 (keyword #f "body")) (_o$7970 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7963 _o$7964 _o$7965 _o$7966 _o$7967 _o$7968 _o$7969 _o$7970))) (if (jolt= G__145 "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$7975 (keyword #f "op")) (_o$7976 (keyword #f "recur")) (_o$7977 (keyword #f "recur-name")) (_o$7978 rt) (_o$7979 (keyword #f "args")) (_o$7980 (let* ((_a$7972 (var-deref "clojure.core" "mapv")) (_a$7973 (lambda (p__93_) (let fnrec7971 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7974 (jolt-rest items))) (jolt-invoke _a$7972 _a$7973 _a$7974)))) (jolt-hash-map _o$7975 _o$7976 _o$7977 _o$7978 _o$7979 _o$7980)))) (if (jolt= G__145 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__145 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__145 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__145 "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__145 "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$7981 (var-deref "jolt.ir" "the-var")) (_a$7982 (jolt-get r (keyword #f "ns"))) (_a$7983 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7981 _a$7982 _a$7983)) (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__145 "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$7984 (keyword #f "op")) (_o$7985 (keyword #f "defmacro")) (_o$7986 (keyword #f "ns")) (_o$7987 cur) (_o$7988 (keyword #f "name")) (_o$7989 nm) (_o$7990 (keyword #f "fn")) (_o$7991 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7984 _o$7985 _o$7986 _o$7987 _o$7988 _o$7989 _o$7990 _o$7991)))) (if (jolt= G__145 "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 fnrec7953 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__145 op)) (if (jolt= G__145 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__145 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__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$7954 (var-deref "jolt.ir" "if-node")) (_a$7955 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7956 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7957 (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$7954 _a$7955 _a$7956 _a$7957))) (if (jolt= G__145 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__145 "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__145 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__145 "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$7962 (var-deref "jolt.ir" "let-node")) (_a$7963 (jolt-first r)) (_a$7964 (let* ((_a$7958 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7959 ctx) (_a$7960 (jolt-drop 2 items)) (_a$7961 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7958 _a$7959 _a$7960 _a$7961)))) (jolt-invoke _a$7962 _a$7963 _a$7964))) (if (jolt= G__145 "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$7965 (keyword #f "op")) (_o$7966 (keyword #f "loop")) (_o$7967 (keyword #f "recur-name")) (_o$7968 rname) (_o$7969 (keyword #f "bindings")) (_o$7970 (jolt-first r)) (_o$7971 (keyword #f "body")) (_o$7972 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7965 _o$7966 _o$7967 _o$7968 _o$7969 _o$7970 _o$7971 _o$7972))) (if (jolt= G__145 "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$7977 (keyword #f "op")) (_o$7978 (keyword #f "recur")) (_o$7979 (keyword #f "recur-name")) (_o$7980 rt) (_o$7981 (keyword #f "args")) (_o$7982 (let* ((_a$7974 (var-deref "clojure.core" "mapv")) (_a$7975 (lambda (p__93_) (let fnrec7973 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7976 (jolt-rest items))) (jolt-invoke _a$7974 _a$7975 _a$7976)))) (jolt-hash-map _o$7977 _o$7978 _o$7979 _o$7980 _o$7981 _o$7982)))) (if (jolt= G__145 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__145 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__145 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__145 "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__145 "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$7983 (var-deref "jolt.ir" "the-var")) (_a$7984 (jolt-get r (keyword #f "ns"))) (_a$7985 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7983 _a$7984 _a$7985)) (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__145 "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$7986 (keyword #f "op")) (_o$7987 (keyword #f "defmacro")) (_o$7988 (keyword #f "ns")) (_o$7989 cur) (_o$7990 (keyword #f "name")) (_o$7991 nm) (_o$7992 (keyword #f "fn")) (_o$7993 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7986 _o$7987 _o$7988 _o$7989 _o$7990 _o$7991 _o$7992 _o$7993)))) (if (jolt= G__145 "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 fnrec7992 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?)))
+  (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec7994 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7993 ((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$7998 (keyword #f "op")) (_o$7999 (keyword #f "host-call")) (_o$8000 (keyword #f "method")) (_o$8001 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8002 (keyword #f "target")) (_o$8003 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8004 (keyword #f "args")) (_o$8005 (let* ((_a$7995 (var-deref "clojure.core" "mapv")) (_a$7996 (lambda (p__94_) (let fnrec7994 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7997 (jolt-drop 2 items))) (jolt-invoke _a$7995 _a$7996 _a$7997)))) (jolt-hash-map _o$7998 _o$7999 _o$8000 _o$8001 _o$8002 _o$8003 _o$8004 _o$8005))))))) analyze-host-call)))
+  (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7995 ((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$8000 (keyword #f "op")) (_o$8001 (keyword #f "host-call")) (_o$8002 (keyword #f "method")) (_o$8003 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8004 (keyword #f "target")) (_o$8005 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8006 (keyword #f "args")) (_o$8007 (let* ((_a$7997 (var-deref "clojure.core" "mapv")) (_a$7998 (lambda (p__94_) (let fnrec7996 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7999 (jolt-drop 2 items))) (jolt-invoke _a$7997 _a$7998 _a$7999)))) (jolt-hash-map _o$8000 _o$8001 _o$8002 _o$8003 _o$8004 _o$8005 _o$8006 _o$8007))))))) analyze-host-call)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8006 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8007 (var-deref "clojure.core" "subs")) (_a$8008 nm) (_a$8009 (jolt-dec (jolt-count nm))) (_a$8010 (jolt-count nm))) (jolt-invoke _a$8007 _a$8008 _a$8009 _a$8010))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?)))
+  (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec8008 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$8009 (var-deref "clojure.core" "subs")) (_a$8010 nm) (_a$8011 (jolt-dec (jolt-count nm))) (_a$8012 (jolt-count nm))) (jolt-invoke _a$8009 _a$8010 _a$8011 _a$8012))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8011 ((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__95_) (let fnrec8012 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor)))
+  (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec8013 ((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__95_) (let fnrec8014 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8013 ((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$8014 (keyword #f "op")) (_o$8015 (keyword #f "ffi-fn")) (_o$8016 (keyword #f "csym")) (_o$8017 (jolt-nth items 1)) (_o$8018 (keyword #f "argtypes")) (_o$8019 (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$8020 (keyword #f "rettype")) (_o$8021 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8022 (keyword #f "blocking")) (_o$8023 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8014 _o$8015 _o$8016 _o$8017 _o$8018 _o$8019 _o$8020 _o$8021 _o$8022 _o$8023))))))) analyze-ffi-fn)))
+  (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec8015 ((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$8016 (keyword #f "op")) (_o$8017 (keyword #f "ffi-fn")) (_o$8018 (keyword #f "csym")) (_o$8019 (jolt-nth items 1)) (_o$8020 (keyword #f "argtypes")) (_o$8021 (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$8022 (keyword #f "rettype")) (_o$8023 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8024 (keyword #f "blocking")) (_o$8025 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8016 _o$8017 _o$8018 _o$8019 _o$8020 _o$8021 _o$8022 _o$8023 _o$8024 _o$8025))))))) analyze-ffi-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8024 ((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$8025 (keyword #f "op")) (_o$8026 (keyword #f "ffi-callable")) (_o$8027 (keyword #f "fn")) (_o$8028 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8029 (keyword #f "argtypes")) (_o$8030 (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$8031 (keyword #f "rettype")) (_o$8032 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8033 (keyword #f "collect-safe")) (_o$8034 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8025 _o$8026 _o$8027 _o$8028 _o$8029 _o$8030 _o$8031 _o$8032 _o$8033 _o$8034))))))) analyze-ffi-callable)))
+  (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec8026 ((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$8027 (keyword #f "op")) (_o$8028 (keyword #f "ffi-callable")) (_o$8029 (keyword #f "fn")) (_o$8030 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8031 (keyword #f "argtypes")) (_o$8032 (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$8033 (keyword #f "rettype")) (_o$8034 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$8035 (keyword #f "collect-safe")) (_o$8036 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$8027 _o$8028 _o$8029 _o$8030 _o$8031 _o$8032 _o$8033 _o$8034 _o$8035 _o$8036))))))) analyze-ffi-callable)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec8035 ((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* ((target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$8040 (var-deref "jolt.ir" "invoke")) (_a$8041 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8042 (let* ((_a$8037 (var-deref "clojure.core" "mapv")) (_a$8038 (lambda (p__96_) (let fnrec8036 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$8039 (jolt-drop 3 items))) (jolt-invoke _a$8037 _a$8038 _a$8039)))) (jolt-invoke _a$8040 _a$8041 _a$8042)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8047 (keyword #f "op")) (_o$8048 (keyword #f "host-call")) (_o$8049 (keyword #f "method")) (_o$8050 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8051 (keyword #f "target")) (_o$8052 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8053 (keyword #f "args")) (_o$8054 (let* ((_a$8044 (var-deref "clojure.core" "mapv")) (_a$8045 (lambda (p__97_) (let fnrec8043 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$8046 (jolt-drop 3 items))) (jolt-invoke _a$8044 _a$8045 _a$8046)))) (jolt-hash-map _o$8047 _o$8048 _o$8049 _o$8050 _o$8051 _o$8052 _o$8053 _o$8054)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8055 (var-deref "jolt.ir" "invoke")) (_a$8056 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8057 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8055 _a$8056 _a$8057)) (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 fnrec8037 ((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* ((target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$8042 (var-deref "jolt.ir" "invoke")) (_a$8043 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8044 (let* ((_a$8039 (var-deref "clojure.core" "mapv")) (_a$8040 (lambda (p__96_) (let fnrec8038 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$8041 (jolt-drop 3 items))) (jolt-invoke _a$8039 _a$8040 _a$8041)))) (jolt-invoke _a$8042 _a$8043 _a$8044)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8049 (keyword #f "op")) (_o$8050 (keyword #f "host-call")) (_o$8051 (keyword #f "method")) (_o$8052 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8053 (keyword #f "target")) (_o$8054 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8055 (keyword #f "args")) (_o$8056 (let* ((_a$8046 (var-deref "clojure.core" "mapv")) (_a$8047 (lambda (p__97_) (let fnrec8045 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$8048 (jolt-drop 3 items))) (jolt-invoke _a$8046 _a$8047 _a$8048)))) (jolt-hash-map _o$8049 _o$8050 _o$8051 _o$8052 _o$8053 _o$8054 _o$8055 _o$8056)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8057 (var-deref "jolt.ir" "invoke")) (_a$8058 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8059 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8057 _a$8058 _a$8059)) (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 fnrec8058 ((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$8059 (keyword #f "op")) (_o$8060 (keyword #f "host-call")) (_o$8061 (keyword #f "method")) (_o$8062 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8063 (keyword #f "target")) (_o$8064 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8065 (keyword #f "args")) (_o$8066 (jolt-vector))) (jolt-hash-map _o$8059 _o$8060 _o$8061 _o$8062 _o$8063 _o$8064 _o$8065 _o$8066))))))) analyze-field)))
+  (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8060 ((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$8061 (keyword #f "op")) (_o$8062 (keyword #f "host-call")) (_o$8063 (keyword #f "method")) (_o$8064 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8065 (keyword #f "target")) (_o$8066 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8067 (keyword #f "args")) (_o$8068 (jolt-vector))) (jolt-hash-map _o$8061 _o$8062 _o$8063 _o$8064 _o$8065 _o$8066 _o$8067 _o$8068))))))) analyze-field)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8067 ((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__25__auto (jolt-nil? ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__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__146 (let* ((_a$8068 (var-deref "jolt.ir" "var-ref")) (_a$8069 (jolt-get r (keyword #f "ns"))) (_a$8070 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8068 _a$8069 _a$8070)))) (let* ((G__147 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__146 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__146))) G__147)) (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__148 (jolt-get r (keyword #f "kind")))) (if (jolt= G__148 (keyword #f "var")) (let* ((G__149 (let* ((_a$8071 (var-deref "jolt.ir" "var-ref")) (_a$8072 (jolt-get r (keyword #f "ns"))) (_a$8073 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8071 _a$8072 _a$8073)))) (let* ((G__150 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__149 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__149))) G__150)) (if (jolt= G__148 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__148 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (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 fnrec8069 ((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__25__auto (jolt-nil? ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__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__146 (let* ((_a$8070 (var-deref "jolt.ir" "var-ref")) (_a$8071 (jolt-get r (keyword #f "ns"))) (_a$8072 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8070 _a$8071 _a$8072)))) (let* ((G__147 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__146 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__146))) G__147)) (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__148 (jolt-get r (keyword #f "kind")))) (if (jolt= G__148 (keyword #f "var")) (let* ((G__149 (let* ((_a$8073 (var-deref "jolt.ir" "var-ref")) (_a$8074 (jolt-get r (keyword #f "ns"))) (_a$8075 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8073 _a$8074 _a$8075)))) (let* ((G__150 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__149 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__149))) G__150)) (if (jolt= G__148 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__148 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (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 fnrec8074 ((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__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8075 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8076 ctx) (_a$8077 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8078 (jolt-rest items)) (_a$8079 env)) (jolt-invoke _a$8075 _a$8076 _a$8077 _a$8078 _a$8079)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8080 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8081 ctx) (_a$8082 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8083 (jolt-drop 2 items)) (_a$8084 env)) (jolt-invoke _a$8080 _a$8081 _a$8082 _a$8083 _a$8084)) (if (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__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$8089 (var-deref "jolt.ir" "invoke")) (_a$8090 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8091 (let* ((_a$8086 (var-deref "clojure.core" "mapv")) (_a$8087 (lambda (p__98_) (let fnrec8085 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8088 (jolt-rest items))) (jolt-invoke _a$8086 _a$8087 _a$8088)))) (jolt-invoke _a$8089 _a$8090 _a$8091))) (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 fnrec8076 ((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__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8077 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8078 ctx) (_a$8079 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8080 (jolt-rest items)) (_a$8081 env)) (jolt-invoke _a$8077 _a$8078 _a$8079 _a$8080 _a$8081)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8082 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8083 ctx) (_a$8084 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8085 (jolt-drop 2 items)) (_a$8086 env)) (jolt-invoke _a$8082 _a$8083 _a$8084 _a$8085 _a$8086)) (if (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__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$8091 (var-deref "jolt.ir" "invoke")) (_a$8092 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8093 (let* ((_a$8088 (var-deref "clojure.core" "mapv")) (_a$8089 (lambda (p__98_) (let fnrec8087 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8090 (jolt-rest items))) (jolt-invoke _a$8088 _a$8089 _a$8090)))) (jolt-invoke _a$8091 _a$8092 _a$8093))) (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" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8092 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8095 (var-deref "jolt.ir" "invoke")) (_a$8096 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8097 (let* ((_o$8093 node) (_o$8094 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8093 _o$8094)))) (jolt-invoke _a$8095 _a$8096 _a$8097)))))))) with-coll-meta)))
+  (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8094 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8097 (var-deref "jolt.ir" "invoke")) (_a$8098 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8099 (let* ((_o$8095 node) (_o$8096 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8095 _o$8096)))) (jolt-invoke _a$8097 _a$8098 _a$8099)))))))) with-coll-meta)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8098 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8099 ((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$8101 (var-deref "clojure.core" "mapv")) (_a$8102 (lambda (p__99_) (let fnrec8100 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8103 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8101 _a$8102 _a$8103)))) (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$8107 (var-deref "clojure.core" "mapv")) (_a$8108 (lambda (p) (let fnrec8104 ((p p)) (let* ((_o$8105 (analyze ctx (jolt-first p) env)) (_o$8106 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8105 _o$8106))))) (_a$8109 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8107 _a$8108 _a$8109)))) (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$8111 (var-deref "clojure.core" "mapv")) (_a$8112 (lambda (p__100_) (let fnrec8110 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8113 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8111 _a$8112 _a$8113)))) (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$8114 (keyword #f "op")) (_o$8115 (keyword #f "regex")) (_o$8116 (keyword #f "source")) (_o$8117 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8114 _o$8115 _o$8116 _o$8117)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8118 (keyword #f "op")) (_o$8119 (keyword #f "inst")) (_o$8120 (keyword #f "source")) (_o$8121 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8118 _o$8119 _o$8120 _o$8121)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8122 (keyword #f "op")) (_o$8123 (keyword #f "uuid")) (_o$8124 (keyword #f "source")) (_o$8125 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8122 _o$8123 _o$8124 _o$8125)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8126 (keyword #f "op")) (_o$8127 (keyword #f "bigdec")) (_o$8128 (keyword #f "source")) (_o$8129 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8126 _o$8127 _o$8128 _o$8129)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8130 (keyword #f "op")) (_o$8131 (keyword #f "the-ns")) (_o$8132 (keyword #f "name")) (_o$8133 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8130 _o$8131 _o$8132 _o$8133)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil))))))))))))))))) analyze)))
+  (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8100 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8101 ((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$8103 (var-deref "clojure.core" "mapv")) (_a$8104 (lambda (p__99_) (let fnrec8102 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8105 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8103 _a$8104 _a$8105)))) (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$8109 (var-deref "clojure.core" "mapv")) (_a$8110 (lambda (p) (let fnrec8106 ((p p)) (let* ((_o$8107 (analyze ctx (jolt-first p) env)) (_o$8108 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8107 _o$8108))))) (_a$8111 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8109 _a$8110 _a$8111)))) (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$8113 (var-deref "clojure.core" "mapv")) (_a$8114 (lambda (p__100_) (let fnrec8112 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8115 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8113 _a$8114 _a$8115)))) (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$8116 (keyword #f "op")) (_o$8117 (keyword #f "regex")) (_o$8118 (keyword #f "source")) (_o$8119 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8116 _o$8117 _o$8118 _o$8119)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8120 (keyword #f "op")) (_o$8121 (keyword #f "inst")) (_o$8122 (keyword #f "source")) (_o$8123 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8120 _o$8121 _o$8122 _o$8123)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8124 (keyword #f "op")) (_o$8125 (keyword #f "uuid")) (_o$8126 (keyword #f "source")) (_o$8127 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8124 _o$8125 _o$8126 _o$8127)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8128 (keyword #f "op")) (_o$8129 (keyword #f "bigdec")) (_o$8130 (keyword #f "source")) (_o$8131 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8128 _o$8129 _o$8130 _o$8131)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8132 (keyword #f "op")) (_o$8133 (keyword #f "the-ns")) (_o$8134 (keyword #f "name")) (_o$8135 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8132 _o$8133 _o$8134 _o$8135)) (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" "native-ops" (let* ((_o$6515 "+") (_o$6516 "+") (_o$6517 "-") (_o$6518 "-") (_o$6519 "*") (_o$6520 "*") (_o$6521 "/") (_o$6522 "/") (_o$6523 "<") (_o$6524 "<") (_o$6525 ">") (_o$6526 ">") (_o$6527 "<=") (_o$6528 "<=") (_o$6529 ">=") (_o$6530 ">=") (_o$6531 "=") (_o$6532 "jolt=") (_o$6533 "inc") (_o$6534 "jolt-inc") (_o$6535 "dec") (_o$6536 "jolt-dec") (_o$6537 "not") (_o$6538 "jolt-not") (_o$6539 "min") (_o$6540 "min") (_o$6541 "max") (_o$6542 "max") (_o$6543 "mod") (_o$6544 "modulo") (_o$6545 "rem") (_o$6546 "remainder") (_o$6547 "quot") (_o$6548 "quotient") (_o$6549 "vector") (_o$6550 "jolt-vector") (_o$6551 "hash-map") (_o$6552 "jolt-hash-map") (_o$6553 "hash-set") (_o$6554 "jolt-hash-set") (_o$6555 "conj") (_o$6556 "jolt-conj") (_o$6557 "get") (_o$6558 "jolt-get") (_o$6559 "nth") (_o$6560 "jolt-nth") (_o$6561 "count") (_o$6562 "jolt-count") (_o$6563 "assoc") (_o$6564 "jolt-assoc") (_o$6565 "dissoc") (_o$6566 "jolt-dissoc") (_o$6567 "contains?") (_o$6568 "jolt-contains?") (_o$6569 "empty?") (_o$6570 "jolt-empty?") (_o$6571 "peek") (_o$6572 "jolt-peek") (_o$6573 "pop") (_o$6574 "jolt-pop") (_o$6575 "first") (_o$6576 "jolt-first") (_o$6577 "rest") (_o$6578 "jolt-rest") (_o$6579 "next") (_o$6580 "jolt-next") (_o$6581 "seq") (_o$6582 "jolt-seq") (_o$6583 "cons") (_o$6584 "jolt-cons") (_o$6585 "list") (_o$6586 "jolt-list") (_o$6587 "reverse") (_o$6588 "jolt-reverse") (_o$6589 "last") (_o$6590 "jolt-last") (_o$6591 "map") (_o$6592 "jolt-map") (_o$6593 "filter") (_o$6594 "jolt-filter") (_o$6595 "remove") (_o$6596 "jolt-remove") (_o$6597 "reduce") (_o$6598 "jolt-reduce") (_o$6599 "into") (_o$6600 "jolt-into") (_o$6601 "concat") (_o$6602 "jolt-concat") (_o$6603 "apply") (_o$6604 "jolt-apply") (_o$6605 "range") (_o$6606 "jolt-range") (_o$6607 "take") (_o$6608 "jolt-take") (_o$6609 "drop") (_o$6610 "jolt-drop") (_o$6611 "keys") (_o$6612 "jolt-keys") (_o$6613 "vals") (_o$6614 "jolt-vals") (_o$6615 "even?") (_o$6616 "jolt-even?") (_o$6617 "odd?") (_o$6618 "jolt-odd?") (_o$6619 "pos?") (_o$6620 "jolt-pos?") (_o$6621 "neg?") (_o$6622 "jolt-neg?") (_o$6623 "zero?") (_o$6624 "jolt-zero?") (_o$6625 "identity") (_o$6626 "jolt-identity") (_o$6627 "nil?") (_o$6628 "jolt-nil?") (_o$6629 "some?") (_o$6630 "jolt-some?") (_o$6631 "ex-info") (_o$6632 "jolt-ex-info") (_o$6633 "protocol-dispatch1") (_o$6634 "protocol-dispatch1") (_o$6635 "protocol-dispatch2") (_o$6636 "protocol-dispatch2") (_o$6637 "protocol-dispatch3") (_o$6638 "protocol-dispatch3")) (jolt-hash-map _o$6515 _o$6516 _o$6517 _o$6518 _o$6519 _o$6520 _o$6521 _o$6522 _o$6523 _o$6524 _o$6525 _o$6526 _o$6527 _o$6528 _o$6529 _o$6530 _o$6531 _o$6532 _o$6533 _o$6534 _o$6535 _o$6536 _o$6537 _o$6538 _o$6539 _o$6540 _o$6541 _o$6542 _o$6543 _o$6544 _o$6545 _o$6546 _o$6547 _o$6548 _o$6549 _o$6550 _o$6551 _o$6552 _o$6553 _o$6554 _o$6555 _o$6556 _o$6557 _o$6558 _o$6559 _o$6560 _o$6561 _o$6562 _o$6563 _o$6564 _o$6565 _o$6566 _o$6567 _o$6568 _o$6569 _o$6570 _o$6571 _o$6572 _o$6573 _o$6574 _o$6575 _o$6576 _o$6577 _o$6578 _o$6579 _o$6580 _o$6581 _o$6582 _o$6583 _o$6584 _o$6585 _o$6586 _o$6587 _o$6588 _o$6589 _o$6590 _o$6591 _o$6592 _o$6593 _o$6594 _o$6595 _o$6596 _o$6597 _o$6598 _o$6599 _o$6600 _o$6601 _o$6602 _o$6603 _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609 _o$6610 _o$6611 _o$6612 _o$6613 _o$6614 _o$6615 _o$6616 _o$6617 _o$6618 _o$6619 _o$6620 _o$6621 _o$6622 _o$6623 _o$6624 _o$6625 _o$6626 _o$6627 _o$6628 _o$6629 _o$6630 _o$6631 _o$6632 _o$6633 _o$6634 _o$6635 _o$6636 _o$6637 _o$6638)) (let* ((_o$6639 (keyword #f "private")) (_o$6640 #t)) (jolt-hash-map _o$6639 _o$6640))))
+  (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$6517 "+") (_o$6518 "+") (_o$6519 "-") (_o$6520 "-") (_o$6521 "*") (_o$6522 "*") (_o$6523 "/") (_o$6524 "/") (_o$6525 "<") (_o$6526 "<") (_o$6527 ">") (_o$6528 ">") (_o$6529 "<=") (_o$6530 "<=") (_o$6531 ">=") (_o$6532 ">=") (_o$6533 "=") (_o$6534 "jolt=") (_o$6535 "inc") (_o$6536 "jolt-inc") (_o$6537 "dec") (_o$6538 "jolt-dec") (_o$6539 "not") (_o$6540 "jolt-not") (_o$6541 "min") (_o$6542 "min") (_o$6543 "max") (_o$6544 "max") (_o$6545 "mod") (_o$6546 "modulo") (_o$6547 "rem") (_o$6548 "remainder") (_o$6549 "quot") (_o$6550 "quotient") (_o$6551 "vector") (_o$6552 "jolt-vector") (_o$6553 "hash-map") (_o$6554 "jolt-hash-map") (_o$6555 "hash-set") (_o$6556 "jolt-hash-set") (_o$6557 "conj") (_o$6558 "jolt-conj") (_o$6559 "get") (_o$6560 "jolt-get") (_o$6561 "nth") (_o$6562 "jolt-nth") (_o$6563 "count") (_o$6564 "jolt-count") (_o$6565 "assoc") (_o$6566 "jolt-assoc") (_o$6567 "dissoc") (_o$6568 "jolt-dissoc") (_o$6569 "contains?") (_o$6570 "jolt-contains?") (_o$6571 "empty?") (_o$6572 "jolt-empty?") (_o$6573 "peek") (_o$6574 "jolt-peek") (_o$6575 "pop") (_o$6576 "jolt-pop") (_o$6577 "first") (_o$6578 "jolt-first") (_o$6579 "rest") (_o$6580 "jolt-rest") (_o$6581 "next") (_o$6582 "jolt-next") (_o$6583 "seq") (_o$6584 "jolt-seq") (_o$6585 "cons") (_o$6586 "jolt-cons") (_o$6587 "list") (_o$6588 "jolt-list") (_o$6589 "reverse") (_o$6590 "jolt-reverse") (_o$6591 "last") (_o$6592 "jolt-last") (_o$6593 "map") (_o$6594 "jolt-map") (_o$6595 "filter") (_o$6596 "jolt-filter") (_o$6597 "remove") (_o$6598 "jolt-remove") (_o$6599 "reduce") (_o$6600 "jolt-reduce") (_o$6601 "into") (_o$6602 "jolt-into") (_o$6603 "concat") (_o$6604 "jolt-concat") (_o$6605 "apply") (_o$6606 "jolt-apply") (_o$6607 "range") (_o$6608 "jolt-range") (_o$6609 "take") (_o$6610 "jolt-take") (_o$6611 "drop") (_o$6612 "jolt-drop") (_o$6613 "keys") (_o$6614 "jolt-keys") (_o$6615 "vals") (_o$6616 "jolt-vals") (_o$6617 "even?") (_o$6618 "jolt-even?") (_o$6619 "odd?") (_o$6620 "jolt-odd?") (_o$6621 "pos?") (_o$6622 "jolt-pos?") (_o$6623 "neg?") (_o$6624 "jolt-neg?") (_o$6625 "zero?") (_o$6626 "jolt-zero?") (_o$6627 "identity") (_o$6628 "jolt-identity") (_o$6629 "nil?") (_o$6630 "jolt-nil?") (_o$6631 "some?") (_o$6632 "jolt-some?") (_o$6633 "ex-info") (_o$6634 "jolt-ex-info") (_o$6635 "protocol-dispatch1") (_o$6636 "protocol-dispatch1") (_o$6637 "protocol-dispatch2") (_o$6638 "protocol-dispatch2") (_o$6639 "protocol-dispatch3") (_o$6640 "protocol-dispatch3")) (jolt-hash-map _o$6517 _o$6518 _o$6519 _o$6520 _o$6521 _o$6522 _o$6523 _o$6524 _o$6525 _o$6526 _o$6527 _o$6528 _o$6529 _o$6530 _o$6531 _o$6532 _o$6533 _o$6534 _o$6535 _o$6536 _o$6537 _o$6538 _o$6539 _o$6540 _o$6541 _o$6542 _o$6543 _o$6544 _o$6545 _o$6546 _o$6547 _o$6548 _o$6549 _o$6550 _o$6551 _o$6552 _o$6553 _o$6554 _o$6555 _o$6556 _o$6557 _o$6558 _o$6559 _o$6560 _o$6561 _o$6562 _o$6563 _o$6564 _o$6565 _o$6566 _o$6567 _o$6568 _o$6569 _o$6570 _o$6571 _o$6572 _o$6573 _o$6574 _o$6575 _o$6576 _o$6577 _o$6578 _o$6579 _o$6580 _o$6581 _o$6582 _o$6583 _o$6584 _o$6585 _o$6586 _o$6587 _o$6588 _o$6589 _o$6590 _o$6591 _o$6592 _o$6593 _o$6594 _o$6595 _o$6596 _o$6597 _o$6598 _o$6599 _o$6600 _o$6601 _o$6602 _o$6603 _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609 _o$6610 _o$6611 _o$6612 _o$6613 _o$6614 _o$6615 _o$6616 _o$6617 _o$6618 _o$6619 _o$6620 _o$6621 _o$6622 _o$6623 _o$6624 _o$6625 _o$6626 _o$6627 _o$6628 _o$6629 _o$6630 _o$6631 _o$6632 _o$6633 _o$6634 _o$6635 _o$6636 _o$6637 _o$6638 _o$6639 _o$6640)) (let* ((_o$6641 (keyword #f "private")) (_o$6642 #t)) (jolt-hash-map _o$6641 _o$6642))))
 (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$6641 "+") (_o$6642 "jolt-add") (_o$6643 "-") (_o$6644 "jolt-sub") (_o$6645 "*") (_o$6646 "jolt-mul") (_o$6647 "/") (_o$6648 "jolt-div") (_o$6649 "min") (_o$6650 "jolt-min") (_o$6651 "max") (_o$6652 "jolt-max")) (jolt-hash-map _o$6641 _o$6642 _o$6643 _o$6644 _o$6645 _o$6646 _o$6647 _o$6648 _o$6649 _o$6650 _o$6651 _o$6652))) (let* ((_o$6653 (keyword #f "private")) (_o$6654 #t)) (jolt-hash-map _o$6653 _o$6654))))
+  (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$6643 "+") (_o$6644 "jolt-add") (_o$6645 "-") (_o$6646 "jolt-sub") (_o$6647 "*") (_o$6648 "jolt-mul") (_o$6649 "/") (_o$6650 "jolt-div") (_o$6651 "min") (_o$6652 "jolt-min") (_o$6653 "max") (_o$6654 "jolt-max")) (jolt-hash-map _o$6643 _o$6644 _o$6645 _o$6646 _o$6647 _o$6648 _o$6649 _o$6650 _o$6651 _o$6652 _o$6653 _o$6654))) (let* ((_o$6655 (keyword #f "private")) (_o$6656 #t)) (jolt-hash-map _o$6655 _o$6656))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6701 "inc") (_o$6702 (lambda (p__42_) (let fnrec6655 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6703 "dec") (_o$6704 (lambda (p__43_) (let fnrec6656 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6705 "not") (_o$6706 (lambda (p__44_) (let fnrec6657 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6707 "count") (_o$6708 (lambda (p__45_) (let fnrec6658 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6709 "empty?") (_o$6710 (lambda (p__46_) (let fnrec6659 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6711 "peek") (_o$6712 (lambda (p__47_) (let fnrec6660 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6713 "pop") (_o$6714 (lambda (p__48_) (let fnrec6661 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6715 "mod") (_o$6716 (lambda (p__49_) (let fnrec6662 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6717 "rem") (_o$6718 (lambda (p__50_) (let fnrec6663 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6719 "quot") (_o$6720 (lambda (p__51_) (let fnrec6664 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6721 "contains?") (_o$6722 (lambda (p__52_) (let fnrec6665 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6723 "get") (_o$6724 (lambda (p__53_) (let fnrec6666 ((p__53_ p__53_)) (let* ((or__26__auto (jolt= p__53_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__53_ 3)))))) (_o$6725 "nth") (_o$6726 (lambda (p__54_) (let fnrec6667 ((p__54_ p__54_)) (let* ((or__26__auto (jolt= p__54_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__54_ 3)))))) (_o$6727 "assoc") (_o$6728 (lambda (p__55_) (let fnrec6668 ((p__55_ p__55_)) (let* ((and__25__auto (>= p__55_ 3))) (if (jolt-truthy? and__25__auto) (jolt-odd? p__55_) and__25__auto))))) (_o$6729 "dissoc") (_o$6730 (lambda (p__56_) (let fnrec6669 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6731 "conj") (_o$6732 (lambda (p__57_) (let fnrec6670 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6733 "first") (_o$6734 (lambda (p__58_) (let fnrec6671 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6735 "rest") (_o$6736 (lambda (p__59_) (let fnrec6672 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6737 "next") (_o$6738 (lambda (p__60_) (let fnrec6673 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6739 "seq") (_o$6740 (lambda (p__61_) (let fnrec6674 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6741 "reverse") (_o$6742 (lambda (p__62_) (let fnrec6675 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6743 "last") (_o$6744 (lambda (p__63_) (let fnrec6676 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6745 "keys") (_o$6746 (lambda (p__64_) (let fnrec6677 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6747 "vals") (_o$6748 (lambda (p__65_) (let fnrec6678 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6749 "even?") (_o$6750 (lambda (p__66_) (let fnrec6679 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6751 "odd?") (_o$6752 (lambda (p__67_) (let fnrec6680 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6753 "pos?") (_o$6754 (lambda (p__68_) (let fnrec6681 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6755 "neg?") (_o$6756 (lambda (p__69_) (let fnrec6682 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6757 "zero?") (_o$6758 (lambda (p__70_) (let fnrec6683 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6759 "identity") (_o$6760 (lambda (p__71_) (let fnrec6684 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6761 "nil?") (_o$6762 (lambda (p__72_) (let fnrec6685 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$6763 "some?") (_o$6764 (lambda (p__73_) (let fnrec6686 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$6765 "protocol-dispatch1") (_o$6766 (lambda (p__74_) (let fnrec6687 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$6767 "protocol-dispatch2") (_o$6768 (lambda (p__75_) (let fnrec6688 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$6769 "protocol-dispatch3") (_o$6770 (lambda (p__76_) (let fnrec6689 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$6771 "cons") (_o$6772 (lambda (p__77_) (let fnrec6690 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6773 "filter") (_o$6774 (lambda (p__78_) (let fnrec6691 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$6775 "remove") (_o$6776 (lambda (p__79_) (let fnrec6692 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$6777 "into") (_o$6778 (lambda (p__80_) (let fnrec6693 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$6779 "take") (_o$6780 (lambda (p__81_) (let fnrec6694 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$6781 "drop") (_o$6782 (lambda (p__82_) (let fnrec6695 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$6783 "map") (_o$6784 (lambda (p__83_) (let fnrec6696 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$6785 "apply") (_o$6786 (lambda (p__84_) (let fnrec6697 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$6787 "reduce") (_o$6788 (lambda (p__85_) (let fnrec6698 ((p__85_ p__85_)) (let* ((or__26__auto (jolt= p__85_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__85_ 3)))))) (_o$6789 "range") (_o$6790 (lambda (p__86_) (let fnrec6699 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$6791 "ex-info") (_o$6792 (lambda (p__87_) (let fnrec6700 ((p__87_ p__87_)) (let* ((or__26__auto (jolt= p__87_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__87_ 3))))))) (jolt-hash-map _o$6701 _o$6702 _o$6703 _o$6704 _o$6705 _o$6706 _o$6707 _o$6708 _o$6709 _o$6710 _o$6711 _o$6712 _o$6713 _o$6714 _o$6715 _o$6716 _o$6717 _o$6718 _o$6719 _o$6720 _o$6721 _o$6722 _o$6723 _o$6724 _o$6725 _o$6726 _o$6727 _o$6728 _o$6729 _o$6730 _o$6731 _o$6732 _o$6733 _o$6734 _o$6735 _o$6736 _o$6737 _o$6738 _o$6739 _o$6740 _o$6741 _o$6742 _o$6743 _o$6744 _o$6745 _o$6746 _o$6747 _o$6748 _o$6749 _o$6750 _o$6751 _o$6752 _o$6753 _o$6754 _o$6755 _o$6756 _o$6757 _o$6758 _o$6759 _o$6760 _o$6761 _o$6762 _o$6763 _o$6764 _o$6765 _o$6766 _o$6767 _o$6768 _o$6769 _o$6770 _o$6771 _o$6772 _o$6773 _o$6774 _o$6775 _o$6776 _o$6777 _o$6778 _o$6779 _o$6780 _o$6781 _o$6782 _o$6783 _o$6784 _o$6785 _o$6786 _o$6787 _o$6788 _o$6789 _o$6790 _o$6791 _o$6792)) (let* ((_o$6793 (keyword #f "private")) (_o$6794 #t)) (jolt-hash-map _o$6793 _o$6794))))
+  (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6703 "inc") (_o$6704 (lambda (p__42_) (let fnrec6657 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6705 "dec") (_o$6706 (lambda (p__43_) (let fnrec6658 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6707 "not") (_o$6708 (lambda (p__44_) (let fnrec6659 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6709 "count") (_o$6710 (lambda (p__45_) (let fnrec6660 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6711 "empty?") (_o$6712 (lambda (p__46_) (let fnrec6661 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6713 "peek") (_o$6714 (lambda (p__47_) (let fnrec6662 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6715 "pop") (_o$6716 (lambda (p__48_) (let fnrec6663 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6717 "mod") (_o$6718 (lambda (p__49_) (let fnrec6664 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6719 "rem") (_o$6720 (lambda (p__50_) (let fnrec6665 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6721 "quot") (_o$6722 (lambda (p__51_) (let fnrec6666 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6723 "contains?") (_o$6724 (lambda (p__52_) (let fnrec6667 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6725 "get") (_o$6726 (lambda (p__53_) (let fnrec6668 ((p__53_ p__53_)) (let* ((or__26__auto (jolt= p__53_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__53_ 3)))))) (_o$6727 "nth") (_o$6728 (lambda (p__54_) (let fnrec6669 ((p__54_ p__54_)) (let* ((or__26__auto (jolt= p__54_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__54_ 3)))))) (_o$6729 "assoc") (_o$6730 (lambda (p__55_) (let fnrec6670 ((p__55_ p__55_)) (let* ((and__25__auto (>= p__55_ 3))) (if (jolt-truthy? and__25__auto) (jolt-odd? p__55_) and__25__auto))))) (_o$6731 "dissoc") (_o$6732 (lambda (p__56_) (let fnrec6671 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6733 "conj") (_o$6734 (lambda (p__57_) (let fnrec6672 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6735 "first") (_o$6736 (lambda (p__58_) (let fnrec6673 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6737 "rest") (_o$6738 (lambda (p__59_) (let fnrec6674 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6739 "next") (_o$6740 (lambda (p__60_) (let fnrec6675 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6741 "seq") (_o$6742 (lambda (p__61_) (let fnrec6676 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6743 "reverse") (_o$6744 (lambda (p__62_) (let fnrec6677 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6745 "last") (_o$6746 (lambda (p__63_) (let fnrec6678 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6747 "keys") (_o$6748 (lambda (p__64_) (let fnrec6679 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6749 "vals") (_o$6750 (lambda (p__65_) (let fnrec6680 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6751 "even?") (_o$6752 (lambda (p__66_) (let fnrec6681 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6753 "odd?") (_o$6754 (lambda (p__67_) (let fnrec6682 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6755 "pos?") (_o$6756 (lambda (p__68_) (let fnrec6683 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6757 "neg?") (_o$6758 (lambda (p__69_) (let fnrec6684 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6759 "zero?") (_o$6760 (lambda (p__70_) (let fnrec6685 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6761 "identity") (_o$6762 (lambda (p__71_) (let fnrec6686 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6763 "nil?") (_o$6764 (lambda (p__72_) (let fnrec6687 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$6765 "some?") (_o$6766 (lambda (p__73_) (let fnrec6688 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$6767 "protocol-dispatch1") (_o$6768 (lambda (p__74_) (let fnrec6689 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$6769 "protocol-dispatch2") (_o$6770 (lambda (p__75_) (let fnrec6690 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$6771 "protocol-dispatch3") (_o$6772 (lambda (p__76_) (let fnrec6691 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$6773 "cons") (_o$6774 (lambda (p__77_) (let fnrec6692 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6775 "filter") (_o$6776 (lambda (p__78_) (let fnrec6693 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$6777 "remove") (_o$6778 (lambda (p__79_) (let fnrec6694 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$6779 "into") (_o$6780 (lambda (p__80_) (let fnrec6695 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$6781 "take") (_o$6782 (lambda (p__81_) (let fnrec6696 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$6783 "drop") (_o$6784 (lambda (p__82_) (let fnrec6697 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$6785 "map") (_o$6786 (lambda (p__83_) (let fnrec6698 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$6787 "apply") (_o$6788 (lambda (p__84_) (let fnrec6699 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$6789 "reduce") (_o$6790 (lambda (p__85_) (let fnrec6700 ((p__85_ p__85_)) (let* ((or__26__auto (jolt= p__85_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__85_ 3)))))) (_o$6791 "range") (_o$6792 (lambda (p__86_) (let fnrec6701 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$6793 "ex-info") (_o$6794 (lambda (p__87_) (let fnrec6702 ((p__87_ p__87_)) (let* ((or__26__auto (jolt= p__87_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__87_ 3))))))) (jolt-hash-map _o$6703 _o$6704 _o$6705 _o$6706 _o$6707 _o$6708 _o$6709 _o$6710 _o$6711 _o$6712 _o$6713 _o$6714 _o$6715 _o$6716 _o$6717 _o$6718 _o$6719 _o$6720 _o$6721 _o$6722 _o$6723 _o$6724 _o$6725 _o$6726 _o$6727 _o$6728 _o$6729 _o$6730 _o$6731 _o$6732 _o$6733 _o$6734 _o$6735 _o$6736 _o$6737 _o$6738 _o$6739 _o$6740 _o$6741 _o$6742 _o$6743 _o$6744 _o$6745 _o$6746 _o$6747 _o$6748 _o$6749 _o$6750 _o$6751 _o$6752 _o$6753 _o$6754 _o$6755 _o$6756 _o$6757 _o$6758 _o$6759 _o$6760 _o$6761 _o$6762 _o$6763 _o$6764 _o$6765 _o$6766 _o$6767 _o$6768 _o$6769 _o$6770 _o$6771 _o$6772 _o$6773 _o$6774 _o$6775 _o$6776 _o$6777 _o$6778 _o$6779 _o$6780 _o$6781 _o$6782 _o$6783 _o$6784 _o$6785 _o$6786 _o$6787 _o$6788 _o$6789 _o$6790 _o$6791 _o$6792 _o$6793 _o$6794)) (let* ((_o$6795 (keyword #f "private")) (_o$6796 #t)) (jolt-hash-map _o$6795 _o$6796))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6795 "<") (_o$6796 ">") (_o$6797 "<=") (_o$6798 ">=")) (jolt-hash-set _o$6795 _o$6796 _o$6797 _o$6798)) (let* ((_o$6799 (keyword #f "private")) (_o$6800 #t)) (jolt-hash-map _o$6799 _o$6800))))
+  (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6797 "<") (_o$6798 ">") (_o$6799 "<=") (_o$6800 ">=")) (jolt-hash-set _o$6797 _o$6798 _o$6799 _o$6800)) (let* ((_o$6801 (keyword #f "private")) (_o$6802 #t)) (jolt-hash-map _o$6801 _o$6802))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6801 "isDirectory") (_o$6802 "listFiles")) (jolt-hash-set _o$6801 _o$6802)) (let* ((_o$6803 (keyword #f "private")) (_o$6804 #t)) (jolt-hash-map _o$6803 _o$6804))))
+  (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6803 "isDirectory") (_o$6804 "listFiles")) (jolt-hash-set _o$6803 _o$6804)) (let* ((_o$6805 (keyword #f "private")) (_o$6806 #t)) (jolt-hash-map _o$6805 _o$6806))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6805 "<") (_o$6806 "<=") (_o$6807 ">") (_o$6808 ">=") (_o$6809 "jolt=") (_o$6810 "jolt-not") (_o$6811 "jolt-even?") (_o$6812 "jolt-odd?") (_o$6813 "jolt-pos?") (_o$6814 "jolt-neg?") (_o$6815 "jolt-zero?") (_o$6816 "jolt-empty?") (_o$6817 "jolt-contains?") (_o$6818 "jolt-nil?") (_o$6819 "jolt-some?")) (jolt-hash-set _o$6805 _o$6806 _o$6807 _o$6808 _o$6809 _o$6810 _o$6811 _o$6812 _o$6813 _o$6814 _o$6815 _o$6816 _o$6817 _o$6818 _o$6819)) (let* ((_o$6820 (keyword #f "private")) (_o$6821 #t)) (jolt-hash-map _o$6820 _o$6821))))
+  (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6807 "<") (_o$6808 "<=") (_o$6809 ">") (_o$6810 ">=") (_o$6811 "jolt=") (_o$6812 "jolt-not") (_o$6813 "jolt-even?") (_o$6814 "jolt-odd?") (_o$6815 "jolt-pos?") (_o$6816 "jolt-neg?") (_o$6817 "jolt-zero?") (_o$6818 "jolt-empty?") (_o$6819 "jolt-contains?") (_o$6820 "jolt-nil?") (_o$6821 "jolt-some?")) (jolt-hash-set _o$6807 _o$6808 _o$6809 _o$6810 _o$6811 _o$6812 _o$6813 _o$6814 _o$6815 _o$6816 _o$6817 _o$6818 _o$6819 _o$6820 _o$6821)) (let* ((_o$6822 (keyword #f "private")) (_o$6823 #t)) (jolt-hash-map _o$6822 _o$6823))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6822 "+") (_o$6823 "fl+") (_o$6824 "-") (_o$6825 "fl-") (_o$6826 "*") (_o$6827 "fl*") (_o$6828 "/") (_o$6829 "fl/") (_o$6830 "min") (_o$6831 "flmin") (_o$6832 "max") (_o$6833 "flmax") (_o$6834 "<") (_o$6835 "fl<?") (_o$6836 ">") (_o$6837 "fl>?") (_o$6838 "<=") (_o$6839 "fl<=?") (_o$6840 ">=") (_o$6841 "fl>=?") (_o$6842 "=") (_o$6843 "fl=?") (_o$6844 "==") (_o$6845 "fl=?")) (jolt-hash-map _o$6822 _o$6823 _o$6824 _o$6825 _o$6826 _o$6827 _o$6828 _o$6829 _o$6830 _o$6831 _o$6832 _o$6833 _o$6834 _o$6835 _o$6836 _o$6837 _o$6838 _o$6839 _o$6840 _o$6841 _o$6842 _o$6843 _o$6844 _o$6845)) (let* ((_o$6846 (keyword #f "private")) (_o$6847 #t)) (jolt-hash-map _o$6846 _o$6847))))
+  (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6824 "+") (_o$6825 "fl+") (_o$6826 "-") (_o$6827 "fl-") (_o$6828 "*") (_o$6829 "fl*") (_o$6830 "/") (_o$6831 "fl/") (_o$6832 "min") (_o$6833 "flmin") (_o$6834 "max") (_o$6835 "flmax") (_o$6836 "<") (_o$6837 "fl<?") (_o$6838 ">") (_o$6839 "fl>?") (_o$6840 "<=") (_o$6841 "fl<=?") (_o$6842 ">=") (_o$6843 "fl>=?") (_o$6844 "=") (_o$6845 "fl=?") (_o$6846 "==") (_o$6847 "fl=?")) (jolt-hash-map _o$6824 _o$6825 _o$6826 _o$6827 _o$6828 _o$6829 _o$6830 _o$6831 _o$6832 _o$6833 _o$6834 _o$6835 _o$6836 _o$6837 _o$6838 _o$6839 _o$6840 _o$6841 _o$6842 _o$6843 _o$6844 _o$6845 _o$6846 _o$6847)) (let* ((_o$6848 (keyword #f "private")) (_o$6849 #t)) (jolt-hash-map _o$6848 _o$6849))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6848 "+") (_o$6849 "fx+") (_o$6850 "-") (_o$6851 "fx-") (_o$6852 "*") (_o$6853 "fx*") (_o$6854 "min") (_o$6855 "fxmin") (_o$6856 "max") (_o$6857 "fxmax") (_o$6858 "unchecked-add") (_o$6859 "fx+") (_o$6860 "unchecked-subtract") (_o$6861 "fx-") (_o$6862 "unchecked-multiply") (_o$6863 "fx*") (_o$6864 "quot") (_o$6865 "fxquotient") (_o$6866 "rem") (_o$6867 "fxremainder") (_o$6868 "mod") (_o$6869 "fxmodulo") (_o$6870 "<") (_o$6871 "fx<?") (_o$6872 ">") (_o$6873 "fx>?") (_o$6874 "<=") (_o$6875 "fx<=?") (_o$6876 ">=") (_o$6877 "fx>=?") (_o$6878 "=") (_o$6879 "fx=?") (_o$6880 "==") (_o$6881 "fx=?")) (jolt-hash-map _o$6848 _o$6849 _o$6850 _o$6851 _o$6852 _o$6853 _o$6854 _o$6855 _o$6856 _o$6857 _o$6858 _o$6859 _o$6860 _o$6861 _o$6862 _o$6863 _o$6864 _o$6865 _o$6866 _o$6867 _o$6868 _o$6869 _o$6870 _o$6871 _o$6872 _o$6873 _o$6874 _o$6875 _o$6876 _o$6877 _o$6878 _o$6879 _o$6880 _o$6881)) (let* ((_o$6882 (keyword #f "private")) (_o$6883 #t)) (jolt-hash-map _o$6882 _o$6883))))
+  (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6850 "+") (_o$6851 "fx+") (_o$6852 "-") (_o$6853 "fx-") (_o$6854 "*") (_o$6855 "fx*") (_o$6856 "min") (_o$6857 "fxmin") (_o$6858 "max") (_o$6859 "fxmax") (_o$6860 "unchecked-add") (_o$6861 "fx+") (_o$6862 "unchecked-subtract") (_o$6863 "fx-") (_o$6864 "unchecked-multiply") (_o$6865 "fx*") (_o$6866 "quot") (_o$6867 "fxquotient") (_o$6868 "rem") (_o$6869 "fxremainder") (_o$6870 "mod") (_o$6871 "fxmodulo") (_o$6872 "<") (_o$6873 "fx<?") (_o$6874 ">") (_o$6875 "fx>?") (_o$6876 "<=") (_o$6877 "fx<=?") (_o$6878 ">=") (_o$6879 "fx>=?") (_o$6880 "=") (_o$6881 "fx=?") (_o$6882 "==") (_o$6883 "fx=?")) (jolt-hash-map _o$6850 _o$6851 _o$6852 _o$6853 _o$6854 _o$6855 _o$6856 _o$6857 _o$6858 _o$6859 _o$6860 _o$6861 _o$6862 _o$6863 _o$6864 _o$6865 _o$6866 _o$6867 _o$6868 _o$6869 _o$6870 _o$6871 _o$6872 _o$6873 _o$6874 _o$6875 _o$6876 _o$6877 _o$6878 _o$6879 _o$6880 _o$6881 _o$6882 _o$6883)) (let* ((_o$6884 (keyword #f "private")) (_o$6885 #t)) (jolt-hash-map _o$6884 _o$6885))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$6884 "+") (_o$6885 "jbd-add") (_o$6886 "-") (_o$6887 "jbd-sub") (_o$6888 "*") (_o$6889 "jbd-mul") (_o$6890 "/") (_o$6891 "jbd-div") (_o$6892 "min") (_o$6893 "jbd-min") (_o$6894 "max") (_o$6895 "jbd-max") (_o$6896 "quot") (_o$6897 "jbd-quot") (_o$6898 "rem") (_o$6899 "jbd-rem") (_o$6900 "<") (_o$6901 "jbd-lt?") (_o$6902 ">") (_o$6903 "jbd-gt?") (_o$6904 "<=") (_o$6905 "jbd-le?") (_o$6906 ">=") (_o$6907 "jbd-ge?") (_o$6908 "zero?") (_o$6909 "jbd-zero?") (_o$6910 "pos?") (_o$6911 "jbd-pos?") (_o$6912 "neg?") (_o$6913 "jbd-neg?")) (jolt-hash-map _o$6884 _o$6885 _o$6886 _o$6887 _o$6888 _o$6889 _o$6890 _o$6891 _o$6892 _o$6893 _o$6894 _o$6895 _o$6896 _o$6897 _o$6898 _o$6899 _o$6900 _o$6901 _o$6902 _o$6903 _o$6904 _o$6905 _o$6906 _o$6907 _o$6908 _o$6909 _o$6910 _o$6911 _o$6912 _o$6913)) (let* ((_o$6914 (keyword #f "private")) (_o$6915 #t)) (jolt-hash-map _o$6914 _o$6915))))
+  (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$6886 "+") (_o$6887 "jbd-add") (_o$6888 "-") (_o$6889 "jbd-sub") (_o$6890 "*") (_o$6891 "jbd-mul") (_o$6892 "/") (_o$6893 "jbd-div") (_o$6894 "min") (_o$6895 "jbd-min") (_o$6896 "max") (_o$6897 "jbd-max") (_o$6898 "quot") (_o$6899 "jbd-quot") (_o$6900 "rem") (_o$6901 "jbd-rem") (_o$6902 "<") (_o$6903 "jbd-lt?") (_o$6904 ">") (_o$6905 "jbd-gt?") (_o$6906 "<=") (_o$6907 "jbd-le?") (_o$6908 ">=") (_o$6909 "jbd-ge?") (_o$6910 "zero?") (_o$6911 "jbd-zero?") (_o$6912 "pos?") (_o$6913 "jbd-pos?") (_o$6914 "neg?") (_o$6915 "jbd-neg?")) (jolt-hash-map _o$6886 _o$6887 _o$6888 _o$6889 _o$6890 _o$6891 _o$6892 _o$6893 _o$6894 _o$6895 _o$6896 _o$6897 _o$6898 _o$6899 _o$6900 _o$6901 _o$6902 _o$6903 _o$6904 _o$6905 _o$6906 _o$6907 _o$6908 _o$6909 _o$6910 _o$6911 _o$6912 _o$6913 _o$6914 _o$6915)) (let* ((_o$6916 (keyword #f "private")) (_o$6917 #t)) (jolt-hash-map _o$6916 _o$6917))))
 (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 fnrec6916 ((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 fnrec6918 ((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 fnrec6917 ((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 fnrec6919 ((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 fnrec6918 () (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 fnrec6920 () (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 fnrec6919 ((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 fnrec6921 ((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 fnrec6920 ((ns ns) (nm nm)) (let* ((_a$6921 (var-deref "clojure.core" "str")) (_a$6922 "jv$") (_a$6923 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$6924 "$") (_a$6925 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$6921 _a$6922 _a$6923 _a$6924 _a$6925)))))) dl-name)))
+  (def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec6922 ((ns ns) (nm nm)) (let* ((_a$6923 (var-deref "clojure.core" "str")) (_a$6924 "jv$") (_a$6925 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$6926 "$") (_a$6927 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$6923 _a$6924 _a$6925 _a$6926 _a$6927)))))) dl-name)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec6926 ((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 fnrec6928 ((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 fnrec6927 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$6928 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$6929 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6928 _a$6929)) and__25__auto)))))) direct-linkable?)))
+  (def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec6929 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$6930 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$6931 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6930 _a$6931)) and__25__auto)))))) direct-linkable?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec6930 ((ns ns) (nm nm)) (let* ((_a$6931 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$6932 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6931 _a$6932)))))) direct-link-fn?)))
+  (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec6932 ((ns ns) (nm nm)) (let* ((_a$6933 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$6934 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6933 _a$6934)))))) direct-link-fn?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$6933 (keyword #f "dynamic")) (_o$6934 #t)) (jolt-hash-map _o$6933 _o$6934))))
+  (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$6935 (keyword #f "dynamic")) (_o$6936 #t)) (jolt-hash-map _o$6935 _o$6936))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$6935 (keyword #f "dynamic")) (_o$6936 #t)) (jolt-hash-map _o$6935 _o$6936))))
+  (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$6937 (keyword #f "dynamic")) (_o$6938 #t)) (jolt-hash-map _o$6937 _o$6938))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6937 (keyword #f "private")) (_o$6938 #t)) (jolt-hash-map _o$6937 _o$6938))))
+  (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6939 (keyword #f "private")) (_o$6940 #t)) (jolt-hash-map _o$6939 _o$6940))))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec6939 ((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 fnrec6941 ((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$6940 "if") (_o$6941 "begin") (_o$6942 "lambda") (_o$6943 "let") (_o$6944 "let*") (_o$6945 "letrec") (_o$6946 "letrec*") (_o$6947 "quote") (_o$6948 "quasiquote") (_o$6949 "unquote") (_o$6950 "set!") (_o$6951 "define") (_o$6952 "define-syntax") (_o$6953 "cond") (_o$6954 "case") (_o$6955 "when") (_o$6956 "unless") (_o$6957 "and") (_o$6958 "or") (_o$6959 "do") (_o$6960 "else") (_o$6961 "guard") (_o$6962 "parameterize") (_o$6963 "delay") (_o$6964 "values")) (jolt-hash-set _o$6940 _o$6941 _o$6942 _o$6943 _o$6944 _o$6945 _o$6946 _o$6947 _o$6948 _o$6949 _o$6950 _o$6951 _o$6952 _o$6953 _o$6954 _o$6955 _o$6956 _o$6957 _o$6958 _o$6959 _o$6960 _o$6961 _o$6962 _o$6963 _o$6964)) (let* ((_o$6965 (keyword #f "private")) (_o$6966 #t)) (jolt-hash-map _o$6965 _o$6966))))
+  (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$6942 "if") (_o$6943 "begin") (_o$6944 "lambda") (_o$6945 "let") (_o$6946 "let*") (_o$6947 "letrec") (_o$6948 "letrec*") (_o$6949 "quote") (_o$6950 "quasiquote") (_o$6951 "unquote") (_o$6952 "set!") (_o$6953 "define") (_o$6954 "define-syntax") (_o$6955 "cond") (_o$6956 "case") (_o$6957 "when") (_o$6958 "unless") (_o$6959 "and") (_o$6960 "or") (_o$6961 "do") (_o$6962 "else") (_o$6963 "guard") (_o$6964 "parameterize") (_o$6965 "delay") (_o$6966 "values")) (jolt-hash-set _o$6942 _o$6943 _o$6944 _o$6945 _o$6946 _o$6947 _o$6948 _o$6949 _o$6950 _o$6951 _o$6952 _o$6953 _o$6954 _o$6955 _o$6956 _o$6957 _o$6958 _o$6959 _o$6960 _o$6961 _o$6962 _o$6963 _o$6964 _o$6965 _o$6966)) (let* ((_o$6967 (keyword #f "private")) (_o$6968 #t)) (jolt-hash-map _o$6967 _o$6968))))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec6967 ((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 fnrec6969 ((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 fnrec6968 ((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 (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__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 fnrec6970 ((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 (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__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 fnrec6969 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec6970 ((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 fnrec6971 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec6972 ((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 fnrec6971 ((v v)) (if (jolt-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__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__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__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$6972 (var-deref "clojure.core" "str")) (_a$6973 "(keyword ") (_a$6974 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$6975 " ") (_a$6976 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$6977 ")")) (jolt-invoke _a$6972 _a$6973 _a$6974 _a$6975 _a$6976 _a$6977))) (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$6978 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$6979 (jolt-hash-map))) (jolt-ex-info _a$6978 _a$6979))) jolt-nil))))))))))) emit-const)))
+  (def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec6973 ((v v)) (if (jolt-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__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__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__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$6974 (var-deref "clojure.core" "str")) (_a$6975 "(keyword ") (_a$6976 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$6977 " ") (_a$6978 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$6979 ")")) (jolt-invoke _a$6974 _a$6975 _a$6976 _a$6977 _a$6978 _a$6979))) (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$6980 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$6981 (jolt-hash-map))) (jolt-ex-info _a$6980 _a$6981))) jolt-nil))))))))))) emit-const)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec6980 ((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 fnrec6981 ((_ _)) (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 fnrec6982 ((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 fnrec6982 ((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 fnrec6983 ((_ _)) (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 fnrec6984 ((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 fnrec6983 ((n n)) (let* ((_a$6989 (let* ((_o$6984 (keyword #f "const")) (_o$6985 (keyword #f "local")) (_o$6986 (keyword #f "var")) (_o$6987 (keyword #f "the-var")) (_o$6988 (keyword #f "quote"))) (jolt-hash-set _o$6984 _o$6985 _o$6986 _o$6987 _o$6988))) (_a$6990 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$6989 _a$6990)))))) side-effect-free?)))
+  (def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec6985 ((n n)) (let* ((_a$6991 (let* ((_o$6986 (keyword #f "const")) (_o$6987 (keyword #f "local")) (_o$6988 (keyword #f "var")) (_o$6989 (keyword #f "the-var")) (_o$6990 (keyword #f "quote"))) (jolt-hash-set _o$6986 _o$6987 _o$6988 _o$6989 _o$6990))) (_a$6992 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$6991 _a$6992)))))) side-effect-free?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec6991 ((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 fnrec6993 ((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 fnrec6992 ((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 fnrec6993 ((_ _)) (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 fnrec6994 ((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 fnrec6994 ((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 fnrec6995 ((_ _)) (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 fnrec6996 ((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 fnrec6995 ((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 fnrec6996 ((p p)) (let* ((_o$6997 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$6998 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$6997 _o$6998)))) pairs)) ")"))))) emit-quoted-map)))
+  (def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec6997 ((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 fnrec6998 ((p p)) (let* ((_o$6999 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7000 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$6999 _o$7000)))) 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 fnrec6999 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7005 (lambda (k) (let fnrec7000 ((k k)) (let* ((_a$7001 (var-deref "clojure.core" "str")) (_a$7002 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7003 " ") (_a$7004 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7001 _a$7002 _a$7003 _a$7004))))) (_a$7006 (jolt-keys m))) (jolt-map _a$7005 _a$7006))))) (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 fnrec7001 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7007 (lambda (k) (let fnrec7002 ((k k)) (let* ((_a$7003 (var-deref "clojure.core" "str")) (_a$7004 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7005 " ") (_a$7006 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7003 _a$7004 _a$7005 _a$7006))))) (_a$7008 (jolt-keys m))) (jolt-map _a$7007 _a$7008))))) (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 fnrec7007 ((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__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$7008 (var-deref "clojure.core" "str")) (_a$7009 "(jolt-symbol/meta ") (_a$7010 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7011 " ") (_a$7012 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7013 " ") (_a$7014 (emit-quoted m)) (_a$7015 ")")) (jolt-invoke _a$7008 _a$7009 _a$7010 _a$7011 _a$7012 _a$7013 _a$7014 _a$7015)) (let* ((_a$7016 (var-deref "clojure.core" "str")) (_a$7017 "(jolt-symbol ") (_a$7018 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7019 " ") (_a$7020 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7021 ")")) (jolt-invoke _a$7016 _a$7017 _a$7018 _a$7019 _a$7020 _a$7021)))) (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 "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") 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$7022 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7023 (jolt-hash-map))) (jolt-ex-info _a$7022 _a$7023))) jolt-nil))))))))))))))))) emit-quoted)))
+  (def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7009 ((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__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$7010 (var-deref "clojure.core" "str")) (_a$7011 "(jolt-symbol/meta ") (_a$7012 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7013 " ") (_a$7014 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7015 " ") (_a$7016 (emit-quoted m)) (_a$7017 ")")) (jolt-invoke _a$7010 _a$7011 _a$7012 _a$7013 _a$7014 _a$7015 _a$7016 _a$7017)) (let* ((_a$7018 (var-deref "clojure.core" "str")) (_a$7019 "(jolt-symbol ") (_a$7020 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7021 " ") (_a$7022 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7023 ")")) (jolt-invoke _a$7018 _a$7019 _a$7020 _a$7021 _a$7022 _a$7023)))) (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 "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") 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$7024 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7025 (jolt-hash-map))) (jolt-ex-info _a$7024 _a$7025))) jolt-nil))))))))))))))))) emit-quoted)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7024 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?)))
+  (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7026 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7025 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta)))
+  (def-var! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7027 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7026 ((b b)) (let* ((_a$7027 (var-deref "clojure.core" "str")) (_a$7028 "(") (_a$7029 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7030 " ") (_a$7031 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7032 ")")) (jolt-invoke _a$7027 _a$7028 _a$7029 _a$7030 _a$7031 _a$7032)))))) emit-binding)))
+  (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7028 ((b b)) (let* ((_a$7029 (var-deref "clojure.core" "str")) (_a$7030 "(") (_a$7031 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7032 " ") (_a$7033 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7034 ")")) (jolt-invoke _a$7029 _a$7030 _a$7031 _a$7032 _a$7033 _a$7034)))))) emit-binding)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7033 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7034 (var-deref "clojure.core" "str")) (_a$7035 "(") (_a$7036 kw) (_a$7037 " (") (_a$7038 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7039 ") ") (_a$7040 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7041 ")")) (jolt-invoke _a$7034 _a$7035 _a$7036 _a$7037 _a$7038 _a$7039 _a$7040 _a$7041))))))) emit-let)))
+  (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7035 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7036 (var-deref "clojure.core" "str")) (_a$7037 "(") (_a$7038 kw) (_a$7039 " (") (_a$7040 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7041 ") ") (_a$7042 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7043 ")")) (jolt-invoke _a$7036 _a$7037 _a$7038 _a$7039 _a$7040 _a$7041 _a$7042 _a$7043))))))) emit-let)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7042 ((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__88_) (let fnrec7043 ((p__88_ p__88_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__88_ 0)))) pairs)) (inits (jolt-map (lambda (p__89_) (let fnrec7044 ((p__89_ p__89_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__89_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7045 ((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 fnrec7046 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__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__20__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 fnrec7044 ((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__88_) (let fnrec7045 ((p__88_ p__88_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__88_ 0)))) pairs)) (inits (jolt-map (lambda (p__89_) (let fnrec7046 ((p__89_ p__89_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__89_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7047 ((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 fnrec7048 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__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__20__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$7047 "int") (_o$7048 "int") (_o$7049 "uint") (_o$7050 "unsigned-int") (_o$7051 "long") (_o$7052 "long") (_o$7053 "ulong") (_o$7054 "unsigned-long") (_o$7055 "int64") (_o$7056 "integer-64") (_o$7057 "uint64") (_o$7058 "unsigned-64") (_o$7059 "size_t") (_o$7060 "size_t") (_o$7061 "ssize_t") (_o$7062 "ssize_t") (_o$7063 "iptr") (_o$7064 "iptr") (_o$7065 "uptr") (_o$7066 "uptr") (_o$7067 "double") (_o$7068 "double") (_o$7069 "float") (_o$7070 "float") (_o$7071 "pointer") (_o$7072 "void*") (_o$7073 "void*") (_o$7074 "void*") (_o$7075 "string") (_o$7076 "string") (_o$7077 "void") (_o$7078 "void") (_o$7079 "uint8") (_o$7080 "unsigned-8") (_o$7081 "u8") (_o$7082 "unsigned-8") (_o$7083 "byte") (_o$7084 "unsigned-8") (_o$7085 "char") (_o$7086 "char")) (jolt-hash-map _o$7047 _o$7048 _o$7049 _o$7050 _o$7051 _o$7052 _o$7053 _o$7054 _o$7055 _o$7056 _o$7057 _o$7058 _o$7059 _o$7060 _o$7061 _o$7062 _o$7063 _o$7064 _o$7065 _o$7066 _o$7067 _o$7068 _o$7069 _o$7070 _o$7071 _o$7072 _o$7073 _o$7074 _o$7075 _o$7076 _o$7077 _o$7078 _o$7079 _o$7080 _o$7081 _o$7082 _o$7083 _o$7084 _o$7085 _o$7086)) (let* ((_o$7087 (keyword #f "private")) (_o$7088 #t)) (jolt-hash-map _o$7087 _o$7088))))
+  (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7049 "int") (_o$7050 "int") (_o$7051 "uint") (_o$7052 "unsigned-int") (_o$7053 "long") (_o$7054 "long") (_o$7055 "ulong") (_o$7056 "unsigned-long") (_o$7057 "int64") (_o$7058 "integer-64") (_o$7059 "uint64") (_o$7060 "unsigned-64") (_o$7061 "size_t") (_o$7062 "size_t") (_o$7063 "ssize_t") (_o$7064 "ssize_t") (_o$7065 "iptr") (_o$7066 "iptr") (_o$7067 "uptr") (_o$7068 "uptr") (_o$7069 "double") (_o$7070 "double") (_o$7071 "float") (_o$7072 "float") (_o$7073 "pointer") (_o$7074 "void*") (_o$7075 "void*") (_o$7076 "void*") (_o$7077 "string") (_o$7078 "string") (_o$7079 "void") (_o$7080 "void") (_o$7081 "uint8") (_o$7082 "unsigned-8") (_o$7083 "u8") (_o$7084 "unsigned-8") (_o$7085 "byte") (_o$7086 "unsigned-8") (_o$7087 "char") (_o$7088 "char")) (jolt-hash-map _o$7049 _o$7050 _o$7051 _o$7052 _o$7053 _o$7054 _o$7055 _o$7056 _o$7057 _o$7058 _o$7059 _o$7060 _o$7061 _o$7062 _o$7063 _o$7064 _o$7065 _o$7066 _o$7067 _o$7068 _o$7069 _o$7070 _o$7071 _o$7072 _o$7073 _o$7074 _o$7075 _o$7076 _o$7077 _o$7078 _o$7079 _o$7080 _o$7081 _o$7082 _o$7083 _o$7084 _o$7085 _o$7086 _o$7087 _o$7088)) (let* ((_o$7089 (keyword #f "private")) (_o$7090 #t)) (jolt-hash-map _o$7089 _o$7090))))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7089 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$7090 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7091 (jolt-hash-map))) (jolt-ex-info _a$7090 _a$7091))))))))) ffi-type->chez)))
+  (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7091 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$7092 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7093 (jolt-hash-map))) (jolt-ex-info _a$7092 _a$7093))))))))) ffi-type->chez)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7092 ((node node)) (let* ((_a$7093 (var-deref "clojure.core" "str")) (_a$7094 "(foreign-procedure ") (_a$7095 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7096 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7097 " (") (_a$7098 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7099 ") ") (_a$7100 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7101 ")")) (jolt-invoke _a$7093 _a$7094 _a$7095 _a$7096 _a$7097 _a$7098 _a$7099 _a$7100 _a$7101)))))) emit-ffi-fn)))
+  (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7094 ((node node)) (let* ((_a$7095 (var-deref "clojure.core" "str")) (_a$7096 "(foreign-procedure ") (_a$7097 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7098 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7099 " (") (_a$7100 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7101 ") ") (_a$7102 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7103 ")")) (jolt-invoke _a$7095 _a$7096 _a$7097 _a$7098 _a$7099 _a$7100 _a$7101 _a$7102 _a$7103)))))) emit-ffi-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7102 ((node node)) (let* ((_a$7103 (var-deref "clojure.core" "str")) (_a$7104 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7105 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7106 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7107 " (") (_a$7108 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7109 ") ") (_a$7110 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7111 "))")) (jolt-invoke _a$7103 _a$7104 _a$7105 _a$7106 _a$7107 _a$7108 _a$7109 _a$7110 _a$7111)))))) emit-ffi-callable)))
+  (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7104 ((node node)) (let* ((_a$7105 (var-deref "clojure.core" "str")) (_a$7106 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7107 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7108 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7109 " (") (_a$7110 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7111 ") ") (_a$7112 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7113 "))")) (jolt-invoke _a$7105 _a$7106 _a$7107 _a$7108 _a$7109 _a$7110 _a$7111 _a$7112 _a$7113)))))) emit-ffi-callable)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7112 ((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$7114 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7115 arg-nodes) (_a$7116 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7117 (lambda (as) (let fnrec7113 ((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$7114 _a$7115 _a$7116 _a$7117)))))))) emit-recur)))
+  (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7114 ((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$7116 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7117 arg-nodes) (_a$7118 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7119 (lambda (as) (let fnrec7115 ((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$7116 _a$7117 _a$7118 _a$7119)))))))) emit-recur)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7118 ((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 fnrec7120 ((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 fnrec7119 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7120 (jolt-hash-map)) (_a$7121 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7120 _a$7121))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__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__20__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__20__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__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__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 fnrec7122 ((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$7123 paramlist) (_o$7124 (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$7123 _o$7124))))))) emit-arity-clause)))
+  (def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7121 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7122 (jolt-hash-map)) (_a$7123 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7122 _a$7123))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__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__20__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__20__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__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__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 fnrec7124 ((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$7125 paramlist) (_o$7126 (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$7125 _o$7126))))))) emit-arity-clause)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7125 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__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__20__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$7126 (var-deref "clojure.core" "str")) (_a$7127 "(lambda ") (_a$7128 (jolt-nth c 0)) (_a$7129 " ") (_a$7130 (jolt-nth c 1)) (_a$7131 ")")) (jolt-invoke _a$7126 _a$7127 _a$7128 _a$7129 _a$7130 _a$7131))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7132 ((c c)) (let* ((_a$7133 (var-deref "clojure.core" "str")) (_a$7134 "(") (_a$7135 (jolt-nth c 0)) (_a$7136 " ") (_a$7137 (jolt-nth c 1)) (_a$7138 ")")) (jolt-invoke _a$7133 _a$7134 _a$7135 _a$7136 _a$7137 _a$7138)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__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 fnrec7127 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__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__20__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$7128 (var-deref "clojure.core" "str")) (_a$7129 "(lambda ") (_a$7130 (jolt-nth c 0)) (_a$7131 " ") (_a$7132 (jolt-nth c 1)) (_a$7133 ")")) (jolt-invoke _a$7128 _a$7129 _a$7130 _a$7131 _a$7132 _a$7133))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7134 ((c c)) (let* ((_a$7135 (var-deref "clojure.core" "str")) (_a$7136 "(") (_a$7137 (jolt-nth c 0)) (_a$7138 " ") (_a$7139 (jolt-nth c 1)) (_a$7140 ")")) (jolt-invoke _a$7135 _a$7136 _a$7137 _a$7138 _a$7139 _a$7140)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__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 fnrec7139 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__134 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__134 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__134 (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-nil? op) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__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 fnrec7141 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__134 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__134 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__134 (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-nil? op) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__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 fnrec7140 ((fnode fnode)) (let* ((G__135 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__135 (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 (let* ((or__26__auto (jolt= G__135 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__135 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__135 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind)))
+  (def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7142 ((fnode fnode)) (let* ((G__135 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__135 (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 (let* ((or__26__auto (jolt= G__135 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__135 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__135 (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 fnrec7141 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?)))
+  (def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7143 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7142 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "inc"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-inc"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "dec"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-dec"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__136 kind)) (if (jolt= G__136 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__136 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__136 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7143 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__136)) (_a$7144 (jolt-hash-map))) (jolt-ex-info _a$7143 _a$7144))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7145 ((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 fnrec7144 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "inc"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-inc"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "dec"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-dec"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__136 kind)) (if (jolt= G__136 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__136 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__136 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7145 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__136)) (_a$7146 (jolt-hash-map))) (jolt-ex-info _a$7145 _a$7146))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7147 ((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" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7146 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7147 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7147 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index)))
+  (def-var! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7148 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7149 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7149 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7148 ((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 fnrec7149 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7150 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7151 () (let* ((_a$7153 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7154 (jolt-cons fnode arg-nodes)) (_a$7155 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7156 (lambda (G__137) (let fnrec7152 ((G__137 G__137)) (let* ((G__138 G__137) (f (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 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$7153 _a$7154 _a$7155 _a$7156)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7157 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$"))) (let* ((_a$7158 (var-deref "clojure.core" "str")) (_a$7159 "(let* ((") (_a$7160 r) (_a$7161 " ") (_a$7162 (jolt-first as)) (_a$7163 ")) ") (_a$7164 "((devirt-resolve ") (_a$7165 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7166 " ") (_a$7167 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7168 " ") (_a$7169 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7170 " ") (_a$7171 r) (_a$7172 ") ") (_a$7173 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7174 "))")) (jolt-invoke _a$7158 _a$7159 _a$7160 _a$7161 _a$7162 _a$7163 _a$7164 _a$7165 _a$7166 _a$7167 _a$7168 _a$7169 _a$7170 _a$7171 _a$7172 _a$7173 _a$7174)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7175 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7176 (jolt-get node (keyword #f "num-kind"))) (_a$7177 (jolt-get fnode (keyword #f "name"))) (_a$7178 args) (_a$7179 order-args)) (jolt-invoke _a$7175 _a$7176 _a$7177 _a$7178 _a$7179)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec7180 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7181 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7182 (jolt-get recv (keyword #f "shape"))) (_a$7183 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7181 _a$7182 _a$7183)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7184 ((as as)) (let* ((_a$7185 (var-deref "clojure.core" "str")) (_a$7186 "(jrec-field-at ") (_a$7187 (jolt-first as)) (_a$7188 " ") (_a$7189 idx) (_a$7190 " ") (_a$7191 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7192 ")")) (jolt-invoke _a$7185 _a$7186 _a$7187 _a$7188 _a$7189 _a$7190 _a$7191 _a$7192))))) (jolt-invoke order-args (lambda (as) (let fnrec7193 ((as as)) (let* ((_a$7194 (var-deref "clojure.core" "str")) (_a$7195 "(jolt-get ") (_a$7196 (jolt-first as)) (_a$7197 " ") (_a$7198 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7199 (jolt-invoke defstr as)) (_a$7200 ")")) (jolt-invoke _a$7194 _a$7195 _a$7196 _a$7197 _a$7198 _a$7199 _a$7200))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7202 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7203 (jolt-cons fnode arg-nodes)) (_a$7204 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7205 (lambda (G__139) (let fnrec7201 ((G__139 G__139)) (let* ((G__140 G__139) (c (jolt-nth G__140 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__140 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7202 _a$7203 _a$7204 _a$7205)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7212 (let* ((_a$7206 (var-deref "clojure.core" "str")) (_a$7207 "emit: unsupported stdlib fn `") (_a$7208 (jolt-get fnode (keyword #f "ns"))) (_a$7209 "/") (_a$7210 (jolt-get fnode (keyword #f "name"))) (_a$7211 "` (no core on Chez yet)")) (jolt-invoke _a$7206 _a$7207 _a$7208 _a$7209 _a$7210 _a$7211))) (_a$7213 (jolt-hash-map))) (jolt-ex-info _a$7212 _a$7213))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7214 ((as as)) (let* ((_a$7215 (var-deref "clojure.core" "str")) (_a$7216 "(host-static-call ") (_a$7217 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7218 " ") (_a$7219 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7220 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7221 ")")) (jolt-invoke _a$7215 _a$7216 _a$7217 _a$7218 _a$7219 _a$7220 _a$7221))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7222 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7223 (jolt-hash-map))) (jolt-ex-info _a$7222 _a$7223))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec7224 ((as as)) (let* ((_a$7225 (var-deref "clojure.core" "str")) (_a$7226 "(") (_a$7227 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7228 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7229 ")")) (jolt-invoke _a$7225 _a$7226 _a$7227 _a$7228 _a$7229))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$7230 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7231 (jolt-get fnode (keyword #f "ns"))) (_a$7232 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7230 _a$7231 _a$7232)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7233 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7234 (jolt-get fnode (keyword #f "ns"))) (_a$7235 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7233 _a$7234 _a$7235)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7236 ((as as)) (let* ((_a$7240 (var-deref "clojure.core" "str")) (_a$7241 "(") (_a$7242 (let* ((_a$7237 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7238 (jolt-get fnode (keyword #f "ns"))) (_a$7239 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7237 _a$7238 _a$7239))) (_a$7243 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7244 ")")) (jolt-invoke _a$7240 _a$7241 _a$7242 _a$7243 _a$7244))))) (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 fnrec7150 ((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 fnrec7151 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7152 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7153 () (let* ((_a$7155 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7156 (jolt-cons fnode arg-nodes)) (_a$7157 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7158 (lambda (G__137) (let fnrec7154 ((G__137 G__137)) (let* ((G__138 G__137) (f (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 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$7155 _a$7156 _a$7157 _a$7158)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7159 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$"))) (let* ((_a$7160 (var-deref "clojure.core" "str")) (_a$7161 "(let* ((") (_a$7162 r) (_a$7163 " ") (_a$7164 (jolt-first as)) (_a$7165 ")) ") (_a$7166 "((devirt-resolve ") (_a$7167 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7168 " ") (_a$7169 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7170 " ") (_a$7171 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7172 " ") (_a$7173 r) (_a$7174 ") ") (_a$7175 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7176 "))")) (jolt-invoke _a$7160 _a$7161 _a$7162 _a$7163 _a$7164 _a$7165 _a$7166 _a$7167 _a$7168 _a$7169 _a$7170 _a$7171 _a$7172 _a$7173 _a$7174 _a$7175 _a$7176)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7177 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7178 (jolt-get node (keyword #f "num-kind"))) (_a$7179 (jolt-get fnode (keyword #f "name"))) (_a$7180 args) (_a$7181 order-args)) (jolt-invoke _a$7177 _a$7178 _a$7179 _a$7180 _a$7181)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec7182 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7183 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7184 (jolt-get recv (keyword #f "shape"))) (_a$7185 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7183 _a$7184 _a$7185)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7186 ((as as)) (let* ((_a$7187 (var-deref "clojure.core" "str")) (_a$7188 "(jrec-field-at ") (_a$7189 (jolt-first as)) (_a$7190 " ") (_a$7191 idx) (_a$7192 " ") (_a$7193 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7194 ")")) (jolt-invoke _a$7187 _a$7188 _a$7189 _a$7190 _a$7191 _a$7192 _a$7193 _a$7194))))) (jolt-invoke order-args (lambda (as) (let fnrec7195 ((as as)) (let* ((_a$7196 (var-deref "clojure.core" "str")) (_a$7197 "(jolt-get ") (_a$7198 (jolt-first as)) (_a$7199 " ") (_a$7200 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7201 (jolt-invoke defstr as)) (_a$7202 ")")) (jolt-invoke _a$7196 _a$7197 _a$7198 _a$7199 _a$7200 _a$7201 _a$7202))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7204 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7205 (jolt-cons fnode arg-nodes)) (_a$7206 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7207 (lambda (G__139) (let fnrec7203 ((G__139 G__139)) (let* ((G__140 G__139) (c (jolt-nth G__140 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__140 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7204 _a$7205 _a$7206 _a$7207)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7214 (let* ((_a$7208 (var-deref "clojure.core" "str")) (_a$7209 "emit: unsupported stdlib fn `") (_a$7210 (jolt-get fnode (keyword #f "ns"))) (_a$7211 "/") (_a$7212 (jolt-get fnode (keyword #f "name"))) (_a$7213 "` (no core on Chez yet)")) (jolt-invoke _a$7208 _a$7209 _a$7210 _a$7211 _a$7212 _a$7213))) (_a$7215 (jolt-hash-map))) (jolt-ex-info _a$7214 _a$7215))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7216 ((as as)) (let* ((_a$7217 (var-deref "clojure.core" "str")) (_a$7218 "(host-static-call ") (_a$7219 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7220 " ") (_a$7221 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7222 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7223 ")")) (jolt-invoke _a$7217 _a$7218 _a$7219 _a$7220 _a$7221 _a$7222 _a$7223))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7224 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7225 (jolt-hash-map))) (jolt-ex-info _a$7224 _a$7225))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec7226 ((as as)) (let* ((_a$7227 (var-deref "clojure.core" "str")) (_a$7228 "(") (_a$7229 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7230 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7231 ")")) (jolt-invoke _a$7227 _a$7228 _a$7229 _a$7230 _a$7231))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$7232 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7233 (jolt-get fnode (keyword #f "ns"))) (_a$7234 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7232 _a$7233 _a$7234)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7235 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7236 (jolt-get fnode (keyword #f "ns"))) (_a$7237 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7235 _a$7236 _a$7237)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7238 ((as as)) (let* ((_a$7242 (var-deref "clojure.core" "str")) (_a$7243 "(") (_a$7244 (let* ((_a$7239 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7240 (jolt-get fnode (keyword #f "ns"))) (_a$7241 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7239 _a$7240 _a$7241))) (_a$7245 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7246 ")")) (jolt-invoke _a$7242 _a$7243 _a$7244 _a$7245 _a$7246))))) (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 fnrec7245 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$7246 (var-deref "clojure.core" "str")) (_a$7247 "(guard (") (_a$7248 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7249 " (else ") (_a$7250 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7251 ")) ") (_a$7252 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7253 ")")) (jolt-invoke _a$7246 _a$7247 _a$7248 _a$7249 _a$7250 _a$7251 _a$7252 _a$7253))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__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 fnrec7247 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$7248 (var-deref "clojure.core" "str")) (_a$7249 "(guard (") (_a$7250 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7251 " (else ") (_a$7252 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7253 ")) ") (_a$7254 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7255 ")")) (jolt-invoke _a$7248 _a$7249 _a$7250 _a$7251 _a$7252 _a$7253 _a$7254 _a$7255))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__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? (case-lambda ((node) (let fnrec7254 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7255 ((node node) (bools bools)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$7256 (var-deref "jolt.backend-scheme" "native-op")) (_a$7257 (jolt-get node (keyword #f "fn"))) (_a$7258 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7256 _a$7257 _a$7258)))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$7260 (lambda (s b) (let fnrec7259 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$7261 bools) (_a$7262 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7260 _a$7261 _a$7262)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?)))
+  (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7256 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7257 ((node node) (bools bools)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$7258 (var-deref "jolt.backend-scheme" "native-op")) (_a$7259 (jolt-get node (keyword #f "fn"))) (_a$7260 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7258 _a$7259 _a$7260)))) (jolt-invoke (var-deref "clojure.core" "boolean") (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$7262 (lambda (s b) (let fnrec7261 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$7263 bools) (_a$7264 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7262 _a$7263 _a$7264)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (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 fnrec7263 ((node node)) (let* ((G__141 (jolt-get node (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__141 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__141 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$7264 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7265 (jolt-get node (keyword #f "ns"))) (_a$7266 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7264 _a$7265 _a$7266))) (let* ((_a$7267 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7268 (jolt-get node (keyword #f "ns"))) (_a$7269 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7267 _a$7268 _a$7269)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7276 (let* ((_a$7270 (var-deref "clojure.core" "str")) (_a$7271 "emit: unsupported stdlib ref `") (_a$7272 (jolt-get node (keyword #f "ns"))) (_a$7273 "/") (_a$7274 (jolt-get node (keyword #f "name"))) (_a$7275 "` (no core on Chez yet)")) (jolt-invoke _a$7270 _a$7271 _a$7272 _a$7273 _a$7274 _a$7275))) (_a$7277 (jolt-hash-map))) (jolt-ex-info _a$7276 _a$7277))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7278 (var-deref "clojure.core" "str")) (_a$7279 "(var-deref ") (_a$7280 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7281 " ") (_a$7282 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7283 ")")) (jolt-invoke _a$7278 _a$7279 _a$7280 _a$7281 _a$7282 _a$7283)) jolt-nil))))) (if (jolt= G__141 (keyword #f "the-var")) (let* ((_a$7284 (var-deref "clojure.core" "str")) (_a$7285 "(jolt-var ") (_a$7286 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7287 " ") (_a$7288 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7289 ")")) (jolt-invoke _a$7284 _a$7285 _a$7286 _a$7287 _a$7288 _a$7289)) (if (jolt= G__141 (keyword #f "set-var")) (let* ((_a$7290 (var-deref "clojure.core" "str")) (_a$7291 "(jolt-var-set ") (_a$7292 (emit (jolt-get node (keyword #f "the-var")))) (_a$7293 " ") (_a$7294 (emit (jolt-get node (keyword #f "val")))) (_a$7295 ")")) (jolt-invoke _a$7290 _a$7291 _a$7292 _a$7293 _a$7294 _a$7295)) (if (jolt= G__141 (keyword #f "set-field")) (let* ((_a$7296 (var-deref "clojure.core" "str")) (_a$7297 "(jolt-set-field! ") (_a$7298 (emit (jolt-get node (keyword #f "obj")))) (_a$7299 " (keyword #f ") (_a$7300 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7301 ") ") (_a$7302 (emit (jolt-get node (keyword #f "val")))) (_a$7303 ")")) (jolt-invoke _a$7296 _a$7297 _a$7298 _a$7299 _a$7300 _a$7301 _a$7302 _a$7303)) (if (jolt= G__141 (keyword #f "defmacro")) (let* ((_a$7304 (var-deref "clojure.core" "str")) (_a$7305 "(begin (def-var! ") (_a$7306 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7307 " ") (_a$7308 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7309 " ") (_a$7310 (emit (jolt-get node (keyword #f "fn")))) (_a$7311 ") (mark-macro! ") (_a$7312 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7313 " ") (_a$7314 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7315 ") jolt-nil)")) (jolt-invoke _a$7304 _a$7305 _a$7306 _a$7307 _a$7308 _a$7309 _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315)) (if (jolt= G__141 (keyword #f "host")) (jolt-throw (let* ((_a$7316 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7317 (jolt-hash-map))) (jolt-ex-info _a$7316 _a$7317))) (if (jolt= G__141 (keyword #f "host-static")) (let* ((_a$7318 (var-deref "clojure.core" "str")) (_a$7319 "(host-static-ref ") (_a$7320 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7321 " ") (_a$7322 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7323 ")")) (jolt-invoke _a$7318 _a$7319 _a$7320 _a$7321 _a$7322 _a$7323)) (if (jolt= G__141 (keyword #f "host-new")) (let* ((_a$7324 (var-deref "clojure.core" "str")) (_a$7325 "(host-new ") (_a$7326 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7327 (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$7328 ")")) (jolt-invoke _a$7324 _a$7325 _a$7326 _a$7327 _a$7328)) (if (jolt= G__141 (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)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$7329 (var-deref "clojure.core" "str")) (_a$7330 "(if ") (_a$7331 t) (_a$7332 " ") (_a$7333 (emit (jolt-get node (keyword #f "then")))) (_a$7334 " ") (_a$7335 (emit (jolt-get node (keyword #f "else")))) (_a$7336 ")")) (jolt-invoke _a$7329 _a$7330 _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336))) (if (jolt= G__141 (keyword #f "do")) (let* ((_a$7337 (var-deref "clojure.core" "str")) (_a$7338 "(begin ") (_a$7339 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7340 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7341 (emit (jolt-get node (keyword #f "ret")))) (_a$7342 ")")) (jolt-invoke _a$7337 _a$7338 _a$7339 _a$7340 _a$7341 _a$7342)) (if (jolt= G__141 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__141 (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__141 (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__141 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7346 (var-deref "clojure.core" "mapcat")) (_a$7347 (lambda (p) (let fnrec7343 ((p p)) (let* ((_o$7344 (emit (jolt-nth p 0))) (_o$7345 (emit (jolt-nth p 1)))) (jolt-vector _o$7344 _o$7345))))) (_a$7348 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7346 _a$7347 _a$7348))) (if (jolt= G__141 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__141 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__141 (keyword #f "coerce")) (let* ((e (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__141 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__141 (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__141 (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__141 (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__141 (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__141 (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__141 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (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$7349 (var-deref "clojure.core" "str")) (_a$7350 "(jolt-host-call ") (_a$7351 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7352 " ") (_a$7353 target) (_a$7354 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7355 ")")) (jolt-invoke _a$7349 _a$7350 _a$7351 _a$7352 _a$7353 _a$7354 _a$7355)) (let* ((_a$7356 (var-deref "clojure.core" "str")) (_a$7357 "(record-method-dispatch ") (_a$7358 target) (_a$7359 " ") (_a$7360 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7361 " (jolt-vector") (_a$7362 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7363 "))")) (jolt-invoke _a$7356 _a$7357 _a$7358 _a$7359 _a$7360 _a$7361 _a$7362 _a$7363)))) (if (jolt= G__141 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__141 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__141 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__141 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__141 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__141 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__141 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7364 (var-deref "clojure.core" "str")) (_a$7365 "(declare-var! ") (_a$7366 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7367 " ") (_a$7368 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7369 ")")) (jolt-invoke _a$7364 _a$7365 _a$7366 _a$7367 _a$7368 _a$7369)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7370 (var-deref "clojure.core" "str")) (_a$7371 "(def-var-with-meta! ") (_a$7372 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7373 " ") (_a$7374 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7375 " ") (_a$7376 (emit (jolt-get node (keyword #f "init")))) (_a$7377 " ") (_a$7378 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7379 ")")) (jolt-invoke _a$7370 _a$7371 _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378 _a$7379)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7380 (var-deref "clojure.core" "str")) (_a$7381 "(def-var! ") (_a$7382 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7383 " ") (_a$7384 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7385 " ") (_a$7386 (emit (jolt-get node (keyword #f "init")))) (_a$7387 ")")) (jolt-invoke _a$7380 _a$7381 _a$7382 _a$7383 _a$7384 _a$7385 _a$7386 _a$7387)) jolt-nil))) (jolt-throw (let* ((_a$7388 (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$7389 (jolt-hash-map))) (jolt-ex-info _a$7388 _a$7389))))))))))))))))))))))))))))))))))))))))) emit)))
+  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7265 ((node node)) (let* ((G__141 (jolt-get node (keyword #f "op")))) (if (jolt= G__141 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__141 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__141 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$7266 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7267 (jolt-get node (keyword #f "ns"))) (_a$7268 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7266 _a$7267 _a$7268))) (let* ((_a$7269 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7270 (jolt-get node (keyword #f "ns"))) (_a$7271 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7269 _a$7270 _a$7271)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$7278 (let* ((_a$7272 (var-deref "clojure.core" "str")) (_a$7273 "emit: unsupported stdlib ref `") (_a$7274 (jolt-get node (keyword #f "ns"))) (_a$7275 "/") (_a$7276 (jolt-get node (keyword #f "name"))) (_a$7277 "` (no core on Chez yet)")) (jolt-invoke _a$7272 _a$7273 _a$7274 _a$7275 _a$7276 _a$7277))) (_a$7279 (jolt-hash-map))) (jolt-ex-info _a$7278 _a$7279))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7280 (var-deref "clojure.core" "str")) (_a$7281 "(var-deref ") (_a$7282 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7283 " ") (_a$7284 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7285 ")")) (jolt-invoke _a$7280 _a$7281 _a$7282 _a$7283 _a$7284 _a$7285)) jolt-nil))))) (if (jolt= G__141 (keyword #f "the-var")) (let* ((_a$7286 (var-deref "clojure.core" "str")) (_a$7287 "(jolt-var ") (_a$7288 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7289 " ") (_a$7290 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7291 ")")) (jolt-invoke _a$7286 _a$7287 _a$7288 _a$7289 _a$7290 _a$7291)) (if (jolt= G__141 (keyword #f "set-var")) (let* ((_a$7292 (var-deref "clojure.core" "str")) (_a$7293 "(jolt-var-set ") (_a$7294 (emit (jolt-get node (keyword #f "the-var")))) (_a$7295 " ") (_a$7296 (emit (jolt-get node (keyword #f "val")))) (_a$7297 ")")) (jolt-invoke _a$7292 _a$7293 _a$7294 _a$7295 _a$7296 _a$7297)) (if (jolt= G__141 (keyword #f "set-field")) (let* ((_a$7298 (var-deref "clojure.core" "str")) (_a$7299 "(jolt-set-field! ") (_a$7300 (emit (jolt-get node (keyword #f "obj")))) (_a$7301 " (keyword #f ") (_a$7302 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7303 ") ") (_a$7304 (emit (jolt-get node (keyword #f "val")))) (_a$7305 ")")) (jolt-invoke _a$7298 _a$7299 _a$7300 _a$7301 _a$7302 _a$7303 _a$7304 _a$7305)) (if (jolt= G__141 (keyword #f "defmacro")) (let* ((_a$7306 (var-deref "clojure.core" "str")) (_a$7307 "(begin (def-var! ") (_a$7308 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7309 " ") (_a$7310 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7311 " ") (_a$7312 (emit (jolt-get node (keyword #f "fn")))) (_a$7313 ") (mark-macro! ") (_a$7314 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7315 " ") (_a$7316 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7317 ") jolt-nil)")) (jolt-invoke _a$7306 _a$7307 _a$7308 _a$7309 _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315 _a$7316 _a$7317)) (if (jolt= G__141 (keyword #f "host")) (jolt-throw (let* ((_a$7318 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7319 (jolt-hash-map))) (jolt-ex-info _a$7318 _a$7319))) (if (jolt= G__141 (keyword #f "host-static")) (let* ((_a$7320 (var-deref "clojure.core" "str")) (_a$7321 "(host-static-ref ") (_a$7322 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7323 " ") (_a$7324 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7325 ")")) (jolt-invoke _a$7320 _a$7321 _a$7322 _a$7323 _a$7324 _a$7325)) (if (jolt= G__141 (keyword #f "host-new")) (let* ((_a$7326 (var-deref "clojure.core" "str")) (_a$7327 "(host-new ") (_a$7328 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7329 (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$7330 ")")) (jolt-invoke _a$7326 _a$7327 _a$7328 _a$7329 _a$7330)) (if (jolt= G__141 (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)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$7331 (var-deref "clojure.core" "str")) (_a$7332 "(if ") (_a$7333 t) (_a$7334 " ") (_a$7335 (emit (jolt-get node (keyword #f "then")))) (_a$7336 " ") (_a$7337 (emit (jolt-get node (keyword #f "else")))) (_a$7338 ")")) (jolt-invoke _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336 _a$7337 _a$7338))) (if (jolt= G__141 (keyword #f "do")) (let* ((_a$7339 (var-deref "clojure.core" "str")) (_a$7340 "(begin ") (_a$7341 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7342 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7343 (emit (jolt-get node (keyword #f "ret")))) (_a$7344 ")")) (jolt-invoke _a$7339 _a$7340 _a$7341 _a$7342 _a$7343 _a$7344)) (if (jolt= G__141 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__141 (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__141 (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__141 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7348 (var-deref "clojure.core" "mapcat")) (_a$7349 (lambda (p) (let fnrec7345 ((p p)) (let* ((_o$7346 (emit (jolt-nth p 0))) (_o$7347 (emit (jolt-nth p 1)))) (jolt-vector _o$7346 _o$7347))))) (_a$7350 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7348 _a$7349 _a$7350))) (if (jolt= G__141 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__141 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__141 (keyword #f "coerce")) (let* ((e (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__141 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__141 (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__141 (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__141 (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__141 (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__141 (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__141 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (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$7351 (var-deref "clojure.core" "str")) (_a$7352 "(jolt-host-call ") (_a$7353 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7354 " ") (_a$7355 target) (_a$7356 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7357 ")")) (jolt-invoke _a$7351 _a$7352 _a$7353 _a$7354 _a$7355 _a$7356 _a$7357)) (let* ((_a$7358 (var-deref "clojure.core" "str")) (_a$7359 "(record-method-dispatch ") (_a$7360 target) (_a$7361 " ") (_a$7362 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7363 " (jolt-vector") (_a$7364 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7365 "))")) (jolt-invoke _a$7358 _a$7359 _a$7360 _a$7361 _a$7362 _a$7363 _a$7364 _a$7365)))) (if (jolt= G__141 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__141 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__141 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__141 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__141 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__141 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__141 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7366 (var-deref "clojure.core" "str")) (_a$7367 "(declare-var! ") (_a$7368 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7369 " ") (_a$7370 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7371 ")")) (jolt-invoke _a$7366 _a$7367 _a$7368 _a$7369 _a$7370 _a$7371)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7372 (var-deref "clojure.core" "str")) (_a$7373 "(def-var-with-meta! ") (_a$7374 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7375 " ") (_a$7376 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7377 " ") (_a$7378 (emit (jolt-get node (keyword #f "init")))) (_a$7379 " ") (_a$7380 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7381 ")")) (jolt-invoke _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378 _a$7379 _a$7380 _a$7381)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7382 (var-deref "clojure.core" "str")) (_a$7383 "(def-var! ") (_a$7384 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7385 " ") (_a$7386 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7387 " ") (_a$7388 (emit (jolt-get node (keyword #f "init")))) (_a$7389 ")")) (jolt-invoke _a$7382 _a$7383 _a$7384 _a$7385 _a$7386 _a$7387 _a$7388 _a$7389)) jolt-nil))) (jolt-throw (let* ((_a$7390 (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$7391 (jolt-hash-map))) (jolt-ex-info _a$7390 _a$7391))))))))))))))))))))))))))))))))))))))))) emit)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7390 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__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 fnrec7392 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__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 fnrec7391 ((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$7392 (var-deref "clojure.core" "str")) (_a$7393 "(begin ") (_a$7394 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7395 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7396 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7397 ")")) (jolt-invoke _a$7392 _a$7393 _a$7394 _a$7395 _a$7396 _a$7397)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__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)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$7398 (var-deref "clojure.core" "str")) (_a$7399 " (jolt-register-source! ") (_a$7400 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7401 " ") (_a$7402 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7403 " ") (_a$7404 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7405 " ") (_a$7406 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$7407 " ") (_a$7408 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7409 ")")) (jolt-invoke _a$7398 _a$7399 _a$7400 _a$7401 _a$7402 _a$7403 _a$7404 _a$7405 _a$7406 _a$7407 _a$7408 _a$7409)) jolt-nil))) (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-truthy? fn?) (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$7410 (var-deref "clojure.core" "str")) (_a$7411 "(begin (define ") (_a$7412 b) (_a$7413 " ") (_a$7414 init) (_a$7415 ") (def-var-with-meta! ") (_a$7416 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7417 " ") (_a$7418 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7419 " ") (_a$7420 b) (_a$7421 " ") (_a$7422 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7423 ")") (_a$7424 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7425 ")")) (jolt-invoke _a$7410 _a$7411 _a$7412 _a$7413 _a$7414 _a$7415 _a$7416 _a$7417 _a$7418 _a$7419 _a$7420 _a$7421 _a$7422 _a$7423 _a$7424 _a$7425)) (let* ((_a$7426 (var-deref "clojure.core" "str")) (_a$7427 "(begin (define ") (_a$7428 b) (_a$7429 " ") (_a$7430 init) (_a$7431 ") (def-var! ") (_a$7432 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7433 " ") (_a$7434 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7435 " ") (_a$7436 b) (_a$7437 ")") (_a$7438 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7439 ")")) (jolt-invoke _a$7426 _a$7427 _a$7428 _a$7429 _a$7430 _a$7431 _a$7432 _a$7433 _a$7434 _a$7435 _a$7436 _a$7437 _a$7438 _a$7439)))))) (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 fnrec7393 ((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$7394 (var-deref "clojure.core" "str")) (_a$7395 "(begin ") (_a$7396 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7397 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7398 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7399 ")")) (jolt-invoke _a$7394 _a$7395 _a$7396 _a$7397 _a$7398 _a$7399)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__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)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$7400 (var-deref "clojure.core" "str")) (_a$7401 " (jolt-register-source! ") (_a$7402 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7403 " ") (_a$7404 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7405 " ") (_a$7406 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7407 " ") (_a$7408 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$7409 " ") (_a$7410 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7411 ")")) (jolt-invoke _a$7400 _a$7401 _a$7402 _a$7403 _a$7404 _a$7405 _a$7406 _a$7407 _a$7408 _a$7409 _a$7410 _a$7411)) jolt-nil))) (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-truthy? fn?) (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$7412 (var-deref "clojure.core" "str")) (_a$7413 "(begin (define ") (_a$7414 b) (_a$7415 " ") (_a$7416 init) (_a$7417 ") (def-var-with-meta! ") (_a$7418 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7419 " ") (_a$7420 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7421 " ") (_a$7422 b) (_a$7423 " ") (_a$7424 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7425 ")") (_a$7426 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7427 ")")) (jolt-invoke _a$7412 _a$7413 _a$7414 _a$7415 _a$7416 _a$7417 _a$7418 _a$7419 _a$7420 _a$7421 _a$7422 _a$7423 _a$7424 _a$7425 _a$7426 _a$7427)) (let* ((_a$7428 (var-deref "clojure.core" "str")) (_a$7429 "(begin (define ") (_a$7430 b) (_a$7431 " ") (_a$7432 init) (_a$7433 ") (def-var! ") (_a$7434 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7435 " ") (_a$7436 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7437 " ") (_a$7438 b) (_a$7439 ")") (_a$7440 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7441 ")")) (jolt-invoke _a$7428 _a$7429 _a$7430 _a$7431 _a$7432 _a$7433 _a$7434 _a$7435 _a$7436 _a$7437 _a$7438 _a$7439 _a$7440 _a$7441)))))) (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$7440 "+") (_o$7441 jolt-add) (_o$7442 "-") (_o$7443 jolt-sub) (_o$7444 "*") (_o$7445 jolt-mul) (_o$7446 "/") (_o$7447 jolt-div) (_o$7448 "<") (_o$7449 <) (_o$7450 ">") (_o$7451 >) (_o$7452 "<=") (_o$7453 <=) (_o$7454 ">=") (_o$7455 >=) (_o$7456 "=") (_o$7457 jolt=) (_o$7458 "inc") (_o$7459 jolt-inc) (_o$7460 "dec") (_o$7461 jolt-dec) (_o$7462 "mod") (_o$7463 modulo) (_o$7464 "rem") (_o$7465 remainder) (_o$7466 "quot") (_o$7467 quotient) (_o$7468 "bit-and") (_o$7469 (var-deref "clojure.core" "__bit-and")) (_o$7470 "bit-or") (_o$7471 (var-deref "clojure.core" "__bit-or")) (_o$7472 "bit-xor") (_o$7473 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$7440 _o$7441 _o$7442 _o$7443 _o$7444 _o$7445 _o$7446 _o$7447 _o$7448 _o$7449 _o$7450 _o$7451 _o$7452 _o$7453 _o$7454 _o$7455 _o$7456 _o$7457 _o$7458 _o$7459 _o$7460 _o$7461 _o$7462 _o$7463 _o$7464 _o$7465 _o$7466 _o$7467 _o$7468 _o$7469 _o$7470 _o$7471 _o$7472 _o$7473)) (let* ((_o$7474 (keyword #f "private")) (_o$7475 #t)) (jolt-hash-map _o$7474 _o$7475))))
+  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$7442 "+") (_o$7443 jolt-add) (_o$7444 "-") (_o$7445 jolt-sub) (_o$7446 "*") (_o$7447 jolt-mul) (_o$7448 "/") (_o$7449 jolt-div) (_o$7450 "<") (_o$7451 <) (_o$7452 ">") (_o$7453 >) (_o$7454 "<=") (_o$7455 <=) (_o$7456 ">=") (_o$7457 >=) (_o$7458 "=") (_o$7459 jolt=) (_o$7460 "inc") (_o$7461 jolt-inc) (_o$7462 "dec") (_o$7463 jolt-dec) (_o$7464 "mod") (_o$7465 modulo) (_o$7466 "rem") (_o$7467 remainder) (_o$7468 "quot") (_o$7469 quotient) (_o$7470 "bit-and") (_o$7471 (var-deref "clojure.core" "__bit-and")) (_o$7472 "bit-or") (_o$7473 (var-deref "clojure.core" "__bit-or")) (_o$7474 "bit-xor") (_o$7475 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$7442 _o$7443 _o$7444 _o$7445 _o$7446 _o$7447 _o$7448 _o$7449 _o$7450 _o$7451 _o$7452 _o$7453 _o$7454 _o$7455 _o$7456 _o$7457 _o$7458 _o$7459 _o$7460 _o$7461 _o$7462 _o$7463 _o$7464 _o$7465 _o$7466 _o$7467 _o$7468 _o$7469 _o$7470 _o$7471 _o$7472 _o$7473 _o$7474 _o$7475)) (let* ((_o$7476 (keyword #f "private")) (_o$7477 #t)) (jolt-hash-map _o$7476 _o$7477))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7476 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?)))
+  (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7478 ((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 fnrec7477 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?)))
+  (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7479 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7478 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__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 fnrec7480 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__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-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7479 ((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__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1547 (else (let* ((e _r$catch1547)) jolt-nil))) (let* ((_o$7481 (keyword #f "op")) (_o$7482 (keyword #f "const")) (_o$7483 (keyword #f "val")) (_o$7484 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7480 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7481 _o$7482 _o$7483 _o$7484))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (let* ((or__26__auto (jolt-nil? (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val"))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$7485 node) (_a$7486 (keyword #f "test")) (_a$7487 t) (_a$7488 (keyword #f "then")) (_a$7489 (const-fold (jolt-get node (keyword #f "then")))) (_a$7490 (keyword #f "else")) (_a$7491 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7485 _a$7486 _a$7487 _a$7488 _a$7489 _a$7490 _a$7491)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7492 (keyword #f "doc")) (_o$7493 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n  all constant numbers becomes a constant; an if with a constant test becomes\n  the taken branch.")) (jolt-hash-map _o$7492 _o$7493))))
+  (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7481 ((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__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1547 (else (let* ((e _r$catch1547)) jolt-nil))) (let* ((_o$7483 (keyword #f "op")) (_o$7484 (keyword #f "const")) (_o$7485 (keyword #f "val")) (_o$7486 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7482 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7483 _o$7484 _o$7485 _o$7486))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (let* ((or__26__auto (jolt-nil? (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val"))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$7487 node) (_a$7488 (keyword #f "test")) (_a$7489 t) (_a$7490 (keyword #f "then")) (_a$7491 (const-fold (jolt-get node (keyword #f "then")))) (_a$7492 (keyword #f "else")) (_a$7493 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7487 _a$7488 _a$7489 _a$7490 _a$7491 _a$7492 _a$7493)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7494 (keyword #f "doc")) (_o$7495 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n  all constant numbers becomes a constant; an if with a constant test becomes\n  the taken branch.")) (jolt-hash-map _o$7494 _o$7495))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7494 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?)))
+  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7496 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec7495 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$7496 (keyword #f "doc")) (_o$7497 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7496 _o$7497))))
+  (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec7497 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$7498 (keyword #f "doc")) (_o$7499 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7498 _o$7499))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7498 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$7499 (keyword #f "doc")) (_o$7500 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7499 _o$7500))))
+  (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7500 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$7501 (keyword #f "doc")) (_o$7502 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7501 _o$7502))))
 (guard (e (#t #f))
   (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6041 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__25__auto))) and__25__auto)))))) int-lit?)))
 (guard (e (#t #f))
@@ -291,87 +291,87 @@
 (guard (e (#t #f))
   (def-var! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec6140 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$6141 (jolt-hash-map)) (_a$6142 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$6141 _a$6142))) (pe (let* ((_a$6144 (lambda (e p) (let fnrec6143 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$6145 tenv) (_a$6146 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$6144 _a$6145 _a$6146)))) (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-with-meta! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec6147 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$6149 (var-deref "clojure.core" "mapv")) (_a$6150 (lambda (a) (let fnrec6148 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$6151 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6149 _a$6150 _a$6151))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6152 ((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$6153 (jolt-get fnode (keyword #f "num-ret"))) (_o$6154 node1)) (jolt-vector _o$6153 _o$6154)) (if (jolt-nil? nm) (let* ((_o$6155 jolt-nil) (_o$6156 node1)) (jolt-vector _o$6155 _o$6156)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6157 ((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= k (keyword #f "bigdec")) (keyword #f "bigdec") (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 fnrec6158 ((allowed allowed) (need need)) (let* ((and__25__auto (jolt-pos? n))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec6159 ((c c)) (let* ((or__26__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec6160 ((c c)) (jolt= c need))) cls) and__25__auto)) and__25__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)) (bs (jolt-invoke (var-deref "jolt.passes.numeric" "bd-spec") nm n))) (if (jolt-truthy? (let* ((and__25__auto ds)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__25__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec6161 ((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$6162 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$6163 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$6162 _o$6163))) (if (jolt-truthy? (let* ((and__25__auto ls)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__25__auto))) (let* ((_o$6164 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$6165 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$6164 _o$6165)) (if (jolt-truthy? (let* ((and__25__auto bs)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "bigdec") (keyword #f "bigdec")) and__25__auto))) (let* ((_o$6166 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$6167 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$6166 _o$6167)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6168 jolt-nil) (_o$6169 node1)) (jolt-vector _o$6168 _o$6169)) jolt-nil))))) jolt-nil)))))))) an-invoke) (let* ((_o$6170 (keyword #f "doc")) (_o$6171 "Annotate an :invoke with its numeric kind. An arithmetic core op specializes to\n  the Chez fl*/fx* op only when every operand is the same kind (:double or :long),\n  except an integer literal is :wild \x2014; valid in either \x2014; so (+ ^double x 2) stays\n  double. A call to a ^double/^long-returning var yields that kind without lowering\n  the call (its body already coerces the return).")) (jolt-hash-map _o$6170 _o$6171))))
+  (def-var-with-meta! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec6147 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$6149 (var-deref "clojure.core" "mapv")) (_a$6150 (lambda (a) (let fnrec6148 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$6151 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6149 _a$6150 _a$6151))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6152 ((r r)) (jolt-nth r 1))) ars)) (node1 (jolt-assoc node (keyword #f "args") argnodes)) (n (jolt-count ars))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "num-read"))) (let* ((_o$6153 (keyword #f "double")) (_o$6154 node1)) (jolt-vector _o$6153 _o$6154)) (if (jolt-truthy? (jolt-get fnode (keyword #f "num-ret"))) (let* ((_o$6155 (jolt-get fnode (keyword #f "num-ret"))) (_o$6156 node1)) (jolt-vector _o$6155 _o$6156)) (if (jolt-nil? nm) (let* ((_o$6157 jolt-nil) (_o$6158 node1)) (jolt-vector _o$6157 _o$6158)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6159 ((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= k (keyword #f "bigdec")) (keyword #f "bigdec") (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 fnrec6160 ((allowed allowed) (need need)) (let* ((and__25__auto (jolt-pos? n))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec6161 ((c c)) (let* ((or__26__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec6162 ((c c)) (jolt= c need))) cls) and__25__auto)) and__25__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)) (bs (jolt-invoke (var-deref "jolt.passes.numeric" "bd-spec") nm n))) (if (jolt-truthy? (let* ((and__25__auto ds)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__25__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec6163 ((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$6164 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$6165 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$6164 _o$6165))) (if (jolt-truthy? (let* ((and__25__auto ls)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__25__auto))) (let* ((_o$6166 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$6167 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$6166 _o$6167)) (if (jolt-truthy? (let* ((and__25__auto bs)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "bigdec") (keyword #f "bigdec")) and__25__auto))) (let* ((_o$6168 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$6169 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$6168 _o$6169)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6170 jolt-nil) (_o$6171 node1)) (jolt-vector _o$6170 _o$6171)) jolt-nil))))) jolt-nil))))))))) an-invoke) (let* ((_o$6172 (keyword #f "doc")) (_o$6173 "Annotate an :invoke with its numeric kind. An arithmetic core op specializes to\n  the Chez fl*/fx* op only when every operand is the same kind (:double or :long),\n  except an integer literal is :wild \x2014; valid in either \x2014; so (+ ^double x 2) stays\n  double. A call to a ^double/^long-returning var yields that kind without lowering\n  the call (its body already coerces the return).")) (jolt-hash-map _o$6172 _o$6173))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec6172 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$6173 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$6174 node)) (jolt-vector _o$6173 _o$6174)) (if (jolt= op (keyword #f "bigdec")) (let* ((_o$6175 (keyword #f "bigdec")) (_o$6176 node)) (jolt-vector _o$6175 _o$6176)) (if (jolt= op (keyword #f "local")) (let* ((_o$6177 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$6178 node)) (jolt-vector _o$6177 _o$6178)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$6179 (jolt-get node (keyword #f "kind"))) (_o$6180 (jolt-assoc node (keyword #f "expr") (jolt-nth (an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$6179 _o$6180)) (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$6191 (lambda (acc b) (let fnrec6181 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (an (jolt-nth b 1) te))) (let* ((_o$6187 (let* ((_a$6182 te) (_a$6183 (jolt-nth b 0)) (_a$6184 (jolt-nth ir 0))) (jolt-assoc _a$6182 _a$6183 _a$6184))) (_o$6188 (jolt-conj binds (let* ((_o$6185 (jolt-nth b 0)) (_o$6186 (jolt-nth ir 1))) (jolt-vector _o$6185 _o$6186))))) (jolt-vector _o$6187 _o$6188)))))) (_a$6192 (let* ((_o$6189 tenv) (_o$6190 (jolt-vector))) (jolt-vector _o$6189 _o$6190))) (_a$6193 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6191 _a$6192 _a$6193))) (br (let* ((_a$6194 (jolt-get node (keyword #f "body"))) (_a$6195 (jolt-nth res 0))) (an _a$6194 _a$6195)))) (let* ((_o$6201 (jolt-nth br 0)) (_o$6202 (let* ((_a$6196 node) (_a$6197 (keyword #f "bindings")) (_a$6198 (jolt-nth res 1)) (_a$6199 (keyword #f "body")) (_a$6200 (jolt-nth br 1))) (jolt-assoc _a$6196 _a$6197 _a$6198 _a$6199 _a$6200)))) (jolt-vector _o$6201 _o$6202))) (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 fnrec6203 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6204 ((b b)) (jolt-nth (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$6210 (var-deref "clojure.core" "mapv")) (_a$6211 (lambda (j) (let fnrec6205 ((j j)) (let* ((k (jolt-nth ik j)) (b (jolt-nth binds j))) (if (jolt-truthy? k) k (if (jolt-truthy? (let* ((and__25__auto (jolt-seq rlists))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth b 1)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (args) (let fnrec6206 ((args args)) (let* ((_a$6207 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$6208 (jolt-nth args j)) (_a$6209 (jolt-nth b 0))) (jolt-invoke _a$6207 _a$6208 _a$6209)))) rlists) and__25__auto)) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$6212 (jolt-range (jolt-count names)))) (jolt-invoke _a$6210 _a$6211 _a$6212))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$6217 (lambda (t i) (let fnrec6213 ((t t) (i i)) (let* ((_a$6214 t) (_a$6215 (jolt-nth names i)) (_a$6216 (jolt-nth lk i))) (jolt-assoc _a$6214 _a$6215 _a$6216))))) (_a$6218 tenv) (_a$6219 (jolt-range (jolt-count names)))) (jolt-reduce _a$6217 _a$6218 _a$6219)))) (let* ((_o$6228 jolt-nil) (_o$6229 (let* ((_a$6223 node) (_a$6224 (keyword #f "bindings")) (_a$6225 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6220 ((b b)) (let* ((_o$6221 (jolt-nth b 0)) (_o$6222 (jolt-nth (an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$6221 _o$6222)))) binds)) (_a$6226 (keyword #f "body")) (_a$6227 (jolt-nth (an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$6223 _a$6224 _a$6225 _a$6226 _a$6227)))) (jolt-vector _o$6228 _o$6229))) (if (jolt= op (keyword #f "if")) (let* ((tr (an (jolt-get node (keyword #f "test")) tenv)) (thn (an (jolt-get node (keyword #f "then")) tenv)) (els (an (jolt-get node (keyword #f "else")) tenv)) (tk (jolt-nth thn 0)) (ek (jolt-nth els 0))) (let* ((_o$6237 (if (jolt= tk ek) tk jolt-nil)) (_o$6238 (let* ((_a$6230 node) (_a$6231 (keyword #f "test")) (_a$6232 (jolt-nth tr 1)) (_a$6233 (keyword #f "then")) (_a$6234 (jolt-nth thn 1)) (_a$6235 (keyword #f "else")) (_a$6236 (jolt-nth els 1))) (jolt-assoc _a$6230 _a$6231 _a$6232 _a$6233 _a$6234 _a$6235 _a$6236)))) (jolt-vector _o$6237 _o$6238))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$6240 (var-deref "clojure.core" "mapv")) (_a$6241 (lambda (s) (let fnrec6239 ((s s)) (jolt-nth (an s tenv) 1)))) (_a$6242 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6240 _a$6241 _a$6242))) (r (an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$6243 (jolt-nth r 0)) (_o$6244 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$6243 _o$6244))) (if (jolt= op (keyword #f "fn")) (let* ((_o$6251 jolt-nil) (_o$6252 (jolt-assoc node (keyword #f "arities") (let* ((_a$6248 (var-deref "clojure.core" "mapv")) (_a$6249 (lambda (a) (let fnrec6245 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$6246 (jolt-get a (keyword #f "body"))) (_a$6247 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (an _a$6246 _a$6247)) 1))))) (_a$6250 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6248 _a$6249 _a$6250))))) (jolt-vector _o$6251 _o$6252)) (if (jolt= op (keyword #f "def")) (let* ((_o$6253 jolt-nil) (_o$6254 (jolt-assoc node (keyword #f "init") (jolt-nth (an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$6253 _o$6254)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6256 jolt-nil) (_o$6257 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6255 ((c c)) (jolt-nth (an c tenv) 1))) node))) (jolt-vector _o$6256 _o$6257)) jolt-nil))))))))))))))))) an)))
+  (def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec6174 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$6175 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$6176 node)) (jolt-vector _o$6175 _o$6176)) (if (jolt= op (keyword #f "bigdec")) (let* ((_o$6177 (keyword #f "bigdec")) (_o$6178 node)) (jolt-vector _o$6177 _o$6178)) (if (jolt= op (keyword #f "local")) (let* ((_o$6179 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$6180 node)) (jolt-vector _o$6179 _o$6180)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$6181 (jolt-get node (keyword #f "kind"))) (_o$6182 (jolt-assoc node (keyword #f "expr") (jolt-nth (an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$6181 _o$6182)) (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$6193 (lambda (acc b) (let fnrec6183 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (an (jolt-nth b 1) te))) (let* ((_o$6189 (let* ((_a$6184 te) (_a$6185 (jolt-nth b 0)) (_a$6186 (jolt-nth ir 0))) (jolt-assoc _a$6184 _a$6185 _a$6186))) (_o$6190 (jolt-conj binds (let* ((_o$6187 (jolt-nth b 0)) (_o$6188 (jolt-nth ir 1))) (jolt-vector _o$6187 _o$6188))))) (jolt-vector _o$6189 _o$6190)))))) (_a$6194 (let* ((_o$6191 tenv) (_o$6192 (jolt-vector))) (jolt-vector _o$6191 _o$6192))) (_a$6195 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6193 _a$6194 _a$6195))) (br (let* ((_a$6196 (jolt-get node (keyword #f "body"))) (_a$6197 (jolt-nth res 0))) (an _a$6196 _a$6197)))) (let* ((_o$6203 (jolt-nth br 0)) (_o$6204 (let* ((_a$6198 node) (_a$6199 (keyword #f "bindings")) (_a$6200 (jolt-nth res 1)) (_a$6201 (keyword #f "body")) (_a$6202 (jolt-nth br 1))) (jolt-assoc _a$6198 _a$6199 _a$6200 _a$6201 _a$6202)))) (jolt-vector _o$6203 _o$6204))) (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 fnrec6205 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6206 ((b b)) (jolt-nth (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$6212 (var-deref "clojure.core" "mapv")) (_a$6213 (lambda (j) (let fnrec6207 ((j j)) (let* ((k (jolt-nth ik j)) (b (jolt-nth binds j))) (if (jolt-truthy? k) k (if (jolt-truthy? (let* ((and__25__auto (jolt-seq rlists))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth b 1)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (args) (let fnrec6208 ((args args)) (let* ((_a$6209 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$6210 (jolt-nth args j)) (_a$6211 (jolt-nth b 0))) (jolt-invoke _a$6209 _a$6210 _a$6211)))) rlists) and__25__auto)) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$6214 (jolt-range (jolt-count names)))) (jolt-invoke _a$6212 _a$6213 _a$6214))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$6219 (lambda (t i) (let fnrec6215 ((t t) (i i)) (let* ((_a$6216 t) (_a$6217 (jolt-nth names i)) (_a$6218 (jolt-nth lk i))) (jolt-assoc _a$6216 _a$6217 _a$6218))))) (_a$6220 tenv) (_a$6221 (jolt-range (jolt-count names)))) (jolt-reduce _a$6219 _a$6220 _a$6221)))) (let* ((_o$6230 jolt-nil) (_o$6231 (let* ((_a$6225 node) (_a$6226 (keyword #f "bindings")) (_a$6227 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6222 ((b b)) (let* ((_o$6223 (jolt-nth b 0)) (_o$6224 (jolt-nth (an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$6223 _o$6224)))) binds)) (_a$6228 (keyword #f "body")) (_a$6229 (jolt-nth (an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$6225 _a$6226 _a$6227 _a$6228 _a$6229)))) (jolt-vector _o$6230 _o$6231))) (if (jolt= op (keyword #f "if")) (let* ((tr (an (jolt-get node (keyword #f "test")) tenv)) (thn (an (jolt-get node (keyword #f "then")) tenv)) (els (an (jolt-get node (keyword #f "else")) tenv)) (tk (jolt-nth thn 0)) (ek (jolt-nth els 0))) (let* ((_o$6239 (if (jolt= tk ek) tk jolt-nil)) (_o$6240 (let* ((_a$6232 node) (_a$6233 (keyword #f "test")) (_a$6234 (jolt-nth tr 1)) (_a$6235 (keyword #f "then")) (_a$6236 (jolt-nth thn 1)) (_a$6237 (keyword #f "else")) (_a$6238 (jolt-nth els 1))) (jolt-assoc _a$6232 _a$6233 _a$6234 _a$6235 _a$6236 _a$6237 _a$6238)))) (jolt-vector _o$6239 _o$6240))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$6242 (var-deref "clojure.core" "mapv")) (_a$6243 (lambda (s) (let fnrec6241 ((s s)) (jolt-nth (an s tenv) 1)))) (_a$6244 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6242 _a$6243 _a$6244))) (r (an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$6245 (jolt-nth r 0)) (_o$6246 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$6245 _o$6246))) (if (jolt= op (keyword #f "fn")) (let* ((_o$6253 jolt-nil) (_o$6254 (jolt-assoc node (keyword #f "arities") (let* ((_a$6250 (var-deref "clojure.core" "mapv")) (_a$6251 (lambda (a) (let fnrec6247 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$6248 (jolt-get a (keyword #f "body"))) (_a$6249 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (an _a$6248 _a$6249)) 1))))) (_a$6252 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6250 _a$6251 _a$6252))))) (jolt-vector _o$6253 _o$6254)) (if (jolt= op (keyword #f "def")) (let* ((_o$6255 jolt-nil) (_o$6256 (jolt-assoc node (keyword #f "init") (jolt-nth (an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$6255 _o$6256)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6258 jolt-nil) (_o$6259 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6257 ((c c)) (jolt-nth (an c tenv) 1))) node))) (jolt-vector _o$6258 _o$6259)) jolt-nil))))))))))))))))) an)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec6258 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate) (let* ((_o$6259 (keyword #f "doc")) (_o$6260 "Tag arithmetic nodes with :num-kind from local numeric type-flow. Returns the\n  rewritten IR (no kind escapes to the caller).")) (jolt-hash-map _o$6259 _o$6260))))
+  (def-var-with-meta! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec6260 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate) (let* ((_o$6261 (keyword #f "doc")) (_o$6262 "Tag arithmetic nodes with :num-kind from local numeric type-flow. Returns the\n  rewritten IR (no kind escapes to the caller).")) (jolt-hash-map _o$6261 _o$6262))))
 (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 fnrec6261 () (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 fnrec6263 () (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)) (let* ((_o$6262 (keyword #f "private")) (_o$6263 #t)) (jolt-hash-map _o$6262 _o$6263))))
+  (def-var-with-meta! "jolt.passes.inline" "rec-shapes" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map)) (let* ((_o$6264 (keyword #f "private")) (_o$6265 #t)) (jolt-hash-map _o$6264 _o$6265))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec6264 ((m m)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "rec-shapes") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-rec-shapes!) (let* ((_o$6265 (keyword #f "doc")) (_o$6266 "Install the record-ctor shape registry the record fold consults.")) (jolt-hash-map _o$6265 _o$6266))))
+  (def-var-with-meta! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec6266 ((m m)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "rec-shapes") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-rec-shapes!) (let* ((_o$6267 (keyword #f "doc")) (_o$6268 "Install the record-ctor shape registry the record fold consults.")) (jolt-hash-map _o$6267 _o$6268))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "fresh-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6267 (keyword #f "private")) (_o$6268 #t)) (jolt-hash-map _o$6267 _o$6268))))
+  (def-var-with-meta! "jolt.passes.inline" "fresh-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6269 (keyword #f "private")) (_o$6270 #t)) (jolt-hash-map _o$6269 _o$6270))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "fresh" (letrec ((fresh (lambda (base) (let fnrec6269 ((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 fnrec6271 ((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 fnrec6270 ((op op)) (let* ((or__26__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "host")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "the-var")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "quote")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "if")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "do")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "let")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "invoke")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "vector")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "throw")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "coerce")))))))))))))))))))))))))))))))))) safe-op?)))
+  (def-var! "jolt.passes.inline" "safe-op?" (letrec ((safe-op? (lambda (op) (let fnrec6272 ((op op)) (let* ((or__26__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "host")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "the-var")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "quote")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "if")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "do")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "let")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "invoke")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "vector")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "throw")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "coerce")))))))))))))))))))))))))))))))))) safe-op?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "inline-budget" 120 (let* ((_o$6271 (keyword #f "private")) (_o$6272 #t)) (jolt-hash-map _o$6271 _o$6272))))
+  (def-var-with-meta! "jolt.passes.inline" "inline-budget" 120 (let* ((_o$6273 (keyword #f "private")) (_o$6274 #t)) (jolt-hash-map _o$6273 _o$6274))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6273 ((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 fnrec6274 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6275 (keyword #f "doc")) (_o$6276 "Node count of an inline-eligible body. A disallowed op contributes a number\n  larger than any budget, so the caller's (<= size budget) test fails and we\n  never try to inline (or alpha-rename) such a body. Only reached for safe ops,\n  so the shared child fold covers it exactly (leaves fold to 1).")) (jolt-hash-map _o$6275 _o$6276))))
+  (def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6275 ((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 fnrec6276 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6277 (keyword #f "doc")) (_o$6278 "Node count of an inline-eligible body. A disallowed op contributes a number\n  larger than any budget, so the caller's (<= size budget) test fails and we\n  never try to inline (or alpha-rename) such a body. Only reached for safe ops,\n  so the shared child fold covers it exactly (leaves fold to 1).")) (jolt-hash-map _o$6277 _o$6278))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6277 ((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__25__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__25__auto)) and__25__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$6289 (lambda (acc b) (let fnrec6278 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$6285 (jolt-assoc e nm (let* ((_o$6279 (keyword #f "op")) (_o$6280 (keyword #f "local")) (_o$6281 (keyword #f "name")) (_o$6282 f)) (jolt-hash-map _o$6279 _o$6280 _o$6281 _o$6282)))) (_o$6286 (jolt-conj binds (let* ((_o$6283 f) (_o$6284 init)) (jolt-vector _o$6283 _o$6284))))) (jolt-vector _o$6285 _o$6286)))))) (_a$6290 (let* ((_o$6287 env) (_o$6288 (jolt-vector))) (jolt-vector _o$6287 _o$6288))) (_a$6291 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6289 _a$6290 _a$6291)))) (let* ((_a$6294 node) (_a$6295 (keyword #f "bindings")) (_a$6296 (jolt-nth res 1)) (_a$6297 (keyword #f "body")) (_a$6298 (let* ((_a$6292 (jolt-get node (keyword #f "body"))) (_a$6293 (jolt-nth res 0))) (subst _a$6292 _a$6293)))) (jolt-assoc _a$6294 _a$6295 _a$6296 _a$6297 _a$6298))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6299 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6300 (keyword #f "doc")) (_o$6301 "Substitute locals in node per env (a map name -> replacement IR node), and\n  alpha-rename every inner :let binder to a globally fresh name (so the spliced\n  body shares no name with the caller). env seeds the params: a trivial arg\n  (local/const) maps a param straight to the arg node (copy propagation \x2014; this\n  is what lets scalar-replace see a map-literal arg through the call boundary);\n  a non-trivial arg maps the param to a fresh :local that a wrapping let binds.")) (jolt-hash-map _o$6300 _o$6301))))
+  (def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6279 ((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__25__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__25__auto)) and__25__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$6291 (lambda (acc b) (let fnrec6280 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$6287 (jolt-assoc e nm (let* ((_o$6281 (keyword #f "op")) (_o$6282 (keyword #f "local")) (_o$6283 (keyword #f "name")) (_o$6284 f)) (jolt-hash-map _o$6281 _o$6282 _o$6283 _o$6284)))) (_o$6288 (jolt-conj binds (let* ((_o$6285 f) (_o$6286 init)) (jolt-vector _o$6285 _o$6286))))) (jolt-vector _o$6287 _o$6288)))))) (_a$6292 (let* ((_o$6289 env) (_o$6290 (jolt-vector))) (jolt-vector _o$6289 _o$6290))) (_a$6293 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6291 _a$6292 _a$6293)))) (let* ((_a$6296 node) (_a$6297 (keyword #f "bindings")) (_a$6298 (jolt-nth res 1)) (_a$6299 (keyword #f "body")) (_a$6300 (let* ((_a$6294 (jolt-get node (keyword #f "body"))) (_a$6295 (jolt-nth res 0))) (subst _a$6294 _a$6295)))) (jolt-assoc _a$6296 _a$6297 _a$6298 _a$6299 _a$6300))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6301 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6302 (keyword #f "doc")) (_o$6303 "Substitute locals in node per env (a map name -> replacement IR node), and\n  alpha-rename every inner :let binder to a globally fresh name (so the spliced\n  body shares no name with the caller). env seeds the params: a trivial arg\n  (local/const) maps a param straight to the arg node (copy propagation \x2014; this\n  is what lets scalar-replace see a map-literal arg through the call boundary);\n  a non-trivial arg maps the param to a fresh :local that a wrapping let binds.")) (jolt-hash-map _o$6302 _o$6303))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec6302 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "const"))))))))) trivial-arg?)))
+  (def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec6304 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "const"))))))))) trivial-arg?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec6303 ((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$6309 (lambda (acc b) (let fnrec6304 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6305 (jolt-conj sc (jolt-nth b 0))) (_o$6306 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6305 _o$6306))))))) (_a$6310 (let* ((_o$6307 scope) (_o$6308 #t)) (jolt-vector _o$6307 _o$6308))) (_a$6311 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6309 _a$6310 _a$6311)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6312 (jolt-get node (keyword #f "body"))) (_a$6313 (jolt-nth res 0))) (body-closed? _a$6312 _a$6313)) and__25__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 fnrec6314 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (body-closed? c scope) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?) (let* ((_o$6315 (keyword #f "doc")) (_o$6316 "True if every :local in node is bound \x2014; by a param (in the initial scope set)\n  or by an enclosing :let within the body. A self-recursive fn fails this: the\n  analyzer binds the fn's own name as a local, so its body has a FREE local (the\n  self-reference) that would dangle once the body is spliced elsewhere.")) (jolt-hash-map _o$6315 _o$6316))))
+  (def-var-with-meta! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec6305 ((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$6311 (lambda (acc b) (let fnrec6306 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6307 (jolt-conj sc (jolt-nth b 0))) (_o$6308 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6307 _o$6308))))))) (_a$6312 (let* ((_o$6309 scope) (_o$6310 #t)) (jolt-vector _o$6309 _o$6310))) (_a$6313 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6311 _a$6312 _a$6313)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6314 (jolt-get node (keyword #f "body"))) (_a$6315 (jolt-nth res 0))) (body-closed? _a$6314 _a$6315)) and__25__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 fnrec6316 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (body-closed? c scope) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?) (let* ((_o$6317 (keyword #f "doc")) (_o$6318 "True if every :local in node is bound \x2014; by a param (in the initial scope set)\n  or by an enclosing :let within the body. A self-recursive fn fails this: the\n  analyzer binds the fn's own name as a local, so its body has a FREE local (the\n  self-reference) that would dangle once the body is spliced elsewhere.")) (jolt-hash-map _o$6317 _o$6318))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6317 ((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$6318 (var-deref "jolt.host" "inline-ir")) (_a$6319 ctx) (_a$6320 (jolt-get f (keyword #f "ns"))) (_a$6321 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6318 _a$6319 _a$6320 _a$6321)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6326 (lambda (m pr) (let fnrec6322 ((m m) (pr pr)) (let* ((_a$6323 m) (_a$6324 (jolt-nth pr 0)) (_a$6325 (jolt-nth pr 1))) (jolt-assoc _a$6323 _a$6324 _a$6325))))) (_a$6327 (jolt-hash-map)) (_a$6328 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6326 _a$6327 _a$6328))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6329 (jolt-count params)) (_a$6330 (jolt-count args))) (jolt= _a$6329 _a$6330)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__25__auto)) and__25__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop6331 ((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$6338 (jolt-inc i)) (_a$6339 (jolt-assoc env p (let* ((_o$6332 (keyword #f "op")) (_o$6333 (keyword #f "local")) (_o$6334 (keyword #f "name")) (_o$6335 f)) (jolt-hash-map _o$6332 _o$6333 _o$6334 _o$6335)))) (_a$6340 (jolt-conj binds (let* ((_o$6336 f) (_o$6337 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6336 _o$6337))))) (loop6331 _a$6338 _a$6339 _a$6340))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6341 (jolt-inc i)) (_a$6342 (jolt-assoc env p a)) (_a$6343 binds)) (loop6331 _a$6341 _a$6342 _a$6343)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6350 (jolt-inc i)) (_a$6351 (jolt-assoc env p (let* ((_o$6344 (keyword #f "op")) (_o$6345 (keyword #f "local")) (_o$6346 (keyword #f "name")) (_o$6347 f)) (jolt-hash-map _o$6344 _o$6345 _o$6346 _o$6347)))) (_a$6352 (jolt-conj binds (let* ((_o$6348 f) (_o$6349 a)) (jolt-vector _o$6348 _o$6349))))) (loop6331 _a$6350 _a$6351 _a$6352))) jolt-nil)))) (let* ((_o$6353 env) (_o$6354 binds)) (jolt-vector _o$6353 _o$6354)))))) (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$6355 (keyword #f "op")) (_o$6356 (keyword #f "let")) (_o$6357 (keyword #f "bindings")) (_o$6358 binds) (_o$6359 (keyword #f "body")) (_o$6360 rbody)) (jolt-hash-map _o$6355 _o$6356 _o$6357 _o$6358 _o$6359 _o$6360))))) node)) node)) node)))))) try-inline) (let* ((_o$6361 (keyword #f "doc")) (_o$6362 "node is an :invoke whose children are already inlined. If its :fn is a var\n  with a stashed, in-budget, arity-matching inline body, return the spliced\n  let; else node.")) (jolt-hash-map _o$6361 _o$6362))))
+  (def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6319 ((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$6320 (var-deref "jolt.host" "inline-ir")) (_a$6321 ctx) (_a$6322 (jolt-get f (keyword #f "ns"))) (_a$6323 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6320 _a$6321 _a$6322 _a$6323)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6328 (lambda (m pr) (let fnrec6324 ((m m) (pr pr)) (let* ((_a$6325 m) (_a$6326 (jolt-nth pr 0)) (_a$6327 (jolt-nth pr 1))) (jolt-assoc _a$6325 _a$6326 _a$6327))))) (_a$6329 (jolt-hash-map)) (_a$6330 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6328 _a$6329 _a$6330))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6331 (jolt-count params)) (_a$6332 (jolt-count args))) (jolt= _a$6331 _a$6332)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__25__auto)) and__25__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop6333 ((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$6340 (jolt-inc i)) (_a$6341 (jolt-assoc env p (let* ((_o$6334 (keyword #f "op")) (_o$6335 (keyword #f "local")) (_o$6336 (keyword #f "name")) (_o$6337 f)) (jolt-hash-map _o$6334 _o$6335 _o$6336 _o$6337)))) (_a$6342 (jolt-conj binds (let* ((_o$6338 f) (_o$6339 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6338 _o$6339))))) (loop6333 _a$6340 _a$6341 _a$6342))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6343 (jolt-inc i)) (_a$6344 (jolt-assoc env p a)) (_a$6345 binds)) (loop6333 _a$6343 _a$6344 _a$6345)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6352 (jolt-inc i)) (_a$6353 (jolt-assoc env p (let* ((_o$6346 (keyword #f "op")) (_o$6347 (keyword #f "local")) (_o$6348 (keyword #f "name")) (_o$6349 f)) (jolt-hash-map _o$6346 _o$6347 _o$6348 _o$6349)))) (_a$6354 (jolt-conj binds (let* ((_o$6350 f) (_o$6351 a)) (jolt-vector _o$6350 _o$6351))))) (loop6333 _a$6352 _a$6353 _a$6354))) jolt-nil)))) (let* ((_o$6355 env) (_o$6356 binds)) (jolt-vector _o$6355 _o$6356)))))) (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$6357 (keyword #f "op")) (_o$6358 (keyword #f "let")) (_o$6359 (keyword #f "bindings")) (_o$6360 binds) (_o$6361 (keyword #f "body")) (_o$6362 rbody)) (jolt-hash-map _o$6357 _o$6358 _o$6359 _o$6360 _o$6361 _o$6362))))) node)) node)) node)))))) try-inline) (let* ((_o$6363 (keyword #f "doc")) (_o$6364 "node is an :invoke whose children are already inlined. If its :fn is a var\n  with a stashed, in-budget, arity-matching inline body, return the spliced\n  let; else node.")) (jolt-hash-map _o$6363 _o$6364))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec6363 ((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 fnrec6364 ((c c)) (inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6365 ((c c)) (inline-node c ctx))) node)))))) inline-node) (let* ((_o$6366 (keyword #f "doc")) (_o$6367 "Bottom-up: inline children first, then attempt to inline this node.")) (jolt-hash-map _o$6366 _o$6367))))
+  (def-var-with-meta! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec6365 ((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 fnrec6366 ((c c)) (inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6367 ((c c)) (inline-node c ctx))) node)))))) inline-node) (let* ((_o$6368 (keyword #f "doc")) (_o$6369 "Bottom-up: inline children first, then attempt to inline this node.")) (jolt-hash-map _o$6368 _o$6369))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec6368 ((binds binds)) (let* ((_a$6374 (lambda (out b) (let fnrec6369 ((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$6372 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$6373 (let* ((_o$6370 nm) (_o$6371 (jolt-get init (keyword #f "body")))) (jolt-vector _o$6370 _o$6371)))) (jolt-conj _a$6372 _a$6373))) (jolt-conj out b)))))) (_a$6375 (jolt-vector)) (_a$6376 binds)) (jolt-reduce _a$6374 _a$6375 _a$6376)))))) flatten-let-bindings)))
+  (def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec6370 ((binds binds)) (let* ((_a$6376 (lambda (out b) (let fnrec6371 ((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$6374 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$6375 (let* ((_o$6372 nm) (_o$6373 (jolt-get init (keyword #f "body")))) (jolt-vector _o$6372 _o$6373)))) (jolt-conj _a$6374 _a$6375))) (jolt-conj out b)))))) (_a$6377 (jolt-vector)) (_a$6378 binds)) (jolt-reduce _a$6376 _a$6377 _a$6378)))))) flatten-let-bindings)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "flatten-lets" (letrec ((flatten-lets (lambda (node) (let fnrec6377 ((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 fnrec6379 ((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$6378 "+") (_o$6379 "-") (_o$6380 "*") (_o$6381 "/") (_o$6382 "<") (_o$6383 ">") (_o$6384 "<=") (_o$6385 ">=") (_o$6386 "=") (_o$6387 "not=") (_o$6388 "inc") (_o$6389 "dec") (_o$6390 "mod") (_o$6391 "rem") (_o$6392 "quot") (_o$6393 "min") (_o$6394 "max") (_o$6395 "abs") (_o$6396 "nil?") (_o$6397 "some?") (_o$6398 "not") (_o$6399 "get") (_o$6400 "zero?") (_o$6401 "pos?") (_o$6402 "neg?") (_o$6403 "even?") (_o$6404 "odd?") (_o$6405 "bit-and") (_o$6406 "bit-or") (_o$6407 "bit-xor")) (jolt-hash-set _o$6378 _o$6379 _o$6380 _o$6381 _o$6382 _o$6383 _o$6384 _o$6385 _o$6386 _o$6387 _o$6388 _o$6389 _o$6390 _o$6391 _o$6392 _o$6393 _o$6394 _o$6395 _o$6396 _o$6397 _o$6398 _o$6399 _o$6400 _o$6401 _o$6402 _o$6403 _o$6404 _o$6405 _o$6406 _o$6407)) (let* ((_o$6408 (keyword #f "private")) (_o$6409 #t)) (jolt-hash-map _o$6408 _o$6409))))
+  (def-var-with-meta! "jolt.passes.inline" "pure-fns" (let* ((_o$6380 "+") (_o$6381 "-") (_o$6382 "*") (_o$6383 "/") (_o$6384 "<") (_o$6385 ">") (_o$6386 "<=") (_o$6387 ">=") (_o$6388 "=") (_o$6389 "not=") (_o$6390 "inc") (_o$6391 "dec") (_o$6392 "mod") (_o$6393 "rem") (_o$6394 "quot") (_o$6395 "min") (_o$6396 "max") (_o$6397 "abs") (_o$6398 "nil?") (_o$6399 "some?") (_o$6400 "not") (_o$6401 "get") (_o$6402 "zero?") (_o$6403 "pos?") (_o$6404 "neg?") (_o$6405 "even?") (_o$6406 "odd?") (_o$6407 "bit-and") (_o$6408 "bit-or") (_o$6409 "bit-xor")) (jolt-hash-set _o$6380 _o$6381 _o$6382 _o$6383 _o$6384 _o$6385 _o$6386 _o$6387 _o$6388 _o$6389 _o$6390 _o$6391 _o$6392 _o$6393 _o$6394 _o$6395 _o$6396 _o$6397 _o$6398 _o$6399 _o$6400 _o$6401 _o$6402 _o$6403 _o$6404 _o$6405 _o$6406 _o$6407 _o$6408 _o$6409)) (let* ((_o$6410 (keyword #f "private")) (_o$6411 #t)) (jolt-hash-map _o$6410 _o$6411))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "pure-fn?" (letrec ((pure-fn? (lambda (f) (let fnrec6410 ((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__25__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) and__25__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 fnrec6412 ((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__25__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) and__25__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-with-meta! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec6411 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__25__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__25__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 fnrec6412 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (pure? c) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?) (let* ((_o$6413 (keyword #f "doc")) (_o$6414 "Conservative: true only for expressions with no side effects that are safe to\n  duplicate or discard. A var/host ref is a pure read; an invoke is pure for a\n  known-pure fn (arithmetic, comparison, keyword lookup, get) or a record\n  constructor (an immutable struct alloc) whose args are themselves pure.")) (jolt-hash-map _o$6413 _o$6414))))
+  (def-var-with-meta! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec6413 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__25__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__25__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 fnrec6414 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (pure? c) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?) (let* ((_o$6415 (keyword #f "doc")) (_o$6416 "Conservative: true only for expressions with no side effects that are safe to\n  duplicate or discard. A var/host ref is a pure read; an invoke is pure for a\n  known-pure fn (arithmetic, comparison, keyword lookup, get) or a record\n  constructor (an immutable struct alloc) whose args are themselves pure.")) (jolt-hash-map _o$6415 _o$6416))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec6415 ((node node)) (let* ((prs (jolt-get node (keyword #f "pairs")))) (let* ((and__25__auto (> (jolt-count prs) 0))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec6416 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__25__auto))))))) const-key-map?)))
+  (def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec6417 ((node node)) (let* ((prs (jolt-get node (keyword #f "pairs")))) (let* ((and__25__auto (> (jolt-count prs) 0))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec6418 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__25__auto))))))) const-key-map?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec6417 ((node node)) (let* ((_a$6419 (var-deref "clojure.core" "every?")) (_a$6420 (lambda (pr) (let fnrec6418 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$6421 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6419 _a$6420 _a$6421)))))) all-vals-pure?)))
+  (def-var! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec6419 ((node node)) (let* ((_a$6421 (var-deref "clojure.core" "every?")) (_a$6422 (lambda (pr) (let fnrec6420 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$6423 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6421 _a$6422 _a$6423)))))) all-vals-pure?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec6422 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop6423 ((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) (loop6423 (jolt-inc i)))) (let* ((_o$6424 (keyword #f "op")) (_o$6425 (keyword #f "const")) (_o$6426 (keyword #f "val")) (_o$6427 jolt-nil)) (jolt-hash-map _o$6424 _o$6425 _o$6426 _o$6427)))))))))) map-val) (let* ((_o$6428 (keyword #f "doc")) (_o$6429 "The value IR at scalar key k in a const-key map node, or a nil constant when k\n  is absent (struct-eligible literal: a missing key reads nil, like the back end).")) (jolt-hash-map _o$6428 _o$6429))))
+  (def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec6424 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop6425 ((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) (loop6425 (jolt-inc i)))) (let* ((_o$6426 (keyword #f "op")) (_o$6427 (keyword #f "const")) (_o$6428 (keyword #f "val")) (_o$6429 jolt-nil)) (jolt-hash-map _o$6426 _o$6427 _o$6428 _o$6429)))))))))) map-val) (let* ((_o$6430 (keyword #f "doc")) (_o$6431 "The value IR at scalar key k in a const-key map node, or a nil constant when k\n  is absent (struct-eligible literal: a missing key reads nil, like the back end).")) (jolt-hash-map _o$6430 _o$6431))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec6430 ((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__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key) (let* ((_o$6431 (keyword #f "doc")) (_o$6432 "If node is a constant-keyword lookup of (:local nm) \x2014; either (:k nm) or\n  (get nm :k) \x2014; return the keyword k; else nil.")) (jolt-hash-map _o$6431 _o$6432))))
+  (def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec6432 ((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__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key) (let* ((_o$6433 (keyword #f "doc")) (_o$6434 "If node is a constant-keyword lookup of (:local nm) \x2014; either (:k nm) or\n  (get nm :k) \x2014; return the keyword k; else nil.")) (jolt-hash-map _o$6433 _o$6434))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec6433 ((binds binds) (nm nm)) (let* ((i 0)) (let loop6434 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop6434 (jolt-inc i))) #f))))))) any-binding-named?)))
+  (def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec6435 ((binds binds) (nm nm)) (let* ((i 0)) (let loop6436 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop6436 (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 fnrec6435 ((names names) (nm nm)) (let* ((i 0)) (let loop6436 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop6436 (jolt-inc i))) #f))))))) any-name?)))
+  (def-var! "jolt.passes.inline" "any-name?" (letrec ((any-name? (lambda (names nm) (let fnrec6437 ((names names) (nm nm)) (let* ((i 0)) (let loop6438 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop6438 (jolt-inc i))) #f))))))) any-name?)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec6437 ((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 loop6438 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop6438 (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__26__auto (local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__26__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop6439 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop6439 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop6440 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6440 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6441 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6441 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6442 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6442 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop6443 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop6443 (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__26__auto (let* ((i 0)) (let loop6444 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6444 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (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 loop6445 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6445 (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__26__auto (let* ((i 0)) (let loop6446 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6446 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (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 loop6447 ((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__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop6447 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__25__auto cb)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__25__auto) (local-escapes? cb nm) and__25__auto)) and__25__auto))))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__25__auto f)) (if (jolt-truthy? and__25__auto) (local-escapes? f nm) and__25__auto))))))) (if (jolt= op (keyword #f "def")) (local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?) (let* ((_o$6448 (keyword #f "doc")) (_o$6449 "Does local nm escape in node \x2014; i.e. is it used anywhere other than as the\n  subject of a constant-keyword lookup? Precise over straight-line expression\n  ops; conservatively true for loop/fn/try/recur/def (and any rebinding of nm),\n  so scalar replacement only fires where the whole use region is simple.\n\n  Stays an explicit per-op walk (not the shared reduce-ir-children fold): its\n  default is conservatively TRUE, and the lookup-subject and rebinding cases\n  inspect node shape beyond child purity \x2014; folding an unhandled op over its\n  children would under-report escape and is unsound for scalar replacement.")) (jolt-hash-map _o$6448 _o$6449))))
+  (def-var-with-meta! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec6439 ((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 loop6440 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop6440 (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__26__auto (local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__26__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop6441 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop6441 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop6442 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6442 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6443 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6443 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6444 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6444 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop6445 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop6445 (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__26__auto (let* ((i 0)) (let loop6446 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6446 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (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 loop6447 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6447 (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__26__auto (let* ((i 0)) (let loop6448 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6448 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (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 loop6449 ((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__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop6449 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__25__auto cb)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__25__auto) (local-escapes? cb nm) and__25__auto)) and__25__auto))))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__25__auto f)) (if (jolt-truthy? and__25__auto) (local-escapes? f nm) and__25__auto))))))) (if (jolt= op (keyword #f "def")) (local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?) (let* ((_o$6450 (keyword #f "doc")) (_o$6451 "Does local nm escape in node \x2014; i.e. is it used anywhere other than as the\n  subject of a constant-keyword lookup? Precise over straight-line expression\n  ops; conservatively true for loop/fn/try/recur/def (and any rebinding of nm),\n  so scalar replacement only fires where the whole use region is simple.\n\n  Stays an explicit per-op walk (not the shared reduce-ir-children fold): its\n  default is conservatively TRUE, and the lookup-subject and rebinding cases\n  inspect node shape beyond child purity \x2014; folding an unhandled op over its\n  children would under-report escape and is unsound for scalar replacement.")) (jolt-hash-map _o$6450 _o$6451))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec6450 ((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$6455 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$6456 (let* ((_a$6451 (var-deref "clojure.core" "str")) (_a$6452 (jolt-get f (keyword #f "ns"))) (_a$6453 "/") (_a$6454 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6451 _a$6452 _a$6453 _a$6454)))) (jolt-get _a$6455 _a$6456)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$6457 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$6458 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$6457 _a$6458)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$6459 (keyword #f "doc")) (_o$6460 "If node is a record-constructor :invoke (its :fn a :var whose ns/name is a\n  registered ctor key, with arg count matching the declared field count), return\n  that record's shape entry; else nil.")) (jolt-hash-map _o$6459 _o$6460))))
+  (def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec6452 ((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$6457 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$6458 (let* ((_a$6453 (var-deref "clojure.core" "str")) (_a$6454 (jolt-get f (keyword #f "ns"))) (_a$6455 "/") (_a$6456 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6453 _a$6454 _a$6455 _a$6456)))) (jolt-get _a$6457 _a$6458)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$6459 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$6460 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$6459 _a$6460)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$6461 (keyword #f "doc")) (_o$6462 "If node is a record-constructor :invoke (its :fn a :var whose ns/name is a\n  registered ctor key, with arg count matching the declared field count), return\n  that record's shape entry; else nil.")) (jolt-hash-map _o$6461 _o$6462))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec6461 ((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 fnrec6463 ((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-with-meta! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec6462 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop6463 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop6463 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$6464 (keyword #f "doc")) (_o$6465 "Index of scalar key k in the declared field tuple fields, or nil.")) (jolt-hash-map _o$6464 _o$6465))))
+  (def-var-with-meta! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec6464 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop6465 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop6465 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$6466 (keyword #f "doc")) (_o$6467 "Index of scalar key k in the declared field tuple fields, or nil.")) (jolt-hash-map _o$6466 _o$6467))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec6466 ((ctor ctor) (rs rs) (k k)) (let* ((_a$6467 (jolt-get ctor (keyword #f "args"))) (_a$6468 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$6467 _a$6468)))))) ctor-val) (let* ((_o$6469 (keyword #f "doc")) (_o$6470 "The positional arg IR at declared field k of record ctor node (shape rs). Only\n  called for a key known to be a field, so the index is always present.")) (jolt-hash-map _o$6469 _o$6470))))
+  (def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec6468 ((ctor ctor) (rs rs) (k k)) (let* ((_a$6469 (jolt-get ctor (keyword #f "args"))) (_a$6470 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$6469 _a$6470)))))) ctor-val) (let* ((_o$6471 (keyword #f "doc")) (_o$6472 "The positional arg IR at declared field k of record ctor node (shape rs). Only\n  called for a key known to be a field, so the index is always present.")) (jolt-hash-map _o$6471 _o$6472))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec6471 ((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 fnrec6472 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$6473 (keyword #f "doc")) (_o$6474 "Accumulate (into atom acc) every constant-keyword lookup key applied to local\n  nm in node. The caller has proven (via local-escapes?) that nm appears only as\n  a lookup subject and is never rebound, so a uniform recursion suffices: at a\n  lookup of nm we record the key and stop (its subject is nm itself); elsewhere\n  we recurse into children.")) (jolt-hash-map _o$6473 _o$6474))))
+  (def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec6473 ((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 fnrec6474 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$6475 (keyword #f "doc")) (_o$6476 "Accumulate (into atom acc) every constant-keyword lookup key applied to local\n  nm in node. The caller has proven (via local-escapes?) that nm appears only as\n  a lookup subject and is never rebound, so a uniform recursion suffices: at a\n  lookup of nm we record the key and stop (its subject is nm itself); elsewhere\n  we recurse into children.")) (jolt-hash-map _o$6475 _o$6476))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec6475 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec6476 ((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$6478 (var-deref "clojure.core" "every?")) (_a$6479 (lambda (k) (let fnrec6477 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$6480 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$6478 _a$6479 _a$6480)))))) nodes))))) lookups-all-fields?) (let* ((_o$6481 (keyword #f "doc")) (_o$6482 "True if every lookup of nm across nodes uses a declared field in fields \x2014; the\n  record-only guard that keeps a :jolt/deftype/unknown-key read (not a positional\n  arg) from being folded to the wrong value.")) (jolt-hash-map _o$6481 _o$6482))))
+  (def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec6477 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec6478 ((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$6480 (var-deref "clojure.core" "every?")) (_a$6481 (lambda (k) (let fnrec6479 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$6482 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$6480 _a$6481 _a$6482)))))) nodes))))) lookups-all-fields?) (let* ((_o$6483 (keyword #f "doc")) (_o$6484 "True if every lookup of nm across nodes uses a declared field in fields \x2014; the\n  record-only guard that keeps a :jolt/deftype/unknown-key read (not a positional\n  arg) from being folded to the wrong value.")) (jolt-hash-map _o$6483 _o$6484))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec6483 ((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) (let* ((_o$6484 (keyword #f "doc")) (_o$6485 "Field value at k from a foldable struct source \x2014; a const-key map (absent key\n  -> nil, struct-map semantics) or a record ctor (k is always a declared field\n  here, guaranteed by lookups-all-fields?).")) (jolt-hash-map _o$6484 _o$6485))))
+  (def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec6485 ((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) (let* ((_o$6486 (keyword #f "doc")) (_o$6487 "Field value at k from a foldable struct source \x2014; a const-key map (absent key\n  -> nil, struct-map semantics) or a record ctor (k is always a declared field\n  here, guaranteed by lookups-all-fields?).")) (jolt-hash-map _o$6486 _o$6487))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec6486 ((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 fnrec6487 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$6488 (keyword #f "doc")) (_o$6489 "Replace every (:k nm)/(get nm :k) in node with the source value at k. The\n  caller guarantees (via local-escapes?) that nm is never rebound here and\n  appears only as a lookup subject, so no shadowing logic is needed.")) (jolt-hash-map _o$6488 _o$6489))))
+  (def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec6488 ((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 fnrec6489 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$6490 (keyword #f "doc")) (_o$6491 "Replace every (:k nm)/(get nm :k) in node with the source value at k. The\n  caller guarantees (via local-escapes?) that nm is never rebound here and\n  appears only as a lookup subject, so no shadowing logic is needed.")) (jolt-hash-map _o$6490 _o$6491))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec6490 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count args)) and__25__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__25__auto)) and__25__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__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__25__auto)) and__25__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) (let* ((_o$6491 (keyword #f "doc")) (_o$6492 "(a) (:k <source>) -> the value at k. <source> is a const-key pure map\n  ((:k {:k a ..}) -> a) or a pure record ctor ((:k (->Rec a ..)) -> the arg for\n  field k). Siblings are duplicated/discarded, so all must be pure; a record\n  lookup folds only for a declared field.")) (jolt-hash-map _o$6491 _o$6492))))
+  (def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec6492 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count args)) and__25__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__25__auto)) and__25__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__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__25__auto)) and__25__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) (let* ((_o$6493 (keyword #f "doc")) (_o$6494 "(a) (:k <source>) -> the value at k. <source> is a const-key pure map\n  ((:k {:k a ..}) -> a) or a pure record ctor ((:k (->Rec a ..)) -> the arg for\n  field k). Siblings are duplicated/discarded, so all must be pure; a record\n  lookup folds only for a declared field.")) (jolt-hash-map _o$6493 _o$6494))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec6493 ((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 loop6494 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__25__auto)) and__25__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto isrec)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__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__25__auto) (let* ((and__25__auto (jolt-not (let* ((j (jolt-inc i))) (let loop6495 ((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 (loop6495 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((_a$6500 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$6501 (jolt-conj (let* ((_a$6497 (var-deref "clojure.core" "mapv")) (_a$6498 (lambda (bb) (let fnrec6496 ((bb bb)) (jolt-nth bb 1)))) (_a$6499 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6497 _a$6498 _a$6499)) body)) (_a$6502 nm) (_a$6503 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$6500 _a$6501 _a$6502 _a$6503)))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$6507 (var-deref "clojure.core" "mapv")) (_a$6508 (lambda (bb) (let fnrec6504 ((bb bb)) (let* ((_o$6505 (jolt-nth bb 0)) (_o$6506 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$6505 _o$6506))))) (_a$6509 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6507 _a$6508 _a$6509))) (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)))) (loop6494 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$6510 (keyword #f "doc")) (_o$6511 "(b) Drop the first non-escaping let binding whose init is a foldable struct\n  source \x2014; a pure const-key map literal or a pure record ctor \x2014; substituting its\n  field reads into the remaining bindings and body. Fixpoint re-runs us for the\n  rest, so one elimination per call keeps it simple. For a record every lookup\n  of the binding must hit a declared field, else we keep the allocation.")) (jolt-hash-map _o$6510 _o$6511))))
+  (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec6495 ((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 loop6496 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__25__auto)) and__25__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto isrec)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__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__25__auto) (let* ((and__25__auto (jolt-not (let* ((j (jolt-inc i))) (let loop6497 ((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 (loop6497 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((_a$6502 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$6503 (jolt-conj (let* ((_a$6499 (var-deref "clojure.core" "mapv")) (_a$6500 (lambda (bb) (let fnrec6498 ((bb bb)) (jolt-nth bb 1)))) (_a$6501 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6499 _a$6500 _a$6501)) body)) (_a$6504 nm) (_a$6505 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$6502 _a$6503 _a$6504 _a$6505)))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$6509 (var-deref "clojure.core" "mapv")) (_a$6510 (lambda (bb) (let fnrec6506 ((bb bb)) (let* ((_o$6507 (jolt-nth bb 0)) (_o$6508 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$6507 _o$6508))))) (_a$6511 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6509 _a$6510 _a$6511))) (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)))) (loop6496 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$6512 (keyword #f "doc")) (_o$6513 "(b) Drop the first non-escaping let binding whose init is a foldable struct\n  source \x2014; a pure const-key map literal or a pure record ctor \x2014; substituting its\n  field reads into the remaining bindings and body. Fixpoint re-runs us for the\n  rest, so one elimination per call keeps it simple. For a record every lookup\n  of the binding must hit a declared field, else we keep the allocation.")) (jolt-hash-map _o$6512 _o$6513))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6512 ((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) (let* ((_o$6513 (keyword #f "doc")) (_o$6514 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6513 _o$6514))))
+  (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6514 ((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) (let* ((_o$6515 (keyword #f "doc")) (_o$6516 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6515 _o$6516))))
 (guard (e (#t #f))
   (def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec5835 ((t t)) (jolt-get t (keyword #f "vec")))))) velem)))
 (guard (e (#t #f))
@@ -459,7 +459,7 @@
 (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 fnrec5178 ((tag tag) (depth depth) (shapes shapes)) (if (let* ((or__26__auto (jolt-nil? tag))) (if (jolt-truthy? or__26__auto) or__26__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 fnrec5178 ((tag tag) (depth depth) (shapes shapes)) (if (let* ((or__26__auto (jolt-nil? tag))) (if (jolt-truthy? or__26__auto) or__26__auto (<= depth 0))) (keyword #f "any") (if (jolt= tag "num") (keyword #f "num") (if (jolt= tag "double") (keyword #f "double") (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 fnrec5179 ((rs rs) (depth depth) (shapes shapes)) (let* ((fields (jolt-get rs (keyword #f "fields"))) (tags (jolt-get rs (keyword #f "tags"))) (fmap (let* ((_a$5188 (lambda (m i) (let fnrec5180 ((m m) (i i)) (let* ((_a$5185 m) (_a$5186 (jolt-nth fields i)) (_a$5187 (let* ((_a$5181 (var-deref "jolt.passes.types" "field-type-from-tag")) (_a$5182 (if (jolt-truthy? tags) (jolt-nth tags i) jolt-nil)) (_a$5183 (jolt-dec depth)) (_a$5184 shapes)) (jolt-invoke _a$5181 _a$5182 _a$5183 _a$5184)))) (jolt-assoc _a$5185 _a$5186 _a$5187))))) (_a$5189 (jolt-hash-map)) (_a$5190 (jolt-range (jolt-count fields)))) (jolt-reduce _a$5188 _a$5189 _a$5190)))) (let* ((_a$5191 (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") fmap)) (_a$5192 (keyword #f "shape")) (_a$5193 (jolt-invoke (var-deref "clojure.core" "vec") fields)) (_a$5194 (keyword #f "type")) (_a$5195 (jolt-get rs (keyword #f "type")))) (jolt-assoc _a$5191 _a$5192 _a$5193 _a$5194 _a$5195))))))) record-type-from-entry)))
 (guard (e (#t #f))
@@ -497,9 +497,9 @@
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.types" "infer-pred-fold" (letrec ((infer-pred-fold (lambda (node fnode cn args tenv env) (let fnrec5303 ((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__25__auto (jolt-not (jolt-nil? v)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types" "pure-node?") (jolt-invoke (var-deref "jolt.passes.types" "nd") ar)) and__25__auto))) (let* ((_o$5308 (keyword #f "any")) (_o$5309 (let* ((_o$5304 (keyword #f "op")) (_o$5305 (keyword #f "const")) (_o$5306 (keyword #f "val")) (_o$5307 v)) (jolt-hash-map _o$5304 _o$5305 _o$5306 _o$5307)))) (jolt-vector _o$5308 _o$5309)) (let* ((_o$5310 (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env)) (_o$5311 (jolt-assoc node (keyword #f "args") (jolt-vector (jolt-invoke (var-deref "jolt.passes.types" "nd") ar))))) (jolt-vector _o$5310 _o$5311)))))))) infer-pred-fold) (let* ((_o$5312 (keyword #f "doc")) (_o$5313 "A type predicate over a single side-effect-free arg whose type PROVES the answer\n  folds to a boolean constant \x2014; eliminating the call, and (once const-fold runs\n  after inference) collapsing any `if` it gates. Falls back to the normal call path\n  when the answer isn't provable or the arg is impure.")) (jolt-hash-map _o$5312 _o$5313))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec5314 ((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$5317 (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$5318 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5315 msub) (_o$5316 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5315 _o$5316)) (jolt-vector msub))))) (jolt-vector _o$5317 _o$5318))))))) infer-kw-lookup) (let* ((_o$5319 (keyword #f "doc")) (_o$5320 "(:k m) / (:k m default): the result is m's field type, and if m is a struct the\n  subject is tagged so the back end drops the guard \x2014; this types nested access end\n  to end (RFC 0005).")) (jolt-hash-map _o$5319 _o$5320))))
+  (def-var-with-meta! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec5314 ((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)) (rt (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (node_PRIME_ (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5315 msub) (_o$5316 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5315 _o$5316)) (jolt-vector msub))))) (let* ((_o$5317 rt) (_o$5318 (if (jolt= rt (keyword #f "double")) (jolt-assoc node_PRIME_ (keyword #f "num-read") (keyword #f "double")) node_PRIME_))) (jolt-vector _o$5317 _o$5318))))))) infer-kw-lookup) (let* ((_o$5319 (keyword #f "doc")) (_o$5320 "(:k m) / (:k m default): the result is m's field type, and if m is a struct the\n  subject is tagged so the back end drops the guard \x2014; this types nested access end\n  to end (RFC 0005).")) (jolt-hash-map _o$5319 _o$5320))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec5321 ((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$5327 (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$5328 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5322 msub) (_o$5323 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$5324 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5322 _o$5323 _o$5324)) (let* ((_o$5325 msub) (_o$5326 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$5325 _o$5326)))))) (jolt-vector _o$5327 _o$5328))))))) infer-get-lookup) (let* ((_o$5329 (keyword #f "doc")) (_o$5330 "(get m :k [default]): the keyword-lookup result type, when the key is a constant\n  keyword.")) (jolt-hash-map _o$5329 _o$5330))))
+  (def-var-with-meta! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec5321 ((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)) (rt (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (node_PRIME_ (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5322 msub) (_o$5323 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$5324 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5322 _o$5323 _o$5324)) (let* ((_o$5325 msub) (_o$5326 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$5325 _o$5326)))))) (let* ((_o$5327 rt) (_o$5328 (if (jolt= rt (keyword #f "double")) (jolt-assoc node_PRIME_ (keyword #f "num-read") (keyword #f "double")) node_PRIME_))) (jolt-vector _o$5327 _o$5328))))))) infer-get-lookup) (let* ((_o$5329 (keyword #f "doc")) (_o$5330 "(get m :k [default]): the keyword-lookup result type, when the key is a constant\n  keyword.")) (jolt-hash-map _o$5329 _o$5330))))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.types" "infer-reduce-hof" (letrec ((infer-reduce-hof (lambda (node args n tenv env) (let fnrec5331 ((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$5336 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5337 (jolt-nth args 0)) (_a$5338 (let* ((_o$5332 0) (_o$5333 init-t) (_o$5334 1) (_o$5335 et)) (jolt-hash-map _o$5332 _o$5333 _o$5334 _o$5335))) (_a$5339 tenv) (_a$5340 env)) (jolt-invoke _a$5336 _a$5337 _a$5338 _a$5339 _a$5340)))) (let* ((_o$5346 (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") init-t (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r))) (_o$5347 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? three) (let* ((_o$5341 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5342 (jolt-invoke (var-deref "jolt.passes.types" "nd") init-r)) (_o$5343 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5341 _o$5342 _o$5343)) (let* ((_o$5344 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5345 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5344 _o$5345)))))) (jolt-vector _o$5346 _o$5347))))))) infer-reduce-hof) (let* ((_o$5348 (keyword #f "doc")) (_o$5349 "reduce over a typed vector with a fn-literal: seed the closure's accumulator\n  (param 0) to the init type and its element (param 1) to the vector's element\n  type, so its body \x2014; and any calls it makes \x2014; see those types.")) (jolt-hash-map _o$5348 _o$5349))))
 (guard (e (#t #f))
diff --git a/jolt-core/jolt/passes/numeric.clj b/jolt-core/jolt/passes/numeric.clj
index 4bcc422..01e6337 100644
--- a/jolt-core/jolt/passes/numeric.clj
+++ b/jolt-core/jolt/passes/numeric.clj
@@ -156,6 +156,10 @@
         node1 (assoc node :args argnodes)
         n (count ars)]
     (cond
+      ;; a field read the structural inference proved is a flonum (a ^double record
+      ;; field) is a :double operand — so (* (:x v) (:x v)) unboxes. The read itself
+      ;; isn't lowered here; it keeps its keyword/jrec-field-at emit.
+      (= :double (get node :num-read)) [:double node1]
       ;; a call to a var with a declared numeric return (^double/^long) yields that
       ;; kind, so an accumulator over the result types. The call itself isn't an
       ;; arithmetic op to lower — its body already coerces the return.
diff --git a/jolt-core/jolt/passes/types.clj b/jolt-core/jolt/passes/types.clj
index 47e4d9a..4eee573 100644
--- a/jolt-core/jolt/passes/types.clj
+++ b/jolt-core/jolt/passes/types.clj
@@ -69,6 +69,7 @@
   (cond
     (or (nil? tag) (<= depth 0)) :any
     (= tag "num") :num
+    (= tag "double") :double   ; a ^double field reads back as a flonum
     :else (let [e (get shapes tag)]
             (if e (record-type-from-entry e depth shapes) :any))))
 (defn- record-type-from-entry [rs depth shapes]
@@ -224,9 +225,13 @@
         mt (ty mr)
         msub (if (struct-safe? mt) (mark-struct (nd mr) mt) (nd mr))
         ft (field-type mt (get fnode :val))
-        dr (when (= n 2) (infer (nth args 1) tenv env))]
-    [(if dr (join ft (ty dr)) ft)
-     (assoc node :args (if dr [msub (nd dr)] [msub]))]))
+        dr (when (= n 2) (infer (nth args 1) tenv env))
+        rt (if dr (join ft (ty dr)) ft)
+        node' (assoc node :args (if dr [msub (nd dr)] [msub]))]
+    ;; a flonum field read is a :double operand for the numeric pass (fl-ops); the
+    ;; lookup itself still emits as a keyword/jrec-field-at read, this only feeds
+    ;; its kind up so (* (:x v) (:x v)) over a ^double-fielded record unboxes.
+    [rt (if (= rt :double) (assoc node' :num-read :double) node')]))
 
 (defn- infer-get-lookup
   "(get m :k [default]): the keyword-lookup result type, when the key is a constant
@@ -237,9 +242,10 @@
         msub (if (struct-safe? mt) (mark-struct (nd mr) mt) (nd mr))
         kr (infer (nth args 1) tenv env)
         ft (field-type mt (get (nth args 1) :val))
-        dr (when (= n 3) (infer (nth args 2) tenv env))]
-    [(if dr (join ft (ty dr)) ft)
-     (assoc node :args (if dr [msub (nd kr) (nd dr)] [msub (nd kr)]))]))
+        dr (when (= n 3) (infer (nth args 2) tenv env))
+        rt (if dr (join ft (ty dr)) ft)
+        node' (assoc node :args (if dr [msub (nd kr) (nd dr)] [msub (nd kr)]))]
+    [rt (if (= rt :double) (assoc node' :num-read :double) node')]))
 
 (defn- infer-reduce-hof
   "reduce over a typed vector with a fn-literal: seed the closure's accumulator