diff --git a/docs/tools-deps.md b/docs/tools-deps.md
index 45165e5..fc27c53 100644
--- a/docs/tools-deps.md
+++ b/docs/tools-deps.md
@@ -182,6 +182,20 @@ a root, transitively.
 - Source only; compiled `.class` files in a git dep are ignored.
 - git `:git/sha` must be a full SHA (`git fetch` can't resolve a short one).
 
+## Stack traces
+
+An uncaught error prints the message, the top-level source location, and — when
+frames are available — a `trace:` backtrace. In an AOT `jolt build --direct-link`
+binary the frames map to `ns/name (file:line)`; on the runtime eval path they are
+the surviving fn names. Tail-call optimization erases tail-called frames, so the
+default trace shows only the non-tail spine.
+
+Set `JOLT_TRACE=1` to opt into a fuller **tail-frame history**. Each compiled fn
+then records itself on entry into a bounded ring-of-rings buffer, so the trace
+recovers TCO-elided frames (including the immediate error site) while a tight tail
+loop stays bounded and its non-tail caller context is preserved. It costs a small
+per-call overhead, so it is off by default and never emitted into a built binary.
+
 ## Conformance
 
 The known-working libraries (see [libraries.md](libraries.md)) and the
diff --git a/host/chez/compile-eval.ss b/host/chez/compile-eval.ss
index 0f32954..95182ff 100644
--- a/host/chez/compile-eval.ss
+++ b/host/chez/compile-eval.ss
@@ -110,6 +110,13 @@
 ;; older seed during the first re-mint pass.
 (let ((scv (var-deref "jolt.backend-scheme" "set-var-cache!")))
   (when (procedure? scv) (scv #t)))
+;; JOLT_TRACE opts into tail-frame history: the emitter prepends a frame-recording
+;; push to every runtime-compiled fn, and the ring buffer is allocated for this
+;; thread. Off by default, so a normal run emits and pays exactly as before.
+(when (getenv "JOLT_TRACE")
+  (let ((stf (var-deref "jolt.backend-scheme" "set-trace-frames!")))
+    (when (procedure? stf) (stf #t)))
+  (jolt-trace-enable!))
 
 ;; (with-meta sym m) -> sym, else x — an (ns ^:no-doc name …) yields the name with
 ;; reader metadata as a with-meta form; strip it to read the bare ns symbol.
@@ -235,6 +242,9 @@
      ;; record this form's source location first, so a compile- or run-time error
      ;; in it reports the right place.
      (jolt-enter-form! form)
+     ;; drop tail-frame history from earlier top-level forms, so an error's trace
+     ;; shows only this form's own call history (a no-op unless JOLT_TRACE is on).
+     (jolt-trace-reset!)
      (eval (read (open-input-string (jolt-analyze-emit-form form ns)))
            (interaction-environment)))))
 
diff --git a/host/chez/emit-image.ss b/host/chez/emit-image.ss
index 286ad6a..a2489cc 100644
--- a/host/chez/emit-image.ss
+++ b/host/chez/emit-image.ss
@@ -46,6 +46,10 @@
 ;; after it). Guarded for the first re-mint pass off an older seed.
 (let ((scv (var-deref "jolt.backend-scheme" "set-var-cache!")))
   (when (procedure? scv) (scv #f)))
+;; Tail-frame tracing off for the mint + `jolt build`: the seed must stay a
+;; byte-fixpoint, and a built app should carry no per-call trace overhead.
+(let ((stf (var-deref "jolt.backend-scheme" "set-trace-frames!")))
+  (when (procedure? stf) (stf #f)))
 (define (ei-compile-form ctx f optimize?)
   (let ((ir (jolt-ce-analyze ctx f)))
     (jolt-ce-emit-top (if optimize? (jolt-ce-run-passes ir ctx) ir))))
diff --git a/host/chez/rt.ss b/host/chez/rt.ss
index 687ca15..0649697 100644
--- a/host/chez/rt.ss
+++ b/host/chez/rt.ss
@@ -60,6 +60,112 @@
 ;; stack trace (source-registry.ss). call/cc is paid only on a throw, never per
 ;; call; the captured k is walked, never invoked.
 (define jolt-throw-cont (make-thread-parameter #f))
+
+;; --- tail-frame history: a ring of rings (opt-in) ----------------------------
+;; TCO erases tail-called frames from the native continuation, so an uncaught
+;; error's backtrace shows only the surviving non-tail spine — the immediate error
+;; site is often a tail call and is missing. When tracing is enabled (JOLT_TRACE,
+;; wired in compile-eval.ss), each compiled fn records its frame-name on entry, and
+;; the reporter reads this history to recover TCO-elided frames.
+;;
+;; The store is MIT-Scheme's "history" shape — a ring of rings. The OUTER ring
+;; holds one RIB per non-tail subproblem (the real call spine); each rib's INNER
+;; ring holds the recent tail-calls made AT that subproblem. A non-tail entry
+;; advances the outer ring (a fresh rib); a tail entry rotates the current rib's
+;; inner ring. So a tight tail loop (mutual recursion, a non-recur self-tail-call)
+;; churns ONE rib's small inner ring instead of flushing the outer spine — the
+;; caller context that led into the loop survives. Both rings are fixed-size, so
+;; the whole history is bounded: a constant space factor, NOT a change to the
+;; asymptotic space TCO guarantees.
+;;
+;; Whether an entry is tail or non-tail is set by the CALLER: the emitter marks a
+;; tail call with (jolt-trace-mark! #t) right before it; a non-tail entry is the
+;; default. NOTE this is best-effort: a tail call routed through jolt-invoke to a
+;; target that has no entry prologue (a core/native fn, an anonymous fn held in a
+;; var) does not consume the mark, so a following non-tail frame can be mislabeled
+;; as a tail rotation — a cosmetic mis-grouping in the trace, never a wrong result.
+(define jolt-trace-outer-size 48)          ; ribs (non-tail spine depth kept)
+(define jolt-trace-inner-size 6)           ; tail-calls kept per subproblem
+;; A history: #(ribs-vector outer-head outer-count). A rib: #(name-vector head count).
+(define (jolt-make-rib) (vector (make-vector jolt-trace-inner-size #f) 0 0))
+(define (jolt-make-history)
+  (let ((ribs (make-vector jolt-trace-outer-size #f)))
+    (let loop ((i 0))
+      (when (fx<? i jolt-trace-outer-size)
+        (vector-set! ribs i (jolt-make-rib)) (loop (fx+ i 1))))
+    (vector ribs 0 0)))
+;; A global switch (all threads) plus a per-thread ring, lazily created on first
+;; use — so code run on a spawned thread (a future/agent) records into ITS OWN
+;; history, not the enabling thread's (make-thread-parameter hands a new thread the
+;; initial #f, so we can't rely on inheritance).
+(define jolt-trace-on? #f)
+(define jolt-trace-ring (make-thread-parameter #f))
+(define jolt-trace-tail? (make-thread-parameter #f))   ; caller-set, consumed per entry
+(define (jolt-trace-enable!) (set! jolt-trace-on? #t) (jolt-trace-ring (jolt-make-history)))
+;; this thread's ring, created on demand while tracing is on
+(define (jolt-trace-cur-ring)
+  (or (jolt-trace-ring)
+      (and jolt-trace-on? (let ((h (jolt-make-history))) (jolt-trace-ring h) h))))
+;; Drop accumulated history at a top-level boundary (compile-eval.ss calls this per
+;; top-level form) so an error's trace shows only the forms that led to it, not the
+;; frames of earlier, already-returned REPL/eval forms.
+(define (jolt-trace-reset!)
+  (when (jolt-trace-ring) (jolt-trace-ring (jolt-make-history)) (jolt-trace-tail? #f)))
+(define (jolt-trace-mark! t) (jolt-trace-tail? t))
+
+;; push name into a rib's inner ring
+(define (jolt-rib-push! rib name)
+  (let ((buf (vector-ref rib 0)) (i (vector-ref rib 1)) (cnt (vector-ref rib 2)))
+    (vector-set! buf i name)
+    (vector-set! rib 1 (fxmod (fx+ i 1) jolt-trace-inner-size))
+    (when (fx<? cnt jolt-trace-inner-size) (vector-set! rib 2 (fx+ cnt 1)))))
+;; a non-tail entry: advance the outer ring, reset the new rib, seed it with name
+(define (jolt-history-nontail! h name)
+  (let* ((ribs (vector-ref h 0)) (oh (vector-ref h 1)) (oc (vector-ref h 2))
+         (rib (vector-ref ribs oh)))
+    (vector-set! rib 1 0) (vector-set! rib 2 0)
+    (jolt-rib-push! rib name)
+    (vector-set! h 1 (fxmod (fx+ oh 1) jolt-trace-outer-size))
+    (when (fx<? oc jolt-trace-outer-size) (vector-set! h 2 (fx+ oc 1)))))
+;; a tail entry: rotate the CURRENT rib's inner ring (bootstrap a rib if none yet)
+(define (jolt-history-tail! h name)
+  (if (fx=? (vector-ref h 2) 0)
+      (jolt-history-nontail! h name)
+      (let* ((ribs (vector-ref h 0))
+             (cur (fxmod (fx+ (fx- (vector-ref h 1) 1) jolt-trace-outer-size)
+                         jolt-trace-outer-size)))
+        (jolt-rib-push! (vector-ref ribs cur) name))))
+;; Record a frame entry, routed by the caller's tail mark; then reset the mark so a
+;; subsequent entry reached WITHOUT a mark (e.g. via apply) defaults to non-tail.
+(define (jolt-trace-push! name)
+  (let ((h (jolt-trace-cur-ring)))
+    (when h
+      (if (jolt-trace-tail?) (jolt-history-tail! h name) (jolt-history-nontail! h name))
+      (jolt-trace-tail? #f)))
+  jolt-nil)
+
+;; a rib's inner names, most-recent (deepest) tail first
+(define (jolt-rib-names rib)
+  (let ((buf (vector-ref rib 0)) (head (vector-ref rib 1)) (cnt (vector-ref rib 2)))
+    (let loop ((k 1) (acc '()))
+      (if (fx>? k cnt)
+          (reverse acc)
+          (loop (fx+ k 1)
+                (cons (vector-ref buf (fxmod (fx+ (fx- head k) jolt-trace-inner-size)
+                                             jolt-trace-inner-size))
+                      acc))))))
+;; The whole history flattened to frame-names, most-recent (deepest) first:
+;; current rib's tail-history, then its non-tail caller's, and so on outward.
+(define (jolt-trace-snapshot)
+  (let ((h (jolt-trace-ring)))
+    (if (not h) '()
+        (let* ((ribs (vector-ref h 0)) (oh (vector-ref h 1)) (oc (vector-ref h 2)))
+          (let loop ((k 1) (acc '()))
+            (if (fx>? k oc)
+                (apply append (reverse acc))
+                (let ((idx (fxmod (fx+ (fx- oh k) jolt-trace-outer-size) jolt-trace-outer-size)))
+                  (loop (fx+ k 1) (cons (jolt-rib-names (vector-ref ribs idx)) acc)))))))))
+
 (define-condition-type &jolt-throw &condition
   make-jolt-throw-condition jolt-throw-condition?
   (value jolt-throw-condition-value))
diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss
index 6b02da9..885e512 100644
--- a/host/chez/seed/image.ss
+++ b/host/chez/seed/image.ss
@@ -1,133 +1,133 @@
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec8427 ((v v)) (let* ((_o$8428 (keyword #f "op")) (_o$8429 (keyword #f "const")) (_o$8430 (keyword #f "val")) (_o$8431 v)) (jolt-hash-map _o$8428 _o$8429 _o$8430 _o$8431)))))) const)))
+  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec8440 ((v v)) (let* ((_o$8441 (keyword #f "op")) (_o$8442 (keyword #f "const")) (_o$8443 (keyword #f "val")) (_o$8444 v)) (jolt-hash-map _o$8441 _o$8442 _o$8443 _o$8444)))))) const)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec8432 ((name name)) (let* ((_o$8433 (keyword #f "op")) (_o$8434 (keyword #f "local")) (_o$8435 (keyword #f "name")) (_o$8436 name)) (jolt-hash-map _o$8433 _o$8434 _o$8435 _o$8436)))))) local)))
+  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec8445 ((name name)) (let* ((_o$8446 (keyword #f "op")) (_o$8447 (keyword #f "local")) (_o$8448 (keyword #f "name")) (_o$8449 name)) (jolt-hash-map _o$8446 _o$8447 _o$8448 _o$8449)))))) local)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec8437 ((ns ns) (name name)) (let* ((_o$8438 (keyword #f "op")) (_o$8439 (keyword #f "var")) (_o$8440 (keyword #f "ns")) (_o$8441 ns) (_o$8442 (keyword #f "name")) (_o$8443 name)) (jolt-hash-map _o$8438 _o$8439 _o$8440 _o$8441 _o$8442 _o$8443)))))) var-ref)))
+  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec8450 ((ns ns) (name name)) (let* ((_o$8451 (keyword #f "op")) (_o$8452 (keyword #f "var")) (_o$8453 (keyword #f "ns")) (_o$8454 ns) (_o$8455 (keyword #f "name")) (_o$8456 name)) (jolt-hash-map _o$8451 _o$8452 _o$8453 _o$8454 _o$8455 _o$8456)))))) var-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec8444 ((ns ns) (name name)) (let* ((_o$8445 (keyword #f "op")) (_o$8446 (keyword #f "the-var")) (_o$8447 (keyword #f "ns")) (_o$8448 ns) (_o$8449 (keyword #f "name")) (_o$8450 name)) (jolt-hash-map _o$8445 _o$8446 _o$8447 _o$8448 _o$8449 _o$8450)))))) the-var)))
+  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec8457 ((ns ns) (name name)) (let* ((_o$8458 (keyword #f "op")) (_o$8459 (keyword #f "the-var")) (_o$8460 (keyword #f "ns")) (_o$8461 ns) (_o$8462 (keyword #f "name")) (_o$8463 name)) (jolt-hash-map _o$8458 _o$8459 _o$8460 _o$8461 _o$8462 _o$8463)))))) the-var)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec8451 ((name name)) (let* ((_o$8452 (keyword #f "op")) (_o$8453 (keyword #f "host")) (_o$8454 (keyword #f "name")) (_o$8455 name)) (jolt-hash-map _o$8452 _o$8453 _o$8454 _o$8455)))))) host-ref)))
+  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec8464 ((name name)) (let* ((_o$8465 (keyword #f "op")) (_o$8466 (keyword #f "host")) (_o$8467 (keyword #f "name")) (_o$8468 name)) (jolt-hash-map _o$8465 _o$8466 _o$8467 _o$8468)))))) host-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec8456 ((class class) (member member)) (let* ((_o$8457 (keyword #f "op")) (_o$8458 (keyword #f "host-static")) (_o$8459 (keyword #f "class")) (_o$8460 class) (_o$8461 (keyword #f "member")) (_o$8462 member)) (jolt-hash-map _o$8457 _o$8458 _o$8459 _o$8460 _o$8461 _o$8462)))))) host-static)))
+  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec8469 ((class class) (member member)) (let* ((_o$8470 (keyword #f "op")) (_o$8471 (keyword #f "host-static")) (_o$8472 (keyword #f "class")) (_o$8473 class) (_o$8474 (keyword #f "member")) (_o$8475 member)) (jolt-hash-map _o$8470 _o$8471 _o$8472 _o$8473 _o$8474 _o$8475)))))) host-static)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec8463 ((class class) (args args)) (let* ((_o$8464 (keyword #f "op")) (_o$8465 (keyword #f "host-new")) (_o$8466 (keyword #f "class")) (_o$8467 class) (_o$8468 (keyword #f "args")) (_o$8469 args)) (jolt-hash-map _o$8464 _o$8465 _o$8466 _o$8467 _o$8468 _o$8469)))))) host-new)))
+  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec8476 ((class class) (args args)) (let* ((_o$8477 (keyword #f "op")) (_o$8478 (keyword #f "host-new")) (_o$8479 (keyword #f "class")) (_o$8480 class) (_o$8481 (keyword #f "args")) (_o$8482 args)) (jolt-hash-map _o$8477 _o$8478 _o$8479 _o$8480 _o$8481 _o$8482)))))) host-new)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec8470 ((test test) (then then) (_else _else)) (let* ((_o$8471 (keyword #f "op")) (_o$8472 (keyword #f "if")) (_o$8473 (keyword #f "test")) (_o$8474 test) (_o$8475 (keyword #f "then")) (_o$8476 then) (_o$8477 (keyword #f "else")) (_o$8478 _else)) (jolt-hash-map _o$8471 _o$8472 _o$8473 _o$8474 _o$8475 _o$8476 _o$8477 _o$8478)))))) if-node)))
+  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec8483 ((test test) (then then) (_else _else)) (let* ((_o$8484 (keyword #f "op")) (_o$8485 (keyword #f "if")) (_o$8486 (keyword #f "test")) (_o$8487 test) (_o$8488 (keyword #f "then")) (_o$8489 then) (_o$8490 (keyword #f "else")) (_o$8491 _else)) (jolt-hash-map _o$8484 _o$8485 _o$8486 _o$8487 _o$8488 _o$8489 _o$8490 _o$8491)))))) if-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec8479 ((statements statements) (ret ret)) (let* ((_o$8480 (keyword #f "op")) (_o$8481 (keyword #f "do")) (_o$8482 (keyword #f "statements")) (_o$8483 statements) (_o$8484 (keyword #f "ret")) (_o$8485 ret)) (jolt-hash-map _o$8480 _o$8481 _o$8482 _o$8483 _o$8484 _o$8485)))))) do-node)))
+  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec8492 ((statements statements) (ret ret)) (let* ((_o$8493 (keyword #f "op")) (_o$8494 (keyword #f "do")) (_o$8495 (keyword #f "statements")) (_o$8496 statements) (_o$8497 (keyword #f "ret")) (_o$8498 ret)) (jolt-hash-map _o$8493 _o$8494 _o$8495 _o$8496 _o$8497 _o$8498)))))) do-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec8486 ((f f) (args args)) (let* ((_o$8487 (keyword #f "op")) (_o$8488 (keyword #f "invoke")) (_o$8489 (keyword #f "fn")) (_o$8490 f) (_o$8491 (keyword #f "args")) (_o$8492 args)) (jolt-hash-map _o$8487 _o$8488 _o$8489 _o$8490 _o$8491 _o$8492)))))) invoke)))
+  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec8499 ((f f) (args args)) (let* ((_o$8500 (keyword #f "op")) (_o$8501 (keyword #f "invoke")) (_o$8502 (keyword #f "fn")) (_o$8503 f) (_o$8504 (keyword #f "args")) (_o$8505 args)) (jolt-hash-map _o$8500 _o$8501 _o$8502 _o$8503 _o$8504 _o$8505)))))) invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec8493 ((ns ns) (name name) (init init)) (let* ((_o$8494 (keyword #f "op")) (_o$8495 (keyword #f "def")) (_o$8496 (keyword #f "ns")) (_o$8497 ns) (_o$8498 (keyword #f "name")) (_o$8499 name) (_o$8500 (keyword #f "init")) (_o$8501 init)) (jolt-hash-map _o$8494 _o$8495 _o$8496 _o$8497 _o$8498 _o$8499 _o$8500 _o$8501)))) ((ns name init meta) (let fnrec8502 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$8503 (keyword #f "op")) (_o$8504 (keyword #f "def")) (_o$8505 (keyword #f "ns")) (_o$8506 ns) (_o$8507 (keyword #f "name")) (_o$8508 name) (_o$8509 (keyword #f "init")) (_o$8510 init) (_o$8511 (keyword #f "meta")) (_o$8512 meta)) (jolt-hash-map _o$8503 _o$8504 _o$8505 _o$8506 _o$8507 _o$8508 _o$8509 _o$8510 _o$8511 _o$8512)) (let* ((_o$8513 (keyword #f "op")) (_o$8514 (keyword #f "def")) (_o$8515 (keyword #f "ns")) (_o$8516 ns) (_o$8517 (keyword #f "name")) (_o$8518 name) (_o$8519 (keyword #f "init")) (_o$8520 init)) (jolt-hash-map _o$8513 _o$8514 _o$8515 _o$8516 _o$8517 _o$8518 _o$8519 _o$8520)))))))) def-node)))
+  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec8506 ((ns ns) (name name) (init init)) (let* ((_o$8507 (keyword #f "op")) (_o$8508 (keyword #f "def")) (_o$8509 (keyword #f "ns")) (_o$8510 ns) (_o$8511 (keyword #f "name")) (_o$8512 name) (_o$8513 (keyword #f "init")) (_o$8514 init)) (jolt-hash-map _o$8507 _o$8508 _o$8509 _o$8510 _o$8511 _o$8512 _o$8513 _o$8514)))) ((ns name init meta) (let fnrec8515 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$8516 (keyword #f "op")) (_o$8517 (keyword #f "def")) (_o$8518 (keyword #f "ns")) (_o$8519 ns) (_o$8520 (keyword #f "name")) (_o$8521 name) (_o$8522 (keyword #f "init")) (_o$8523 init) (_o$8524 (keyword #f "meta")) (_o$8525 meta)) (jolt-hash-map _o$8516 _o$8517 _o$8518 _o$8519 _o$8520 _o$8521 _o$8522 _o$8523 _o$8524 _o$8525)) (let* ((_o$8526 (keyword #f "op")) (_o$8527 (keyword #f "def")) (_o$8528 (keyword #f "ns")) (_o$8529 ns) (_o$8530 (keyword #f "name")) (_o$8531 name) (_o$8532 (keyword #f "init")) (_o$8533 init)) (jolt-hash-map _o$8526 _o$8527 _o$8528 _o$8529 _o$8530 _o$8531 _o$8532 _o$8533)))))))) def-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec8521 ((bindings bindings) (body body)) (let* ((_o$8522 (keyword #f "op")) (_o$8523 (keyword #f "let")) (_o$8524 (keyword #f "bindings")) (_o$8525 bindings) (_o$8526 (keyword #f "body")) (_o$8527 body)) (jolt-hash-map _o$8522 _o$8523 _o$8524 _o$8525 _o$8526 _o$8527)))))) let-node)))
+  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec8534 ((bindings bindings) (body body)) (let* ((_o$8535 (keyword #f "op")) (_o$8536 (keyword #f "let")) (_o$8537 (keyword #f "bindings")) (_o$8538 bindings) (_o$8539 (keyword #f "body")) (_o$8540 body)) (jolt-hash-map _o$8535 _o$8536 _o$8537 _o$8538 _o$8539 _o$8540)))))) let-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec8528 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$8529 (keyword #f "op")) (_o$8530 (keyword #f "fn")) (_o$8531 (keyword #f "name")) (_o$8532 name) (_o$8533 (keyword #f "arities")) (_o$8534 arities)) (jolt-hash-map _o$8529 _o$8530 _o$8531 _o$8532 _o$8533 _o$8534)) (let* ((_o$8535 (keyword #f "op")) (_o$8536 (keyword #f "fn")) (_o$8537 (keyword #f "arities")) (_o$8538 arities)) (jolt-hash-map _o$8535 _o$8536 _o$8537 _o$8538))))))) fn-node)))
+  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec8541 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$8542 (keyword #f "op")) (_o$8543 (keyword #f "fn")) (_o$8544 (keyword #f "name")) (_o$8545 name) (_o$8546 (keyword #f "arities")) (_o$8547 arities)) (jolt-hash-map _o$8542 _o$8543 _o$8544 _o$8545 _o$8546 _o$8547)) (let* ((_o$8548 (keyword #f "op")) (_o$8549 (keyword #f "fn")) (_o$8550 (keyword #f "arities")) (_o$8551 arities)) (jolt-hash-map _o$8548 _o$8549 _o$8550 _o$8551))))))) fn-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec8539 ((items items)) (let* ((_o$8540 (keyword #f "op")) (_o$8541 (keyword #f "vector")) (_o$8542 (keyword #f "items")) (_o$8543 items)) (jolt-hash-map _o$8540 _o$8541 _o$8542 _o$8543)))))) vector-node)))
+  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec8552 ((items items)) (let* ((_o$8553 (keyword #f "op")) (_o$8554 (keyword #f "vector")) (_o$8555 (keyword #f "items")) (_o$8556 items)) (jolt-hash-map _o$8553 _o$8554 _o$8555 _o$8556)))))) vector-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec8544 ((pairs pairs)) (let* ((_o$8545 (keyword #f "op")) (_o$8546 (keyword #f "map")) (_o$8547 (keyword #f "pairs")) (_o$8548 pairs)) (jolt-hash-map _o$8545 _o$8546 _o$8547 _o$8548)))))) map-node)))
+  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec8557 ((pairs pairs)) (let* ((_o$8558 (keyword #f "op")) (_o$8559 (keyword #f "map")) (_o$8560 (keyword #f "pairs")) (_o$8561 pairs)) (jolt-hash-map _o$8558 _o$8559 _o$8560 _o$8561)))))) map-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec8549 ((items items)) (let* ((_o$8550 (keyword #f "op")) (_o$8551 (keyword #f "set")) (_o$8552 (keyword #f "items")) (_o$8553 items)) (jolt-hash-map _o$8550 _o$8551 _o$8552 _o$8553)))))) set-node)))
+  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec8562 ((items items)) (let* ((_o$8563 (keyword #f "op")) (_o$8564 (keyword #f "set")) (_o$8565 (keyword #f "items")) (_o$8566 items)) (jolt-hash-map _o$8563 _o$8564 _o$8565 _o$8566)))))) set-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec8554 ((form form)) (let* ((_o$8555 (keyword #f "op")) (_o$8556 (keyword #f "quote")) (_o$8557 (keyword #f "form")) (_o$8558 form)) (jolt-hash-map _o$8555 _o$8556 _o$8557 _o$8558)))))) quote-node)))
+  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec8567 ((form form)) (let* ((_o$8568 (keyword #f "op")) (_o$8569 (keyword #f "quote")) (_o$8570 (keyword #f "form")) (_o$8571 form)) (jolt-hash-map _o$8568 _o$8569 _o$8570 _o$8571)))))) quote-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec8559 ((expr expr)) (let* ((_o$8560 (keyword #f "op")) (_o$8561 (keyword #f "throw")) (_o$8562 (keyword #f "expr")) (_o$8563 expr)) (jolt-hash-map _o$8560 _o$8561 _o$8562 _o$8563)))))) throw-node)))
+  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec8572 ((expr expr)) (let* ((_o$8573 (keyword #f "op")) (_o$8574 (keyword #f "throw")) (_o$8575 (keyword #f "expr")) (_o$8576 expr)) (jolt-hash-map _o$8573 _o$8574 _o$8575 _o$8576)))))) throw-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec8564 ((kind kind) (expr expr)) (let* ((_o$8565 (keyword #f "op")) (_o$8566 (keyword #f "coerce")) (_o$8567 (keyword #f "kind")) (_o$8568 kind) (_o$8569 (keyword #f "expr")) (_o$8570 expr)) (jolt-hash-map _o$8565 _o$8566 _o$8567 _o$8568 _o$8569 _o$8570)))))) coerce-node)))
+  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec8577 ((kind kind) (expr expr)) (let* ((_o$8578 (keyword #f "op")) (_o$8579 (keyword #f "coerce")) (_o$8580 (keyword #f "kind")) (_o$8581 kind) (_o$8582 (keyword #f "expr")) (_o$8583 expr)) (jolt-hash-map _o$8578 _o$8579 _o$8580 _o$8581 _o$8582 _o$8583)))))) coerce-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec8571 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8572 node) (_a$8573 (keyword #f "test")) (_a$8574 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$8575 (keyword #f "then")) (_a$8576 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$8577 (keyword #f "else")) (_a$8578 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8572 _a$8573 _a$8574 _a$8575 _a$8576 _a$8577 _a$8578)) (if (jolt= op (keyword #f "do")) (let* ((_a$8579 node) (_a$8580 (keyword #f "statements")) (_a$8581 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$8582 (keyword #f "ret")) (_a$8583 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$8579 _a$8580 _a$8581 _a$8582 _a$8583)) (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$8584 node) (_a$8585 (keyword #f "obj")) (_a$8586 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$8587 (keyword #f "val")) (_a$8588 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$8584 _a$8585 _a$8586 _a$8587 _a$8588)) (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$8589 node) (_a$8590 (keyword #f "fn")) (_a$8591 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$8592 (keyword #f "args")) (_a$8593 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8589 _a$8590 _a$8591 _a$8592 _a$8593)) (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$8597 (var-deref "clojure.core" "mapv")) (_a$8598 (lambda (pr) (let fnrec8594 ((pr pr)) (let* ((_o$8595 (jolt-invoke f (jolt-nth pr 0))) (_o$8596 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$8595 _o$8596))))) (_a$8599 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8597 _a$8598 _a$8599))) (if (jolt= op (keyword #f "let")) (let* ((_a$8606 node) (_a$8607 (keyword #f "bindings")) (_a$8608 (let* ((_a$8603 (var-deref "clojure.core" "mapv")) (_a$8604 (lambda (b) (let fnrec8600 ((b b)) (let* ((_o$8601 (jolt-nth b 0)) (_o$8602 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8601 _o$8602))))) (_a$8605 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8603 _a$8604 _a$8605))) (_a$8609 (keyword #f "body")) (_a$8610 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8606 _a$8607 _a$8608 _a$8609 _a$8610)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8617 node) (_a$8618 (keyword #f "bindings")) (_a$8619 (let* ((_a$8614 (var-deref "clojure.core" "mapv")) (_a$8615 (lambda (b) (let fnrec8611 ((b b)) (let* ((_o$8612 (jolt-nth b 0)) (_o$8613 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8612 _o$8613))))) (_a$8616 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8614 _a$8615 _a$8616))) (_a$8620 (keyword #f "body")) (_a$8621 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8617 _a$8618 _a$8619 _a$8620 _a$8621)) (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$8623 (var-deref "clojure.core" "mapv")) (_a$8624 (lambda (a) (let fnrec8622 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$8625 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8623 _a$8624 _a$8625))) (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$8626 node) (_a$8627 (keyword #f "target")) (_a$8628 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$8629 (keyword #f "args")) (_a$8630 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8626 _a$8627 _a$8628 _a$8629 _a$8630)) (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 fnrec8584 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8585 node) (_a$8586 (keyword #f "test")) (_a$8587 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$8588 (keyword #f "then")) (_a$8589 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$8590 (keyword #f "else")) (_a$8591 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8585 _a$8586 _a$8587 _a$8588 _a$8589 _a$8590 _a$8591)) (if (jolt= op (keyword #f "do")) (let* ((_a$8592 node) (_a$8593 (keyword #f "statements")) (_a$8594 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$8595 (keyword #f "ret")) (_a$8596 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$8592 _a$8593 _a$8594 _a$8595 _a$8596)) (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$8597 node) (_a$8598 (keyword #f "obj")) (_a$8599 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$8600 (keyword #f "val")) (_a$8601 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$8597 _a$8598 _a$8599 _a$8600 _a$8601)) (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$8602 node) (_a$8603 (keyword #f "fn")) (_a$8604 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$8605 (keyword #f "args")) (_a$8606 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8602 _a$8603 _a$8604 _a$8605 _a$8606)) (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$8610 (var-deref "clojure.core" "mapv")) (_a$8611 (lambda (pr) (let fnrec8607 ((pr pr)) (let* ((_o$8608 (jolt-invoke f (jolt-nth pr 0))) (_o$8609 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$8608 _o$8609))))) (_a$8612 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8610 _a$8611 _a$8612))) (if (jolt= op (keyword #f "let")) (let* ((_a$8619 node) (_a$8620 (keyword #f "bindings")) (_a$8621 (let* ((_a$8616 (var-deref "clojure.core" "mapv")) (_a$8617 (lambda (b) (let fnrec8613 ((b b)) (let* ((_o$8614 (jolt-nth b 0)) (_o$8615 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8614 _o$8615))))) (_a$8618 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8616 _a$8617 _a$8618))) (_a$8622 (keyword #f "body")) (_a$8623 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8619 _a$8620 _a$8621 _a$8622 _a$8623)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8630 node) (_a$8631 (keyword #f "bindings")) (_a$8632 (let* ((_a$8627 (var-deref "clojure.core" "mapv")) (_a$8628 (lambda (b) (let fnrec8624 ((b b)) (let* ((_o$8625 (jolt-nth b 0)) (_o$8626 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$8625 _o$8626))))) (_a$8629 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$8627 _a$8628 _a$8629))) (_a$8633 (keyword #f "body")) (_a$8634 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$8630 _a$8631 _a$8632 _a$8633 _a$8634)) (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$8636 (var-deref "clojure.core" "mapv")) (_a$8637 (lambda (a) (let fnrec8635 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$8638 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8636 _a$8637 _a$8638))) (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$8639 node) (_a$8640 (keyword #f "target")) (_a$8641 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$8642 (keyword #f "args")) (_a$8643 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$8639 _a$8640 _a$8641 _a$8642 _a$8643)) (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 fnrec8631 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8635 f) (_a$8636 (let* ((_a$8632 f) (_a$8633 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$8634 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$8632 _a$8633 _a$8634))) (_a$8637 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$8635 _a$8636 _a$8637)) (if (jolt= op (keyword #f "do")) (let* ((_a$8638 f) (_a$8639 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$8640 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$8638 _a$8639 _a$8640)) (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$8641 f) (_a$8642 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$8643 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$8641 _a$8642 _a$8643)) (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$8644 f) (_a$8645 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$8646 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8644 _a$8645 _a$8646)) (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$8651 (lambda (a pr) (let fnrec8647 ((a a) (pr pr)) (let* ((_a$8648 f) (_a$8649 (jolt-invoke f a (jolt-nth pr 0))) (_a$8650 (jolt-nth pr 1))) (jolt-invoke _a$8648 _a$8649 _a$8650))))) (_a$8652 acc) (_a$8653 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$8651 _a$8652 _a$8653)) (if (jolt= op (keyword #f "let")) (let* ((_a$8658 f) (_a$8659 (let* ((_a$8655 (lambda (a b) (let fnrec8654 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8656 acc) (_a$8657 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8655 _a$8656 _a$8657))) (_a$8660 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8658 _a$8659 _a$8660)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8665 f) (_a$8666 (let* ((_a$8662 (lambda (a b) (let fnrec8661 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8663 acc) (_a$8664 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8662 _a$8663 _a$8664))) (_a$8667 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8665 _a$8666 _a$8667)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$8669 (lambda (a ar) (let fnrec8668 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$8670 acc) (_a$8671 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$8669 _a$8670 _a$8671)) (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$8672 f) (_a$8673 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$8674 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8672 _a$8673 _a$8674)) (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 fnrec8644 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$8648 f) (_a$8649 (let* ((_a$8645 f) (_a$8646 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$8647 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$8645 _a$8646 _a$8647))) (_a$8650 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$8648 _a$8649 _a$8650)) (if (jolt= op (keyword #f "do")) (let* ((_a$8651 f) (_a$8652 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$8653 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$8651 _a$8652 _a$8653)) (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$8654 f) (_a$8655 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$8656 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$8654 _a$8655 _a$8656)) (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$8657 f) (_a$8658 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$8659 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8657 _a$8658 _a$8659)) (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$8664 (lambda (a pr) (let fnrec8660 ((a a) (pr pr)) (let* ((_a$8661 f) (_a$8662 (jolt-invoke f a (jolt-nth pr 0))) (_a$8663 (jolt-nth pr 1))) (jolt-invoke _a$8661 _a$8662 _a$8663))))) (_a$8665 acc) (_a$8666 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$8664 _a$8665 _a$8666)) (if (jolt= op (keyword #f "let")) (let* ((_a$8671 f) (_a$8672 (let* ((_a$8668 (lambda (a b) (let fnrec8667 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8669 acc) (_a$8670 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8668 _a$8669 _a$8670))) (_a$8673 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8671 _a$8672 _a$8673)) (if (jolt= op (keyword #f "loop")) (let* ((_a$8678 f) (_a$8679 (let* ((_a$8675 (lambda (a b) (let fnrec8674 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$8676 acc) (_a$8677 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8675 _a$8676 _a$8677))) (_a$8680 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$8678 _a$8679 _a$8680)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$8682 (lambda (a ar) (let fnrec8681 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$8683 acc) (_a$8684 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$8682 _a$8683 _a$8684)) (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$8685 f) (_a$8686 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$8687 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$8685 _a$8686 _a$8687)) (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$8675 "quote") (_o$8676 "if") (_o$8677 "do") (_o$8678 "def") (_o$8679 "fn*") (_o$8680 "let*") (_o$8681 "loop*") (_o$8682 "recur") (_o$8683 "throw") (_o$8684 "try") (_o$8685 "syntax-quote") (_o$8686 "var") (_o$8687 "letfn*") (_o$8688 "set!") (_o$8689 "defmacro")) (jolt-hash-set _o$8675 _o$8676 _o$8677 _o$8678 _o$8679 _o$8680 _o$8681 _o$8682 _o$8683 _o$8684 _o$8685 _o$8686 _o$8687 _o$8688 _o$8689)) (let* ((_o$8690 (keyword #f "private")) (_o$8691 #t)) (jolt-hash-map _o$8690 _o$8691))))
+  (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$8688 "quote") (_o$8689 "if") (_o$8690 "do") (_o$8691 "def") (_o$8692 "fn*") (_o$8693 "let*") (_o$8694 "loop*") (_o$8695 "recur") (_o$8696 "throw") (_o$8697 "try") (_o$8698 "syntax-quote") (_o$8699 "var") (_o$8700 "letfn*") (_o$8701 "set!") (_o$8702 "defmacro")) (jolt-hash-set _o$8688 _o$8689 _o$8690 _o$8691 _o$8692 _o$8693 _o$8694 _o$8695 _o$8696 _o$8697 _o$8698 _o$8699 _o$8700 _o$8701 _o$8702)) (let* ((_o$8703 (keyword #f "private")) (_o$8704 #t)) (jolt-hash-map _o$8703 _o$8704))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec8692 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable) (let* ((_o$8693 (keyword #f "private")) (_o$8694 #t)) (jolt-hash-map _o$8693 _o$8694))))
+  (def-var-with-meta! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec8705 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable) (let* ((_o$8706 (keyword #f "private")) (_o$8707 #t)) (jolt-hash-map _o$8706 _o$8707))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$8695 (keyword #f "private")) (_o$8696 #t)) (jolt-hash-map _o$8695 _o$8696))))
+  (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$8708 (keyword #f "private")) (_o$8709 #t)) (jolt-hash-map _o$8708 _o$8709))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec8697 ((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) (let* ((_o$8698 (keyword #f "private")) (_o$8699 #t)) (jolt-hash-map _o$8698 _o$8699))))
+  (def-var-with-meta! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec8710 ((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) (let* ((_o$8711 (keyword #f "private")) (_o$8712 #t)) (jolt-hash-map _o$8711 _o$8712))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec8700 () (let* ((_o$8701 (keyword #f "locals")) (_o$8702 (jolt-hash-set)) (_o$8703 (keyword #f "hints")) (_o$8704 (jolt-hash-map))) (jolt-hash-map _o$8701 _o$8702 _o$8703 _o$8704)))))) empty-env) (let* ((_o$8705 (keyword #f "private")) (_o$8706 #t)) (jolt-hash-map _o$8705 _o$8706))))
+  (def-var-with-meta! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec8713 () (let* ((_o$8714 (keyword #f "locals")) (_o$8715 (jolt-hash-set)) (_o$8716 (keyword #f "hints")) (_o$8717 (jolt-hash-map))) (jolt-hash-map _o$8714 _o$8715 _o$8716 _o$8717)))))) empty-env) (let* ((_o$8718 (keyword #f "private")) (_o$8719 #t)) (jolt-hash-map _o$8718 _o$8719))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec8707 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?) (let* ((_o$8708 (keyword #f "private")) (_o$8709 #t)) (jolt-hash-map _o$8708 _o$8709))))
+  (def-var-with-meta! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec8720 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?) (let* ((_o$8721 (keyword #f "private")) (_o$8722 #t)) (jolt-hash-map _o$8721 _o$8722))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec8710 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__97_) (let fnrec8711 ((p__97_ p__97_)) (jolt-reduce jolt-conj p__97_ names)))))))) add-locals) (let* ((_o$8712 (keyword #f "private")) (_o$8713 #t)) (jolt-hash-map _o$8712 _o$8713))))
+  (def-var-with-meta! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec8723 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__97_) (let fnrec8724 ((p__97_ p__97_)) (jolt-reduce jolt-conj p__97_ names)))))))) add-locals) (let* ((_o$8725 (keyword #f "private")) (_o$8726 #t)) (jolt-hash-map _o$8725 _o$8726))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "amp-env-map" (letrec ((amp-env-map (lambda (env) (let fnrec8714 ((env env)) (let* ((_a$8716 (lambda (m n) (let fnrec8715 ((m m) (n n)) (jolt-assoc m (jolt-invoke (var-deref "clojure.core" "symbol") n) jolt-nil)))) (_a$8717 (jolt-hash-map)) (_a$8718 (jolt-get env (keyword #f "locals")))) (jolt-reduce _a$8716 _a$8717 _a$8718)))))) amp-env-map) (let* ((_o$8719 (keyword #f "private")) (_o$8720 #t)) (jolt-hash-map _o$8719 _o$8720))))
+  (def-var-with-meta! "jolt.analyzer" "amp-env-map" (letrec ((amp-env-map (lambda (env) (let fnrec8727 ((env env)) (let* ((_a$8729 (lambda (m n) (let fnrec8728 ((m m) (n n)) (jolt-assoc m (jolt-invoke (var-deref "clojure.core" "symbol") n) jolt-nil)))) (_a$8730 (jolt-hash-map)) (_a$8731 (jolt-get env (keyword #f "locals")))) (jolt-reduce _a$8729 _a$8730 _a$8731)))))) amp-env-map) (let* ((_o$8732 (keyword #f "private")) (_o$8733 #t)) (jolt-hash-map _o$8732 _o$8733))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec8721 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur) (let* ((_o$8722 (keyword #f "private")) (_o$8723 #t)) (jolt-hash-map _o$8722 _o$8723))))
+  (def-var-with-meta! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec8734 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur) (let* ((_o$8735 (keyword #f "private")) (_o$8736 #t)) (jolt-hash-map _o$8735 _o$8736))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec8724 ((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) (let* ((_o$8725 (keyword #f "private")) (_o$8726 #t)) (jolt-hash-map _o$8725 _o$8726))))
+  (def-var-with-meta! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec8737 ((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) (let* ((_o$8738 (keyword #f "private")) (_o$8739 #t)) (jolt-hash-map _o$8738 _o$8739))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec8727 ((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) (let* ((_o$8728 (keyword #f "private")) (_o$8729 #t)) (jolt-hash-map _o$8728 _o$8729))))
+  (def-var-with-meta! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec8740 ((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) (let* ((_o$8741 (keyword #f "private")) (_o$8742 #t)) (jolt-hash-map _o$8741 _o$8742))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec8730 ((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) (let* ((_o$8731 (keyword #f "private")) (_o$8732 #t)) (jolt-hash-map _o$8731 _o$8732))))
+  (def-var-with-meta! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec8743 ((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) (let* ((_o$8744 (keyword #f "private")) (_o$8745 #t)) (jolt-hash-map _o$8744 _o$8745))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec8733 ((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) (let* ((_o$8734 (keyword #f "private")) (_o$8735 #t)) (jolt-hash-map _o$8734 _o$8735))))
+  (def-var-with-meta! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec8746 ((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) (let* ((_o$8747 (keyword #f "private")) (_o$8748 #t)) (jolt-hash-map _o$8747 _o$8748))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec8736 ((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) (let* ((_o$8737 (keyword #f "private")) (_o$8738 #t)) (jolt-hash-map _o$8737 _o$8738))))
+  (def-var-with-meta! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec8749 ((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) (let* ((_o$8750 (keyword #f "private")) (_o$8751 #t)) (jolt-hash-map _o$8750 _o$8751))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec8739 ((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$8741 (var-deref "clojure.core" "mapv")) (_a$8742 (lambda (a) (let fnrec8740 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$8743 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8741 _a$8742 _a$8743))) node))))) with-ret-nhint) (let* ((_o$8744 (keyword #f "private")) (_o$8745 #t)) (jolt-hash-map _o$8744 _o$8745))))
+  (def-var-with-meta! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec8752 ((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$8754 (var-deref "clojure.core" "mapv")) (_a$8755 (lambda (a) (let fnrec8753 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$8756 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$8754 _a$8755 _a$8756))) node))))) with-ret-nhint) (let* ((_o$8757 (keyword #f "private")) (_o$8758 #t)) (jolt-hash-map _o$8757 _o$8758))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec8746 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__98_) (let fnrec8747 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ 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$8748 (var-deref "jolt.ir" "do-node")) (_a$8749 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$8750 (jolt-peek v))) (jolt-invoke _a$8748 _a$8749 _a$8750)) jolt-nil)))))))) analyze-seq) (let* ((_o$8751 (keyword #f "private")) (_o$8752 #t)) (jolt-hash-map _o$8751 _o$8752))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec8759 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__98_) (let fnrec8760 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ 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$8761 (var-deref "jolt.ir" "do-node")) (_a$8762 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$8763 (jolt-peek v))) (jolt-invoke _a$8761 _a$8762 _a$8763)) jolt-nil)))))))) analyze-seq) (let* ((_o$8764 (keyword #f "private")) (_o$8765 #t)) (jolt-hash-map _o$8764 _o$8765))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec8753 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop8754 ((i i) (env env) (pairs pairs)) (if (jolt-n< 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$8761 (jolt-n+ i 2)) (_a$8762 (let* ((_a$8755 (var-deref "jolt.analyzer" "add-hint")) (_a$8756 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$8757 nm) (_a$8758 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$8755 _a$8756 _a$8757 _a$8758))) (_a$8763 (jolt-conj pairs (let* ((_o$8759 nm) (_o$8760 init)) (jolt-vector _o$8759 _o$8760))))) (loop8754 _a$8761 _a$8762 _a$8763))))) (let* ((_o$8764 pairs) (_o$8765 env)) (jolt-vector _o$8764 _o$8765))))))))) analyze-bindings) (let* ((_o$8766 (keyword #f "private")) (_o$8767 #t)) (jolt-hash-map _o$8766 _o$8767))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec8766 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop8767 ((i i) (env env) (pairs pairs)) (if (jolt-n< 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$8774 (jolt-n+ i 2)) (_a$8775 (let* ((_a$8768 (var-deref "jolt.analyzer" "add-hint")) (_a$8769 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$8770 nm) (_a$8771 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$8768 _a$8769 _a$8770 _a$8771))) (_a$8776 (jolt-conj pairs (let* ((_o$8772 nm) (_o$8773 init)) (jolt-vector _o$8772 _o$8773))))) (loop8767 _a$8774 _a$8775 _a$8776))))) (let* ((_o$8777 pairs) (_o$8778 env)) (jolt-vector _o$8777 _o$8778))))))))) analyze-bindings) (let* ((_o$8779 (keyword #f "private")) (_o$8780 #t)) (jolt-hash-map _o$8779 _o$8780))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec8768 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop8769 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (jolt-n< 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$8770 (jolt-n+ i 2)) (_a$8771 fixed) (_a$8772 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$8773 hints) (_a$8774 phints) (_a$8775 nhints)) (loop8769 _a$8770 _a$8771 _a$8772 _a$8773 _a$8774 _a$8775)))) (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$8782 (jolt-inc i)) (_a$8783 (jolt-conj fixed nm)) (_a$8784 rest-name) (_a$8785 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$8776 nm) (_o$8777 h)) (jolt-vector _o$8776 _o$8777))) hints)) (_a$8786 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$8778 nm) (_o$8779 ph)) (jolt-vector _o$8778 _o$8779))) phints)) (_a$8787 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$8780 nm) (_o$8781 nh)) (jolt-vector _o$8780 _o$8781))) nhints))) (loop8769 _a$8782 _a$8783 _a$8784 _a$8785 _a$8786 _a$8787)))))) (let* ((_o$8788 (keyword #f "fixed")) (_o$8789 fixed) (_o$8790 (keyword #f "rest")) (_o$8791 rest-name) (_o$8792 (keyword #f "hints")) (_o$8793 hints) (_o$8794 (keyword #f "phints")) (_o$8795 phints) (_o$8796 (keyword #f "nhints")) (_o$8797 nhints)) (jolt-hash-map _o$8788 _o$8789 _o$8790 _o$8791 _o$8792 _o$8793 _o$8794 _o$8795 _o$8796 _o$8797))))))))) parse-params) (let* ((_o$8798 (keyword #f "private")) (_o$8799 #t)) (jolt-hash-map _o$8798 _o$8799))))
+  (def-var-with-meta! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec8781 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop8782 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (jolt-n< 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$8783 (jolt-n+ i 2)) (_a$8784 fixed) (_a$8785 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$8786 hints) (_a$8787 phints) (_a$8788 nhints)) (loop8782 _a$8783 _a$8784 _a$8785 _a$8786 _a$8787 _a$8788)))) (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$8795 (jolt-inc i)) (_a$8796 (jolt-conj fixed nm)) (_a$8797 rest-name) (_a$8798 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$8789 nm) (_o$8790 h)) (jolt-vector _o$8789 _o$8790))) hints)) (_a$8799 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$8791 nm) (_o$8792 ph)) (jolt-vector _o$8791 _o$8792))) phints)) (_a$8800 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$8793 nm) (_o$8794 nh)) (jolt-vector _o$8793 _o$8794))) nhints))) (loop8782 _a$8795 _a$8796 _a$8797 _a$8798 _a$8799 _a$8800)))))) (let* ((_o$8801 (keyword #f "fixed")) (_o$8802 fixed) (_o$8803 (keyword #f "rest")) (_o$8804 rest-name) (_o$8805 (keyword #f "hints")) (_o$8806 hints) (_o$8807 (keyword #f "phints")) (_o$8808 phints) (_o$8809 (keyword #f "nhints")) (_o$8810 nhints)) (jolt-hash-map _o$8801 _o$8802 _o$8803 _o$8804 _o$8805 _o$8806 _o$8807 _o$8808 _o$8809 _o$8810))))))))) parse-params) (let* ((_o$8811 (keyword #f "private")) (_o$8812 #t)) (jolt-hash-map _o$8811 _o$8812))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec8800 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop8801 ((i i) (out out)) (if (jolt-n< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop8802 ((j j)) (if (jolt-n>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop8802 (jolt-inc j)) jolt-nil))))))) (let* ((_a$8803 (jolt-inc i)) (_a$8804 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop8801 _a$8803 _a$8804))) out)))))))) uniquify-params) (let* ((_o$8805 (keyword #f "private")) (_o$8806 #t)) (jolt-hash-map _o$8805 _o$8806))))
+  (def-var-with-meta! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec8813 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop8814 ((i i) (out out)) (if (jolt-n< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop8815 ((j j)) (if (jolt-n>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop8815 (jolt-inc j)) jolt-nil))))))) (let* ((_a$8816 (jolt-inc i)) (_a$8817 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop8814 _a$8816 _a$8817))) out)))))))) uniquify-params) (let* ((_o$8818 (keyword #f "private")) (_o$8819 #t)) (jolt-hash-map _o$8818 _o$8819))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec8807 ((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$8808 (var-deref "clojure.core" "str")) (_a$8809 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$8810 "/") (_a$8811 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$8812 "--")) (jolt-invoke _a$8808 _a$8809 _a$8810 _a$8811 _a$8812)))) (names (let* ((G__151 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__152 (if (jolt-truthy? rst) (jolt-conj G__151 rst) G__151))) (let* ((G__153 (if (jolt-truthy? fn-name) (jolt-conj G__152 fn-name) G__152))) G__153)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$8818 (lambda (e pr) (let fnrec8813 ((e e) (pr pr)) (let* ((_a$8814 (var-deref "jolt.analyzer" "add-hint")) (_a$8815 e) (_a$8816 (jolt-nth pr 0)) (_a$8817 (jolt-nth pr 1))) (jolt-invoke _a$8814 _a$8815 _a$8816 _a$8817))))) (_a$8819 env0) (_a$8820 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$8818 _a$8819 _a$8820))) (arity (let* ((_o$8821 (keyword #f "params")) (_o$8822 fixed) (_o$8823 (keyword #f "recur-name")) (_o$8824 rname) (_o$8825 (keyword #f "body")) (_o$8826 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$8821 _o$8822 _o$8823 _o$8824 _o$8825 _o$8826))) (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) (let* ((_o$8827 (keyword #f "private")) (_o$8828 #t)) (jolt-hash-map _o$8827 _o$8828))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec8820 ((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$8821 (var-deref "clojure.core" "str")) (_a$8822 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$8823 "/") (_a$8824 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$8825 "--")) (jolt-invoke _a$8821 _a$8822 _a$8823 _a$8824 _a$8825)))) (names (let* ((G__149 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__150 (if (jolt-truthy? rst) (jolt-conj G__149 rst) G__149))) (let* ((G__151 (if (jolt-truthy? fn-name) (jolt-conj G__150 fn-name) G__150))) G__151)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$8831 (lambda (e pr) (let fnrec8826 ((e e) (pr pr)) (let* ((_a$8827 (var-deref "jolt.analyzer" "add-hint")) (_a$8828 e) (_a$8829 (jolt-nth pr 0)) (_a$8830 (jolt-nth pr 1))) (jolt-invoke _a$8827 _a$8828 _a$8829 _a$8830))))) (_a$8832 env0) (_a$8833 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$8831 _a$8832 _a$8833))) (arity (let* ((_o$8834 (keyword #f "params")) (_o$8835 fixed) (_o$8836 (keyword #f "recur-name")) (_o$8837 rname) (_o$8838 (keyword #f "body")) (_o$8839 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$8834 _o$8835 _o$8836 _o$8837 _o$8838 _o$8839))) (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) (let* ((_o$8840 (keyword #f "private")) (_o$8841 #t)) (jolt-hash-map _o$8840 _o$8841))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec8829 ((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) (let* ((_o$8830 (keyword #f "private")) (_o$8831 #t)) (jolt-hash-map _o$8830 _o$8831))))
+  (def-var-with-meta! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec8842 ((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) (let* ((_o$8843 (keyword #f "private")) (_o$8844 #t)) (jolt-hash-map _o$8843 _o$8844))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec8832 ((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 fnrec8833 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$8834 (var-deref "jolt.analyzer" "analyze-arity")) (_a$8835 ctx) (_a$8836 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$8837 (jolt-rest cl)) (_a$8838 env) (_a$8839 fn-name)) (jolt-invoke _a$8834 _a$8835 _a$8836 _a$8837 _a$8838 _a$8839))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn) (let* ((_o$8840 (keyword #f "private")) (_o$8841 #t)) (jolt-hash-map _o$8840 _o$8841))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec8845 ((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 fnrec8846 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$8847 (var-deref "jolt.analyzer" "analyze-arity")) (_a$8848 ctx) (_a$8849 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$8850 (jolt-rest cl)) (_a$8851 env) (_a$8852 fn-name)) (jolt-invoke _a$8847 _a$8848 _a$8849 _a$8850 _a$8851 _a$8852))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn) (let* ((_o$8853 (keyword #f "private")) (_o$8854 #t)) (jolt-hash-map _o$8853 _o$8854))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$8842 "Throwable") (_o$8843 "java.lang.Throwable") (_o$8844 "Object") (_o$8845 "java.lang.Object")) (jolt-hash-set _o$8842 _o$8843 _o$8844 _o$8845)) (let* ((_o$8846 (keyword #f "private")) (_o$8847 #t)) (jolt-hash-map _o$8846 _o$8847))))
+  (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$8855 "Throwable") (_o$8856 "java.lang.Throwable") (_o$8857 "Object") (_o$8858 "java.lang.Object")) (jolt-hash-set _o$8855 _o$8856 _o$8857 _o$8858)) (let* ((_o$8859 (keyword #f "private")) (_o$8860 #t)) (jolt-hash-map _o$8859 _o$8860))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8848 ((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 fnrec8849 ((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-n< (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$8850 (keyword #f "op")) (_o$8851 (keyword #f "try")) (_o$8852 (keyword #f "body")) (_o$8853 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8850 _o$8851 _o$8852 _o$8853))) (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")) (raw-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch-raw")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$8858 (lambda (_else cl) (let fnrec8854 ((_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$8855 (jolt-symbol #f "or")) (_a$8856 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8857 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8855 _a$8856 _a$8857)) letform _else)))))) (_a$8859 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8860 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8858 _a$8859 _a$8860)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-raw-sym") raw-name (keyword #f "catch-body") (let* ((_a$8861 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8862 ctx) (_a$8863 (jolt-list dispatch)) (_a$8864 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8861 _a$8862 _a$8863 _a$8864)))) 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) (let* ((_o$8865 (keyword #f "private")) (_o$8866 #t)) (jolt-hash-map _o$8865 _o$8866))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec8861 ((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 fnrec8862 ((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-n< (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$8863 (keyword #f "op")) (_o$8864 (keyword #f "try")) (_o$8865 (keyword #f "body")) (_o$8866 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$8863 _o$8864 _o$8865 _o$8866))) (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")) (raw-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch-raw")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$8871 (lambda (_else cl) (let fnrec8867 ((_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$8868 (jolt-symbol #f "or")) (_a$8869 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$8870 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$8868 _a$8869 _a$8870)) letform _else)))))) (_a$8872 (jolt-list (jolt-symbol #f "throw") evar)) (_a$8873 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$8871 _a$8872 _a$8873)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-raw-sym") raw-name (keyword #f "catch-body") (let* ((_a$8874 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8875 ctx) (_a$8876 (jolt-list dispatch)) (_a$8877 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$8874 _a$8875 _a$8876 _a$8877)))) 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) (let* ((_o$8878 (keyword #f "private")) (_o$8879 #t)) (jolt-hash-map _o$8878 _o$8879))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-letfn*" (letrec ((analyze-letfn* (lambda (ctx items env) (let fnrec8867 ((ctx ctx) (items items) (env env)) (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (n (jolt-quot (jolt-count bvec) 2)) (names (let* ((_a$8869 (var-deref "clojure.core" "mapv")) (_a$8870 (lambda (i) (let fnrec8868 ((i i)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth bvec (jolt-n* 2 i)))))) (_a$8871 (jolt-range n))) (jolt-invoke _a$8869 _a$8870 _a$8871))) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (let* ((_a$8875 (var-deref "clojure.core" "mapv")) (_a$8876 (lambda (i) (let fnrec8872 ((i i)) (let* ((_o$8873 (jolt-nth names i)) (_o$8874 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc (jolt-n* 2 i))) env*))) (jolt-vector _o$8873 _o$8874))))) (_a$8877 (jolt-range n))) (jolt-invoke _a$8875 _a$8876 _a$8877)))) (let* ((_o$8878 (keyword #f "op")) (_o$8879 (keyword #f "let")) (_o$8880 (keyword #f "letrec")) (_o$8881 #t) (_o$8882 (keyword #f "bindings")) (_o$8883 binds) (_o$8884 (keyword #f "body")) (_o$8885 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8878 _o$8879 _o$8880 _o$8881 _o$8882 _o$8883 _o$8884 _o$8885))))))) analyze-letfn*) (let* ((_o$8886 (keyword #f "private")) (_o$8887 #t)) (jolt-hash-map _o$8886 _o$8887))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-letfn*" (letrec ((analyze-letfn* (lambda (ctx items env) (let fnrec8880 ((ctx ctx) (items items) (env env)) (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (n (jolt-quot (jolt-count bvec) 2)) (names (let* ((_a$8882 (var-deref "clojure.core" "mapv")) (_a$8883 (lambda (i) (let fnrec8881 ((i i)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth bvec (jolt-n* 2 i)))))) (_a$8884 (jolt-range n))) (jolt-invoke _a$8882 _a$8883 _a$8884))) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (let* ((_a$8888 (var-deref "clojure.core" "mapv")) (_a$8889 (lambda (i) (let fnrec8885 ((i i)) (let* ((_o$8886 (jolt-nth names i)) (_o$8887 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc (jolt-n* 2 i))) env*))) (jolt-vector _o$8886 _o$8887))))) (_a$8890 (jolt-range n))) (jolt-invoke _a$8888 _a$8889 _a$8890)))) (let* ((_o$8891 (keyword #f "op")) (_o$8892 (keyword #f "let")) (_o$8893 (keyword #f "letrec")) (_o$8894 #t) (_o$8895 (keyword #f "bindings")) (_o$8896 binds) (_o$8897 (keyword #f "body")) (_o$8898 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$8891 _o$8892 _o$8893 _o$8894 _o$8895 _o$8896 _o$8897 _o$8898))))))) analyze-letfn*) (let* ((_o$8899 (keyword #f "private")) (_o$8900 #t)) (jolt-hash-map _o$8899 _o$8900))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8888 ((nm nm)) (let* ((and__25__auto (jolt-n> (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?) (let* ((_o$8889 (keyword #f "private")) (_o$8890 #t)) (jolt-hash-map _o$8889 _o$8890))))
+  (def-var-with-meta! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec8901 ((nm nm)) (let* ((and__25__auto (jolt-n> (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?) (let* ((_o$8902 (keyword #f "private")) (_o$8903 #t)) (jolt-hash-map _o$8902 _o$8903))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8891 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8895 (var-deref "clojure.core" "mapv")) (_a$8896 (lambda (p) (let fnrec8892 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8893 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8894 (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$8893 _o$8894)))))) (_a$8897 (jolt-seq base))) (jolt-invoke _a$8895 _a$8896 _a$8897))) jolt-nil))))) def-meta-expr) (let* ((_o$8898 (keyword #f "private")) (_o$8899 #t)) (jolt-hash-map _o$8898 _o$8899))))
+  (def-var-with-meta! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec8904 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$8908 (var-deref "clojure.core" "mapv")) (_a$8909 (lambda (p) (let fnrec8905 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$8906 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$8907 (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$8906 _o$8907)))))) (_a$8910 (jolt-seq base))) (jolt-invoke _a$8908 _a$8909 _a$8910))) jolt-nil))))) def-meta-expr) (let* ((_o$8911 (keyword #f "private")) (_o$8912 #t)) (jolt-hash-map _o$8911 _o$8912))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8900 ((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-n< (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$8901 (keyword #f "op")) (_o$8902 (keyword #f "def")) (_o$8903 (keyword #f "ns")) (_o$8904 cur) (_o$8905 (keyword #f "name")) (_o$8906 nm) (_o$8907 (keyword #f "no-init")) (_o$8908 #t)) (jolt-hash-map _o$8901 _o$8902 _o$8903 _o$8904 _o$8905 _o$8906 _o$8907 _o$8908)))) (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-n> (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$8909 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8910 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8911 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8909 _a$8910 _a$8911)) 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) (let* ((_o$8912 (keyword #f "private")) (_o$8913 #t)) (jolt-hash-map _o$8912 _o$8913))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec8913 ((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-n< (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$8914 (keyword #f "op")) (_o$8915 (keyword #f "def")) (_o$8916 (keyword #f "ns")) (_o$8917 cur) (_o$8918 (keyword #f "name")) (_o$8919 nm) (_o$8920 (keyword #f "no-init")) (_o$8921 #t)) (jolt-hash-map _o$8914 _o$8915 _o$8916 _o$8917 _o$8918 _o$8919 _o$8920 _o$8921)))) (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-n> (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$8922 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$8923 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$8924 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$8922 _a$8923 _a$8924)) 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) (let* ((_o$8925 (keyword #f "private")) (_o$8926 #t)) (jolt-hash-map _o$8925 _o$8926))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8914 ((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$8915 (keyword #f "op")) (_o$8916 (keyword #f "set-field")) (_o$8917 (keyword #f "obj")) (_o$8918 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8919 (keyword #f "field")) (_o$8920 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8921 (keyword #f "val")) (_o$8922 val-node)) (jolt-hash-map _o$8915 _o$8916 _o$8917 _o$8918 _o$8919 _o$8920 _o$8921 _o$8922)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-n>= (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$8926 (var-deref "jolt.ir" "invoke")) (_a$8927 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8928 (let* ((_o$8923 (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$8924 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8925 val-node)) (jolt-vector _o$8923 _o$8924 _o$8925)))) (jolt-invoke _a$8926 _a$8927 _a$8928)) (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$8932 (keyword #f "op")) (_o$8933 (keyword #f "set-var")) (_o$8934 (keyword #f "the-var")) (_o$8935 (let* ((_a$8929 (var-deref "jolt.ir" "the-var")) (_a$8930 (jolt-get r (keyword #f "ns"))) (_a$8931 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8929 _a$8930 _a$8931))) (_o$8936 (keyword #f "val")) (_o$8937 val-node)) (jolt-hash-map _o$8932 _o$8933 _o$8934 _o$8935 _o$8936 _o$8937))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!) (let* ((_o$8938 (keyword #f "private")) (_o$8939 #t)) (jolt-hash-map _o$8938 _o$8939))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec8927 ((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$8928 (keyword #f "op")) (_o$8929 (keyword #f "set-field")) (_o$8930 (keyword #f "obj")) (_o$8931 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$8932 (keyword #f "field")) (_o$8933 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$8934 (keyword #f "val")) (_o$8935 val-node)) (jolt-hash-map _o$8928 _o$8929 _o$8930 _o$8931 _o$8932 _o$8933 _o$8934 _o$8935)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-n>= (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$8939 (var-deref "jolt.ir" "invoke")) (_a$8940 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$8941 (let* ((_o$8936 (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$8937 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$8938 val-node)) (jolt-vector _o$8936 _o$8937 _o$8938)))) (jolt-invoke _a$8939 _a$8940 _a$8941)) (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$8945 (keyword #f "op")) (_o$8946 (keyword #f "set-var")) (_o$8947 (keyword #f "the-var")) (_o$8948 (let* ((_a$8942 (var-deref "jolt.ir" "the-var")) (_a$8943 (jolt-get r (keyword #f "ns"))) (_a$8944 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8942 _a$8943 _a$8944))) (_o$8949 (keyword #f "val")) (_o$8950 val-node)) (jolt-hash-map _o$8945 _o$8946 _o$8947 _o$8948 _o$8949 _o$8950))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!) (let* ((_o$8951 (keyword #f "private")) (_o$8952 #t)) (jolt-hash-map _o$8951 _o$8952))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8940 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__154 op)) (if (jolt= G__154 "quote") (let* ((qf (jolt-invoke (var-deref "clojure.core" "second") items)) (m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") qf)) (m (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") m)) (let* ((u (jolt-dissoc m (keyword #f "line") (keyword #f "column") (keyword #f "end-line") (keyword #f "end-column") (keyword #f "file")))) (if (jolt-truthy? (jolt-seq u)) u jolt-nil)) jolt-nil))) (if (jolt-nil? m) (jolt-invoke (var-deref "jolt.ir" "quote-node") qf) (let* ((_a$8943 (var-deref "jolt.ir" "invoke")) (_a$8944 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8945 (let* ((_o$8941 (jolt-invoke (var-deref "jolt.ir" "quote-node") qf)) (_o$8942 (jolt-invoke (var-deref "jolt.ir" "quote-node") m))) (jolt-vector _o$8941 _o$8942)))) (jolt-invoke _a$8943 _a$8944 _a$8945)))) (if (jolt= G__154 "if") (begin (if (let* ((or__26__auto (jolt-n< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-n> (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$8946 (var-deref "jolt.ir" "if-node")) (_a$8947 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8948 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8949 (if (jolt-n> (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$8946 _a$8947 _a$8948 _a$8949))) (if (jolt= G__154 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__154 "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__154 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__154 "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$8954 (var-deref "jolt.ir" "let-node")) (_a$8955 (jolt-first r)) (_a$8956 (let* ((_a$8950 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8951 ctx) (_a$8952 (jolt-drop 2 items)) (_a$8953 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8950 _a$8951 _a$8952 _a$8953)))) (jolt-invoke _a$8954 _a$8955 _a$8956))) (if (jolt= G__154 "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$8957 (keyword #f "op")) (_o$8958 (keyword #f "loop")) (_o$8959 (keyword #f "recur-name")) (_o$8960 rname) (_o$8961 (keyword #f "bindings")) (_o$8962 (jolt-first r)) (_o$8963 (keyword #f "body")) (_o$8964 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8957 _o$8958 _o$8959 _o$8960 _o$8961 _o$8962 _o$8963 _o$8964))) (if (jolt= G__154 "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$8969 (keyword #f "op")) (_o$8970 (keyword #f "recur")) (_o$8971 (keyword #f "recur-name")) (_o$8972 rt) (_o$8973 (keyword #f "args")) (_o$8974 (let* ((_a$8966 (var-deref "clojure.core" "mapv")) (_a$8967 (lambda (p__99_) (let fnrec8965 ((p__99_ p__99_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__99_ env)))) (_a$8968 (jolt-rest items))) (jolt-invoke _a$8966 _a$8967 _a$8968)))) (jolt-hash-map _o$8969 _o$8970 _o$8971 _o$8972 _o$8973 _o$8974)))) (if (jolt= G__154 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__154 "letfn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn*") ctx items env) (if (jolt= G__154 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__154 "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__154 "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$8975 (var-deref "jolt.ir" "the-var")) (_a$8976 (jolt-get r (keyword #f "ns"))) (_a$8977 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8975 _a$8976 _a$8977)) (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__154 "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$8978 (keyword #f "op")) (_o$8979 (keyword #f "defmacro")) (_o$8980 (keyword #f "ns")) (_o$8981 cur) (_o$8982 (keyword #f "name")) (_o$8983 nm) (_o$8984 (keyword #f "fn")) (_o$8985 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8978 _o$8979 _o$8980 _o$8981 _o$8982 _o$8983 _o$8984 _o$8985)))) (if (jolt= G__154 "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) (let* ((_o$8986 (keyword #f "private")) (_o$8987 #t)) (jolt-hash-map _o$8986 _o$8987))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec8953 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__152 op)) (if (jolt= G__152 "quote") (let* ((qf (jolt-invoke (var-deref "clojure.core" "second") items)) (m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") qf)) (m (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") m)) (let* ((u (jolt-dissoc m (keyword #f "line") (keyword #f "column") (keyword #f "end-line") (keyword #f "end-column") (keyword #f "file")))) (if (jolt-truthy? (jolt-seq u)) u jolt-nil)) jolt-nil))) (if (jolt-nil? m) (jolt-invoke (var-deref "jolt.ir" "quote-node") qf) (let* ((_a$8956 (var-deref "jolt.ir" "invoke")) (_a$8957 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8958 (let* ((_o$8954 (jolt-invoke (var-deref "jolt.ir" "quote-node") qf)) (_o$8955 (jolt-invoke (var-deref "jolt.ir" "quote-node") m))) (jolt-vector _o$8954 _o$8955)))) (jolt-invoke _a$8956 _a$8957 _a$8958)))) (if (jolt= G__152 "if") (begin (if (let* ((or__26__auto (jolt-n< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-n> (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$8959 (var-deref "jolt.ir" "if-node")) (_a$8960 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$8961 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$8962 (if (jolt-n> (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$8959 _a$8960 _a$8961 _a$8962))) (if (jolt= G__152 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__152 "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__152 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__152 "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$8967 (var-deref "jolt.ir" "let-node")) (_a$8968 (jolt-first r)) (_a$8969 (let* ((_a$8963 (var-deref "jolt.analyzer" "analyze-seq")) (_a$8964 ctx) (_a$8965 (jolt-drop 2 items)) (_a$8966 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$8963 _a$8964 _a$8965 _a$8966)))) (jolt-invoke _a$8967 _a$8968 _a$8969))) (if (jolt= G__152 "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$8970 (keyword #f "op")) (_o$8971 (keyword #f "loop")) (_o$8972 (keyword #f "recur-name")) (_o$8973 rname) (_o$8974 (keyword #f "bindings")) (_o$8975 (jolt-first r)) (_o$8976 (keyword #f "body")) (_o$8977 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$8970 _o$8971 _o$8972 _o$8973 _o$8974 _o$8975 _o$8976 _o$8977))) (if (jolt= G__152 "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$8982 (keyword #f "op")) (_o$8983 (keyword #f "recur")) (_o$8984 (keyword #f "recur-name")) (_o$8985 rt) (_o$8986 (keyword #f "args")) (_o$8987 (let* ((_a$8979 (var-deref "clojure.core" "mapv")) (_a$8980 (lambda (p__99_) (let fnrec8978 ((p__99_ p__99_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__99_ env)))) (_a$8981 (jolt-rest items))) (jolt-invoke _a$8979 _a$8980 _a$8981)))) (jolt-hash-map _o$8982 _o$8983 _o$8984 _o$8985 _o$8986 _o$8987)))) (if (jolt= G__152 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__152 "letfn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn*") ctx items env) (if (jolt= G__152 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__152 "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__152 "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$8988 (var-deref "jolt.ir" "the-var")) (_a$8989 (jolt-get r (keyword #f "ns"))) (_a$8990 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8988 _a$8989 _a$8990)) (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__152 "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$8991 (keyword #f "op")) (_o$8992 (keyword #f "defmacro")) (_o$8993 (keyword #f "ns")) (_o$8994 cur) (_o$8995 (keyword #f "name")) (_o$8996 nm) (_o$8997 (keyword #f "fn")) (_o$8998 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$8991 _o$8992 _o$8993 _o$8994 _o$8995 _o$8996 _o$8997 _o$8998)))) (if (jolt= G__152 "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) (let* ((_o$8999 (keyword #f "private")) (_o$9000 #t)) (jolt-hash-map _o$8999 _o$9000))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec8988 ((nm nm)) (let* ((and__25__auto (jolt-n> (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?) (let* ((_o$8989 (keyword #f "private")) (_o$8990 #t)) (jolt-hash-map _o$8989 _o$8990))))
+  (def-var-with-meta! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec9001 ((nm nm)) (let* ((and__25__auto (jolt-n> (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?) (let* ((_o$9002 (keyword #f "private")) (_o$9003 #t)) (jolt-hash-map _o$9002 _o$9003))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec8991 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (jolt-n< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$8996 (keyword #f "op")) (_o$8997 (keyword #f "host-call")) (_o$8998 (keyword #f "method")) (_o$8999 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$9000 (keyword #f "target")) (_o$9001 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$9002 (keyword #f "args")) (_o$9003 (let* ((_a$8993 (var-deref "clojure.core" "mapv")) (_a$8994 (lambda (p__100_) (let fnrec8992 ((p__100_ p__100_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__100_ env)))) (_a$8995 (jolt-drop 2 items))) (jolt-invoke _a$8993 _a$8994 _a$8995)))) (jolt-hash-map _o$8996 _o$8997 _o$8998 _o$8999 _o$9000 _o$9001 _o$9002 _o$9003))))))) analyze-host-call) (let* ((_o$9004 (keyword #f "private")) (_o$9005 #t)) (jolt-hash-map _o$9004 _o$9005))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec9004 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (jolt-n< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$9009 (keyword #f "op")) (_o$9010 (keyword #f "host-call")) (_o$9011 (keyword #f "method")) (_o$9012 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$9013 (keyword #f "target")) (_o$9014 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$9015 (keyword #f "args")) (_o$9016 (let* ((_a$9006 (var-deref "clojure.core" "mapv")) (_a$9007 (lambda (p__100_) (let fnrec9005 ((p__100_ p__100_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__100_ env)))) (_a$9008 (jolt-drop 2 items))) (jolt-invoke _a$9006 _a$9007 _a$9008)))) (jolt-hash-map _o$9009 _o$9010 _o$9011 _o$9012 _o$9013 _o$9014 _o$9015 _o$9016))))))) analyze-host-call) (let* ((_o$9017 (keyword #f "private")) (_o$9018 #t)) (jolt-hash-map _o$9017 _o$9018))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec9006 ((nm nm)) (let* ((and__25__auto (jolt-n> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$9007 (var-deref "clojure.core" "subs")) (_a$9008 nm) (_a$9009 (jolt-dec (jolt-count nm))) (_a$9010 (jolt-count nm))) (jolt-invoke _a$9007 _a$9008 _a$9009 _a$9010))))) (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?) (let* ((_o$9011 (keyword #f "private")) (_o$9012 #t)) (jolt-hash-map _o$9011 _o$9012))))
+  (def-var-with-meta! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec9019 ((nm nm)) (let* ((and__25__auto (jolt-n> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$9020 (var-deref "clojure.core" "subs")) (_a$9021 nm) (_a$9022 (jolt-dec (jolt-count nm))) (_a$9023 (jolt-count nm))) (jolt-invoke _a$9020 _a$9021 _a$9022 _a$9023))))) (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?) (let* ((_o$9024 (keyword #f "private")) (_o$9025 #t)) (jolt-hash-map _o$9024 _o$9025))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec9013 ((ctx ctx) (class class) (args args) (env env)) (let* ((_a$9015 (var-deref "jolt.ir" "host-new")) (_a$9016 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "deftype-ctor-class") ctx class))) (if (jolt-truthy? or__26__auto) or__26__auto class))) (_a$9017 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__101_) (let fnrec9014 ((p__101_ p__101_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__101_ env))) args))) (jolt-invoke _a$9015 _a$9016 _a$9017)))))) analyze-ctor) (let* ((_o$9018 (keyword #f "private")) (_o$9019 #t)) (jolt-hash-map _o$9018 _o$9019))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec9026 ((ctx ctx) (class class) (args args) (env env)) (let* ((_a$9028 (var-deref "jolt.ir" "host-new")) (_a$9029 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "deftype-ctor-class") ctx class))) (if (jolt-truthy? or__26__auto) or__26__auto class))) (_a$9030 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__101_) (let fnrec9027 ((p__101_ p__101_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__101_ env))) args))) (jolt-invoke _a$9028 _a$9029 _a$9030)))))) analyze-ctor) (let* ((_o$9031 (keyword #f "private")) (_o$9032 #t)) (jolt-hash-map _o$9031 _o$9032))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec9020 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (jolt-n<= 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$9021 (keyword #f "op")) (_o$9022 (keyword #f "ffi-fn")) (_o$9023 (keyword #f "csym")) (_o$9024 (jolt-nth items 1)) (_o$9025 (keyword #f "argtypes")) (_o$9026 (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$9027 (keyword #f "rettype")) (_o$9028 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$9029 (keyword #f "blocking")) (_o$9030 (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$9021 _o$9022 _o$9023 _o$9024 _o$9025 _o$9026 _o$9027 _o$9028 _o$9029 _o$9030))))))) analyze-ffi-fn) (let* ((_o$9031 (keyword #f "private")) (_o$9032 #t)) (jolt-hash-map _o$9031 _o$9032))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec9033 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (jolt-n<= 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$9034 (keyword #f "op")) (_o$9035 (keyword #f "ffi-fn")) (_o$9036 (keyword #f "csym")) (_o$9037 (jolt-nth items 1)) (_o$9038 (keyword #f "argtypes")) (_o$9039 (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$9040 (keyword #f "rettype")) (_o$9041 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$9042 (keyword #f "blocking")) (_o$9043 (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$9034 _o$9035 _o$9036 _o$9037 _o$9038 _o$9039 _o$9040 _o$9041 _o$9042 _o$9043))))))) analyze-ffi-fn) (let* ((_o$9044 (keyword #f "private")) (_o$9045 #t)) (jolt-hash-map _o$9044 _o$9045))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec9033 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (jolt-n<= 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$9034 (keyword #f "op")) (_o$9035 (keyword #f "ffi-callable")) (_o$9036 (keyword #f "fn")) (_o$9037 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$9038 (keyword #f "argtypes")) (_o$9039 (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$9040 (keyword #f "rettype")) (_o$9041 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$9042 (keyword #f "collect-safe")) (_o$9043 (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$9034 _o$9035 _o$9036 _o$9037 _o$9038 _o$9039 _o$9040 _o$9041 _o$9042 _o$9043))))))) analyze-ffi-callable) (let* ((_o$9044 (keyword #f "private")) (_o$9045 #t)) (jolt-hash-map _o$9044 _o$9045))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec9046 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (jolt-n<= 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$9047 (keyword #f "op")) (_o$9048 (keyword #f "ffi-callable")) (_o$9049 (keyword #f "fn")) (_o$9050 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$9051 (keyword #f "argtypes")) (_o$9052 (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$9053 (keyword #f "rettype")) (_o$9054 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$9055 (keyword #f "collect-safe")) (_o$9056 (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$9047 _o$9048 _o$9049 _o$9050 _o$9051 _o$9052 _o$9053 _o$9054 _o$9055 _o$9056))))))) analyze-ffi-callable) (let* ((_o$9057 (keyword #f "private")) (_o$9058 #t)) (jolt-hash-map _o$9057 _o$9058))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec9046 ((ctx ctx) (items items) (env env)) (begin (if (jolt-n< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member0 (jolt-nth items 2)) (items (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") member0)) (let* ((ml (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") member0)))) (let* ((_a$9050 (let* ((_o$9047 (jolt-nth items 0)) (_o$9048 (jolt-nth items 1)) (_o$9049 (jolt-first ml))) (jolt-vector _o$9047 _o$9048 _o$9049))) (_a$9051 (jolt-rest ml))) (jolt-into _a$9050 _a$9051))) items)) (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$9056 (var-deref "jolt.ir" "invoke")) (_a$9057 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$9058 (let* ((_a$9053 (var-deref "clojure.core" "mapv")) (_a$9054 (lambda (p__102_) (let fnrec9052 ((p__102_ p__102_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__102_ env)))) (_a$9055 (jolt-drop 3 items))) (jolt-invoke _a$9053 _a$9054 _a$9055)))) (jolt-invoke _a$9056 _a$9057 _a$9058)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$9063 (keyword #f "op")) (_o$9064 (keyword #f "host-call")) (_o$9065 (keyword #f "method")) (_o$9066 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$9067 (keyword #f "target")) (_o$9068 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$9069 (keyword #f "args")) (_o$9070 (let* ((_a$9060 (var-deref "clojure.core" "mapv")) (_a$9061 (lambda (p__103_) (let fnrec9059 ((p__103_ p__103_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__103_ env)))) (_a$9062 (jolt-drop 3 items))) (jolt-invoke _a$9060 _a$9061 _a$9062)))) (jolt-hash-map _o$9063 _o$9064 _o$9065 _o$9066 _o$9067 _o$9068 _o$9069 _o$9070)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$9071 (var-deref "jolt.ir" "invoke")) (_a$9072 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$9073 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$9071 _a$9072 _a$9073)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot) (let* ((_o$9074 (keyword #f "private")) (_o$9075 #t)) (jolt-hash-map _o$9074 _o$9075))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec9059 ((ctx ctx) (items items) (env env)) (begin (if (jolt-n< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((member0 (jolt-nth items 2)) (items (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") member0)) (let* ((ml (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") member0)))) (let* ((_a$9063 (let* ((_o$9060 (jolt-nth items 0)) (_o$9061 (jolt-nth items 1)) (_o$9062 (jolt-first ml))) (jolt-vector _o$9060 _o$9061 _o$9062))) (_a$9064 (jolt-rest ml))) (jolt-into _a$9063 _a$9064))) items)) (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$9069 (var-deref "jolt.ir" "invoke")) (_a$9070 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$9071 (let* ((_a$9066 (var-deref "clojure.core" "mapv")) (_a$9067 (lambda (p__102_) (let fnrec9065 ((p__102_ p__102_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__102_ env)))) (_a$9068 (jolt-drop 3 items))) (jolt-invoke _a$9066 _a$9067 _a$9068)))) (jolt-invoke _a$9069 _a$9070 _a$9071)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$9076 (keyword #f "op")) (_o$9077 (keyword #f "host-call")) (_o$9078 (keyword #f "method")) (_o$9079 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$9080 (keyword #f "target")) (_o$9081 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$9082 (keyword #f "args")) (_o$9083 (let* ((_a$9073 (var-deref "clojure.core" "mapv")) (_a$9074 (lambda (p__103_) (let fnrec9072 ((p__103_ p__103_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__103_ env)))) (_a$9075 (jolt-drop 3 items))) (jolt-invoke _a$9073 _a$9074 _a$9075)))) (jolt-hash-map _o$9076 _o$9077 _o$9078 _o$9079 _o$9080 _o$9081 _o$9082 _o$9083)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$9084 (var-deref "jolt.ir" "invoke")) (_a$9085 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$9086 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$9084 _a$9085 _a$9086)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot) (let* ((_o$9087 (keyword #f "private")) (_o$9088 #t)) (jolt-hash-map _o$9087 _o$9088))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec9076 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (jolt-n< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$9077 (keyword #f "op")) (_o$9078 (keyword #f "host-call")) (_o$9079 (keyword #f "method")) (_o$9080 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$9081 (keyword #f "target")) (_o$9082 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$9083 (keyword #f "args")) (_o$9084 (jolt-vector))) (jolt-hash-map _o$9077 _o$9078 _o$9079 _o$9080 _o$9081 _o$9082 _o$9083 _o$9084))))))) analyze-field) (let* ((_o$9085 (keyword #f "private")) (_o$9086 #t)) (jolt-hash-map _o$9085 _o$9086))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec9089 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (jolt-n< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$9090 (keyword #f "op")) (_o$9091 (keyword #f "host-call")) (_o$9092 (keyword #f "method")) (_o$9093 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$9094 (keyword #f "target")) (_o$9095 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$9096 (keyword #f "args")) (_o$9097 (jolt-vector))) (jolt-hash-map _o$9090 _o$9091 _o$9092 _o$9093 _o$9094 _o$9095 _o$9096 _o$9097))))))) analyze-field) (let* ((_o$9098 (keyword #f "private")) (_o$9099 #t)) (jolt-hash-map _o$9098 _o$9099))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec9087 ((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__155 (let* ((_a$9088 (var-deref "jolt.ir" "var-ref")) (_a$9089 (jolt-get r (keyword #f "ns"))) (_a$9090 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$9088 _a$9089 _a$9090)))) (let* ((G__156 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__155 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__155))) G__156)) (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__157 (jolt-get r (keyword #f "kind")))) (if (jolt= G__157 (keyword #f "var")) (let* ((G__158 (let* ((_a$9091 (var-deref "jolt.ir" "var-ref")) (_a$9092 (jolt-get r (keyword #f "ns"))) (_a$9093 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$9091 _a$9092 _a$9093)))) (let* ((G__159 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__158 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__158))) G__159)) (if (jolt= G__157 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__157 (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) (let* ((_o$9094 (keyword #f "private")) (_o$9095 #t)) (jolt-hash-map _o$9094 _o$9095))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec9100 ((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__153 (let* ((_a$9101 (var-deref "jolt.ir" "var-ref")) (_a$9102 (jolt-get r (keyword #f "ns"))) (_a$9103 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$9101 _a$9102 _a$9103)))) (let* ((G__154 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__153 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__153))) G__154)) (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__155 (jolt-get r (keyword #f "kind")))) (if (jolt= G__155 (keyword #f "var")) (let* ((G__156 (let* ((_a$9104 (var-deref "jolt.ir" "var-ref")) (_a$9105 (jolt-get r (keyword #f "ns"))) (_a$9106 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$9104 _a$9105 _a$9106)))) (let* ((G__157 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__156 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__156))) G__157)) (if (jolt= G__155 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__155 (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) (let* ((_o$9107 (keyword #f "private")) (_o$9108 #t)) (jolt-hash-map _o$9107 _o$9108))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "unchecked-arith" (letrec ((unchecked-arith (lambda (hname n) (let fnrec9096 ((hname hname) (n n)) (if (jolt= hname "+") "unchecked-add" (if (jolt= hname "*") "unchecked-multiply" (if (jolt= hname "-") (if (jolt= n 2) "unchecked-negate" "unchecked-subtract") (if (jolt= hname "inc") "unchecked-inc" (if (jolt= hname "dec") "unchecked-dec" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))))) unchecked-arith) (let* ((_o$9097 (keyword #f "private")) (_o$9098 #t)) (jolt-hash-map _o$9097 _o$9098))))
+  (def-var-with-meta! "jolt.analyzer" "unchecked-arith" (letrec ((unchecked-arith (lambda (hname n) (let fnrec9109 ((hname hname) (n n)) (if (jolt= hname "+") "unchecked-add" (if (jolt= hname "*") "unchecked-multiply" (if (jolt= hname "-") (if (jolt= n 2) "unchecked-negate" "unchecked-subtract") (if (jolt= hname "inc") "unchecked-inc" (if (jolt= hname "dec") "unchecked-dec" (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))))) unchecked-arith) (let* ((_o$9110 (keyword #f "private")) (_o$9111 #t)) (jolt-hash-map _o$9110 _o$9111))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec9099 ((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)) (sf-name (let* ((or__26__auto hname)) (if (jolt-truthy? or__26__auto) or__26__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= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) 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))) (unm (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "unchecked-math?"))) (let* ((opn (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (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)))) (if (jolt-truthy? opn) (jolt-invoke (var-deref "jolt.analyzer" "unchecked-arith") opn (jolt-count items)) jolt-nil)) jolt-nil))) (if (jolt-truthy? unm) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (let* ((_a$9100 (jolt-invoke (var-deref "clojure.core" "symbol") unm)) (_a$9101 (jolt-rest items))) (jolt-cons _a$9100 _a$9101)) 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-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name)))) (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 (jolt-invoke (var-deref "jolt.analyzer" "amp-env-map") env)) 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 sf-name)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx sf-name 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$9102 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$9103 ctx) (_a$9104 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$9105 (jolt-rest items)) (_a$9106 env)) (jolt-invoke _a$9102 _a$9103 _a$9104 _a$9105 _a$9106)) (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-n>= (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$9107 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$9108 ctx) (_a$9109 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$9110 (jolt-drop 2 items)) (_a$9111 env)) (jolt-invoke _a$9107 _a$9108 _a$9109 _a$9110 _a$9111)) (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$9116 (var-deref "jolt.ir" "invoke")) (_a$9117 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$9118 (let* ((_a$9113 (var-deref "clojure.core" "mapv")) (_a$9114 (lambda (p__104_) (let fnrec9112 ((p__104_ p__104_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__104_ env)))) (_a$9115 (jolt-rest items))) (jolt-invoke _a$9113 _a$9114 _a$9115)))) (jolt-invoke _a$9116 _a$9117 _a$9118))) (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) (let* ((_o$9119 (keyword #f "private")) (_o$9120 #t)) (jolt-hash-map _o$9119 _o$9120))))
+  (def-var-with-meta! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec9112 ((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)) (sf-name (let* ((or__26__auto hname)) (if (jolt-truthy? or__26__auto) or__26__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= "clojure.core" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) 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))) (unm (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "unchecked-math?"))) (let* ((opn (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (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)))) (if (jolt-truthy? opn) (jolt-invoke (var-deref "jolt.analyzer" "unchecked-arith") opn (jolt-count items)) jolt-nil)) jolt-nil))) (if (jolt-truthy? unm) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (let* ((_a$9113 (jolt-invoke (var-deref "clojure.core" "symbol") unm)) (_a$9114 (jolt-rest items))) (jolt-cons _a$9113 _a$9114)) 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-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name)))) (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 (jolt-invoke (var-deref "jolt.analyzer" "amp-env-map") env)) 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 sf-name)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") sf-name) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx sf-name 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$9115 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$9116 ctx) (_a$9117 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$9118 (jolt-rest items)) (_a$9119 env)) (jolt-invoke _a$9115 _a$9116 _a$9117 _a$9118 _a$9119)) (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-n>= (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$9120 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$9121 ctx) (_a$9122 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$9123 (jolt-drop 2 items)) (_a$9124 env)) (jolt-invoke _a$9120 _a$9121 _a$9122 _a$9123 _a$9124)) (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$9129 (var-deref "jolt.ir" "invoke")) (_a$9130 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$9131 (let* ((_a$9126 (var-deref "clojure.core" "mapv")) (_a$9127 (lambda (p__104_) (let fnrec9125 ((p__104_ p__104_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__104_ env)))) (_a$9128 (jolt-rest items))) (jolt-invoke _a$9126 _a$9127 _a$9128)))) (jolt-invoke _a$9129 _a$9130 _a$9131))) (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) (let* ((_o$9132 (keyword #f "private")) (_o$9133 #t)) (jolt-hash-map _o$9132 _o$9133))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec9121 ((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$9124 (var-deref "jolt.ir" "invoke")) (_a$9125 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$9126 (let* ((_o$9122 node) (_o$9123 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$9122 _o$9123)))) (jolt-invoke _a$9124 _a$9125 _a$9126)))))))) with-coll-meta) (let* ((_o$9127 (keyword #f "private")) (_o$9128 #t)) (jolt-hash-map _o$9127 _o$9128))))
+  (def-var-with-meta! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec9134 ((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$9137 (var-deref "jolt.ir" "invoke")) (_a$9138 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$9139 (let* ((_o$9135 node) (_o$9136 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$9135 _o$9136)))) (jolt-invoke _a$9137 _a$9138 _a$9139)))))))) with-coll-meta) (let* ((_o$9140 (keyword #f "private")) (_o$9141 #t)) (jolt-hash-map _o$9140 _o$9141))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec9129 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec9130 ((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$9132 (var-deref "clojure.core" "mapv")) (_a$9133 (lambda (p__105_) (let fnrec9131 ((p__105_ p__105_)) (analyze ctx p__105_ env)))) (_a$9134 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$9132 _a$9133 _a$9134)))) (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$9138 (var-deref "clojure.core" "mapv")) (_a$9139 (lambda (p) (let fnrec9135 ((p p)) (let* ((_o$9136 (analyze ctx (jolt-first p) env)) (_o$9137 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$9136 _o$9137))))) (_a$9140 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$9138 _a$9139 _a$9140)))) (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$9142 (var-deref "clojure.core" "mapv")) (_a$9143 (lambda (p__106_) (let fnrec9141 ((p__106_ p__106_)) (analyze ctx p__106_ env)))) (_a$9144 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$9142 _a$9143 _a$9144)))) (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$9145 (keyword #f "op")) (_o$9146 (keyword #f "regex")) (_o$9147 (keyword #f "source")) (_o$9148 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$9145 _o$9146 _o$9147 _o$9148)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$9149 (keyword #f "op")) (_o$9150 (keyword #f "inst")) (_o$9151 (keyword #f "source")) (_o$9152 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$9149 _o$9150 _o$9151 _o$9152)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$9153 (keyword #f "op")) (_o$9154 (keyword #f "uuid")) (_o$9155 (keyword #f "source")) (_o$9156 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$9153 _o$9154 _o$9155 _o$9156)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$9157 (keyword #f "op")) (_o$9158 (keyword #f "bigdec")) (_o$9159 (keyword #f "source")) (_o$9160 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$9157 _o$9158 _o$9159 _o$9160)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$9161 (keyword #f "op")) (_o$9162 (keyword #f "the-ns")) (_o$9163 (keyword #f "name")) (_o$9164 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$9161 _o$9162 _o$9163 _o$9164)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-var-value?") form)) (let* ((_a$9165 (var-deref "jolt.ir" "the-var")) (_a$9166 (jolt-invoke (var-deref "jolt.host" "form-var-value-ns") form)) (_a$9167 (jolt-invoke (var-deref "jolt.host" "form-var-value-name") form))) (jolt-invoke _a$9165 _a$9166 _a$9167)) (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 fnrec9142 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec9143 ((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$9145 (var-deref "clojure.core" "mapv")) (_a$9146 (lambda (p__105_) (let fnrec9144 ((p__105_ p__105_)) (analyze ctx p__105_ env)))) (_a$9147 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$9145 _a$9146 _a$9147)))) (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$9151 (var-deref "clojure.core" "mapv")) (_a$9152 (lambda (p) (let fnrec9148 ((p p)) (let* ((_o$9149 (analyze ctx (jolt-first p) env)) (_o$9150 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$9149 _o$9150))))) (_a$9153 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$9151 _a$9152 _a$9153)))) (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$9155 (var-deref "clojure.core" "mapv")) (_a$9156 (lambda (p__106_) (let fnrec9154 ((p__106_ p__106_)) (analyze ctx p__106_ env)))) (_a$9157 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$9155 _a$9156 _a$9157)))) (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$9158 (keyword #f "op")) (_o$9159 (keyword #f "regex")) (_o$9160 (keyword #f "source")) (_o$9161 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$9158 _o$9159 _o$9160 _o$9161)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$9162 (keyword #f "op")) (_o$9163 (keyword #f "inst")) (_o$9164 (keyword #f "source")) (_o$9165 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$9162 _o$9163 _o$9164 _o$9165)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$9166 (keyword #f "op")) (_o$9167 (keyword #f "uuid")) (_o$9168 (keyword #f "source")) (_o$9169 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$9166 _o$9167 _o$9168 _o$9169)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$9170 (keyword #f "op")) (_o$9171 (keyword #f "bigdec")) (_o$9172 (keyword #f "source")) (_o$9173 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$9170 _o$9171 _o$9172 _o$9173)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$9174 (keyword #f "op")) (_o$9175 (keyword #f "the-ns")) (_o$9176 (keyword #f "name")) (_o$9177 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$9174 _o$9175 _o$9176 _o$9177)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-var-value?") form)) (let* ((_a$9178 (var-deref "jolt.ir" "the-var")) (_a$9179 (jolt-invoke (var-deref "jolt.host" "form-var-value-ns") form)) (_a$9180 (jolt-invoke (var-deref "jolt.host" "form-var-value-name") form))) (jolt-invoke _a$9178 _a$9179 _a$9180)) (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$7267 "+") (_o$7268 "jolt-n+") (_o$7269 "-") (_o$7270 "jolt-n-") (_o$7271 "*") (_o$7272 "jolt-n*") (_o$7273 "/") (_o$7274 "jolt-n-div") (_o$7275 "<") (_o$7276 "jolt-n<") (_o$7277 ">") (_o$7278 "jolt-n>") (_o$7279 "<=") (_o$7280 "jolt-n<=") (_o$7281 ">=") (_o$7282 "jolt-n>=") (_o$7283 "=") (_o$7284 "jolt=") (_o$7285 "inc") (_o$7286 "jolt-inc") (_o$7287 "dec") (_o$7288 "jolt-dec") (_o$7289 "not") (_o$7290 "jolt-not") (_o$7291 "min") (_o$7292 "jolt-n-min") (_o$7293 "max") (_o$7294 "jolt-n-max") (_o$7295 "mod") (_o$7296 "jolt-mod") (_o$7297 "rem") (_o$7298 "jolt-rem") (_o$7299 "quot") (_o$7300 "jolt-quot") (_o$7301 "vector") (_o$7302 "jolt-vector") (_o$7303 "hash-map") (_o$7304 "jolt-hash-map-fn") (_o$7305 "hash-set") (_o$7306 "jolt-hash-set") (_o$7307 "conj") (_o$7308 "jolt-conj") (_o$7309 "get") (_o$7310 "jolt-get") (_o$7311 "nth") (_o$7312 "jolt-nth") (_o$7313 "count") (_o$7314 "jolt-count") (_o$7315 "assoc") (_o$7316 "jolt-assoc") (_o$7317 "dissoc") (_o$7318 "jolt-dissoc") (_o$7319 "contains?") (_o$7320 "jolt-contains?") (_o$7321 "empty?") (_o$7322 "jolt-empty?") (_o$7323 "peek") (_o$7324 "jolt-peek") (_o$7325 "pop") (_o$7326 "jolt-pop") (_o$7327 "first") (_o$7328 "jolt-first") (_o$7329 "rest") (_o$7330 "jolt-rest") (_o$7331 "next") (_o$7332 "jolt-next") (_o$7333 "seq") (_o$7334 "jolt-seq") (_o$7335 "cons") (_o$7336 "jolt-cons") (_o$7337 "list") (_o$7338 "jolt-list") (_o$7339 "reverse") (_o$7340 "jolt-reverse") (_o$7341 "last") (_o$7342 "jolt-last") (_o$7343 "map") (_o$7344 "jolt-map") (_o$7345 "filter") (_o$7346 "jolt-filter") (_o$7347 "remove") (_o$7348 "jolt-remove") (_o$7349 "reduce") (_o$7350 "jolt-reduce") (_o$7351 "into") (_o$7352 "jolt-into") (_o$7353 "concat") (_o$7354 "jolt-concat") (_o$7355 "apply") (_o$7356 "jolt-apply") (_o$7357 "range") (_o$7358 "jolt-range") (_o$7359 "take") (_o$7360 "jolt-take") (_o$7361 "drop") (_o$7362 "jolt-drop") (_o$7363 "keys") (_o$7364 "jolt-keys") (_o$7365 "vals") (_o$7366 "jolt-vals") (_o$7367 "even?") (_o$7368 "jolt-even?") (_o$7369 "odd?") (_o$7370 "jolt-odd?") (_o$7371 "pos?") (_o$7372 "jolt-pos?") (_o$7373 "neg?") (_o$7374 "jolt-neg?") (_o$7375 "zero?") (_o$7376 "jolt-zero?") (_o$7377 "identity") (_o$7378 "jolt-identity") (_o$7379 "nil?") (_o$7380 "jolt-nil?") (_o$7381 "some?") (_o$7382 "jolt-some?") (_o$7383 "ex-info") (_o$7384 "jolt-ex-info") (_o$7385 "bit-and") (_o$7386 "bitwise-and") (_o$7387 "bit-or") (_o$7388 "bitwise-ior") (_o$7389 "bit-xor") (_o$7390 "bitwise-xor") (_o$7391 "bit-not") (_o$7392 "bitwise-not") (_o$7393 "bit-shift-left") (_o$7394 "jolt-bit-shift-left") (_o$7395 "bit-shift-right") (_o$7396 "jolt-bit-shift-right") (_o$7397 "unsigned-bit-shift-right") (_o$7398 "jolt-unsigned-bit-shift-right") (_o$7399 "protocol-dispatch1") (_o$7400 "protocol-dispatch1") (_o$7401 "protocol-dispatch2") (_o$7402 "protocol-dispatch2") (_o$7403 "protocol-dispatch3") (_o$7404 "protocol-dispatch3")) (jolt-hash-map _o$7267 _o$7268 _o$7269 _o$7270 _o$7271 _o$7272 _o$7273 _o$7274 _o$7275 _o$7276 _o$7277 _o$7278 _o$7279 _o$7280 _o$7281 _o$7282 _o$7283 _o$7284 _o$7285 _o$7286 _o$7287 _o$7288 _o$7289 _o$7290 _o$7291 _o$7292 _o$7293 _o$7294 _o$7295 _o$7296 _o$7297 _o$7298 _o$7299 _o$7300 _o$7301 _o$7302 _o$7303 _o$7304 _o$7305 _o$7306 _o$7307 _o$7308 _o$7309 _o$7310 _o$7311 _o$7312 _o$7313 _o$7314 _o$7315 _o$7316 _o$7317 _o$7318 _o$7319 _o$7320 _o$7321 _o$7322 _o$7323 _o$7324 _o$7325 _o$7326 _o$7327 _o$7328 _o$7329 _o$7330 _o$7331 _o$7332 _o$7333 _o$7334 _o$7335 _o$7336 _o$7337 _o$7338 _o$7339 _o$7340 _o$7341 _o$7342 _o$7343 _o$7344 _o$7345 _o$7346 _o$7347 _o$7348 _o$7349 _o$7350 _o$7351 _o$7352 _o$7353 _o$7354 _o$7355 _o$7356 _o$7357 _o$7358 _o$7359 _o$7360 _o$7361 _o$7362 _o$7363 _o$7364 _o$7365 _o$7366 _o$7367 _o$7368 _o$7369 _o$7370 _o$7371 _o$7372 _o$7373 _o$7374 _o$7375 _o$7376 _o$7377 _o$7378 _o$7379 _o$7380 _o$7381 _o$7382 _o$7383 _o$7384 _o$7385 _o$7386 _o$7387 _o$7388 _o$7389 _o$7390 _o$7391 _o$7392 _o$7393 _o$7394 _o$7395 _o$7396 _o$7397 _o$7398 _o$7399 _o$7400 _o$7401 _o$7402 _o$7403 _o$7404)) (let* ((_o$7405 (keyword #f "private")) (_o$7406 #t)) (jolt-hash-map _o$7405 _o$7406))))
 (guard (e (#t #f))
@@ -165,123 +165,141 @@
 (guard (e (#t #f))
   (def-var! "jolt.backend-scheme" "set-var-cache!" (letrec ((set-var-cache! (lambda (on) (let fnrec7714 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "var-cache?") on))))) set-var-cache!)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7715 ((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) (let* ((_o$7716 (keyword #f "private")) (_o$7717 #t)) (jolt-hash-map _o$7716 _o$7717))))
+  (def-var! "jolt.backend-scheme" "trace-frames?" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7718 ((ns ns) (nm nm)) (let* ((_a$7719 (var-deref "clojure.core" "str")) (_a$7720 "jv$") (_a$7721 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7722 "$") (_a$7723 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7719 _a$7720 _a$7721 _a$7722 _a$7723)))))) dl-name) (let* ((_o$7724 (keyword #f "private")) (_o$7725 #t)) (jolt-hash-map _o$7724 _o$7725))))
+  (def-var! "jolt.backend-scheme" "set-trace-frames!" (letrec ((set-trace-frames! (lambda (on) (let fnrec7715 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "trace-frames?") on))))) set-trace-frames!)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7726 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn) (let* ((_o$7727 (keyword #f "private")) (_o$7728 #t)) (jolt-hash-map _o$7727 _o$7728))))
+  (def-var-with-meta! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec7716 ((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) (let* ((_o$7717 (keyword #f "private")) (_o$7718 #t)) (jolt-hash-map _o$7717 _o$7718))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7729 ((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$7730 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7731 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7730 _a$7731)) and__25__auto)))))) direct-linkable?) (let* ((_o$7732 (keyword #f "private")) (_o$7733 #t)) (jolt-hash-map _o$7732 _o$7733))))
+  (def-var-with-meta! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec7719 ((ns ns) (nm nm)) (let* ((_a$7720 (var-deref "clojure.core" "str")) (_a$7721 "jv$") (_a$7722 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$7723 "$") (_a$7724 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$7720 _a$7721 _a$7722 _a$7723 _a$7724)))))) dl-name) (let* ((_o$7725 (keyword #f "private")) (_o$7726 #t)) (jolt-hash-map _o$7725 _o$7726))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7734 ((ns ns) (nm nm)) (let* ((_a$7735 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7736 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7735 _a$7736)))))) direct-link-fn?) (let* ((_o$7737 (keyword #f "private")) (_o$7738 #t)) (jolt-hash-map _o$7737 _o$7738))))
+  (def-var-with-meta! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec7727 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn) (let* ((_o$7728 (keyword #f "private")) (_o$7729 #t)) (jolt-hash-map _o$7728 _o$7729))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7739 (keyword #f "dynamic")) (_o$7740 #t)) (jolt-hash-map _o$7739 _o$7740))))
+  (def-var-with-meta! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec7730 ((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$7731 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$7732 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7731 _a$7732)) and__25__auto)))))) direct-linkable?) (let* ((_o$7733 (keyword #f "private")) (_o$7734 #t)) (jolt-hash-map _o$7733 _o$7734))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7741 (keyword #f "dynamic")) (_o$7742 #t)) (jolt-hash-map _o$7741 _o$7742))))
+  (def-var-with-meta! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec7735 ((ns ns) (nm nm)) (let* ((_a$7736 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$7737 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$7736 _a$7737)))))) direct-link-fn?) (let* ((_o$7738 (keyword #f "private")) (_o$7739 #t)) (jolt-hash-map _o$7738 _o$7739))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7743 (keyword #f "private")) (_o$7744 #t)) (jolt-hash-map _o$7743 _o$7744))))
+  (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$7740 (keyword #f "dynamic")) (_o$7741 #t)) (jolt-hash-map _o$7740 _o$7741))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7745 ((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) (let* ((_o$7746 (keyword #f "private")) (_o$7747 #t)) (jolt-hash-map _o$7746 _o$7747))))
+  (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$7742 (keyword #f "dynamic")) (_o$7743 #t)) (jolt-hash-map _o$7742 _o$7743))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "cache-cells" (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil) (let* ((_o$7748 (keyword #f "private")) (_o$7749 #t)) (jolt-hash-map _o$7748 _o$7749))))
+  (def-var-with-meta! "jolt.backend-scheme" "*tail?*" #f (let* ((_o$7744 (keyword #f "dynamic")) (_o$7745 #t)) (jolt-hash-map _o$7744 _o$7745))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-with-cells" (letrec ((emit-with-cells (lambda (emit-thunk) (let fnrec7750 ((emit-thunk emit-thunk)) (let* ((cells (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (prev (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "cache-cells") cells)) (raw (jolt-invoke emit-thunk)) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "cache-cells") prev))) (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-invoke (var-deref "clojure.core" "str") "(let (" (jolt-invoke (var-deref "clojure.string" "join") " " (let* ((_a$7752 (lambda (c) (let fnrec7751 ((c c)) (jolt-invoke (var-deref "clojure.core" "str") "(" c " #f)")))) (_a$7753 (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-map _a$7752 _a$7753))) ") " raw ")") raw)))))) emit-with-cells) (let* ((_o$7754 (keyword #f "private")) (_o$7755 #t)) (jolt-hash-map _o$7754 _o$7755))))
+  (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7746 (keyword #f "private")) (_o$7747 #t)) (jolt-hash-map _o$7746 _o$7747))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7756 "if") (_o$7757 "begin") (_o$7758 "lambda") (_o$7759 "let") (_o$7760 "let*") (_o$7761 "letrec") (_o$7762 "letrec*") (_o$7763 "quote") (_o$7764 "quasiquote") (_o$7765 "unquote") (_o$7766 "set!") (_o$7767 "define") (_o$7768 "define-syntax") (_o$7769 "cond") (_o$7770 "case") (_o$7771 "when") (_o$7772 "unless") (_o$7773 "and") (_o$7774 "or") (_o$7775 "do") (_o$7776 "else") (_o$7777 "guard") (_o$7778 "parameterize") (_o$7779 "delay") (_o$7780 "values")) (jolt-hash-set _o$7756 _o$7757 _o$7758 _o$7759 _o$7760 _o$7761 _o$7762 _o$7763 _o$7764 _o$7765 _o$7766 _o$7767 _o$7768 _o$7769 _o$7770 _o$7771 _o$7772 _o$7773 _o$7774 _o$7775 _o$7776 _o$7777 _o$7778 _o$7779 _o$7780)) (let* ((_o$7781 (keyword #f "private")) (_o$7782 #t)) (jolt-hash-map _o$7781 _o$7782))))
+  (def-var-with-meta! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec7748 ((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) (let* ((_o$7749 (keyword #f "private")) (_o$7750 #t)) (jolt-hash-map _o$7749 _o$7750))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "bare-native-names" (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "clojure.core" "keep") (lambda (G__141) (let fnrec7783 ((G__141 G__141)) (let* ((G__142 G__141) (k (jolt-nth G__142 0 jolt-nil)) (v (jolt-nth G__142 1 jolt-nil))) (if (jolt= k v) k jolt-nil)))) (var-deref "jolt.backend-scheme" "native-ops"))) (let* ((_o$7784 (keyword #f "private")) (_o$7785 #t)) (jolt-hash-map _o$7784 _o$7785))))
+  (def-var-with-meta! "jolt.backend-scheme" "cache-cells" (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil) (let* ((_o$7751 (keyword #f "private")) (_o$7752 #t)) (jolt-hash-map _o$7751 _o$7752))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7786 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (let* ((or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "bare-native-names") s))) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name) (let* ((_o$7787 (keyword #f "private")) (_o$7788 #t)) (jolt-hash-map _o$7787 _o$7788))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-with-cells" (letrec ((emit-with-cells (lambda (emit-thunk) (let fnrec7753 ((emit-thunk emit-thunk)) (let* ((cells (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (prev (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "cache-cells") cells)) (raw (jolt-invoke emit-thunk)) (_ (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "cache-cells") prev))) (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-invoke (var-deref "clojure.core" "str") "(let (" (jolt-invoke (var-deref "clojure.string" "join") " " (let* ((_a$7755 (lambda (c) (let fnrec7754 ((c c)) (jolt-invoke (var-deref "clojure.core" "str") "(" c " #f)")))) (_a$7756 (jolt-invoke (var-deref "clojure.core" "deref") cells))) (jolt-map _a$7755 _a$7756))) ") " raw ")") raw)))))) emit-with-cells) (let* ((_o$7757 (keyword #f "private")) (_o$7758 #t)) (jolt-hash-map _o$7757 _o$7758))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$7759 "if") (_o$7760 "begin") (_o$7761 "lambda") (_o$7762 "let") (_o$7763 "let*") (_o$7764 "letrec") (_o$7765 "letrec*") (_o$7766 "quote") (_o$7767 "quasiquote") (_o$7768 "unquote") (_o$7769 "set!") (_o$7770 "define") (_o$7771 "define-syntax") (_o$7772 "cond") (_o$7773 "case") (_o$7774 "when") (_o$7775 "unless") (_o$7776 "and") (_o$7777 "or") (_o$7778 "do") (_o$7779 "else") (_o$7780 "guard") (_o$7781 "parameterize") (_o$7782 "delay") (_o$7783 "values")) (jolt-hash-set _o$7759 _o$7760 _o$7761 _o$7762 _o$7763 _o$7764 _o$7765 _o$7766 _o$7767 _o$7768 _o$7769 _o$7770 _o$7771 _o$7772 _o$7773 _o$7774 _o$7775 _o$7776 _o$7777 _o$7778 _o$7779 _o$7780 _o$7781 _o$7782 _o$7783)) (let* ((_o$7784 (keyword #f "private")) (_o$7785 #t)) (jolt-hash-map _o$7784 _o$7785))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "bare-native-names" (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "clojure.core" "keep") (lambda (G__141) (let fnrec7786 ((G__141 G__141)) (let* ((G__142 G__141) (k (jolt-nth G__142 0 jolt-nil)) (v (jolt-nth G__142 1 jolt-nil))) (if (jolt= k v) k jolt-nil)))) (var-deref "jolt.backend-scheme" "native-ops"))) (let* ((_o$7787 (keyword #f "private")) (_o$7788 #t)) (jolt-hash-map _o$7787 _o$7788))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec7789 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (let* ((or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.backend-scheme" "bare-native-names") s))) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name) (let* ((_o$7790 (keyword #f "private")) (_o$7791 #t)) (jolt-hash-map _o$7790 _o$7791))))
 (guard (e (#t #f))
   (declare-var! "jolt.backend-scheme" "emit"))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7789 ((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 (jolt-n>= cp 32))) (if (jolt-truthy? and__25__auto) (jolt-n< 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) (let* ((_o$7790 (keyword #f "private")) (_o$7791 #t)) (jolt-hash-map _o$7790 _o$7791))))
+  (declare-var! "jolt.backend-scheme" "emit*"))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7792 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7793 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit) (let* ((_o$7794 (keyword #f "private")) (_o$7795 #t)) (jolt-hash-map _o$7794 _o$7795))))
+  (def-var-with-meta! "jolt.backend-scheme" "tail-transparent-ops" (let* ((_o$7792 (keyword #f "if")) (_o$7793 (keyword #f "do")) (_o$7794 (keyword #f "let")) (_o$7795 (keyword #f "loop")) (_o$7796 (keyword #f "invoke"))) (jolt-hash-set _o$7792 _o$7793 _o$7794 _o$7795 _o$7796)) (let* ((_o$7797 (keyword #f "private")) (_o$7798 #t)) (jolt-hash-map _o$7797 _o$7798))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7796 ((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$7797 (var-deref "clojure.core" "str")) (_a$7798 "(keyword ") (_a$7799 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7800 " ") (_a$7801 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7802 ")")) (jolt-invoke _a$7797 _a$7798 _a$7799 _a$7800 _a$7801 _a$7802))) (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$7803 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7804 (jolt-hash-map))) (jolt-ex-info _a$7803 _a$7804))) jolt-nil))))))))))) emit-const) (let* ((_o$7805 (keyword #f "private")) (_o$7806 #t)) (jolt-hash-map _o$7805 _o$7806))))
+  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7799 ((node node)) (if (jolt-truthy? (let* ((and__25__auto (var-deref "jolt.backend-scheme" "*tail?*"))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "tail-transparent-ops") (jolt-get node (keyword #f "op")))) and__25__auto))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*tail?*") #f))) (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*") node)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit*") node)))))) emit)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7807 ((ctor ctor) (arg-strs arg-strs)) (if (jolt-n< (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 fnrec7808 ((_ _)) (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 fnrec7809 ((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) (let* ((_o$7810 (keyword #f "private")) (_o$7811 #t)) (jolt-hash-map _o$7810 _o$7811))))
+  (def-var-with-meta! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec7800 ((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 (jolt-n>= cp 32))) (if (jolt-truthy? and__25__auto) (jolt-n< 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) (let* ((_o$7801 (keyword #f "private")) (_o$7802 #t)) (jolt-hash-map _o$7801 _o$7802))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7812 ((n n)) (let* ((_a$7818 (let* ((_o$7813 (keyword #f "const")) (_o$7814 (keyword #f "local")) (_o$7815 (keyword #f "var")) (_o$7816 (keyword #f "the-var")) (_o$7817 (keyword #f "quote"))) (jolt-hash-set _o$7813 _o$7814 _o$7815 _o$7816 _o$7817))) (_a$7819 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7818 _a$7819)))))) side-effect-free?) (let* ((_o$7820 (keyword #f "private")) (_o$7821 #t)) (jolt-hash-map _o$7820 _o$7821))))
+  (def-var-with-meta! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec7803 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec7804 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit) (let* ((_o$7805 (keyword #f "private")) (_o$7806 #t)) (jolt-hash-map _o$7805 _o$7806))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7822 ((nodes nodes)) (jolt-n> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?) (let* ((_o$7823 (keyword #f "private")) (_o$7824 #t)) (jolt-hash-map _o$7823 _o$7824))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec7807 ((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$7808 (var-deref "clojure.core" "str")) (_a$7809 "(keyword ") (_a$7810 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$7811 " ") (_a$7812 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$7813 ")")) (jolt-invoke _a$7808 _a$7809 _a$7810 _a$7811 _a$7812 _a$7813))) (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$7814 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$7815 (jolt-hash-map))) (jolt-ex-info _a$7814 _a$7815))) jolt-nil))))))))))) emit-const) (let* ((_o$7816 (keyword #f "private")) (_o$7817 #t)) (jolt-hash-map _o$7816 _o$7817))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7825 ((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 fnrec7826 ((_ _)) (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 fnrec7827 ((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) (let* ((_o$7828 (keyword #f "private")) (_o$7829 #t)) (jolt-hash-map _o$7828 _o$7829))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec7818 ((ctor ctor) (arg-strs arg-strs)) (if (jolt-n< (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 fnrec7819 ((_ _)) (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 fnrec7820 ((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) (let* ((_o$7821 (keyword #f "private")) (_o$7822 #t)) (jolt-hash-map _o$7821 _o$7822))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec7823 ((n n)) (let* ((_a$7829 (let* ((_o$7824 (keyword #f "const")) (_o$7825 (keyword #f "local")) (_o$7826 (keyword #f "var")) (_o$7827 (keyword #f "the-var")) (_o$7828 (keyword #f "quote"))) (jolt-hash-set _o$7824 _o$7825 _o$7826 _o$7827 _o$7828))) (_a$7830 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$7829 _a$7830)))))) side-effect-free?) (let* ((_o$7831 (keyword #f "private")) (_o$7832 #t)) (jolt-hash-map _o$7831 _o$7832))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec7833 ((nodes nodes)) (jolt-n> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?) (let* ((_o$7834 (keyword #f "private")) (_o$7835 #t)) (jolt-hash-map _o$7834 _o$7835))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec7836 ((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 fnrec7837 ((_ _)) (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 fnrec7838 ((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) (let* ((_o$7839 (keyword #f "private")) (_o$7840 #t)) (jolt-hash-map _o$7839 _o$7840))))
 (guard (e (#t #f))
   (declare-var! "jolt.backend-scheme" "emit-quoted"))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7830 ((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 fnrec7831 ((p p)) (let* ((_o$7832 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7833 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7832 _o$7833)))) pairs)) ")"))))) emit-quoted-map) (let* ((_o$7834 (keyword #f "private")) (_o$7835 #t)) (jolt-hash-map _o$7834 _o$7835))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec7841 ((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 fnrec7842 ((p p)) (let* ((_o$7843 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$7844 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$7843 _o$7844)))) pairs)) ")"))))) emit-quoted-map) (let* ((_o$7845 (keyword #f "private")) (_o$7846 #t)) (jolt-hash-map _o$7845 _o$7846))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7836 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7842 (lambda (k) (let fnrec7837 ((k k)) (let* ((_a$7838 (var-deref "clojure.core" "str")) (_a$7839 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7840 " ") (_a$7841 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7838 _a$7839 _a$7840 _a$7841))))) (_a$7843 (jolt-keys m))) (jolt-map _a$7842 _a$7843))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value) (let* ((_o$7844 (keyword #f "private")) (_o$7845 #t)) (jolt-hash-map _o$7844 _o$7845))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec7847 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$7853 (lambda (k) (let fnrec7848 ((k k)) (let* ((_a$7849 (var-deref "clojure.core" "str")) (_a$7850 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$7851 " ") (_a$7852 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$7849 _a$7850 _a$7851 _a$7852))))) (_a$7854 (jolt-keys m))) (jolt-map _a$7853 _a$7854))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value) (let* ((_o$7855 (keyword #f "private")) (_o$7856 #t)) (jolt-hash-map _o$7855 _o$7856))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7846 ((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$7847 (var-deref "clojure.core" "str")) (_a$7848 "(jolt-symbol/meta ") (_a$7849 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7850 " ") (_a$7851 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7852 " ") (_a$7853 (emit-quoted m)) (_a$7854 ")")) (jolt-invoke _a$7847 _a$7848 _a$7849 _a$7850 _a$7851 _a$7852 _a$7853 _a$7854)) (let* ((_a$7855 (var-deref "clojure.core" "str")) (_a$7856 "(jolt-symbol ") (_a$7857 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7858 " ") (_a$7859 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7860 ")")) (jolt-invoke _a$7855 _a$7856 _a$7857 _a$7858 _a$7859 _a$7860)))) (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 "jolt.host" "form-inst?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-inst-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form)) ")") (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") form))) (if (jolt-truthy? and__25__auto) (jolt= (keyword "jolt" "tagged") (jolt-get form (keyword "jolt" "type"))) and__25__auto))) (let* ((nm (jolt-invoke (var-deref "clojure.core" "name") (jolt-get form (keyword #f "tag")))) (tsym (if (jolt= (integer->char 35) (jolt-first nm)) (jolt-invoke (var-deref "clojure.core" "subs") nm 1) nm))) (let* ((_a$7861 (var-deref "clojure.core" "str")) (_a$7862 "(jolt-tagged-literal (jolt-symbol #f ") (_a$7863 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") tsym)) (_a$7864 ") ") (_a$7865 (emit-quoted (jolt-get form (keyword #f "form")))) (_a$7866 ")")) (jolt-invoke _a$7861 _a$7862 _a$7863 _a$7864 _a$7865 _a$7866))) (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$7867 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7868 (jolt-hash-map))) (jolt-ex-info _a$7867 _a$7868))) jolt-nil)))))))))))))))))))) emit-quoted) (let* ((_o$7869 (keyword #f "private")) (_o$7870 #t)) (jolt-hash-map _o$7869 _o$7870))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec7857 ((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$7858 (var-deref "clojure.core" "str")) (_a$7859 "(jolt-symbol/meta ") (_a$7860 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7861 " ") (_a$7862 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7863 " ") (_a$7864 (emit-quoted m)) (_a$7865 ")")) (jolt-invoke _a$7858 _a$7859 _a$7860 _a$7861 _a$7862 _a$7863 _a$7864 _a$7865)) (let* ((_a$7866 (var-deref "clojure.core" "str")) (_a$7867 "(jolt-symbol ") (_a$7868 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$7869 " ") (_a$7870 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7871 ")")) (jolt-invoke _a$7866 _a$7867 _a$7868 _a$7869 _a$7870 _a$7871)))) (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 "jolt.host" "form-inst?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-inst-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form)) ")") (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") form))) (if (jolt-truthy? and__25__auto) (jolt= (keyword "jolt" "tagged") (jolt-get form (keyword "jolt" "type"))) and__25__auto))) (let* ((nm (jolt-invoke (var-deref "clojure.core" "name") (jolt-get form (keyword #f "tag")))) (tsym (if (jolt= (integer->char 35) (jolt-first nm)) (jolt-invoke (var-deref "clojure.core" "subs") nm 1) nm))) (let* ((_a$7872 (var-deref "clojure.core" "str")) (_a$7873 "(jolt-tagged-literal (jolt-symbol #f ") (_a$7874 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") tsym)) (_a$7875 ") ") (_a$7876 (emit-quoted (jolt-get form (keyword #f "form")))) (_a$7877 ")")) (jolt-invoke _a$7872 _a$7873 _a$7874 _a$7875 _a$7876 _a$7877))) (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$7878 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$7879 (jolt-hash-map))) (jolt-ex-info _a$7878 _a$7879))) jolt-nil)))))))))))))))))))) emit-quoted) (let* ((_o$7880 (keyword #f "private")) (_o$7881 #t)) (jolt-hash-map _o$7880 _o$7881))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7871 ((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?) (let* ((_o$7872 (keyword #f "private")) (_o$7873 #t)) (jolt-hash-map _o$7872 _o$7873))))
+  (def-var-with-meta! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec7882 ((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?) (let* ((_o$7883 (keyword #f "private")) (_o$7884 #t)) (jolt-hash-map _o$7883 _o$7884))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7874 ((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) (let* ((_o$7875 (keyword #f "private")) (_o$7876 #t)) (jolt-hash-map _o$7875 _o$7876))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec7885 ((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) (let* ((_o$7886 (keyword #f "private")) (_o$7887 #t)) (jolt-hash-map _o$7886 _o$7887))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7877 ((b b)) (let* ((_a$7878 (var-deref "clojure.core" "str")) (_a$7879 "(") (_a$7880 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7881 " ") (_a$7882 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7883 ")")) (jolt-invoke _a$7878 _a$7879 _a$7880 _a$7881 _a$7882 _a$7883)))))) emit-binding) (let* ((_o$7884 (keyword #f "private")) (_o$7885 #t)) (jolt-hash-map _o$7884 _o$7885))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec7888 ((b b)) (let* ((_a$7889 (var-deref "clojure.core" "str")) (_a$7890 "(") (_a$7891 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$7892 " ") (_a$7893 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$7894 ")")) (jolt-invoke _a$7889 _a$7890 _a$7891 _a$7892 _a$7893 _a$7894)))))) emit-binding) (let* ((_o$7895 (keyword #f "private")) (_o$7896 #t)) (jolt-hash-map _o$7895 _o$7896))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7886 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$7887 (var-deref "clojure.core" "str")) (_a$7888 "(") (_a$7889 kw) (_a$7890 " (") (_a$7891 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7892 ") ") (_a$7893 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7894 ")")) (jolt-invoke _a$7887 _a$7888 _a$7889 _a$7890 _a$7891 _a$7892 _a$7893 _a$7894))))))) emit-let) (let* ((_o$7895 (keyword #f "private")) (_o$7896 #t)) (jolt-hash-map _o$7895 _o$7896))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec7897 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*")) (binds (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*tail?*") #f))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(" kw " (" binds ") " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))) ")")))))) emit-let) (let* ((_o$7898 (keyword #f "private")) (_o$7899 #t)) (jolt-hash-map _o$7898 _o$7899))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7897 ((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__95_) (let fnrec7898 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__95_ 0)))) pairs)) (inits (jolt-map (lambda (p__96_) (let fnrec7899 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__96_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7900 ((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 fnrec7901 ((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) (let* ((_o$7902 (keyword #f "private")) (_o$7903 #t)) (jolt-hash-map _o$7902 _o$7903))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7900 ((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__95_) (let fnrec7901 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__95_ 0)))) pairs)) (inits (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*tail?*") #f))) (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") (lambda (p__96_) (let fnrec7902 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__96_ 1)))) pairs)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7903 ((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 fnrec7904 ((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) (let* ((_o$7905 (keyword #f "private")) (_o$7906 #t)) (jolt-hash-map _o$7905 _o$7906))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7904 "int") (_o$7905 "int") (_o$7906 "uint") (_o$7907 "unsigned-int") (_o$7908 "long") (_o$7909 "long") (_o$7910 "ulong") (_o$7911 "unsigned-long") (_o$7912 "int64") (_o$7913 "integer-64") (_o$7914 "uint64") (_o$7915 "unsigned-64") (_o$7916 "size_t") (_o$7917 "size_t") (_o$7918 "ssize_t") (_o$7919 "ssize_t") (_o$7920 "iptr") (_o$7921 "iptr") (_o$7922 "uptr") (_o$7923 "uptr") (_o$7924 "double") (_o$7925 "double") (_o$7926 "float") (_o$7927 "float") (_o$7928 "pointer") (_o$7929 "void*") (_o$7930 "void*") (_o$7931 "void*") (_o$7932 "string") (_o$7933 "string") (_o$7934 "void") (_o$7935 "void") (_o$7936 "uint8") (_o$7937 "unsigned-8") (_o$7938 "u8") (_o$7939 "unsigned-8") (_o$7940 "byte") (_o$7941 "unsigned-8") (_o$7942 "char") (_o$7943 "char")) (jolt-hash-map _o$7904 _o$7905 _o$7906 _o$7907 _o$7908 _o$7909 _o$7910 _o$7911 _o$7912 _o$7913 _o$7914 _o$7915 _o$7916 _o$7917 _o$7918 _o$7919 _o$7920 _o$7921 _o$7922 _o$7923 _o$7924 _o$7925 _o$7926 _o$7927 _o$7928 _o$7929 _o$7930 _o$7931 _o$7932 _o$7933 _o$7934 _o$7935 _o$7936 _o$7937 _o$7938 _o$7939 _o$7940 _o$7941 _o$7942 _o$7943)) (let* ((_o$7944 (keyword #f "private")) (_o$7945 #t)) (jolt-hash-map _o$7944 _o$7945))))
+  (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7907 "int") (_o$7908 "int") (_o$7909 "uint") (_o$7910 "unsigned-int") (_o$7911 "long") (_o$7912 "long") (_o$7913 "ulong") (_o$7914 "unsigned-long") (_o$7915 "int64") (_o$7916 "integer-64") (_o$7917 "uint64") (_o$7918 "unsigned-64") (_o$7919 "size_t") (_o$7920 "size_t") (_o$7921 "ssize_t") (_o$7922 "ssize_t") (_o$7923 "iptr") (_o$7924 "iptr") (_o$7925 "uptr") (_o$7926 "uptr") (_o$7927 "double") (_o$7928 "double") (_o$7929 "float") (_o$7930 "float") (_o$7931 "pointer") (_o$7932 "void*") (_o$7933 "void*") (_o$7934 "void*") (_o$7935 "string") (_o$7936 "string") (_o$7937 "void") (_o$7938 "void") (_o$7939 "uint8") (_o$7940 "unsigned-8") (_o$7941 "u8") (_o$7942 "unsigned-8") (_o$7943 "byte") (_o$7944 "unsigned-8") (_o$7945 "char") (_o$7946 "char")) (jolt-hash-map _o$7907 _o$7908 _o$7909 _o$7910 _o$7911 _o$7912 _o$7913 _o$7914 _o$7915 _o$7916 _o$7917 _o$7918 _o$7919 _o$7920 _o$7921 _o$7922 _o$7923 _o$7924 _o$7925 _o$7926 _o$7927 _o$7928 _o$7929 _o$7930 _o$7931 _o$7932 _o$7933 _o$7934 _o$7935 _o$7936 _o$7937 _o$7938 _o$7939 _o$7940 _o$7941 _o$7942 _o$7943 _o$7944 _o$7945 _o$7946)) (let* ((_o$7947 (keyword #f "private")) (_o$7948 #t)) (jolt-hash-map _o$7947 _o$7948))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7946 ((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$7947 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7948 (jolt-hash-map))) (jolt-ex-info _a$7947 _a$7948))))))))) ffi-type->chez) (let* ((_o$7949 (keyword #f "private")) (_o$7950 #t)) (jolt-hash-map _o$7949 _o$7950))))
+  (def-var-with-meta! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7949 ((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$7950 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7951 (jolt-hash-map))) (jolt-ex-info _a$7950 _a$7951))))))))) ffi-type->chez) (let* ((_o$7952 (keyword #f "private")) (_o$7953 #t)) (jolt-hash-map _o$7952 _o$7953))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7951 ((node node)) (let* ((_a$7952 (var-deref "clojure.core" "str")) (_a$7953 "(foreign-procedure ") (_a$7954 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7955 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7956 " (") (_a$7957 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7958 ") ") (_a$7959 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7960 ")")) (jolt-invoke _a$7952 _a$7953 _a$7954 _a$7955 _a$7956 _a$7957 _a$7958 _a$7959 _a$7960)))))) emit-ffi-fn) (let* ((_o$7961 (keyword #f "private")) (_o$7962 #t)) (jolt-hash-map _o$7961 _o$7962))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7954 ((node node)) (let* ((_a$7955 (var-deref "clojure.core" "str")) (_a$7956 "(foreign-procedure ") (_a$7957 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7958 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7959 " (") (_a$7960 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7961 ") ") (_a$7962 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7963 ")")) (jolt-invoke _a$7955 _a$7956 _a$7957 _a$7958 _a$7959 _a$7960 _a$7961 _a$7962 _a$7963)))))) emit-ffi-fn) (let* ((_o$7964 (keyword #f "private")) (_o$7965 #t)) (jolt-hash-map _o$7964 _o$7965))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7963 ((node node)) (let* ((_a$7964 (var-deref "clojure.core" "str")) (_a$7965 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7966 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7967 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7968 " (") (_a$7969 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7970 ") ") (_a$7971 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7972 "))")) (jolt-invoke _a$7964 _a$7965 _a$7966 _a$7967 _a$7968 _a$7969 _a$7970 _a$7971 _a$7972)))))) emit-ffi-callable) (let* ((_o$7973 (keyword #f "private")) (_o$7974 #t)) (jolt-hash-map _o$7973 _o$7974))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7966 ((node node)) (let* ((_a$7967 (var-deref "clojure.core" "str")) (_a$7968 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7969 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7970 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7971 " (") (_a$7972 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7973 ") ") (_a$7974 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7975 "))")) (jolt-invoke _a$7967 _a$7968 _a$7969 _a$7970 _a$7971 _a$7972 _a$7973 _a$7974 _a$7975)))))) emit-ffi-callable) (let* ((_o$7976 (keyword #f "private")) (_o$7977 #t)) (jolt-hash-map _o$7976 _o$7977))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7975 ((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$7977 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7978 arg-nodes) (_a$7979 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7980 (lambda (as) (let fnrec7976 ((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$7977 _a$7978 _a$7979 _a$7980)))))))) emit-recur) (let* ((_o$7981 (keyword #f "private")) (_o$7982 #t)) (jolt-hash-map _o$7981 _o$7982))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7978 ((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$7980 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7981 arg-nodes) (_a$7982 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7983 (lambda (as) (let fnrec7979 ((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$7980 _a$7981 _a$7982 _a$7983)))))))) emit-recur) (let* ((_o$7984 (keyword #f "private")) (_o$7985 #t)) (jolt-hash-map _o$7984 _o$7985))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7983 ((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) (let* ((_o$7984 (keyword #f "private")) (_o$7985 #t)) (jolt-hash-map _o$7984 _o$7985))))
+  (def-var-with-meta! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7986 ((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) (let* ((_o$7987 (keyword #f "private")) (_o$7988 #t)) (jolt-hash-map _o$7987 _o$7988))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7986 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7987 (jolt-hash-map)) (_a$7988 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7987 _a$7988))) (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 fnrec7989 ((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$7990 paramlist) (_o$7991 (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$7990 _o$7991))))))) emit-arity-clause) (let* ((_o$7992 (keyword #f "private")) (_o$7993 #t)) (jolt-hash-map _o$7992 _o$7993))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7989 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7990 (jolt-hash-map)) (_a$7991 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7990 _a$7991))) (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")) (ret (jolt-get a (keyword #f "ret-nhint"))) (body-tail? (jolt-not (let* ((or__26__auto (jolt= ret (keyword #f "double")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= ret (keyword #f "long")))))) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label (jolt-var "jolt.backend-scheme" "*tail?*") body-tail?))) (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 fnrec7992 ((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$7993 paramlist) (_o$7994 (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$7993 _o$7994))))))) emit-arity-clause) (let* ((_o$7995 (keyword #f "private")) (_o$7996 #t)) (jolt-hash-map _o$7995 _o$7996))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7994 ((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$7995 (var-deref "clojure.core" "str")) (_a$7996 "(lambda ") (_a$7997 (jolt-nth c 0)) (_a$7998 " ") (_a$7999 (jolt-nth c 1)) (_a$8000 ")")) (jolt-invoke _a$7995 _a$7996 _a$7997 _a$7998 _a$7999 _a$8000))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec8001 ((c c)) (let* ((_a$8002 (var-deref "clojure.core" "str")) (_a$8003 "(") (_a$8004 (jolt-nth c 0)) (_a$8005 " ") (_a$8006 (jolt-nth c 1)) (_a$8007 ")")) (jolt-invoke _a$8002 _a$8003 _a$8004 _a$8005 _a$8006 _a$8007)))) 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) (let* ((_o$8008 (keyword #f "private")) (_o$8009 #t)) (jolt-hash-map _o$8008 _o$8009))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7997 ((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"))))))) (clauses (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "trace-frames?")))) (if (jolt-truthy? and__25__auto) self and__25__auto))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (c) (let fnrec7998 ((c c)) (let* ((_o$8005 (jolt-nth c 0)) (_o$8006 (let* ((_a$7999 (var-deref "clojure.core" "str")) (_a$8000 "(begin (jolt-trace-push! ") (_a$8001 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") self)) (_a$8002 ") ") (_a$8003 (jolt-nth c 1)) (_a$8004 ")")) (jolt-invoke _a$7999 _a$8000 _a$8001 _a$8002 _a$8003 _a$8004)))) (jolt-vector _o$8005 _o$8006)))) clauses) clauses)) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$8007 (var-deref "clojure.core" "str")) (_a$8008 "(lambda ") (_a$8009 (jolt-nth c 0)) (_a$8010 " ") (_a$8011 (jolt-nth c 1)) (_a$8012 ")")) (jolt-invoke _a$8007 _a$8008 _a$8009 _a$8010 _a$8011 _a$8012))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec8013 ((c c)) (let* ((_a$8014 (var-deref "clojure.core" "str")) (_a$8015 "(") (_a$8016 (jolt-nth c 0)) (_a$8017 " ") (_a$8018 (jolt-nth c 1)) (_a$8019 ")")) (jolt-invoke _a$8014 _a$8015 _a$8016 _a$8017 _a$8018 _a$8019)))) 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) (let* ((_o$8020 (keyword #f "private")) (_o$8021 #t)) (jolt-hash-map _o$8020 _o$8021))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec8010 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__143 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__143 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__143 (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) (let* ((_o$8011 (keyword #f "private")) (_o$8012 #t)) (jolt-hash-map _o$8011 _o$8012))))
+  (def-var-with-meta! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec8022 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__143 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__143 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__143 (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) (let* ((_o$8023 (keyword #f "private")) (_o$8024 #t)) (jolt-hash-map _o$8023 _o$8024))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec8013 ((fnode fnode)) (let* ((G__144 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__144 (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__144 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__144 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__144 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind) (let* ((_o$8014 (keyword #f "private")) (_o$8015 #t)) (jolt-hash-map _o$8014 _o$8015))))
+  (def-var-with-meta! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec8025 ((fnode fnode)) (let* ((G__144 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__144 (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__144 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__144 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__144 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind) (let* ((_o$8026 (keyword #f "private")) (_o$8027 #t)) (jolt-hash-map _o$8026 _o$8027))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec8016 ((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?) (let* ((_o$8017 (keyword #f "private")) (_o$8018 #t)) (jolt-hash-map _o$8017 _o$8018))))
+  (def-var-with-meta! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec8028 ((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?) (let* ((_o$8029 (keyword #f "private")) (_o$8030 #t)) (jolt-hash-map _o$8029 _o$8030))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec8019 ((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) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-inc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-dec " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncinc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncdec " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__145 kind)) (if (jolt= G__145 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__145 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__145 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$8020 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__145)) (_a$8021 (jolt-hash-map))) (jolt-ex-info _a$8020 _a$8021))))))))) (jolt-invoke order-args (lambda (as) (let fnrec8022 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))))) emit-numeric) (let* ((_o$8023 (keyword #f "private")) (_o$8024 #t)) (jolt-hash-map _o$8023 _o$8024))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec8031 ((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) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-inc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-l-dec " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncinc " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (jolt= nm "unchecked-dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uncdec " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__145 kind)) (if (jolt= G__145 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__145 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__145 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$8032 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__145)) (_a$8033 (jolt-hash-map))) (jolt-ex-info _a$8032 _a$8033))))))))) (jolt-invoke order-args (lambda (as) (let fnrec8034 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))))) emit-numeric) (let* ((_o$8035 (keyword #f "private")) (_o$8036 #t)) (jolt-hash-map _o$8035 _o$8036))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec8025 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop8026 ((i i)) (if (jolt-n>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop8026 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index) (let* ((_o$8027 (keyword #f "private")) (_o$8028 #t)) (jolt-hash-map _o$8027 _o$8028))))
+  (def-var-with-meta! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec8037 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop8038 ((i i)) (if (jolt-n>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop8038 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index) (let* ((_o$8039 (keyword #f "private")) (_o$8040 #t)) (jolt-hash-map _o$8039 _o$8040))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec8029 ((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 fnrec8030 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec8031 ((as as)) (if (jolt-n> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec8032 () (let* ((_a$8034 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$8035 (jolt-cons fnode arg-nodes)) (_a$8036 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$8037 (lambda (G__146) (let fnrec8033 ((G__146 G__146)) (let* ((G__147 G__146) (f (jolt-nth G__147 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__147 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$8034 _a$8035 _a$8036 _a$8037)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec8038 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$")) (dv (let* ((_a$8039 (var-deref "clojure.core" "str")) (_a$8040 "(devirt-resolve ") (_a$8041 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$8042 " ") (_a$8043 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$8044 " ") (_a$8045 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$8046 " ") (_a$8047 r) (_a$8048 ")")) (jolt-invoke _a$8039 _a$8040 _a$8041 _a$8042 _a$8043 _a$8044 _a$8045 _a$8046 _a$8047 _a$8048))) (cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (resolver (if (jolt-truthy? cells) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_dvc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(or " c " (let ((_f " dv ")) (set! " c " _f) _f))"))) dv))) (let* ((_a$8049 (var-deref "clojure.core" "str")) (_a$8050 "(let* ((") (_a$8051 r) (_a$8052 " ") (_a$8053 (jolt-first as)) (_a$8054 ")) (") (_a$8055 resolver) (_a$8056 " ") (_a$8057 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$8058 "))")) (jolt-invoke _a$8049 _a$8050 _a$8051 _a$8052 _a$8053 _a$8054 _a$8055 _a$8056 _a$8057 _a$8058)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$8059 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$8060 (jolt-get node (keyword #f "num-kind"))) (_a$8061 (jolt-get fnode (keyword #f "name"))) (_a$8062 args) (_a$8063 order-args)) (jolt-invoke _a$8059 _a$8060 _a$8061 _a$8062 _a$8063)) (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 fnrec8064 ((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$8065 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$8066 (jolt-get recv (keyword #f "shape"))) (_a$8067 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$8065 _a$8066 _a$8067)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec8068 ((as as)) (let* ((_a$8069 (var-deref "clojure.core" "str")) (_a$8070 "(jrec-field-at ") (_a$8071 (jolt-first as)) (_a$8072 " ") (_a$8073 idx) (_a$8074 " ") (_a$8075 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$8076 ")")) (jolt-invoke _a$8069 _a$8070 _a$8071 _a$8072 _a$8073 _a$8074 _a$8075 _a$8076))))) (jolt-invoke order-args (lambda (as) (let fnrec8077 ((as as)) (let* ((_a$8078 (var-deref "clojure.core" "str")) (_a$8079 "(jolt-get ") (_a$8080 (jolt-first as)) (_a$8081 " ") (_a$8082 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$8083 (jolt-invoke defstr as)) (_a$8084 ")")) (jolt-invoke _a$8078 _a$8079 _a$8080 _a$8081 _a$8082 _a$8083 _a$8084))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$8092 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$8093 (jolt-cons fnode arg-nodes)) (_a$8094 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$8095 (lambda (G__148) (let fnrec8085 ((G__148 G__148)) (let* ((G__149 G__148) (c (jolt-nth G__149 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__149 1))) (let* ((_a$8086 (var-deref "clojure.core" "str")) (_a$8087 (if (let* ((and__25__auto (jolt= (keyword #f "vector") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count as)) and__25__auto)) "(jolt-nth " "(jolt-get ")) (_a$8088 c) (_a$8089 " ") (_a$8090 (jolt-invoke (var-deref "clojure.string" "join") " " as)) (_a$8091 ")")) (jolt-invoke _a$8086 _a$8087 _a$8088 _a$8089 _a$8090 _a$8091))))))) (jolt-invoke _a$8092 _a$8093 _a$8094 _a$8095)) (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$8102 (let* ((_a$8096 (var-deref "clojure.core" "str")) (_a$8097 "emit: unsupported stdlib fn `") (_a$8098 (jolt-get fnode (keyword #f "ns"))) (_a$8099 "/") (_a$8100 (jolt-get fnode (keyword #f "name"))) (_a$8101 "` (no core on Chez yet)")) (jolt-invoke _a$8096 _a$8097 _a$8098 _a$8099 _a$8100 _a$8101))) (_a$8103 (jolt-hash-map))) (jolt-ex-info _a$8102 _a$8103))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec8104 ((as as)) (let* ((_a$8105 (var-deref "clojure.core" "str")) (_a$8106 "(host-static-call ") (_a$8107 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$8108 " ") (_a$8109 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$8110 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$8111 ")")) (jolt-invoke _a$8105 _a$8106 _a$8107 _a$8108 _a$8109 _a$8110 _a$8111))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$8112 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$8113 (jolt-hash-map))) (jolt-ex-info _a$8112 _a$8113))) (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 fnrec8114 ((as as)) (let* ((_a$8115 (var-deref "clojure.core" "str")) (_a$8116 "(") (_a$8117 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$8118 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$8119 ")")) (jolt-invoke _a$8115 _a$8116 _a$8117 _a$8118 _a$8119))))) (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$8120 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8121 (jolt-get fnode (keyword #f "ns"))) (_a$8122 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8120 _a$8121 _a$8122)))) (if (jolt-truthy? and__25__auto) (let* ((_a$8123 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$8124 (jolt-get fnode (keyword #f "ns"))) (_a$8125 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8123 _a$8124 _a$8125)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec8126 ((as as)) (let* ((_a$8130 (var-deref "clojure.core" "str")) (_a$8131 "(") (_a$8132 (let* ((_a$8127 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8128 (jolt-get fnode (keyword #f "ns"))) (_a$8129 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8127 _a$8128 _a$8129))) (_a$8133 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$8134 ")")) (jolt-invoke _a$8130 _a$8131 _a$8132 _a$8133 _a$8134))))) (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) (let* ((_o$8135 (keyword #f "private")) (_o$8136 #t)) (jolt-hash-map _o$8135 _o$8136))))
+  (def-var-with-meta! "jolt.backend-scheme" "plain-call" (letrec ((plain-call (lambda (callee operand-strs) (let fnrec8041 ((callee callee) (operand-strs operand-strs)) (jolt-invoke (var-deref "clojure.core" "str") "(" callee (if (jolt-truthy? (jolt-seq operand-strs)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " operand-strs)) "") ")"))))) plain-call) (let* ((_o$8042 (keyword #f "private")) (_o$8043 #t)) (jolt-hash-map _o$8042 _o$8043))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec8137 ((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* ((raw (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "catch-raw-sym"))))) (let* ((_a$8138 (var-deref "clojure.core" "str")) (_a$8139 "(guard (") (_a$8140 raw) (_a$8141 " (else (let ((") (_a$8142 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$8143 " (jolt-unwrap-throw ") (_a$8144 raw) (_a$8145 "))) ") (_a$8146 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$8147 "))) ") (_a$8148 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$8149 ")")) (jolt-invoke _a$8138 _a$8139 _a$8140 _a$8141 _a$8142 _a$8143 _a$8144 _a$8145 _a$8146 _a$8147 _a$8148 _a$8149)))) (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) (let* ((_o$8150 (keyword #f "private")) (_o$8151 #t)) (jolt-hash-map _o$8150 _o$8151))))
+  (def-var-with-meta! "jolt.backend-scheme" "tail-marked-call" (letrec ((tail-marked-call (lambda (callee operand-strs) (let fnrec8044 ((callee callee) (operand-strs operand-strs)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec8045 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_tt$"))) operand-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec8046 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps operand-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (jolt-trace-mark! #t) " (jolt-invoke (var-deref "jolt.backend-scheme" "plain-call") callee tmps) ")")))))) tail-marked-call) (let* ((_o$8047 (keyword #f "private")) (_o$8048 #t)) (jolt-hash-map _o$8047 _o$8048))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec8152 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec8153 ((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$8154 (var-deref "jolt.backend-scheme" "native-op")) (_a$8155 (jolt-get node (keyword #f "fn"))) (_a$8156 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$8154 _a$8155 _a$8156)))) (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$8158 (lambda (s b) (let fnrec8157 ((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$8159 bools) (_a$8160 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8158 _a$8159 _a$8160)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?) (let* ((_o$8161 (keyword #f "private")) (_o$8162 #t)) (jolt-hash-map _o$8161 _o$8162))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-call" (letrec ((emit-call (lambda (tail? callee operand-strs) (let fnrec8049 ((tail? tail?) (callee callee) (operand-strs operand-strs)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "trace-frames?")))) (if (jolt-truthy? and__25__auto) tail? and__25__auto))) (jolt-invoke (var-deref "jolt.backend-scheme" "tail-marked-call") callee operand-strs) (jolt-invoke (var-deref "jolt.backend-scheme" "plain-call") callee operand-strs)))))) emit-call) (let* ((_o$8050 (keyword #f "private")) (_o$8051 #t)) (jolt-hash-map _o$8050 _o$8051))))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec8163 ((node node)) (let* ((G__150 (jolt-get node (keyword #f "op")))) (if (jolt= G__150 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__150 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__150 (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$8164 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8165 (jolt-get node (keyword #f "ns"))) (_a$8166 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8164 _a$8165 _a$8166))) (let* ((_a$8167 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8168 (jolt-get node (keyword #f "ns"))) (_a$8169 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8167 _a$8168 _a$8169)) (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$8176 (let* ((_a$8170 (var-deref "clojure.core" "str")) (_a$8171 "emit: unsupported stdlib ref `") (_a$8172 (jolt-get node (keyword #f "ns"))) (_a$8173 "/") (_a$8174 (jolt-get node (keyword #f "name"))) (_a$8175 "` (no core on Chez yet)")) (jolt-invoke _a$8170 _a$8171 _a$8172 _a$8173 _a$8174 _a$8175))) (_a$8177 (jolt-hash-map))) (jolt-ex-info _a$8176 _a$8177))) (if (jolt-truthy? (keyword #f "else")) (let* ((cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (nslit (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (nmlit (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "var-cache?")))) (if (jolt-truthy? and__25__auto) cells and__25__auto))) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_vc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(var-cell-deref (or " c " (let ((_v (jolt-var " nslit " " nmlit "))) (set! " c " _v) _v)))"))) (jolt-invoke (var-deref "clojure.core" "str") "(var-deref " nslit " " nmlit ")"))) jolt-nil))))) (if (jolt= G__150 (keyword #f "the-var")) (let* ((_a$8178 (var-deref "clojure.core" "str")) (_a$8179 "(jolt-var ") (_a$8180 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8181 " ") (_a$8182 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8183 ")")) (jolt-invoke _a$8178 _a$8179 _a$8180 _a$8181 _a$8182 _a$8183)) (if (jolt= G__150 (keyword #f "set-var")) (let* ((_a$8184 (var-deref "clojure.core" "str")) (_a$8185 "(jolt-var-set ") (_a$8186 (emit (jolt-get node (keyword #f "the-var")))) (_a$8187 " ") (_a$8188 (emit (jolt-get node (keyword #f "val")))) (_a$8189 ")")) (jolt-invoke _a$8184 _a$8185 _a$8186 _a$8187 _a$8188 _a$8189)) (if (jolt= G__150 (keyword #f "set-field")) (let* ((_a$8190 (var-deref "clojure.core" "str")) (_a$8191 "(jolt-set-field! ") (_a$8192 (emit (jolt-get node (keyword #f "obj")))) (_a$8193 " (keyword #f ") (_a$8194 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$8195 ") ") (_a$8196 (emit (jolt-get node (keyword #f "val")))) (_a$8197 ")")) (jolt-invoke _a$8190 _a$8191 _a$8192 _a$8193 _a$8194 _a$8195 _a$8196 _a$8197)) (if (jolt= G__150 (keyword #f "defmacro")) (let* ((_a$8198 (var-deref "clojure.core" "str")) (_a$8199 "(begin (def-var! ") (_a$8200 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8201 " ") (_a$8202 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8203 " ") (_a$8204 (emit (jolt-get node (keyword #f "fn")))) (_a$8205 ") (mark-macro! ") (_a$8206 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8207 " ") (_a$8208 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8209 ") jolt-nil)")) (jolt-invoke _a$8198 _a$8199 _a$8200 _a$8201 _a$8202 _a$8203 _a$8204 _a$8205 _a$8206 _a$8207 _a$8208 _a$8209)) (if (jolt= G__150 (keyword #f "host")) (jolt-throw (let* ((_a$8210 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$8211 (jolt-hash-map))) (jolt-ex-info _a$8210 _a$8211))) (if (jolt= G__150 (keyword #f "host-static")) (let* ((_a$8212 (var-deref "clojure.core" "str")) (_a$8213 "(host-static-ref ") (_a$8214 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8215 " ") (_a$8216 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$8217 ")")) (jolt-invoke _a$8212 _a$8213 _a$8214 _a$8215 _a$8216 _a$8217)) (if (jolt= G__150 (keyword #f "host-new")) (let* ((_a$8218 (var-deref "clojure.core" "str")) (_a$8219 "(host-new ") (_a$8220 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8221 (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$8222 ")")) (jolt-invoke _a$8218 _a$8219 _a$8220 _a$8221 _a$8222)) (if (jolt= G__150 (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$8223 (var-deref "clojure.core" "str")) (_a$8224 "(if ") (_a$8225 t) (_a$8226 " ") (_a$8227 (emit (jolt-get node (keyword #f "then")))) (_a$8228 " ") (_a$8229 (emit (jolt-get node (keyword #f "else")))) (_a$8230 ")")) (jolt-invoke _a$8223 _a$8224 _a$8225 _a$8226 _a$8227 _a$8228 _a$8229 _a$8230))) (if (jolt= G__150 (keyword #f "do")) (let* ((_a$8231 (var-deref "clojure.core" "str")) (_a$8232 "(begin ") (_a$8233 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$8234 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8235 (emit (jolt-get node (keyword #f "ret")))) (_a$8236 ")")) (jolt-invoke _a$8231 _a$8232 _a$8233 _a$8234 _a$8235 _a$8236)) (if (jolt= G__150 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__150 (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__150 (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__150 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$8240 (var-deref "clojure.core" "mapcat")) (_a$8241 (lambda (p) (let fnrec8237 ((p p)) (let* ((_o$8238 (emit (jolt-nth p 0))) (_o$8239 (emit (jolt-nth p 1)))) (jolt-vector _o$8238 _o$8239))))) (_a$8242 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8240 _a$8241 _a$8242))) (if (jolt= G__150 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__150 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__150 (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__150 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__150 (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__150 (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__150 (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__150 (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__150 (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__150 (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$8243 (var-deref "clojure.core" "str")) (_a$8244 "(jolt-host-call ") (_a$8245 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8246 " ") (_a$8247 target) (_a$8248 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8249 ")")) (jolt-invoke _a$8243 _a$8244 _a$8245 _a$8246 _a$8247 _a$8248 _a$8249)) (let* ((_a$8250 (var-deref "clojure.core" "str")) (_a$8251 "(record-method-dispatch ") (_a$8252 target) (_a$8253 " ") (_a$8254 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8255 " (jolt-vector") (_a$8256 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8257 "))")) (jolt-invoke _a$8250 _a$8251 _a$8252 _a$8253 _a$8254 _a$8255 _a$8256 _a$8257)))) (if (jolt= G__150 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__150 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__150 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__150 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__150 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__150 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__150 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$8258 (var-deref "clojure.core" "str")) (_a$8259 "(declare-var! ") (_a$8260 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8261 " ") (_a$8262 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8263 ")")) (jolt-invoke _a$8258 _a$8259 _a$8260 _a$8261 _a$8262 _a$8263)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8265 (var-deref "clojure.core" "str")) (_a$8266 "(def-var-with-meta! ") (_a$8267 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8268 " ") (_a$8269 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8270 " ") (_a$8271 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8264 () (emit (jolt-get node (keyword #f "init"))))))) (_a$8272 " ") (_a$8273 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8274 ")")) (jolt-invoke _a$8265 _a$8266 _a$8267 _a$8268 _a$8269 _a$8270 _a$8271 _a$8272 _a$8273 _a$8274)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8276 (var-deref "clojure.core" "str")) (_a$8277 "(def-var! ") (_a$8278 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8279 " ") (_a$8280 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8281 " ") (_a$8282 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8275 () (emit (jolt-get node (keyword #f "init"))))))) (_a$8283 ")")) (jolt-invoke _a$8276 _a$8277 _a$8278 _a$8279 _a$8280 _a$8281 _a$8282 _a$8283)) jolt-nil))) (jolt-throw (let* ((_a$8284 (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$8285 (jolt-hash-map))) (jolt-ex-info _a$8284 _a$8285))))))))))))))))))))))))))))))))))))))))) emit)))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec8052 ((node node)) (let* ((tail? (var-deref "jolt.backend-scheme" "*tail?*"))) (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*tail?*") #f))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (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 fnrec8053 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec8054 ((as as)) (if (jolt-n> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec8055 () (let* ((_a$8057 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$8058 (jolt-cons fnode arg-nodes)) (_a$8059 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$8060 (lambda (operands) (let fnrec8056 ((operands operands)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-call") tail? "jolt-invoke" operands))))) (jolt-invoke _a$8057 _a$8058 _a$8059 _a$8060)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec8061 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$")) (dv (let* ((_a$8062 (var-deref "clojure.core" "str")) (_a$8063 "(devirt-resolve ") (_a$8064 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$8065 " ") (_a$8066 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$8067 " ") (_a$8068 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$8069 " ") (_a$8070 r) (_a$8071 ")")) (jolt-invoke _a$8062 _a$8063 _a$8064 _a$8065 _a$8066 _a$8067 _a$8068 _a$8069 _a$8070 _a$8071))) (cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (resolver (if (jolt-truthy? cells) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_dvc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(or " c " (let ((_f " dv ")) (set! " c " _f) _f))"))) dv))) (let* ((_a$8072 (var-deref "clojure.core" "str")) (_a$8073 "(let* ((") (_a$8074 r) (_a$8075 " ") (_a$8076 (jolt-first as)) (_a$8077 ")) (") (_a$8078 resolver) (_a$8079 " ") (_a$8080 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$8081 "))")) (jolt-invoke _a$8072 _a$8073 _a$8074 _a$8075 _a$8076 _a$8077 _a$8078 _a$8079 _a$8080 _a$8081)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$8082 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$8083 (jolt-get node (keyword #f "num-kind"))) (_a$8084 (jolt-get fnode (keyword #f "name"))) (_a$8085 args) (_a$8086 order-args)) (jolt-invoke _a$8082 _a$8083 _a$8084 _a$8085 _a$8086)) (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 fnrec8087 ((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$8088 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$8089 (jolt-get recv (keyword #f "shape"))) (_a$8090 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$8088 _a$8089 _a$8090)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec8091 ((as as)) (let* ((_a$8092 (var-deref "clojure.core" "str")) (_a$8093 "(jrec-field-at ") (_a$8094 (jolt-first as)) (_a$8095 " ") (_a$8096 idx) (_a$8097 " ") (_a$8098 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$8099 ")")) (jolt-invoke _a$8092 _a$8093 _a$8094 _a$8095 _a$8096 _a$8097 _a$8098 _a$8099))))) (jolt-invoke order-args (lambda (as) (let fnrec8100 ((as as)) (let* ((_a$8101 (var-deref "clojure.core" "str")) (_a$8102 "(jolt-get ") (_a$8103 (jolt-first as)) (_a$8104 " ") (_a$8105 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$8106 (jolt-invoke defstr as)) (_a$8107 ")")) (jolt-invoke _a$8101 _a$8102 _a$8103 _a$8104 _a$8105 _a$8106 _a$8107))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$8115 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$8116 (jolt-cons fnode arg-nodes)) (_a$8117 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$8118 (lambda (G__146) (let fnrec8108 ((G__146 G__146)) (let* ((G__147 G__146) (c (jolt-nth G__147 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__147 1))) (let* ((_a$8109 (var-deref "clojure.core" "str")) (_a$8110 (if (let* ((and__25__auto (jolt= (keyword #f "vector") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count as)) and__25__auto)) "(jolt-nth " "(jolt-get ")) (_a$8111 c) (_a$8112 " ") (_a$8113 (jolt-invoke (var-deref "clojure.string" "join") " " as)) (_a$8114 ")")) (jolt-invoke _a$8109 _a$8110 _a$8111 _a$8112 _a$8113 _a$8114))))))) (jolt-invoke _a$8115 _a$8116 _a$8117 _a$8118)) (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$8125 (let* ((_a$8119 (var-deref "clojure.core" "str")) (_a$8120 "emit: unsupported stdlib fn `") (_a$8121 (jolt-get fnode (keyword #f "ns"))) (_a$8122 "/") (_a$8123 (jolt-get fnode (keyword #f "name"))) (_a$8124 "` (no core on Chez yet)")) (jolt-invoke _a$8119 _a$8120 _a$8121 _a$8122 _a$8123 _a$8124))) (_a$8126 (jolt-hash-map))) (jolt-ex-info _a$8125 _a$8126))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec8127 ((as as)) (let* ((_a$8128 (var-deref "clojure.core" "str")) (_a$8129 "(host-static-call ") (_a$8130 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$8131 " ") (_a$8132 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$8133 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$8134 ")")) (jolt-invoke _a$8128 _a$8129 _a$8130 _a$8131 _a$8132 _a$8133 _a$8134))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$8135 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$8136 (jolt-hash-map))) (jolt-ex-info _a$8135 _a$8136))) (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 fnrec8137 ((as as)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-call") tail? (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))) as)))) (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$8138 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8139 (jolt-get fnode (keyword #f "ns"))) (_a$8140 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8138 _a$8139 _a$8140)))) (if (jolt-truthy? and__25__auto) (let* ((_a$8141 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$8142 (jolt-get fnode (keyword #f "ns"))) (_a$8143 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8141 _a$8142 _a$8143)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec8144 ((as as)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-call") tail? (let* ((_a$8145 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8146 (jolt-get fnode (keyword #f "ns"))) (_a$8147 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$8145 _a$8146 _a$8147)) as)))) (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))))))))))))))))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))))))) emit-invoke) (let* ((_o$8148 (keyword #f "private")) (_o$8149 #t)) (jolt-hash-map _o$8148 _o$8149))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec8286 ((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?) (let* ((_o$8287 (keyword #f "private")) (_o$8288 #t)) (jolt-hash-map _o$8287 _o$8288))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec8150 ((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* ((raw (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "catch-raw-sym"))))) (let* ((_a$8151 (var-deref "clojure.core" "str")) (_a$8152 "(guard (") (_a$8153 raw) (_a$8154 " (else (let ((") (_a$8155 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$8156 " (jolt-unwrap-throw ") (_a$8157 raw) (_a$8158 "))) ") (_a$8159 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$8160 "))) ") (_a$8161 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$8162 ")")) (jolt-invoke _a$8151 _a$8152 _a$8153 _a$8154 _a$8155 _a$8156 _a$8157 _a$8158 _a$8159 _a$8160 _a$8161 _a$8162)))) (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) (let* ((_o$8163 (keyword #f "private")) (_o$8164 #t)) (jolt-hash-map _o$8163 _o$8164))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.backend-scheme" "emit-def-cached" (letrec ((emit-def-cached (lambda (node) (let fnrec8289 ((node node)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (dl? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (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))) (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 dl?)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto)) and__25__auto))) (let* ((_a$8290 (var-deref "clojure.core" "str")) (_a$8291 " (jolt-register-source! ") (_a$8292 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$8293 " ") (_a$8294 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8295 " ") (_a$8296 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8297 " ") (_a$8298 (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$8299 " ") (_a$8300 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$8301 ")")) (jolt-invoke _a$8290 _a$8291 _a$8292 _a$8293 _a$8294 _a$8295 _a$8296 _a$8297 _a$8298 _a$8299 _a$8300 _a$8301)) jolt-nil)) (_ (if (jolt-truthy? dl?) (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)) jolt-nil)) (init (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8302 () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init")))))))) (if (jolt-truthy? dl?) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8303 (var-deref "clojure.core" "str")) (_a$8304 "(begin (define ") (_a$8305 b) (_a$8306 " ") (_a$8307 init) (_a$8308 ") (def-var-with-meta! ") (_a$8309 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8310 " ") (_a$8311 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8312 " ") (_a$8313 b) (_a$8314 " ") (_a$8315 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8316 ")") (_a$8317 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8318 ")")) (jolt-invoke _a$8303 _a$8304 _a$8305 _a$8306 _a$8307 _a$8308 _a$8309 _a$8310 _a$8311 _a$8312 _a$8313 _a$8314 _a$8315 _a$8316 _a$8317 _a$8318)) (let* ((_a$8319 (var-deref "clojure.core" "str")) (_a$8320 "(begin (define ") (_a$8321 b) (_a$8322 " ") (_a$8323 init) (_a$8324 ") (def-var! ") (_a$8325 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8326 " ") (_a$8327 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8328 " ") (_a$8329 b) (_a$8330 ")") (_a$8331 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8332 ")")) (jolt-invoke _a$8319 _a$8320 _a$8321 _a$8322 _a$8323 _a$8324 _a$8325 _a$8326 _a$8327 _a$8328 _a$8329 _a$8330 _a$8331 _a$8332))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8333 (var-deref "clojure.core" "str")) (_a$8334 "(def-var-with-meta! ") (_a$8335 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8336 " ") (_a$8337 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8338 " ") (_a$8339 init) (_a$8340 " ") (_a$8341 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8342 ")")) (jolt-invoke _a$8333 _a$8334 _a$8335 _a$8336 _a$8337 _a$8338 _a$8339 _a$8340 _a$8341 _a$8342)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8343 (var-deref "clojure.core" "str")) (_a$8344 "(def-var! ") (_a$8345 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8346 " ") (_a$8347 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8348 " ") (_a$8349 init) (_a$8350 ")")) (jolt-invoke _a$8343 _a$8344 _a$8345 _a$8346 _a$8347 _a$8348 _a$8349 _a$8350)) jolt-nil)))))))) emit-def-cached) (let* ((_o$8351 (keyword #f "private")) (_o$8352 #t)) (jolt-hash-map _o$8351 _o$8352))))
+  (def-var-with-meta! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec8165 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec8166 ((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$8167 (var-deref "jolt.backend-scheme" "native-op")) (_a$8168 (jolt-get node (keyword #f "fn"))) (_a$8169 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$8167 _a$8168 _a$8169)))) (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$8171 (lambda (s b) (let fnrec8170 ((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$8172 bools) (_a$8173 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$8171 _a$8172 _a$8173)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?) (let* ((_o$8174 (keyword #f "private")) (_o$8175 #t)) (jolt-hash-map _o$8174 _o$8175))))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec8353 ((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$8354 (var-deref "clojure.core" "str")) (_a$8355 "(begin ") (_a$8356 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$8357 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8358 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$8359 ")")) (jolt-invoke _a$8354 _a$8355 _a$8356 _a$8357 _a$8358 _a$8359)) (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)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-cached") node) (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*" (letrec ((emit* (lambda (node) (let fnrec8176 ((node node)) (let* ((G__148 (jolt-get node (keyword #f "op")))) (if (jolt= G__148 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__148 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__148 (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$8177 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$8178 (jolt-get node (keyword #f "ns"))) (_a$8179 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8177 _a$8178 _a$8179))) (let* ((_a$8180 (var-deref "jolt.backend-scheme" "dl-name")) (_a$8181 (jolt-get node (keyword #f "ns"))) (_a$8182 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$8180 _a$8181 _a$8182)) (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$8189 (let* ((_a$8183 (var-deref "clojure.core" "str")) (_a$8184 "emit: unsupported stdlib ref `") (_a$8185 (jolt-get node (keyword #f "ns"))) (_a$8186 "/") (_a$8187 (jolt-get node (keyword #f "name"))) (_a$8188 "` (no core on Chez yet)")) (jolt-invoke _a$8183 _a$8184 _a$8185 _a$8186 _a$8187 _a$8188))) (_a$8190 (jolt-hash-map))) (jolt-ex-info _a$8189 _a$8190))) (if (jolt-truthy? (keyword #f "else")) (let* ((cells (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "cache-cells"))) (nslit (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (nmlit (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "var-cache?")))) (if (jolt-truthy? and__25__auto) cells and__25__auto))) (let* ((c (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_vc$"))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") cells jolt-conj c) (jolt-invoke (var-deref "clojure.core" "str") "(var-cell-deref (or " c " (let ((_v (jolt-var " nslit " " nmlit "))) (set! " c " _v) _v)))"))) (jolt-invoke (var-deref "clojure.core" "str") "(var-deref " nslit " " nmlit ")"))) jolt-nil))))) (if (jolt= G__148 (keyword #f "the-var")) (let* ((_a$8191 (var-deref "clojure.core" "str")) (_a$8192 "(jolt-var ") (_a$8193 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8194 " ") (_a$8195 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8196 ")")) (jolt-invoke _a$8191 _a$8192 _a$8193 _a$8194 _a$8195 _a$8196)) (if (jolt= G__148 (keyword #f "set-var")) (let* ((_a$8197 (var-deref "clojure.core" "str")) (_a$8198 "(jolt-var-set ") (_a$8199 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "the-var")))) (_a$8200 " ") (_a$8201 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "val")))) (_a$8202 ")")) (jolt-invoke _a$8197 _a$8198 _a$8199 _a$8200 _a$8201 _a$8202)) (if (jolt= G__148 (keyword #f "set-field")) (let* ((_a$8203 (var-deref "clojure.core" "str")) (_a$8204 "(jolt-set-field! ") (_a$8205 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "obj")))) (_a$8206 " (keyword #f ") (_a$8207 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$8208 ") ") (_a$8209 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "val")))) (_a$8210 ")")) (jolt-invoke _a$8203 _a$8204 _a$8205 _a$8206 _a$8207 _a$8208 _a$8209 _a$8210)) (if (jolt= G__148 (keyword #f "defmacro")) (let* ((_a$8211 (var-deref "clojure.core" "str")) (_a$8212 "(begin (def-var! ") (_a$8213 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8214 " ") (_a$8215 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8216 " ") (_a$8217 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$8218 ") (mark-macro! ") (_a$8219 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8220 " ") (_a$8221 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8222 ") jolt-nil)")) (jolt-invoke _a$8211 _a$8212 _a$8213 _a$8214 _a$8215 _a$8216 _a$8217 _a$8218 _a$8219 _a$8220 _a$8221 _a$8222)) (if (jolt= G__148 (keyword #f "host")) (jolt-throw (let* ((_a$8223 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$8224 (jolt-hash-map))) (jolt-ex-info _a$8223 _a$8224))) (if (jolt= G__148 (keyword #f "host-static")) (let* ((_a$8225 (var-deref "clojure.core" "str")) (_a$8226 "(host-static-ref ") (_a$8227 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8228 " ") (_a$8229 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$8230 ")")) (jolt-invoke _a$8225 _a$8226 _a$8227 _a$8228 _a$8229 _a$8230)) (if (jolt= G__148 (keyword #f "host-new")) (let* ((_a$8231 (var-deref "clojure.core" "str")) (_a$8232 "(host-new ") (_a$8233 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$8234 (let* ((args (jolt-map (var-deref "jolt.backend-scheme" "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$8235 ")")) (jolt-invoke _a$8231 _a$8232 _a$8233 _a$8234 _a$8235)) (if (jolt= G__148 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*tail?*") #f))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") test) ")"))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (let* ((_a$8236 (var-deref "clojure.core" "str")) (_a$8237 "(if ") (_a$8238 t) (_a$8239 " ") (_a$8240 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "then")))) (_a$8241 " ") (_a$8242 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "else")))) (_a$8243 ")")) (jolt-invoke _a$8236 _a$8237 _a$8238 _a$8239 _a$8240 _a$8241 _a$8242 _a$8243))) (if (jolt= G__148 (keyword #f "do")) (let* ((_a$8244 (var-deref "clojure.core" "str")) (_a$8245 "(begin ") (_a$8246 (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*tail?*") #f))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "statements"))))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_a$8247 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8248 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "ret")))) (_a$8249 ")")) (jolt-invoke _a$8244 _a$8245 _a$8246 _a$8247 _a$8248 _a$8249)) (if (jolt= G__148 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__148 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "items")))) (if (jolt= G__148 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "items")))) (if (jolt= G__148 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$8253 (var-deref "clojure.core" "mapcat")) (_a$8254 (lambda (p) (let fnrec8250 ((p p)) (let* ((_o$8251 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p 0))) (_o$8252 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p 1)))) (jolt-vector _o$8251 _o$8252))))) (_a$8255 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$8253 _a$8254 _a$8255))) (if (jolt= G__148 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__148 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__148 (keyword #f "coerce")) (let* ((e (jolt-invoke (var-deref "jolt.backend-scheme" "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__148 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__148 (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__148 (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__148 (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__148 (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__148 (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__148 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "target")))) (args (jolt-map (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$8256 (var-deref "clojure.core" "str")) (_a$8257 "(jolt-host-call ") (_a$8258 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8259 " ") (_a$8260 target) (_a$8261 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8262 ")")) (jolt-invoke _a$8256 _a$8257 _a$8258 _a$8259 _a$8260 _a$8261 _a$8262)) (let* ((_a$8263 (var-deref "clojure.core" "str")) (_a$8264 "(record-method-dispatch ") (_a$8265 target) (_a$8266 " ") (_a$8267 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$8268 " (jolt-vector") (_a$8269 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$8270 "))")) (jolt-invoke _a$8263 _a$8264 _a$8265 _a$8266 _a$8267 _a$8268 _a$8269 _a$8270)))) (if (jolt= G__148 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__148 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__148 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__148 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__148 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__148 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__148 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$8271 (var-deref "clojure.core" "str")) (_a$8272 "(declare-var! ") (_a$8273 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8274 " ") (_a$8275 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8276 ")")) (jolt-invoke _a$8271 _a$8272 _a$8273 _a$8274 _a$8275 _a$8276)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8278 (var-deref "clojure.core" "str")) (_a$8279 "(def-var-with-meta! ") (_a$8280 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8281 " ") (_a$8282 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8283 " ") (_a$8284 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8277 () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))))) (_a$8285 " ") (_a$8286 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8287 ")")) (jolt-invoke _a$8278 _a$8279 _a$8280 _a$8281 _a$8282 _a$8283 _a$8284 _a$8285 _a$8286 _a$8287)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8289 (var-deref "clojure.core" "str")) (_a$8290 "(def-var! ") (_a$8291 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$8292 " ") (_a$8293 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$8294 " ") (_a$8295 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8288 () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))))) (_a$8296 ")")) (jolt-invoke _a$8289 _a$8290 _a$8291 _a$8292 _a$8293 _a$8294 _a$8295 _a$8296)) jolt-nil))) (jolt-throw (let* ((_a$8297 (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$8298 (jolt-hash-map))) (jolt-ex-info _a$8297 _a$8298))))))))))))))))))))))))))))))))))))))))) emit*)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$8360 "+") (_o$8361 jolt-add) (_o$8362 "-") (_o$8363 jolt-sub) (_o$8364 "*") (_o$8365 jolt-mul) (_o$8366 "/") (_o$8367 jolt-div) (_o$8368 "<") (_o$8369 jolt-lt) (_o$8370 ">") (_o$8371 jolt-gt) (_o$8372 "<=") (_o$8373 jolt-le) (_o$8374 ">=") (_o$8375 jolt-ge) (_o$8376 "=") (_o$8377 jolt=) (_o$8378 "inc") (_o$8379 jolt-inc) (_o$8380 "dec") (_o$8381 jolt-dec) (_o$8382 "mod") (_o$8383 jolt-mod) (_o$8384 "rem") (_o$8385 jolt-rem) (_o$8386 "quot") (_o$8387 jolt-quot) (_o$8388 "bit-and") (_o$8389 (var-deref "clojure.core" "__bit-and")) (_o$8390 "bit-or") (_o$8391 (var-deref "clojure.core" "__bit-or")) (_o$8392 "bit-xor") (_o$8393 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$8360 _o$8361 _o$8362 _o$8363 _o$8364 _o$8365 _o$8366 _o$8367 _o$8368 _o$8369 _o$8370 _o$8371 _o$8372 _o$8373 _o$8374 _o$8375 _o$8376 _o$8377 _o$8378 _o$8379 _o$8380 _o$8381 _o$8382 _o$8383 _o$8384 _o$8385 _o$8386 _o$8387 _o$8388 _o$8389 _o$8390 _o$8391 _o$8392 _o$8393)) (let* ((_o$8394 (keyword #f "private")) (_o$8395 #t)) (jolt-hash-map _o$8394 _o$8395))))
+  (def-var-with-meta! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec8299 ((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?) (let* ((_o$8300 (keyword #f "private")) (_o$8301 #t)) (jolt-hash-map _o$8300 _o$8301))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec8396 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?) (let* ((_o$8397 (keyword #f "private")) (_o$8398 #t)) (jolt-hash-map _o$8397 _o$8398))))
+  (def-var-with-meta! "jolt.backend-scheme" "emit-def-cached" (letrec ((emit-def-cached (lambda (node) (let fnrec8302 ((node node)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (dl? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (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))) (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 dl?)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto)) and__25__auto))) (let* ((_a$8303 (var-deref "clojure.core" "str")) (_a$8304 " (jolt-register-source! ") (_a$8305 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$8306 " ") (_a$8307 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8308 " ") (_a$8309 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8310 " ") (_a$8311 (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$8312 " ") (_a$8313 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$8314 ")")) (jolt-invoke _a$8303 _a$8304 _a$8305 _a$8306 _a$8307 _a$8308 _a$8309 _a$8310 _a$8311 _a$8312 _a$8313 _a$8314)) jolt-nil)) (_ (if (jolt-truthy? dl?) (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)) jolt-nil)) (init (jolt-invoke (var-deref "jolt.backend-scheme" "emit-with-cells") (lambda () (let fnrec8315 () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init")))))))) (if (jolt-truthy? dl?) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8316 (var-deref "clojure.core" "str")) (_a$8317 "(begin (define ") (_a$8318 b) (_a$8319 " ") (_a$8320 init) (_a$8321 ") (def-var-with-meta! ") (_a$8322 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8323 " ") (_a$8324 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8325 " ") (_a$8326 b) (_a$8327 " ") (_a$8328 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8329 ")") (_a$8330 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8331 ")")) (jolt-invoke _a$8316 _a$8317 _a$8318 _a$8319 _a$8320 _a$8321 _a$8322 _a$8323 _a$8324 _a$8325 _a$8326 _a$8327 _a$8328 _a$8329 _a$8330 _a$8331)) (let* ((_a$8332 (var-deref "clojure.core" "str")) (_a$8333 "(begin (define ") (_a$8334 b) (_a$8335 " ") (_a$8336 init) (_a$8337 ") (def-var! ") (_a$8338 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8339 " ") (_a$8340 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8341 " ") (_a$8342 b) (_a$8343 ")") (_a$8344 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$8345 ")")) (jolt-invoke _a$8332 _a$8333 _a$8334 _a$8335 _a$8336 _a$8337 _a$8338 _a$8339 _a$8340 _a$8341 _a$8342 _a$8343 _a$8344 _a$8345))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$8346 (var-deref "clojure.core" "str")) (_a$8347 "(def-var-with-meta! ") (_a$8348 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8349 " ") (_a$8350 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8351 " ") (_a$8352 init) (_a$8353 " ") (_a$8354 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$8355 ")")) (jolt-invoke _a$8346 _a$8347 _a$8348 _a$8349 _a$8350 _a$8351 _a$8352 _a$8353 _a$8354 _a$8355)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$8356 (var-deref "clojure.core" "str")) (_a$8357 "(def-var! ") (_a$8358 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$8359 " ") (_a$8360 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$8361 " ") (_a$8362 init) (_a$8363 ")")) (jolt-invoke _a$8356 _a$8357 _a$8358 _a$8359 _a$8360 _a$8361 _a$8362 _a$8363)) jolt-nil)))))))) emit-def-cached) (let* ((_o$8364 (keyword #f "private")) (_o$8365 #t)) (jolt-hash-map _o$8364 _o$8365))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec8399 ((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?) (let* ((_o$8400 (keyword #f "private")) (_o$8401 #t)) (jolt-hash-map _o$8400 _o$8401))))
+  (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec8366 ((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$8367 (var-deref "clojure.core" "str")) (_a$8368 "(begin ") (_a$8369 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$8370 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$8371 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$8372 ")")) (jolt-invoke _a$8367 _a$8368 _a$8369 _a$8370 _a$8371 _a$8372)) (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)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-cached") node) (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" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec8402 ((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) (let* ((_o$8403 (keyword #f "private")) (_o$8404 #t)) (jolt-hash-map _o$8403 _o$8404))))
+  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$8373 "+") (_o$8374 jolt-add) (_o$8375 "-") (_o$8376 jolt-sub) (_o$8377 "*") (_o$8378 jolt-mul) (_o$8379 "/") (_o$8380 jolt-div) (_o$8381 "<") (_o$8382 jolt-lt) (_o$8383 ">") (_o$8384 jolt-gt) (_o$8385 "<=") (_o$8386 jolt-le) (_o$8387 ">=") (_o$8388 jolt-ge) (_o$8389 "=") (_o$8390 jolt=) (_o$8391 "inc") (_o$8392 jolt-inc) (_o$8393 "dec") (_o$8394 jolt-dec) (_o$8395 "mod") (_o$8396 jolt-mod) (_o$8397 "rem") (_o$8398 jolt-rem) (_o$8399 "quot") (_o$8400 jolt-quot) (_o$8401 "bit-and") (_o$8402 (var-deref "clojure.core" "__bit-and")) (_o$8403 "bit-or") (_o$8404 (var-deref "clojure.core" "__bit-or")) (_o$8405 "bit-xor") (_o$8406 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$8373 _o$8374 _o$8375 _o$8376 _o$8377 _o$8378 _o$8379 _o$8380 _o$8381 _o$8382 _o$8383 _o$8384 _o$8385 _o$8386 _o$8387 _o$8388 _o$8389 _o$8390 _o$8391 _o$8392 _o$8393 _o$8394 _o$8395 _o$8396 _o$8397 _o$8398 _o$8399 _o$8400 _o$8401 _o$8402 _o$8403 _o$8404 _o$8405 _o$8406)) (let* ((_o$8407 (keyword #f "private")) (_o$8408 #t)) (jolt-hash-map _o$8407 _o$8408))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec8405 ((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$catch-raw1620 (else (let ((_r$catch1619 (jolt-unwrap-throw _r$catch-raw1620))) (let* ((e _r$catch1619)) jolt-nil)))) (let* ((_o$8407 (keyword #f "op")) (_o$8408 (keyword #f "const")) (_o$8409 (keyword #f "val")) (_o$8410 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec8406 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$8407 _o$8408 _o$8409 _o$8410))) 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$8411 node) (_a$8412 (keyword #f "test")) (_a$8413 t) (_a$8414 (keyword #f "then")) (_a$8415 (const-fold (jolt-get node (keyword #f "then")))) (_a$8416 (keyword #f "else")) (_a$8417 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8411 _a$8412 _a$8413 _a$8414 _a$8415 _a$8416 _a$8417)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$8418 (keyword #f "doc")) (_o$8419 "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$8418 _o$8419))))
+  (def-var-with-meta! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec8409 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?) (let* ((_o$8410 (keyword #f "private")) (_o$8411 #t)) (jolt-hash-map _o$8410 _o$8411))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec8420 ((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-with-meta! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec8412 ((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?) (let* ((_o$8413 (keyword #f "private")) (_o$8414 #t)) (jolt-hash-map _o$8413 _o$8414))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec8421 ((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$8422 (keyword #f "doc")) (_o$8423 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$8422 _o$8423))))
+  (def-var-with-meta! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec8415 ((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) (let* ((_o$8416 (keyword #f "private")) (_o$8417 #t)) (jolt-hash-map _o$8416 _o$8417))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec8424 ((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$8425 (keyword #f "doc")) (_o$8426 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$8425 _o$8426))))
+  (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec8418 ((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$catch-raw1628 (else (let ((_r$catch1627 (jolt-unwrap-throw _r$catch-raw1628))) (let* ((e _r$catch1627)) jolt-nil)))) (let* ((_o$8420 (keyword #f "op")) (_o$8421 (keyword #f "const")) (_o$8422 (keyword #f "val")) (_o$8423 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec8419 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$8420 _o$8421 _o$8422 _o$8423))) 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$8424 node) (_a$8425 (keyword #f "test")) (_a$8426 t) (_a$8427 (keyword #f "then")) (_a$8428 (const-fold (jolt-get node (keyword #f "then")))) (_a$8429 (keyword #f "else")) (_a$8430 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$8424 _a$8425 _a$8426 _a$8427 _a$8428 _a$8429 _a$8430)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$8431 (keyword #f "doc")) (_o$8432 "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$8431 _o$8432))))
+(guard (e (#t #f))
+  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec8433 ((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 fnrec8434 ((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$8435 (keyword #f "doc")) (_o$8436 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$8435 _o$8436))))
+(guard (e (#t #f))
+  (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec8437 ((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$8438 (keyword #f "doc")) (_o$8439 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$8438 _o$8439))))
 (guard (e (#t #f))
   (def-var-with-meta! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6706 ((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?) (let* ((_o$6707 (keyword #f "private")) (_o$6708 #t)) (jolt-hash-map _o$6707 _o$6708))))
 (guard (e (#t #f))
diff --git a/host/chez/smoke.sh b/host/chez/smoke.sh
index ceff451..7648257 100755
--- a/host/chez/smoke.sh
+++ b/host/chez/smoke.sh
@@ -30,6 +30,39 @@ check_loc() {
   fi
 }
 
+# An uncaught error's stack trace must name the runtime-eval'd fn frames that
+# survive TCO (the non-tail spine), even though the eval path registers no source
+# map — "print what is available". Asserts a substring appears under "  trace:".
+check_trace() {
+  err="$(bin/joltc -e "$1" 2>&1 >/dev/null)"
+  if printf '%s' "$err" | grep -q '  trace:' && printf '%s' "$err" | grep -q "$2"; then
+    pass=$((pass + 1))
+  else
+    echo "  FAIL (trace): $1"
+    echo "    want stderr trace to contain \`$2\`, got \`$err\`"
+    fails=$((fails + 1))
+  fi
+}
+
+# JOLT_TRACE opts into the tail-frame history (the ring of rings): every $2 (an
+# ERE) must match the "  trace:" block. Used to assert TCO-elided frames are
+# recovered and non-tail caller context survives a tail loop.
+check_trace_on() {
+  err="$(JOLT_TRACE=1 bin/joltc -e "$1" 2>&1 >/dev/null)"
+  ok=1
+  printf '%s' "$err" | grep -q '  trace:' || ok=0
+  shift
+  for want in "$@"; do
+    printf '%s' "$err" | grep -Eq "$want" || ok=0
+  done
+  if [ "$ok" = 1 ]; then
+    pass=$((pass + 1))
+  else
+    echo "  FAIL (trace-on): want [$*] in trace, got \`$err\`"
+    fails=$((fails + 1))
+  fi
+}
+
 check '(+ 1 2)' '3'
 check '(defn fib [n] (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2))))) (fib 15)' '610'
 check '(->> (range 10) (filter even?) (map (fn [x] (* x x))) (reduce +))' '120'
@@ -60,6 +93,38 @@ check '(try (load-string "(+") (catch :default e (ex-message e)))' 'EOF while re
 check_loc '(throw (ex-info "boom" {}))' 'boom'
 check_loc '(do (+ 1 1) (/ 1 0))' '  at 1:'
 
+# Runtime-eval'd fns aren't source-mapped, but their native frame names survive on
+# the non-tail spine; the trace must show them. deepest/+ are tail calls (erased);
+# middle and outer wait on a non-tail (inc …) so their frames are live at the throw.
+trace_prog='(defn deepest [x] (+ x 1)) (defn middle [x] (inc (deepest x))) (defn outer [x] (inc (middle x))) (outer :nan)'
+check_trace "$trace_prog" 'middle'
+check_trace "$trace_prog" 'outer'
+
+# JOLT_TRACE (tail-frame history / ring of rings). An all-tail chain is entirely
+# TCO-erased from the continuation, but the history recovers every frame — incl.
+# `deepest`, the actual error site.
+check_trace_on '(defn deepest [x] (+ x 1)) (defn middle [x] (deepest x)) (defn outer [x] (middle x)) (outer :nan)' \
+  'deepest' 'middle' 'outer'
+# A tail loop (a<->b) under a NON-tail caller: the loop is confined to one rib's
+# bounded inner ring, so the caller context (`driver`, `top`) is NOT flushed out —
+# the point of the ring of rings.
+check_trace_on '(declare b) (defn a [n] (if (zero? n) (+ :x 1) (b (dec n)))) (defn b [n] (a n)) (defn driver [] (inc (a 6))) (defn top [] (inc (driver))) (top)' \
+  'driver' 'top'
+# A ^long/^double return hint wraps the body in a coercion, so the hinted fn's call
+# is NOT a tail call — its own frame is still live and must appear (not be elided).
+check_trace_on '(defn g [n] (+ :x n)) (defn ^long f [n] (g n)) (f 3)' 'f' 'g'
+# History is per top-level form: a later form's error trace shows its own frames
+# (h2/u2), not frames from an earlier, already-returned form (h1/u1).
+check_trace_on '(defn h1 [x] (inc x)) (defn u1 [] (inc (h1 5))) (u1) (defn h2 [x] (+ :x x)) (defn u2 [] (inc (h2 5))) (u2)' \
+  'h2' 'u2'
+err_stale="$(JOLT_TRACE=1 bin/joltc -e '(defn h1 [x] (inc x)) (defn u1 [] (inc (h1 5))) (u1) (defn h2 [x] (+ :x x)) (defn u2 [] (inc (h2 5))) (u2)' 2>&1 >/dev/null)"
+if printf '%s' "$err_stale" | grep -q 'h1'; then
+  echo "  FAIL (trace-on): stale frame h1 from an earlier form leaked into the trace"
+  fails=$((fails + 1))
+else
+  pass=$((pass + 1))
+fi
+
 # --help prints usage, and lists the nREPL server under its real flag name.
 help_out="$(bin/joltc --help 2>/dev/null)"
 if printf '%s' "$help_out" | grep -q -- '--nrepl-server'; then
diff --git a/host/chez/source-registry.ss b/host/chez/source-registry.ss
index a72a794..45928bd 100644
--- a/host/chez/source-registry.ss
+++ b/host/chez/source-registry.ss
@@ -57,10 +57,36 @@
                       ((symbol? nm) (symbol->string nm))
                       (else #f)))))))
 
-;; Walk a continuation, returning the registered jolt frames (innermost first) as
-;; (frame-name . record) pairs, where record is #(ns name file line) or the symbol
-;; 'ambiguous. Unmapped frames (host spine, anonymous lambdas) are skipped; raw
-;; depth is capped.
+;; Frame names that are pure Chez / jolt-runtime plumbing — the eval boundary,
+;; the var-cell trampoline, continuation/winder internals. They carry no Clojure
+;; meaning, so an unmapped frame with one of these names is dropped from the trace
+;; (a MAPPED frame is always kept — a jolt fn that happens to share the name still
+;; resolves to its source). Any name Chez prefixes with `$` (system) or that jolt
+;; prefixes with `jolt-` (host runtime) is plumbing too.
+(define srcreg-plumbing-names
+  (let ((h (make-hashtable string-hash string=?)))
+    (for-each (lambda (s) (hashtable-set! h s #t))
+              '("dynamic-wind" "winder-dummy" "ksrc" "invoke" "apply"
+                "call-with-values" "call/cc" "call-with-current-continuation"
+                "raise" "raise-continuable" "with-exception-handler" "guard"
+                "eval" "compile" "interpret" "expand" "read" "load"
+                ;; host dispatch/coercion helpers (not `jolt-` prefixed) that carry
+                ;; no Clojure meaning in a trace
+                "record-method-dispatch" "protocol-resolve" "devirt-resolve"
+                "list->cseq" "host-static-call" "host-call"))
+    h))
+(define (srcreg-plumbing-name? nm)
+  (or (hashtable-ref srcreg-plumbing-names nm #f)
+      (and (fx>? (string-length nm) 0) (char=? (string-ref nm 0) #\$))
+      (and (fx>=? (string-length nm) 5) (string=? (substring nm 0 5) "jolt-"))))
+
+;; Walk a continuation, returning its frames (innermost first) as (frame-name .
+;; record) pairs. record is a source vector #(ns name file line) for a frame that
+;; maps to registered Clojure source, the symbol 'ambiguous for a short name shared
+;; across namespaces, or #f for an unmapped-but-named frame (the common case on the
+;; open-world eval path, where nothing is registered — the bare frame name is still
+;; a useful trace line). Plumbing frames (host spine, eval boundary) and unnamed
+;; frames are skipped; raw depth is capped.
 (define (jolt-frame-records k)
   ;; read the env at call time, not load time: a built binary runs top-level forms
   ;; at heap-build time, where this would always be unset.
@@ -70,39 +96,72 @@
       (if (or (not io) (fx>=? n 400))
           (reverse acc)
           (let* ((nm (srcreg-frame-name io))
-                 (src (and nm (hashtable-ref source-registry nm #f))))
+                 (src (and nm (hashtable-ref source-registry nm #f)))
+                 ;; keep a frame that maps, or any named frame that isn't plumbing
+                 (keep? (and nm (or src (not (srcreg-plumbing-name? nm))))))
             (when (and debug? nm)
-              (display (string-append "  [frame] " nm (if src " *MAPPED*" "") "\n")
+              (display (string-append "  [frame] " nm (if src " *MAPPED*"
+                                                          (if keep? "" " (skipped)")) "\n")
                        (current-error-port)))
             (loop (guard (e (#t #f)) (io 'link)) (fx+ n 1)
-                  (if src (cons (cons nm src) acc) acc))))))))
+                  (if keep? (cons (cons nm src) acc) acc))))))))
 
-;; Multi-line backtrace for an uncaught value — "  ns/name (file:line)" for a
-;; mapped frame, the bare frame name for an ambiguous one — or #f when no jolt
-;; frame maps (the caller then prints just the top-level location). Capped to the
-;; innermost frames.
+;; Render a list of (frame-name . record) pairs (innermost/deepest first) to a
+;; backtrace string. record is a source vector #(ns name file line) -> "ns/name
+;; (file:line)", or 'ambiguous / #f -> the bare frame name. A run of the same
+;; frame-name collapses to one "name (xN)" line (deep recursion, or a hot fn a
+;; loop re-enters), and the number of distinct lines is capped.
+(define (jolt-render-recs recs)
+  (let ((port (open-output-string)))
+    (let loop ((rs recs) (shown 0))
+      (if (or (null? rs) (fx>=? shown 30))
+          (get-output-string port)
+          (let* ((p (car rs)) (frame-name (car p)) (r (cdr p)))
+            ;; count a maximal run of the same frame-name
+            (let run ((tail (cdr rs)) (cnt 1))
+              (if (and (pair? tail) (string=? (car (car tail)) frame-name))
+                  (run (cdr tail) (fx+ cnt 1))
+                  (begin
+                    (put-string port "    ")
+                    (if (vector? r)
+                        (let ((ns (vector-ref r 0)) (nm (vector-ref r 1))
+                              (file (vector-ref r 2)) (line (vector-ref r 3)))
+                          (put-string port ns) (put-string port "/") (put-string port nm)
+                          (when (string? file)
+                            (put-string port " (") (put-string port file)
+                            (put-string port ":") (put-string port (number->string line))
+                            (put-string port ")")))
+                        (put-string port frame-name))   ; 'ambiguous / unmapped: bare name
+                    (when (fx>? cnt 1)
+                      (put-string port " (x") (put-string port (number->string cnt)) (put-string port ")"))
+                    (put-char port #\newline)
+                    (loop tail (fx+ shown 1))))))))))
+
+;; Multi-line backtrace for an uncaught value. Two sources, in preference order:
+;;   1. The tail-frame history ring (rt.ss), when JOLT_TRACE enabled it — an
+;;      execution history of the runtime-compiled fns entered before the throw,
+;;      INCLUDING ones TCO erased from the live continuation. Most-recent first.
+;;   2. Otherwise the live continuation (jolt-frame-records) — the accurate but
+;;      TCO-truncated non-tail spine.
+;; Each frame maps to "ns/name (file:line)" when registered, else its bare name.
+;; #f when neither source yields a frame (the caller then prints just the location).
 (define (jolt-backtrace-string v)
-  (let ((k (jolt-error-continuation v)))
-    (and k
-         (let ((recs (jolt-frame-records k)))
-           (and (pair? recs)
-                (let ((port (open-output-string)))
-                  (let loop ((rs recs) (shown 0))
-                    (when (and (pair? rs) (fx<? shown 30))
-                      (let* ((p (car rs)) (frame-name (car p)) (r (cdr p)))
-                        (put-string port "    ")
-                        (if (vector? r)
-                            (let ((ns (vector-ref r 0)) (nm (vector-ref r 1))
-                                  (file (vector-ref r 2)) (line (vector-ref r 3)))
-                              (put-string port ns) (put-string port "/") (put-string port nm)
-                              (when (string? file)
-                                (put-string port " (") (put-string port file)
-                                (put-string port ":") (put-string port (number->string line))
-                                (put-string port ")")))
-                            (put-string port frame-name))   ; 'ambiguous: bare name
-                        (put-char port #\newline))
-                      (loop (cdr rs) (fx+ shown 1))))
-                  (get-output-string port)))))))
+  (let* ((hist (jolt-trace-snapshot))
+         ;; a mapped frame is always kept; else drop plumbing (same rule as the
+         ;; continuation path) so the two backtrace sources read consistently
+         (recs (let loop ((ns hist) (acc '()))
+                 (if (null? ns)
+                     (reverse acc)
+                     (let* ((nm (car ns)) (src (hashtable-ref source-registry nm #f)))
+                       (loop (cdr ns)
+                             (if (or src (not (srcreg-plumbing-name? nm)))
+                                 (cons (cons nm src) acc) acc)))))))
+    (if (pair? recs)
+        (jolt-render-recs recs)
+        (let ((k (jolt-error-continuation v)))
+          (and k
+               (let ((recs (jolt-frame-records k)))
+                 (and (pair? recs) (jolt-render-recs recs))))))))
 
 ;; Render an uncaught jolt throw (any value, not just a Chez condition) to a port:
 ;; an ex-info shows its message + ex-data (+ a host cause); anything else is
diff --git a/jolt-core/jolt/backend_scheme.clj b/jolt-core/jolt/backend_scheme.clj
index 4475dc6..1a4bc7f 100644
--- a/jolt-core/jolt/backend_scheme.clj
+++ b/jolt-core/jolt/backend_scheme.clj
@@ -172,6 +172,14 @@
 (def var-cache? (atom false))
 (defn set-var-cache! [on] (reset! var-cache? on))
 
+;; Opt-in tail-frame history (JOLT_TRACE): emit a (jolt-trace-push! "name") at the
+;; head of every named fn body, so an entry records the frame into the runtime ring
+;; buffer (rt.ss) and a TCO-elided frame still shows in an error's backtrace. OFF
+;; during the seed mint and `jolt build` (byte-determinism + no runtime cost);
+;; compile-eval.ss turns it on for runtime-eval'd user code when JOLT_TRACE is set.
+(def trace-frames? (atom false))
+(defn set-trace-frames! [on] (reset! trace-frames? on))
+
 ;; A direct-link Scheme binding name for a var. The fqn maps to a unique identifier
 ;; jv$<ns>$<name>; chars that break a Scheme identifier or the `$` separator are
 ;; escaped so distinct vars never collide.
@@ -191,6 +199,13 @@
 ;; recursion auto-restores them (no manual save/restore, no throw-leak).
 (def ^:dynamic *recur-target* nil)
 (def ^:dynamic *known-procs* #{})
+;; True while emitting a node in TAIL position. Only used, in trace mode, to mark a
+;; tail call so the runtime routes its callee into the current history rib instead
+;; of a new one (rt.ss). It never affects semantics — a wrong value only mislabels
+;; a debug trace line — so partial propagation is safe. `emit` (the wrapper below)
+;; clears it by default; the tail-transparent forms (fn body, if/do/let/loop) pass
+;; it to their tail child. Default false so a top-level form is treated non-tail.
+(def ^:dynamic *tail?* false)
 
 (def ^:private gensym-counter (atom 0))
 (defn- fresh-label [prefix] (str prefix (swap! gensym-counter inc)))
@@ -253,6 +268,17 @@
     (if (or (contains? scheme-reserved s) (contains? bare-native-names s)) (str "_" s) s)))
 
 (declare emit)
+(declare emit*)
+;; Ops that pass tail position through to a child (the child can itself be a tail
+;; call): if/do carry it to their tail branch/last form, let/loop to their body,
+;; and invoke reads it to decide whether the call is tail. Every other op's
+;; children are non-tail, so `emit` clears *tail?* before dispatching them — that
+;; way a stray true can't leak into, say, a call sitting in a vector literal.
+(def ^:private tail-transparent-ops #{:if :do :let :loop :invoke})
+(defn emit [node]
+  (if (and *tail?* (not (tail-transparent-ops (:op node))))
+    (binding [*tail?* false] (emit* node))
+    (emit* node)))
 
 ;; A Chez string literal. Every char outside printable ASCII becomes a
 ;; codepoint hex escape \x<cp>; ; the named escapes (\n \t \r \" \\) match what
@@ -413,9 +439,10 @@
 ;; letfn lowers to a :let flagged :letrec (mutually-recursive named local fns):
 ;; Scheme `letrec*` binds them so each sees its siblings. A plain let uses let*.
 (defn- emit-let [node]
-  (let [kw (if (:letrec node) "letrec*" "let*")]
-    (str "(" kw " (" (str/join " " (map emit-binding (:bindings node))) ") "
-         (emit (:body node)) ")")))
+  (let [kw (if (:letrec node) "letrec*" "let*")
+        ;; bindings are non-tail; the body inherits the let's tail position
+        binds (binding [*tail?* false] (str/join " " (mapv emit-binding (:bindings node))))]
+    (str "(" kw " (" binds ") " (emit (:body node)) ")")))
 
 (defn- emit-loop [node]
   (let [label (fresh-label "loop")
@@ -423,9 +450,10 @@
         names (map #(munge-name (nth % 0)) pairs)
         ;; inits evaluate in the OUTER scope (recur-target unchanged) and, like
         ;; Clojure loop/let, SEQUENTIALLY — wrap a let* around the named let.
-        inits (map #(emit (nth % 1)) pairs)
+        inits (binding [*tail?* false] (mapv #(emit (nth % 1)) pairs))
         seq-bs (str/join " " (map (fn [n i] (str "(" n " " i ")")) names inits))
         rebinds (str/join " " (map (fn [n] (str "(" n " " n ")")) names))
+        ;; the loop body inherits the loop's tail position
         body (binding [*recur-target* label] (emit (:body node)))]
     (str "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))
 
@@ -486,7 +514,11 @@
         params (map munge-name orig)
         restp (when-let [r (:rest a)] (munge-name r))
         label (fresh-label "fnrec")
-        body (binding [*recur-target* label] (emit (:body a)))
+        ret (:ret-nhint a)
+        ;; the body is the fn's tail position — UNLESS a ^double/^long return hint
+        ;; wraps it in a coercion below, which puts the body back in non-tail.
+        body-tail? (not (or (= ret :double) (= ret :long)))
+        body (binding [*recur-target* label *tail?* body-tail?] (emit (:body a)))
         paramlist (cond
                     (and restp (empty? params)) restp
                     restp (str "(" (str/join " " params) " . " restp ")")
@@ -511,6 +543,16 @@
         self (when-let [nm (:name node)] (munge-name nm))
         clauses (binding [*known-procs* (if self (conj *known-procs* self) *known-procs*)]
                   (mapv emit-arity-clause arities))
+        ;; trace mode: record this frame on entry (before the body), so a frame
+        ;; the body then tail-calls away is still in the ring at throw time. A
+        ;; `recur` re-enters via the named-let, not the lambda, so a tight loop
+        ;; records once, not per iteration.
+        clauses (if (and @trace-frames? self)
+                  (mapv (fn [c] [(nth c 0)
+                                 (str "(begin (jolt-trace-push! " (chez-str-lit self) ") "
+                                      (nth c 1) ")")])
+                        clauses)
+                  clauses)
         lambda (if (= 1 (count clauses))
                  (let [c (first clauses)] (str "(lambda " (nth c 0) " " (nth c 1) ")"))
                  (str "(case-lambda "
@@ -573,8 +615,31 @@
             (= (nth shape i) kw) i
             :else (recur (inc i))))))
 
+;; A plain Scheme application: (callee op ...).
+(defn- plain-call [callee operand-strs]
+  (str "(" callee (if (seq operand-strs) (str " " (str/join " " operand-strs)) "") ")"))
+;; A tail call in trace mode. Force-bind the operands to temps FIRST (so any
+;; operand whose own evaluation records a trace entry runs before our mark), THEN
+;; set the tail mark, THEN apply — the callee's entry prologue consumes the mark
+;; with nothing in between, so it can't be clobbered. Still a tail call: the let*'s
+;; last form is the application, so TCO is preserved.
+(defn- tail-marked-call [callee operand-strs]
+  (let [tmps (mapv (fn [_] (fresh-label "_tt$")) operand-strs)
+        binds (str/join " " (map (fn [t a] (str "(" t " " a ")")) tmps operand-strs))]
+    (str "(let* (" binds ") (jolt-trace-mark! #t) " (plain-call callee tmps) ")")))
+;; Emit a call, tail-marked when we're in tail position and tracing is on; a plain
+;; application otherwise. The mark is consumed by the callee's entry prologue —
+;; direct calls (:local known-proc, direct-link) always have one; a jolt-invoke
+;; call usually reaches one but not always (see the best-effort note in rt.ss).
+(defn- emit-call [tail? callee operand-strs]
+  (if (and @trace-frames? tail?)
+    (tail-marked-call callee operand-strs)
+    (plain-call callee operand-strs)))
+
 (defn- emit-invoke [node]
-  (let [fnode (:fn node)
+  (let [tail? *tail?*]           ; capture: children below emit non-tail
+   (binding [*tail?* false]
+    (let [fnode (:fn node)
         arg-nodes (:args node)
         args (mapv emit arg-nodes)
         nop (native-op fnode (count args))
@@ -586,8 +651,7 @@
         ;; order [callee & args] together when ordering is observable.
         invoke (fn []
                  (ordered-call (cons fnode arg-nodes) (cons (emit fnode) args)
-                               (fn [[f & as]]
-                                 (str "(jolt-invoke " f (if (seq as) (str " " (str/join " " as)) "") ")"))))]
+                               (fn [operands] (emit-call tail? "jolt-invoke" operands))))]
     (cond
       ;; devirtualized protocol call: the inference proved the receiver (arg 0) is
       ;; one record type, so resolve the impl by that static tag instead of routing
@@ -662,8 +726,7 @@
       ;; holds an arbitrary IFn -> dynamic dispatch.
       (= :local (:op fnode))
       (if (*known-procs* (munge-name (:name fnode)))
-        (order-args (fn [as] (str "(" (munge-name (:name fnode))
-                                  (if (seq as) (str " " (str/join " " as)) "") ")")))
+        (order-args (fn [as] (emit-call tail? (munge-name (:name fnode)) as)))
         (invoke))
       ;; closed-world direct call: the callee var is an app fn def already emitted
       ;; with a Scheme binding — apply it directly, no var lookup, no jolt-invoke.
@@ -672,8 +735,7 @@
       ;; below (which still uses the direct binding as the invoke target).
       (and (= :var (:op fnode)) (direct-linkable? (:ns fnode) (:name fnode))
            (direct-link-fn? (:ns fnode) (:name fnode)))
-      (order-args (fn [as] (str "(" (dl-name (:ns fnode) (:name fnode))
-                                (if (seq as) (str " " (str/join " " as)) "") ")")))
+      (order-args (fn [as] (emit-call tail? (dl-name (:ns fnode) (:name fnode)) as)))
       ;; a late-bound :var call head can hold a procedure OR a non-applicable
       ;; value the RT dispatches (multimethod, keyword/coll IFn) — route via
       ;; jolt-invoke (transparent for a procedure).
@@ -681,7 +743,7 @@
       (invoke)
       ;; a computed callee can yield ANY IFn — route through jolt-invoke.
       :else
-      (invoke))))
+      (invoke))))))
 
 ;; try/catch/finally. throw raises a Chez condition wrapping the jolt value
 ;; (jolt-throw = Scheme `raise` of a &jolt-throw condition); catch lowers to
@@ -728,7 +790,7 @@
        (returns-scheme-bool? (:body node) bools'))
      :else false)))
 
-(defn emit [node]
+(defn emit* [node]
   (case (:op node)
     :const (emit-const (:val node))
     :local (munge-name (:name node))
@@ -776,11 +838,14 @@
     :host-new (str "(host-new " (chez-str-lit (:class node))
                    (let [args (map emit (:args node))]
                      (if (empty? args) "" (str " " (str/join " " args)))) ")")
+    ;; the test is non-tail; then/else inherit the if's tail position
     :if (let [test (:test node)
-              t (if (returns-scheme-bool? test) (emit test)
-                    (str "(jolt-truthy? " (emit test) ")"))]
+              t (binding [*tail?* false]
+                  (if (returns-scheme-bool? test) (emit test)
+                      (str "(jolt-truthy? " (emit test) ")")))]
           (str "(if " t " " (emit (:then node)) " " (emit (:else node)) ")"))
-    :do (str "(begin " (str/join " " (map emit (:statements node)))
+    ;; non-last statements are non-tail; the ret inherits the do's tail position
+    :do (str "(begin " (binding [*tail?* false] (str/join " " (mapv emit (:statements node))))
              (if (empty? (:statements node)) "" " ") (emit (:ret node)) ")")
     :invoke (emit-invoke node)
     ;; collection literals -> rt constructors (collections.ss). Elements are