diff --git a/Makefile b/Makefile
index 0f9d1b6..3bac7d0 100644
--- a/Makefile
+++ b/Makefile
@@ -4,7 +4,7 @@
 # build step. `make test` is the full gate. `make remint` rebuilds the seed after a
 # source change.
 
-.PHONY: test ci values corpus unit smoke buildsmoke selfhost sci certify ffi transient infer wp directlink numeric inline shakesmoke remint
+.PHONY: test ci values corpus unit smoke buildsmoke selfhost sci certify ffi transient infer wp devirt directlink numeric inline shakesmoke remint
 
 # Full gate (dev machine). Includes the self-host byte-fixpoint, which only holds
 # on the same Chez that minted the seed.
@@ -15,7 +15,7 @@ test: selfhost ci
 # lockfile) — it RUNS correctly on any Chez, but `selfhost` rebuilds it and a
 # different Chez version may emit byte-different (gensym/order) output, so the
 # byte-fixpoint is a dev-machine check, not a CI one (jolt-8479).
-ci: values corpus unit smoke buildsmoke sci ffi transient infer wp directlink numeric inline certify
+ci: values corpus unit smoke buildsmoke sci ffi transient infer wp devirt directlink numeric inline certify
 	@echo "OK: CI gates passed"
 
 # Self-host fixpoint: bootstrap.ss rebuild == checked-in seed.
@@ -67,6 +67,12 @@ infer:
 wp:
 	@chez --script host/chez/run-wp.ss
 
+# Protocol-call devirtualization: a monomorphic call resolves its impl by the
+# inferred record tag (find-protocol-method) instead of routing through the
+# protocol var; the result must match ordinary dispatch.
+devirt:
+	@chez --script host/chez/run-devirt.ss
+
 # Direct-linking emission: a closed-world build binds top-level app defs to jv$
 # Scheme bindings and routes app->app calls/refs to them, skipping var-deref +
 # jolt-invoke; ^:dynamic/^:redef and nested defs opt out.
diff --git a/host/chez/run-devirt.ss b/host/chez/run-devirt.ss
new file mode 100644
index 0000000..1a45190
--- /dev/null
+++ b/host/chez/run-devirt.ss
@@ -0,0 +1,71 @@
+;; run-devirt.ss — protocol-call devirtualization gate (backend_scheme emit).
+;;
+;; The inference annotates a monomorphic protocol call with :devirt-type/-proto/
+;; -method (jolt.passes.types); the back end then resolves the impl by that static
+;; tag. This gate pins both halves: the emitted form uses find-protocol-method, and
+;; evaluating it returns the same value the ordinary dispatch would — for a record's
+;; inline impl, an extend-type impl, and across distinct receiver types.
+;;
+;;   chez --script host/chez/run-devirt.ss
+(import (chezscheme))
+(load "host/chez/rt.ss")
+(set-chez-ns! "clojure.core")
+(load "host/chez/seed/prelude.ss")
+(load "host/chez/post-prelude.ss")
+(set-chez-ns! "user")
+(load "host/chez/host-contract.ss")
+(load "host/chez/seed/image.ss")
+(load "host/chez/compile-eval.ss")
+
+(define analyze (var-deref "jolt.analyzer" "analyze"))
+(define emit    (var-deref "jolt.backend-scheme" "emit"))
+(define kw      (lambda (n) (keyword #f n)))
+
+(define (evals src) (jolt-compile-eval (string-append "(do " src ")") "user"))
+;; define two record types implementing one protocol — Circle via an inline impl,
+;; Square via extend-type — plus instances to dispatch on.
+(evals "(defprotocol Shape (area [s]))")
+(evals "(defrecord Circle [r] Shape (area [s] (:r s)))")
+(evals "(defrecord Square [w])")
+(evals "(extend-type Square Shape (area [s] (* (:w s) (:w s))))")
+(evals "(def c (->Circle 7))")
+(evals "(def sq (->Square 5))")
+
+;; analyze (area RECV), annotate it as a devirt call on `type`, and emit. RECV is a
+;; var name (c/sq) the emitted code resolves at eval time.
+(define (devirt-emit type recv)
+  (let* ((ir (analyze (make-analyze-ctx "user") (jolt-ce-read (string-append "(area " recv ")"))))
+         (dv (jolt-assoc ir (kw "devirt-type") type (kw "devirt-proto") "Shape"
+                         (kw "devirt-method") "area")))
+    (emit dv)))
+
+(define fails 0) (define total 0)
+(define (check label actual expected)
+  (set! total (+ total 1))
+  (unless (equal? actual expected)
+    (set! fails (+ fails 1))
+    (printf "  FAIL ~a: got ~s expected ~s\n" label actual expected)))
+(define (has-sub? s sub)
+  (let ((n (string-length s)) (m (string-length sub)))
+    (let loop ((i 0)) (cond ((> (+ i m) n) #f)
+                            ((string=? (substring s i (+ i m)) sub) #t)
+                            (else (loop (+ i 1)))))))
+;; eval an emitted Scheme string in the loaded runtime (var-deref resolves c/sq).
+(define (run-emit scm) (eval (read (open-input-string scm)) (interaction-environment)))
+
+(let ((e (devirt-emit "user.Circle" "c")))
+  (check "emit uses find-protocol-method" (has-sub? e "find-protocol-method") #t)
+  (check "devirt inline impl == dispatch" (run-emit e) (evals "(area c)")))   ; 7
+
+(let ((e (devirt-emit "user.Square" "sq")))
+  (check "devirt extend-type impl == dispatch" (run-emit e) (evals "(area sq)")))  ; 25
+
+;; a normal (no devirt) call still goes through dispatch and agrees — the path the
+;; megamorphic / unknown-receiver site keeps.
+(let ((e (emit (analyze (make-analyze-ctx "user") (jolt-ce-read "(area c)")))))
+  (check "non-devirt path no find-protocol-method" (has-sub? e "find-protocol-method") #f)
+  (check "non-devirt still dispatches" (run-emit e) 7))
+
+(if (= fails 0)
+    (begin (printf "devirt gate: ~a/~a passed\n" total total) (exit 0))
+    (begin (printf "devirt gate: ~a/~a passed (~a failed)\n" (- total fails) total fails) (exit 1)))
diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss
index 1089b72..5a0f913 100644
--- a/host/chez/seed/image.ss
+++ b/host/chez/seed/image.ss
@@ -1,129 +1,129 @@
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7429 ((v v)) (let* ((_o$7430 (keyword #f "op")) (_o$7431 (keyword #f "const")) (_o$7432 (keyword #f "val")) (_o$7433 v)) (jolt-hash-map _o$7430 _o$7431 _o$7432 _o$7433)))))) const)))
+  (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7440 ((v v)) (let* ((_o$7441 (keyword #f "op")) (_o$7442 (keyword #f "const")) (_o$7443 (keyword #f "val")) (_o$7444 v)) (jolt-hash-map _o$7441 _o$7442 _o$7443 _o$7444)))))) const)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7434 ((name name)) (let* ((_o$7435 (keyword #f "op")) (_o$7436 (keyword #f "local")) (_o$7437 (keyword #f "name")) (_o$7438 name)) (jolt-hash-map _o$7435 _o$7436 _o$7437 _o$7438)))))) local)))
+  (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7445 ((name name)) (let* ((_o$7446 (keyword #f "op")) (_o$7447 (keyword #f "local")) (_o$7448 (keyword #f "name")) (_o$7449 name)) (jolt-hash-map _o$7446 _o$7447 _o$7448 _o$7449)))))) local)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7439 ((ns ns) (name name)) (let* ((_o$7440 (keyword #f "op")) (_o$7441 (keyword #f "var")) (_o$7442 (keyword #f "ns")) (_o$7443 ns) (_o$7444 (keyword #f "name")) (_o$7445 name)) (jolt-hash-map _o$7440 _o$7441 _o$7442 _o$7443 _o$7444 _o$7445)))))) var-ref)))
+  (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7450 ((ns ns) (name name)) (let* ((_o$7451 (keyword #f "op")) (_o$7452 (keyword #f "var")) (_o$7453 (keyword #f "ns")) (_o$7454 ns) (_o$7455 (keyword #f "name")) (_o$7456 name)) (jolt-hash-map _o$7451 _o$7452 _o$7453 _o$7454 _o$7455 _o$7456)))))) var-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7446 ((ns ns) (name name)) (let* ((_o$7447 (keyword #f "op")) (_o$7448 (keyword #f "the-var")) (_o$7449 (keyword #f "ns")) (_o$7450 ns) (_o$7451 (keyword #f "name")) (_o$7452 name)) (jolt-hash-map _o$7447 _o$7448 _o$7449 _o$7450 _o$7451 _o$7452)))))) the-var)))
+  (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7457 ((ns ns) (name name)) (let* ((_o$7458 (keyword #f "op")) (_o$7459 (keyword #f "the-var")) (_o$7460 (keyword #f "ns")) (_o$7461 ns) (_o$7462 (keyword #f "name")) (_o$7463 name)) (jolt-hash-map _o$7458 _o$7459 _o$7460 _o$7461 _o$7462 _o$7463)))))) the-var)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7453 ((name name)) (let* ((_o$7454 (keyword #f "op")) (_o$7455 (keyword #f "host")) (_o$7456 (keyword #f "name")) (_o$7457 name)) (jolt-hash-map _o$7454 _o$7455 _o$7456 _o$7457)))))) host-ref)))
+  (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7464 ((name name)) (let* ((_o$7465 (keyword #f "op")) (_o$7466 (keyword #f "host")) (_o$7467 (keyword #f "name")) (_o$7468 name)) (jolt-hash-map _o$7465 _o$7466 _o$7467 _o$7468)))))) host-ref)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7458 ((class class) (member member)) (let* ((_o$7459 (keyword #f "op")) (_o$7460 (keyword #f "host-static")) (_o$7461 (keyword #f "class")) (_o$7462 class) (_o$7463 (keyword #f "member")) (_o$7464 member)) (jolt-hash-map _o$7459 _o$7460 _o$7461 _o$7462 _o$7463 _o$7464)))))) host-static)))
+  (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7469 ((class class) (member member)) (let* ((_o$7470 (keyword #f "op")) (_o$7471 (keyword #f "host-static")) (_o$7472 (keyword #f "class")) (_o$7473 class) (_o$7474 (keyword #f "member")) (_o$7475 member)) (jolt-hash-map _o$7470 _o$7471 _o$7472 _o$7473 _o$7474 _o$7475)))))) host-static)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7465 ((class class) (args args)) (let* ((_o$7466 (keyword #f "op")) (_o$7467 (keyword #f "host-new")) (_o$7468 (keyword #f "class")) (_o$7469 class) (_o$7470 (keyword #f "args")) (_o$7471 args)) (jolt-hash-map _o$7466 _o$7467 _o$7468 _o$7469 _o$7470 _o$7471)))))) host-new)))
+  (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7476 ((class class) (args args)) (let* ((_o$7477 (keyword #f "op")) (_o$7478 (keyword #f "host-new")) (_o$7479 (keyword #f "class")) (_o$7480 class) (_o$7481 (keyword #f "args")) (_o$7482 args)) (jolt-hash-map _o$7477 _o$7478 _o$7479 _o$7480 _o$7481 _o$7482)))))) host-new)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7472 ((test test) (then then) (_else _else)) (let* ((_o$7473 (keyword #f "op")) (_o$7474 (keyword #f "if")) (_o$7475 (keyword #f "test")) (_o$7476 test) (_o$7477 (keyword #f "then")) (_o$7478 then) (_o$7479 (keyword #f "else")) (_o$7480 _else)) (jolt-hash-map _o$7473 _o$7474 _o$7475 _o$7476 _o$7477 _o$7478 _o$7479 _o$7480)))))) if-node)))
+  (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7483 ((test test) (then then) (_else _else)) (let* ((_o$7484 (keyword #f "op")) (_o$7485 (keyword #f "if")) (_o$7486 (keyword #f "test")) (_o$7487 test) (_o$7488 (keyword #f "then")) (_o$7489 then) (_o$7490 (keyword #f "else")) (_o$7491 _else)) (jolt-hash-map _o$7484 _o$7485 _o$7486 _o$7487 _o$7488 _o$7489 _o$7490 _o$7491)))))) if-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7481 ((statements statements) (ret ret)) (let* ((_o$7482 (keyword #f "op")) (_o$7483 (keyword #f "do")) (_o$7484 (keyword #f "statements")) (_o$7485 statements) (_o$7486 (keyword #f "ret")) (_o$7487 ret)) (jolt-hash-map _o$7482 _o$7483 _o$7484 _o$7485 _o$7486 _o$7487)))))) do-node)))
+  (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7492 ((statements statements) (ret ret)) (let* ((_o$7493 (keyword #f "op")) (_o$7494 (keyword #f "do")) (_o$7495 (keyword #f "statements")) (_o$7496 statements) (_o$7497 (keyword #f "ret")) (_o$7498 ret)) (jolt-hash-map _o$7493 _o$7494 _o$7495 _o$7496 _o$7497 _o$7498)))))) do-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7488 ((f f) (args args)) (let* ((_o$7489 (keyword #f "op")) (_o$7490 (keyword #f "invoke")) (_o$7491 (keyword #f "fn")) (_o$7492 f) (_o$7493 (keyword #f "args")) (_o$7494 args)) (jolt-hash-map _o$7489 _o$7490 _o$7491 _o$7492 _o$7493 _o$7494)))))) invoke)))
+  (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7499 ((f f) (args args)) (let* ((_o$7500 (keyword #f "op")) (_o$7501 (keyword #f "invoke")) (_o$7502 (keyword #f "fn")) (_o$7503 f) (_o$7504 (keyword #f "args")) (_o$7505 args)) (jolt-hash-map _o$7500 _o$7501 _o$7502 _o$7503 _o$7504 _o$7505)))))) invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7495 ((ns ns) (name name) (init init)) (let* ((_o$7496 (keyword #f "op")) (_o$7497 (keyword #f "def")) (_o$7498 (keyword #f "ns")) (_o$7499 ns) (_o$7500 (keyword #f "name")) (_o$7501 name) (_o$7502 (keyword #f "init")) (_o$7503 init)) (jolt-hash-map _o$7496 _o$7497 _o$7498 _o$7499 _o$7500 _o$7501 _o$7502 _o$7503)))) ((ns name init meta) (let fnrec7504 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7505 (keyword #f "op")) (_o$7506 (keyword #f "def")) (_o$7507 (keyword #f "ns")) (_o$7508 ns) (_o$7509 (keyword #f "name")) (_o$7510 name) (_o$7511 (keyword #f "init")) (_o$7512 init) (_o$7513 (keyword #f "meta")) (_o$7514 meta)) (jolt-hash-map _o$7505 _o$7506 _o$7507 _o$7508 _o$7509 _o$7510 _o$7511 _o$7512 _o$7513 _o$7514)) (let* ((_o$7515 (keyword #f "op")) (_o$7516 (keyword #f "def")) (_o$7517 (keyword #f "ns")) (_o$7518 ns) (_o$7519 (keyword #f "name")) (_o$7520 name) (_o$7521 (keyword #f "init")) (_o$7522 init)) (jolt-hash-map _o$7515 _o$7516 _o$7517 _o$7518 _o$7519 _o$7520 _o$7521 _o$7522)))))))) def-node)))
+  (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7506 ((ns ns) (name name) (init init)) (let* ((_o$7507 (keyword #f "op")) (_o$7508 (keyword #f "def")) (_o$7509 (keyword #f "ns")) (_o$7510 ns) (_o$7511 (keyword #f "name")) (_o$7512 name) (_o$7513 (keyword #f "init")) (_o$7514 init)) (jolt-hash-map _o$7507 _o$7508 _o$7509 _o$7510 _o$7511 _o$7512 _o$7513 _o$7514)))) ((ns name init meta) (let fnrec7515 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7516 (keyword #f "op")) (_o$7517 (keyword #f "def")) (_o$7518 (keyword #f "ns")) (_o$7519 ns) (_o$7520 (keyword #f "name")) (_o$7521 name) (_o$7522 (keyword #f "init")) (_o$7523 init) (_o$7524 (keyword #f "meta")) (_o$7525 meta)) (jolt-hash-map _o$7516 _o$7517 _o$7518 _o$7519 _o$7520 _o$7521 _o$7522 _o$7523 _o$7524 _o$7525)) (let* ((_o$7526 (keyword #f "op")) (_o$7527 (keyword #f "def")) (_o$7528 (keyword #f "ns")) (_o$7529 ns) (_o$7530 (keyword #f "name")) (_o$7531 name) (_o$7532 (keyword #f "init")) (_o$7533 init)) (jolt-hash-map _o$7526 _o$7527 _o$7528 _o$7529 _o$7530 _o$7531 _o$7532 _o$7533)))))))) def-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7523 ((bindings bindings) (body body)) (let* ((_o$7524 (keyword #f "op")) (_o$7525 (keyword #f "let")) (_o$7526 (keyword #f "bindings")) (_o$7527 bindings) (_o$7528 (keyword #f "body")) (_o$7529 body)) (jolt-hash-map _o$7524 _o$7525 _o$7526 _o$7527 _o$7528 _o$7529)))))) let-node)))
+  (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7534 ((bindings bindings) (body body)) (let* ((_o$7535 (keyword #f "op")) (_o$7536 (keyword #f "let")) (_o$7537 (keyword #f "bindings")) (_o$7538 bindings) (_o$7539 (keyword #f "body")) (_o$7540 body)) (jolt-hash-map _o$7535 _o$7536 _o$7537 _o$7538 _o$7539 _o$7540)))))) let-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7530 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7531 (keyword #f "op")) (_o$7532 (keyword #f "fn")) (_o$7533 (keyword #f "name")) (_o$7534 name) (_o$7535 (keyword #f "arities")) (_o$7536 arities)) (jolt-hash-map _o$7531 _o$7532 _o$7533 _o$7534 _o$7535 _o$7536)) (let* ((_o$7537 (keyword #f "op")) (_o$7538 (keyword #f "fn")) (_o$7539 (keyword #f "arities")) (_o$7540 arities)) (jolt-hash-map _o$7537 _o$7538 _o$7539 _o$7540))))))) fn-node)))
+  (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7541 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7542 (keyword #f "op")) (_o$7543 (keyword #f "fn")) (_o$7544 (keyword #f "name")) (_o$7545 name) (_o$7546 (keyword #f "arities")) (_o$7547 arities)) (jolt-hash-map _o$7542 _o$7543 _o$7544 _o$7545 _o$7546 _o$7547)) (let* ((_o$7548 (keyword #f "op")) (_o$7549 (keyword #f "fn")) (_o$7550 (keyword #f "arities")) (_o$7551 arities)) (jolt-hash-map _o$7548 _o$7549 _o$7550 _o$7551))))))) fn-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7541 ((items items)) (let* ((_o$7542 (keyword #f "op")) (_o$7543 (keyword #f "vector")) (_o$7544 (keyword #f "items")) (_o$7545 items)) (jolt-hash-map _o$7542 _o$7543 _o$7544 _o$7545)))))) vector-node)))
+  (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7552 ((items items)) (let* ((_o$7553 (keyword #f "op")) (_o$7554 (keyword #f "vector")) (_o$7555 (keyword #f "items")) (_o$7556 items)) (jolt-hash-map _o$7553 _o$7554 _o$7555 _o$7556)))))) vector-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7546 ((pairs pairs)) (let* ((_o$7547 (keyword #f "op")) (_o$7548 (keyword #f "map")) (_o$7549 (keyword #f "pairs")) (_o$7550 pairs)) (jolt-hash-map _o$7547 _o$7548 _o$7549 _o$7550)))))) map-node)))
+  (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7557 ((pairs pairs)) (let* ((_o$7558 (keyword #f "op")) (_o$7559 (keyword #f "map")) (_o$7560 (keyword #f "pairs")) (_o$7561 pairs)) (jolt-hash-map _o$7558 _o$7559 _o$7560 _o$7561)))))) map-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7551 ((items items)) (let* ((_o$7552 (keyword #f "op")) (_o$7553 (keyword #f "set")) (_o$7554 (keyword #f "items")) (_o$7555 items)) (jolt-hash-map _o$7552 _o$7553 _o$7554 _o$7555)))))) set-node)))
+  (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7562 ((items items)) (let* ((_o$7563 (keyword #f "op")) (_o$7564 (keyword #f "set")) (_o$7565 (keyword #f "items")) (_o$7566 items)) (jolt-hash-map _o$7563 _o$7564 _o$7565 _o$7566)))))) set-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7556 ((form form)) (let* ((_o$7557 (keyword #f "op")) (_o$7558 (keyword #f "quote")) (_o$7559 (keyword #f "form")) (_o$7560 form)) (jolt-hash-map _o$7557 _o$7558 _o$7559 _o$7560)))))) quote-node)))
+  (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7567 ((form form)) (let* ((_o$7568 (keyword #f "op")) (_o$7569 (keyword #f "quote")) (_o$7570 (keyword #f "form")) (_o$7571 form)) (jolt-hash-map _o$7568 _o$7569 _o$7570 _o$7571)))))) quote-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7561 ((expr expr)) (let* ((_o$7562 (keyword #f "op")) (_o$7563 (keyword #f "throw")) (_o$7564 (keyword #f "expr")) (_o$7565 expr)) (jolt-hash-map _o$7562 _o$7563 _o$7564 _o$7565)))))) throw-node)))
+  (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7572 ((expr expr)) (let* ((_o$7573 (keyword #f "op")) (_o$7574 (keyword #f "throw")) (_o$7575 (keyword #f "expr")) (_o$7576 expr)) (jolt-hash-map _o$7573 _o$7574 _o$7575 _o$7576)))))) throw-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7566 ((kind kind) (expr expr)) (let* ((_o$7567 (keyword #f "op")) (_o$7568 (keyword #f "coerce")) (_o$7569 (keyword #f "kind")) (_o$7570 kind) (_o$7571 (keyword #f "expr")) (_o$7572 expr)) (jolt-hash-map _o$7567 _o$7568 _o$7569 _o$7570 _o$7571 _o$7572)))))) coerce-node)))
+  (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7577 ((kind kind) (expr expr)) (let* ((_o$7578 (keyword #f "op")) (_o$7579 (keyword #f "coerce")) (_o$7580 (keyword #f "kind")) (_o$7581 kind) (_o$7582 (keyword #f "expr")) (_o$7583 expr)) (jolt-hash-map _o$7578 _o$7579 _o$7580 _o$7581 _o$7582 _o$7583)))))) coerce-node)))
 (guard (e (#t #f))
-  (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec7573 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7574 node) (_a$7575 (keyword #f "test")) (_a$7576 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7577 (keyword #f "then")) (_a$7578 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7579 (keyword #f "else")) (_a$7580 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7574 _a$7575 _a$7576 _a$7577 _a$7578 _a$7579 _a$7580)) (if (jolt= op (keyword #f "do")) (let* ((_a$7581 node) (_a$7582 (keyword #f "statements")) (_a$7583 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7584 (keyword #f "ret")) (_a$7585 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7581 _a$7582 _a$7583 _a$7584 _a$7585)) (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$7586 node) (_a$7587 (keyword #f "obj")) (_a$7588 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7589 (keyword #f "val")) (_a$7590 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7586 _a$7587 _a$7588 _a$7589 _a$7590)) (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$7591 node) (_a$7592 (keyword #f "fn")) (_a$7593 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7594 (keyword #f "args")) (_a$7595 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7591 _a$7592 _a$7593 _a$7594 _a$7595)) (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$7599 (var-deref "clojure.core" "mapv")) (_a$7600 (lambda (pr) (let fnrec7596 ((pr pr)) (let* ((_o$7597 (jolt-invoke f (jolt-nth pr 0))) (_o$7598 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7597 _o$7598))))) (_a$7601 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7599 _a$7600 _a$7601))) (if (jolt= op (keyword #f "let")) (let* ((_a$7608 node) (_a$7609 (keyword #f "bindings")) (_a$7610 (let* ((_a$7605 (var-deref "clojure.core" "mapv")) (_a$7606 (lambda (b) (let fnrec7602 ((b b)) (let* ((_o$7603 (jolt-nth b 0)) (_o$7604 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7603 _o$7604))))) (_a$7607 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7605 _a$7606 _a$7607))) (_a$7611 (keyword #f "body")) (_a$7612 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7608 _a$7609 _a$7610 _a$7611 _a$7612)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7619 node) (_a$7620 (keyword #f "bindings")) (_a$7621 (let* ((_a$7616 (var-deref "clojure.core" "mapv")) (_a$7617 (lambda (b) (let fnrec7613 ((b b)) (let* ((_o$7614 (jolt-nth b 0)) (_o$7615 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7614 _o$7615))))) (_a$7618 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7616 _a$7617 _a$7618))) (_a$7622 (keyword #f "body")) (_a$7623 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7619 _a$7620 _a$7621 _a$7622 _a$7623)) (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$7625 (var-deref "clojure.core" "mapv")) (_a$7626 (lambda (a) (let fnrec7624 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7627 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7625 _a$7626 _a$7627))) (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$7628 node) (_a$7629 (keyword #f "target")) (_a$7630 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7631 (keyword #f "args")) (_a$7632 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7628 _a$7629 _a$7630 _a$7631 _a$7632)) (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 fnrec7584 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7585 node) (_a$7586 (keyword #f "test")) (_a$7587 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7588 (keyword #f "then")) (_a$7589 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7590 (keyword #f "else")) (_a$7591 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7585 _a$7586 _a$7587 _a$7588 _a$7589 _a$7590 _a$7591)) (if (jolt= op (keyword #f "do")) (let* ((_a$7592 node) (_a$7593 (keyword #f "statements")) (_a$7594 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7595 (keyword #f "ret")) (_a$7596 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7592 _a$7593 _a$7594 _a$7595 _a$7596)) (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$7597 node) (_a$7598 (keyword #f "obj")) (_a$7599 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7600 (keyword #f "val")) (_a$7601 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7597 _a$7598 _a$7599 _a$7600 _a$7601)) (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$7602 node) (_a$7603 (keyword #f "fn")) (_a$7604 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7605 (keyword #f "args")) (_a$7606 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7602 _a$7603 _a$7604 _a$7605 _a$7606)) (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$7610 (var-deref "clojure.core" "mapv")) (_a$7611 (lambda (pr) (let fnrec7607 ((pr pr)) (let* ((_o$7608 (jolt-invoke f (jolt-nth pr 0))) (_o$7609 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7608 _o$7609))))) (_a$7612 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7610 _a$7611 _a$7612))) (if (jolt= op (keyword #f "let")) (let* ((_a$7619 node) (_a$7620 (keyword #f "bindings")) (_a$7621 (let* ((_a$7616 (var-deref "clojure.core" "mapv")) (_a$7617 (lambda (b) (let fnrec7613 ((b b)) (let* ((_o$7614 (jolt-nth b 0)) (_o$7615 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7614 _o$7615))))) (_a$7618 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7616 _a$7617 _a$7618))) (_a$7622 (keyword #f "body")) (_a$7623 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7619 _a$7620 _a$7621 _a$7622 _a$7623)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7630 node) (_a$7631 (keyword #f "bindings")) (_a$7632 (let* ((_a$7627 (var-deref "clojure.core" "mapv")) (_a$7628 (lambda (b) (let fnrec7624 ((b b)) (let* ((_o$7625 (jolt-nth b 0)) (_o$7626 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7625 _o$7626))))) (_a$7629 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7627 _a$7628 _a$7629))) (_a$7633 (keyword #f "body")) (_a$7634 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7630 _a$7631 _a$7632 _a$7633 _a$7634)) (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$7636 (var-deref "clojure.core" "mapv")) (_a$7637 (lambda (a) (let fnrec7635 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7638 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7636 _a$7637 _a$7638))) (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$7639 node) (_a$7640 (keyword #f "target")) (_a$7641 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7642 (keyword #f "args")) (_a$7643 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7639 _a$7640 _a$7641 _a$7642 _a$7643)) (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 fnrec7633 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7637 f) (_a$7638 (let* ((_a$7634 f) (_a$7635 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7636 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7634 _a$7635 _a$7636))) (_a$7639 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7637 _a$7638 _a$7639)) (if (jolt= op (keyword #f "do")) (let* ((_a$7640 f) (_a$7641 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7642 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7640 _a$7641 _a$7642)) (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$7643 f) (_a$7644 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7645 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7643 _a$7644 _a$7645)) (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$7646 f) (_a$7647 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7648 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7646 _a$7647 _a$7648)) (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$7653 (lambda (a pr) (let fnrec7649 ((a a) (pr pr)) (let* ((_a$7650 f) (_a$7651 (jolt-invoke f a (jolt-nth pr 0))) (_a$7652 (jolt-nth pr 1))) (jolt-invoke _a$7650 _a$7651 _a$7652))))) (_a$7654 acc) (_a$7655 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7653 _a$7654 _a$7655)) (if (jolt= op (keyword #f "let")) (let* ((_a$7660 f) (_a$7661 (let* ((_a$7657 (lambda (a b) (let fnrec7656 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7658 acc) (_a$7659 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7657 _a$7658 _a$7659))) (_a$7662 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7660 _a$7661 _a$7662)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7667 f) (_a$7668 (let* ((_a$7664 (lambda (a b) (let fnrec7663 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7665 acc) (_a$7666 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7664 _a$7665 _a$7666))) (_a$7669 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7667 _a$7668 _a$7669)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7671 (lambda (a ar) (let fnrec7670 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7672 acc) (_a$7673 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7671 _a$7672 _a$7673)) (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$7674 f) (_a$7675 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7676 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7674 _a$7675 _a$7676)) (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 fnrec7644 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7648 f) (_a$7649 (let* ((_a$7645 f) (_a$7646 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7647 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7645 _a$7646 _a$7647))) (_a$7650 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7648 _a$7649 _a$7650)) (if (jolt= op (keyword #f "do")) (let* ((_a$7651 f) (_a$7652 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7653 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7651 _a$7652 _a$7653)) (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$7654 f) (_a$7655 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7656 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7654 _a$7655 _a$7656)) (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$7657 f) (_a$7658 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7659 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7657 _a$7658 _a$7659)) (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$7664 (lambda (a pr) (let fnrec7660 ((a a) (pr pr)) (let* ((_a$7661 f) (_a$7662 (jolt-invoke f a (jolt-nth pr 0))) (_a$7663 (jolt-nth pr 1))) (jolt-invoke _a$7661 _a$7662 _a$7663))))) (_a$7665 acc) (_a$7666 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7664 _a$7665 _a$7666)) (if (jolt= op (keyword #f "let")) (let* ((_a$7671 f) (_a$7672 (let* ((_a$7668 (lambda (a b) (let fnrec7667 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7669 acc) (_a$7670 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7668 _a$7669 _a$7670))) (_a$7673 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7671 _a$7672 _a$7673)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7678 f) (_a$7679 (let* ((_a$7675 (lambda (a b) (let fnrec7674 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7676 acc) (_a$7677 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7675 _a$7676 _a$7677))) (_a$7680 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7678 _a$7679 _a$7680)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7682 (lambda (a ar) (let fnrec7681 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7683 acc) (_a$7684 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7682 _a$7683 _a$7684)) (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$7685 f) (_a$7686 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7687 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7685 _a$7686 _a$7687)) (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$7677 "quote") (_o$7678 "if") (_o$7679 "do") (_o$7680 "def") (_o$7681 "fn*") (_o$7682 "let*") (_o$7683 "loop*") (_o$7684 "recur") (_o$7685 "throw") (_o$7686 "try") (_o$7687 "syntax-quote") (_o$7688 "var") (_o$7689 "letfn") (_o$7690 "set!") (_o$7691 "defmacro")) (jolt-hash-set _o$7677 _o$7678 _o$7679 _o$7680 _o$7681 _o$7682 _o$7683 _o$7684 _o$7685 _o$7686 _o$7687 _o$7688 _o$7689 _o$7690 _o$7691)) (let* ((_o$7692 (keyword #f "private")) (_o$7693 #t)) (jolt-hash-map _o$7692 _o$7693))))
+  (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$7688 "quote") (_o$7689 "if") (_o$7690 "do") (_o$7691 "def") (_o$7692 "fn*") (_o$7693 "let*") (_o$7694 "loop*") (_o$7695 "recur") (_o$7696 "throw") (_o$7697 "try") (_o$7698 "syntax-quote") (_o$7699 "var") (_o$7700 "letfn") (_o$7701 "set!") (_o$7702 "defmacro")) (jolt-hash-set _o$7688 _o$7689 _o$7690 _o$7691 _o$7692 _o$7693 _o$7694 _o$7695 _o$7696 _o$7697 _o$7698 _o$7699 _o$7700 _o$7701 _o$7702)) (let* ((_o$7703 (keyword #f "private")) (_o$7704 #t)) (jolt-hash-map _o$7703 _o$7704))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7694 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable)))
+  (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7705 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7695 (keyword #f "private")) (_o$7696 #t)) (jolt-hash-map _o$7695 _o$7696))))
+  (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7706 (keyword #f "private")) (_o$7707 #t)) (jolt-hash-map _o$7706 _o$7707))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7697 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name)))
+  (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7708 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7698 () (let* ((_o$7699 (keyword #f "locals")) (_o$7700 (jolt-hash-set)) (_o$7701 (keyword #f "hints")) (_o$7702 (jolt-hash-map))) (jolt-hash-map _o$7699 _o$7700 _o$7701 _o$7702)))))) empty-env)))
+  (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7709 () (let* ((_o$7710 (keyword #f "locals")) (_o$7711 (jolt-hash-set)) (_o$7712 (keyword #f "hints")) (_o$7713 (jolt-hash-map))) (jolt-hash-map _o$7710 _o$7711 _o$7712 _o$7713)))))) empty-env)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7703 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?)))
+  (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7714 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7704 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7705 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals)))
+  (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7715 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7716 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7706 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur)))
+  (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7717 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7707 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-nil? m) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of)))
+  (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7718 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-nil? m) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec7708 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint)))
+  (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec7719 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec7709 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of)))
+  (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec7720 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec7710 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind)))
+  (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec7721 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec7711 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of)))
+  (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec7722 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7712 ((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$7714 (var-deref "clojure.core" "mapv")) (_a$7715 (lambda (a) (let fnrec7713 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7716 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7714 _a$7715 _a$7716))) node))))) with-ret-nhint)))
+  (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7723 ((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$7725 (var-deref "clojure.core" "mapv")) (_a$7726 (lambda (a) (let fnrec7724 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7727 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7725 _a$7726 _a$7727))) node))))) with-ret-nhint)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7717 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7718 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7719 (var-deref "jolt.ir" "do-node")) (_a$7720 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7721 (jolt-peek v))) (jolt-invoke _a$7719 _a$7720 _a$7721)) jolt-nil)))))))) analyze-seq)))
+  (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7728 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7729 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7730 (var-deref "jolt.ir" "do-node")) (_a$7731 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7732 (jolt-peek v))) (jolt-invoke _a$7730 _a$7731 _a$7732)) jolt-nil)))))))) analyze-seq)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7722 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7723 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$7730 (+ i 2)) (_a$7731 (let* ((_a$7724 (var-deref "jolt.analyzer" "add-hint")) (_a$7725 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7726 nm) (_a$7727 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7724 _a$7725 _a$7726 _a$7727))) (_a$7732 (jolt-conj pairs (let* ((_o$7728 nm) (_o$7729 init)) (jolt-vector _o$7728 _o$7729))))) (loop7723 _a$7730 _a$7731 _a$7732))))) (let* ((_o$7733 pairs) (_o$7734 env)) (jolt-vector _o$7733 _o$7734))))))))) analyze-bindings)))
+  (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7733 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7734 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$7741 (+ i 2)) (_a$7742 (let* ((_a$7735 (var-deref "jolt.analyzer" "add-hint")) (_a$7736 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7737 nm) (_a$7738 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7735 _a$7736 _a$7737 _a$7738))) (_a$7743 (jolt-conj pairs (let* ((_o$7739 nm) (_o$7740 init)) (jolt-vector _o$7739 _o$7740))))) (loop7734 _a$7741 _a$7742 _a$7743))))) (let* ((_o$7744 pairs) (_o$7745 env)) (jolt-vector _o$7744 _o$7745))))))))) analyze-bindings)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7735 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7736 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$7737 (+ i 2)) (_a$7738 fixed) (_a$7739 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7740 hints) (_a$7741 phints) (_a$7742 nhints)) (loop7736 _a$7737 _a$7738 _a$7739 _a$7740 _a$7741 _a$7742)))) (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$7749 (jolt-inc i)) (_a$7750 (jolt-conj fixed nm)) (_a$7751 rest-name) (_a$7752 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7743 nm) (_o$7744 h)) (jolt-vector _o$7743 _o$7744))) hints)) (_a$7753 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7745 nm) (_o$7746 ph)) (jolt-vector _o$7745 _o$7746))) phints)) (_a$7754 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7747 nm) (_o$7748 nh)) (jolt-vector _o$7747 _o$7748))) nhints))) (loop7736 _a$7749 _a$7750 _a$7751 _a$7752 _a$7753 _a$7754)))))) (let* ((_o$7755 (keyword #f "fixed")) (_o$7756 fixed) (_o$7757 (keyword #f "rest")) (_o$7758 rest-name) (_o$7759 (keyword #f "hints")) (_o$7760 hints) (_o$7761 (keyword #f "phints")) (_o$7762 phints) (_o$7763 (keyword #f "nhints")) (_o$7764 nhints)) (jolt-hash-map _o$7755 _o$7756 _o$7757 _o$7758 _o$7759 _o$7760 _o$7761 _o$7762 _o$7763 _o$7764))))))))) parse-params)))
+  (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7746 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7747 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$7748 (+ i 2)) (_a$7749 fixed) (_a$7750 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7751 hints) (_a$7752 phints) (_a$7753 nhints)) (loop7747 _a$7748 _a$7749 _a$7750 _a$7751 _a$7752 _a$7753)))) (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$7760 (jolt-inc i)) (_a$7761 (jolt-conj fixed nm)) (_a$7762 rest-name) (_a$7763 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7754 nm) (_o$7755 h)) (jolt-vector _o$7754 _o$7755))) hints)) (_a$7764 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7756 nm) (_o$7757 ph)) (jolt-vector _o$7756 _o$7757))) phints)) (_a$7765 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7758 nm) (_o$7759 nh)) (jolt-vector _o$7758 _o$7759))) nhints))) (loop7747 _a$7760 _a$7761 _a$7762 _a$7763 _a$7764 _a$7765)))))) (let* ((_o$7766 (keyword #f "fixed")) (_o$7767 fixed) (_o$7768 (keyword #f "rest")) (_o$7769 rest-name) (_o$7770 (keyword #f "hints")) (_o$7771 hints) (_o$7772 (keyword #f "phints")) (_o$7773 phints) (_o$7774 (keyword #f "nhints")) (_o$7775 nhints)) (jolt-hash-map _o$7766 _o$7767 _o$7768 _o$7769 _o$7770 _o$7771 _o$7772 _o$7773 _o$7774 _o$7775))))))))) parse-params)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7765 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7766 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7767 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7767 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7768 (jolt-inc i)) (_a$7769 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7766 _a$7768 _a$7769))) out)))))))) uniquify-params)))
+  (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7776 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7777 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7778 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7778 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7779 (jolt-inc i)) (_a$7780 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7777 _a$7779 _a$7780))) out)))))))) uniquify-params)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7770 ((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$7771 (var-deref "clojure.core" "str")) (_a$7772 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7773 "/") (_a$7774 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7775 "--")) (jolt-invoke _a$7771 _a$7772 _a$7773 _a$7774 _a$7775)))) (names (let* ((G__140 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__141 (if (jolt-truthy? rst) (jolt-conj G__140 rst) G__140))) (let* ((G__142 (if (jolt-truthy? fn-name) (jolt-conj G__141 fn-name) G__141))) G__142)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7781 (lambda (e pr) (let fnrec7776 ((e e) (pr pr)) (let* ((_a$7777 (var-deref "jolt.analyzer" "add-hint")) (_a$7778 e) (_a$7779 (jolt-nth pr 0)) (_a$7780 (jolt-nth pr 1))) (jolt-invoke _a$7777 _a$7778 _a$7779 _a$7780))))) (_a$7782 env0) (_a$7783 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7781 _a$7782 _a$7783))) (arity (let* ((_o$7784 (keyword #f "params")) (_o$7785 fixed) (_o$7786 (keyword #f "recur-name")) (_o$7787 rname) (_o$7788 (keyword #f "body")) (_o$7789 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7784 _o$7785 _o$7786 _o$7787 _o$7788 _o$7789))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity)))
+  (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7781 ((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$7782 (var-deref "clojure.core" "str")) (_a$7783 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7784 "/") (_a$7785 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7786 "--")) (jolt-invoke _a$7782 _a$7783 _a$7784 _a$7785 _a$7786)))) (names (let* ((G__140 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__141 (if (jolt-truthy? rst) (jolt-conj G__140 rst) G__140))) (let* ((G__142 (if (jolt-truthy? fn-name) (jolt-conj G__141 fn-name) G__141))) G__142)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7792 (lambda (e pr) (let fnrec7787 ((e e) (pr pr)) (let* ((_a$7788 (var-deref "jolt.analyzer" "add-hint")) (_a$7789 e) (_a$7790 (jolt-nth pr 0)) (_a$7791 (jolt-nth pr 1))) (jolt-invoke _a$7788 _a$7789 _a$7790 _a$7791))))) (_a$7793 env0) (_a$7794 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7792 _a$7793 _a$7794))) (arity (let* ((_o$7795 (keyword #f "params")) (_o$7796 fixed) (_o$7797 (keyword #f "recur-name")) (_o$7798 rname) (_o$7799 (keyword #f "body")) (_o$7800 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7795 _o$7796 _o$7797 _o$7798 _o$7799 _o$7800))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7790 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta)))
+  (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7801 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec7791 ((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 fnrec7792 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7793 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7794 ctx) (_a$7795 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7796 (jolt-rest cl)) (_a$7797 env) (_a$7798 fn-name)) (jolt-invoke _a$7793 _a$7794 _a$7795 _a$7796 _a$7797 _a$7798))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn)))
+  (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec7802 ((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 fnrec7803 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7804 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7805 ctx) (_a$7806 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7807 (jolt-rest cl)) (_a$7808 env) (_a$7809 fn-name)) (jolt-invoke _a$7804 _a$7805 _a$7806 _a$7807 _a$7808 _a$7809))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7799 "Throwable") (_o$7800 "java.lang.Throwable") (_o$7801 "Object") (_o$7802 "java.lang.Object")) (jolt-hash-set _o$7799 _o$7800 _o$7801 _o$7802)) (let* ((_o$7803 (keyword #f "private")) (_o$7804 #t)) (jolt-hash-map _o$7803 _o$7804))))
+  (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7810 "Throwable") (_o$7811 "java.lang.Throwable") (_o$7812 "Object") (_o$7813 "java.lang.Object")) (jolt-hash-set _o$7810 _o$7811 _o$7812 _o$7813)) (let* ((_o$7814 (keyword #f "private")) (_o$7815 #t)) (jolt-hash-map _o$7814 _o$7815))))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7805 ((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 fnrec7806 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$7807 (keyword #f "op")) (_o$7808 (keyword #f "try")) (_o$7809 (keyword #f "body")) (_o$7810 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7807 _o$7808 _o$7809 _o$7810))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$7815 (lambda (_else cl) (let fnrec7811 ((_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$7812 (jolt-symbol #f "or")) (_a$7813 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7814 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7812 _a$7813 _a$7814)) letform _else)))))) (_a$7816 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7817 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7815 _a$7816 _a$7817)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7818 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7819 ctx) (_a$7820 (jolt-list dispatch)) (_a$7821 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7818 _a$7819 _a$7820 _a$7821)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try)))
+  (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7816 ((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 fnrec7817 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$7818 (keyword #f "op")) (_o$7819 (keyword #f "try")) (_o$7820 (keyword #f "body")) (_o$7821 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7818 _o$7819 _o$7820 _o$7821))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$7826 (lambda (_else cl) (let fnrec7822 ((_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$7823 (jolt-symbol #f "or")) (_a$7824 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7825 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7823 _a$7824 _a$7825)) letform _else)))))) (_a$7827 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7828 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7826 _a$7827 _a$7828)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7829 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7830 ctx) (_a$7831 (jolt-list dispatch)) (_a$7832 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7829 _a$7830 _a$7831 _a$7832)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec7822 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__92_) (let fnrec7823 ((p__92_ p__92_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7824 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7825 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7826 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7825 _o$7826))))) specs))) (let* ((_o$7827 (keyword #f "op")) (_o$7828 (keyword #f "let")) (_o$7829 (keyword #f "letrec")) (_o$7830 #t) (_o$7831 (keyword #f "bindings")) (_o$7832 binds) (_o$7833 (keyword #f "body")) (_o$7834 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7827 _o$7828 _o$7829 _o$7830 _o$7831 _o$7832 _o$7833 _o$7834))))))) analyze-letfn)))
+  (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec7833 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__92_) (let fnrec7834 ((p__92_ p__92_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7835 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7836 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7837 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7836 _o$7837))))) specs))) (let* ((_o$7838 (keyword #f "op")) (_o$7839 (keyword #f "let")) (_o$7840 (keyword #f "letrec")) (_o$7841 #t) (_o$7842 (keyword #f "bindings")) (_o$7843 binds) (_o$7844 (keyword #f "body")) (_o$7845 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7838 _o$7839 _o$7840 _o$7841 _o$7842 _o$7843 _o$7844 _o$7845))))))) analyze-letfn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7835 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?)))
+  (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7846 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7836 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7840 (var-deref "clojure.core" "mapv")) (_a$7841 (lambda (p) (let fnrec7837 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7838 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7839 (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$7838 _o$7839)))))) (_a$7842 (jolt-seq base))) (jolt-invoke _a$7840 _a$7841 _a$7842))) jolt-nil))))) def-meta-expr)))
+  (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7847 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7851 (var-deref "clojure.core" "mapv")) (_a$7852 (lambda (p) (let fnrec7848 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7849 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7850 (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$7849 _o$7850)))))) (_a$7853 (jolt-seq base))) (jolt-invoke _a$7851 _a$7852 _a$7853))) jolt-nil))))) def-meta-expr)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7843 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$7844 (keyword #f "op")) (_o$7845 (keyword #f "def")) (_o$7846 (keyword #f "ns")) (_o$7847 cur) (_o$7848 (keyword #f "name")) (_o$7849 nm) (_o$7850 (keyword #f "no-init")) (_o$7851 #t)) (jolt-hash-map _o$7844 _o$7845 _o$7846 _o$7847 _o$7848 _o$7849 _o$7850 _o$7851)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$7852 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7853 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7854 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7852 _a$7853 _a$7854)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def)))
+  (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7854 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$7855 (keyword #f "op")) (_o$7856 (keyword #f "def")) (_o$7857 (keyword #f "ns")) (_o$7858 cur) (_o$7859 (keyword #f "name")) (_o$7860 nm) (_o$7861 (keyword #f "no-init")) (_o$7862 #t)) (jolt-hash-map _o$7855 _o$7856 _o$7857 _o$7858 _o$7859 _o$7860 _o$7861 _o$7862)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$7863 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7864 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7865 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7863 _a$7864 _a$7865)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec7855 ((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$7856 (keyword #f "op")) (_o$7857 (keyword #f "set-field")) (_o$7858 (keyword #f "obj")) (_o$7859 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7860 (keyword #f "field")) (_o$7861 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7862 (keyword #f "val")) (_o$7863 val-node)) (jolt-hash-map _o$7856 _o$7857 _o$7858 _o$7859 _o$7860 _o$7861 _o$7862 _o$7863)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$7867 (var-deref "jolt.ir" "invoke")) (_a$7868 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7869 (let* ((_o$7864 (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$7865 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7866 val-node)) (jolt-vector _o$7864 _o$7865 _o$7866)))) (jolt-invoke _a$7867 _a$7868 _a$7869)) (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$7873 (keyword #f "op")) (_o$7874 (keyword #f "set-var")) (_o$7875 (keyword #f "the-var")) (_o$7876 (let* ((_a$7870 (var-deref "jolt.ir" "the-var")) (_a$7871 (jolt-get r (keyword #f "ns"))) (_a$7872 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7870 _a$7871 _a$7872))) (_o$7877 (keyword #f "val")) (_o$7878 val-node)) (jolt-hash-map _o$7873 _o$7874 _o$7875 _o$7876 _o$7877 _o$7878))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!)))
+  (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec7866 ((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$7867 (keyword #f "op")) (_o$7868 (keyword #f "set-field")) (_o$7869 (keyword #f "obj")) (_o$7870 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7871 (keyword #f "field")) (_o$7872 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7873 (keyword #f "val")) (_o$7874 val-node)) (jolt-hash-map _o$7867 _o$7868 _o$7869 _o$7870 _o$7871 _o$7872 _o$7873 _o$7874)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$7878 (var-deref "jolt.ir" "invoke")) (_a$7879 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7880 (let* ((_o$7875 (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$7876 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7877 val-node)) (jolt-vector _o$7875 _o$7876 _o$7877)))) (jolt-invoke _a$7878 _a$7879 _a$7880)) (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$7884 (keyword #f "op")) (_o$7885 (keyword #f "set-var")) (_o$7886 (keyword #f "the-var")) (_o$7887 (let* ((_a$7881 (var-deref "jolt.ir" "the-var")) (_a$7882 (jolt-get r (keyword #f "ns"))) (_a$7883 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7881 _a$7882 _a$7883))) (_o$7888 (keyword #f "val")) (_o$7889 val-node)) (jolt-hash-map _o$7884 _o$7885 _o$7886 _o$7887 _o$7888 _o$7889))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec7879 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__143 op)) (if (jolt= G__143 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__143 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$7880 (var-deref "jolt.ir" "if-node")) (_a$7881 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7882 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7883 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$7880 _a$7881 _a$7882 _a$7883))) (if (jolt= G__143 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__143 "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__143 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__143 "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$7888 (var-deref "jolt.ir" "let-node")) (_a$7889 (jolt-first r)) (_a$7890 (let* ((_a$7884 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7885 ctx) (_a$7886 (jolt-drop 2 items)) (_a$7887 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7884 _a$7885 _a$7886 _a$7887)))) (jolt-invoke _a$7888 _a$7889 _a$7890))) (if (jolt= G__143 "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$7891 (keyword #f "op")) (_o$7892 (keyword #f "loop")) (_o$7893 (keyword #f "recur-name")) (_o$7894 rname) (_o$7895 (keyword #f "bindings")) (_o$7896 (jolt-first r)) (_o$7897 (keyword #f "body")) (_o$7898 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7891 _o$7892 _o$7893 _o$7894 _o$7895 _o$7896 _o$7897 _o$7898))) (if (jolt= G__143 "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$7903 (keyword #f "op")) (_o$7904 (keyword #f "recur")) (_o$7905 (keyword #f "recur-name")) (_o$7906 rt) (_o$7907 (keyword #f "args")) (_o$7908 (let* ((_a$7900 (var-deref "clojure.core" "mapv")) (_a$7901 (lambda (p__93_) (let fnrec7899 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7902 (jolt-rest items))) (jolt-invoke _a$7900 _a$7901 _a$7902)))) (jolt-hash-map _o$7903 _o$7904 _o$7905 _o$7906 _o$7907 _o$7908)))) (if (jolt= G__143 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__143 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__143 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__143 "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__143 "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$7909 (var-deref "jolt.ir" "the-var")) (_a$7910 (jolt-get r (keyword #f "ns"))) (_a$7911 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7909 _a$7910 _a$7911)) (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__143 "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$7912 (keyword #f "op")) (_o$7913 (keyword #f "defmacro")) (_o$7914 (keyword #f "ns")) (_o$7915 cur) (_o$7916 (keyword #f "name")) (_o$7917 nm) (_o$7918 (keyword #f "fn")) (_o$7919 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7912 _o$7913 _o$7914 _o$7915 _o$7916 _o$7917 _o$7918 _o$7919)))) (if (jolt= G__143 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special)))
+  (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec7890 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__143 op)) (if (jolt= G__143 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__143 "if") (begin (if (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$7891 (var-deref "jolt.ir" "if-node")) (_a$7892 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7893 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7894 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$7891 _a$7892 _a$7893 _a$7894))) (if (jolt= G__143 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__143 "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__143 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__143 "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$7899 (var-deref "jolt.ir" "let-node")) (_a$7900 (jolt-first r)) (_a$7901 (let* ((_a$7895 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7896 ctx) (_a$7897 (jolt-drop 2 items)) (_a$7898 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7895 _a$7896 _a$7897 _a$7898)))) (jolt-invoke _a$7899 _a$7900 _a$7901))) (if (jolt= G__143 "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$7902 (keyword #f "op")) (_o$7903 (keyword #f "loop")) (_o$7904 (keyword #f "recur-name")) (_o$7905 rname) (_o$7906 (keyword #f "bindings")) (_o$7907 (jolt-first r)) (_o$7908 (keyword #f "body")) (_o$7909 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7902 _o$7903 _o$7904 _o$7905 _o$7906 _o$7907 _o$7908 _o$7909))) (if (jolt= G__143 "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$7914 (keyword #f "op")) (_o$7915 (keyword #f "recur")) (_o$7916 (keyword #f "recur-name")) (_o$7917 rt) (_o$7918 (keyword #f "args")) (_o$7919 (let* ((_a$7911 (var-deref "clojure.core" "mapv")) (_a$7912 (lambda (p__93_) (let fnrec7910 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7913 (jolt-rest items))) (jolt-invoke _a$7911 _a$7912 _a$7913)))) (jolt-hash-map _o$7914 _o$7915 _o$7916 _o$7917 _o$7918 _o$7919)))) (if (jolt= G__143 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__143 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__143 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__143 "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__143 "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$7920 (var-deref "jolt.ir" "the-var")) (_a$7921 (jolt-get r (keyword #f "ns"))) (_a$7922 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7920 _a$7921 _a$7922)) (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__143 "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$7923 (keyword #f "op")) (_o$7924 (keyword #f "defmacro")) (_o$7925 (keyword #f "ns")) (_o$7926 cur) (_o$7927 (keyword #f "name")) (_o$7928 nm) (_o$7929 (keyword #f "fn")) (_o$7930 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7923 _o$7924 _o$7925 _o$7926 _o$7927 _o$7928 _o$7929 _o$7930)))) (if (jolt= G__143 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec7920 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?)))
+  (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec7931 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7921 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$7926 (keyword #f "op")) (_o$7927 (keyword #f "host-call")) (_o$7928 (keyword #f "method")) (_o$7929 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7930 (keyword #f "target")) (_o$7931 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7932 (keyword #f "args")) (_o$7933 (let* ((_a$7923 (var-deref "clojure.core" "mapv")) (_a$7924 (lambda (p__94_) (let fnrec7922 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7925 (jolt-drop 2 items))) (jolt-invoke _a$7923 _a$7924 _a$7925)))) (jolt-hash-map _o$7926 _o$7927 _o$7928 _o$7929 _o$7930 _o$7931 _o$7932 _o$7933))))))) analyze-host-call)))
+  (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7932 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$7937 (keyword #f "op")) (_o$7938 (keyword #f "host-call")) (_o$7939 (keyword #f "method")) (_o$7940 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7941 (keyword #f "target")) (_o$7942 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7943 (keyword #f "args")) (_o$7944 (let* ((_a$7934 (var-deref "clojure.core" "mapv")) (_a$7935 (lambda (p__94_) (let fnrec7933 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7936 (jolt-drop 2 items))) (jolt-invoke _a$7934 _a$7935 _a$7936)))) (jolt-hash-map _o$7937 _o$7938 _o$7939 _o$7940 _o$7941 _o$7942 _o$7943 _o$7944))))))) analyze-host-call)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec7934 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$7935 (var-deref "clojure.core" "subs")) (_a$7936 nm) (_a$7937 (jolt-dec (jolt-count nm))) (_a$7938 (jolt-count nm))) (jolt-invoke _a$7935 _a$7936 _a$7937 _a$7938))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?)))
+  (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec7945 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$7946 (var-deref "clojure.core" "subs")) (_a$7947 nm) (_a$7948 (jolt-dec (jolt-count nm))) (_a$7949 (jolt-count nm))) (jolt-invoke _a$7946 _a$7947 _a$7948 _a$7949))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec7939 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__95_) (let fnrec7940 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor)))
+  (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec7950 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__95_) (let fnrec7951 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec7941 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$7942 (keyword #f "op")) (_o$7943 (keyword #f "ffi-fn")) (_o$7944 (keyword #f "csym")) (_o$7945 (jolt-nth items 1)) (_o$7946 (keyword #f "argtypes")) (_o$7947 (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$7948 (keyword #f "rettype")) (_o$7949 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7950 (keyword #f "blocking")) (_o$7951 (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$7942 _o$7943 _o$7944 _o$7945 _o$7946 _o$7947 _o$7948 _o$7949 _o$7950 _o$7951))))))) analyze-ffi-fn)))
+  (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec7952 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$7953 (keyword #f "op")) (_o$7954 (keyword #f "ffi-fn")) (_o$7955 (keyword #f "csym")) (_o$7956 (jolt-nth items 1)) (_o$7957 (keyword #f "argtypes")) (_o$7958 (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$7959 (keyword #f "rettype")) (_o$7960 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7961 (keyword #f "blocking")) (_o$7962 (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$7953 _o$7954 _o$7955 _o$7956 _o$7957 _o$7958 _o$7959 _o$7960 _o$7961 _o$7962))))))) analyze-ffi-fn)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec7952 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$7953 (keyword #f "op")) (_o$7954 (keyword #f "ffi-callable")) (_o$7955 (keyword #f "fn")) (_o$7956 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7957 (keyword #f "argtypes")) (_o$7958 (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$7959 (keyword #f "rettype")) (_o$7960 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7961 (keyword #f "collect-safe")) (_o$7962 (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$7953 _o$7954 _o$7955 _o$7956 _o$7957 _o$7958 _o$7959 _o$7960 _o$7961 _o$7962))))))) analyze-ffi-callable)))
+  (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec7963 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$7964 (keyword #f "op")) (_o$7965 (keyword #f "ffi-callable")) (_o$7966 (keyword #f "fn")) (_o$7967 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7968 (keyword #f "argtypes")) (_o$7969 (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$7970 (keyword #f "rettype")) (_o$7971 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7972 (keyword #f "collect-safe")) (_o$7973 (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$7964 _o$7965 _o$7966 _o$7967 _o$7968 _o$7969 _o$7970 _o$7971 _o$7972 _o$7973))))))) analyze-ffi-callable)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec7963 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$7968 (var-deref "jolt.ir" "invoke")) (_a$7969 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$7970 (let* ((_a$7965 (var-deref "clojure.core" "mapv")) (_a$7966 (lambda (p__96_) (let fnrec7964 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$7967 (jolt-drop 3 items))) (jolt-invoke _a$7965 _a$7966 _a$7967)))) (jolt-invoke _a$7968 _a$7969 _a$7970)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$7975 (keyword #f "op")) (_o$7976 (keyword #f "host-call")) (_o$7977 (keyword #f "method")) (_o$7978 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$7979 (keyword #f "target")) (_o$7980 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$7981 (keyword #f "args")) (_o$7982 (let* ((_a$7972 (var-deref "clojure.core" "mapv")) (_a$7973 (lambda (p__97_) (let fnrec7971 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$7974 (jolt-drop 3 items))) (jolt-invoke _a$7972 _a$7973 _a$7974)))) (jolt-hash-map _o$7975 _o$7976 _o$7977 _o$7978 _o$7979 _o$7980 _o$7981 _o$7982)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$7983 (var-deref "jolt.ir" "invoke")) (_a$7984 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$7985 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$7983 _a$7984 _a$7985)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot)))
+  (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec7974 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$7979 (var-deref "jolt.ir" "invoke")) (_a$7980 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$7981 (let* ((_a$7976 (var-deref "clojure.core" "mapv")) (_a$7977 (lambda (p__96_) (let fnrec7975 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$7978 (jolt-drop 3 items))) (jolt-invoke _a$7976 _a$7977 _a$7978)))) (jolt-invoke _a$7979 _a$7980 _a$7981)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$7986 (keyword #f "op")) (_o$7987 (keyword #f "host-call")) (_o$7988 (keyword #f "method")) (_o$7989 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$7990 (keyword #f "target")) (_o$7991 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$7992 (keyword #f "args")) (_o$7993 (let* ((_a$7983 (var-deref "clojure.core" "mapv")) (_a$7984 (lambda (p__97_) (let fnrec7982 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$7985 (jolt-drop 3 items))) (jolt-invoke _a$7983 _a$7984 _a$7985)))) (jolt-hash-map _o$7986 _o$7987 _o$7988 _o$7989 _o$7990 _o$7991 _o$7992 _o$7993)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$7994 (var-deref "jolt.ir" "invoke")) (_a$7995 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$7996 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$7994 _a$7995 _a$7996)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec7986 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$7987 (keyword #f "op")) (_o$7988 (keyword #f "host-call")) (_o$7989 (keyword #f "method")) (_o$7990 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7991 (keyword #f "target")) (_o$7992 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7993 (keyword #f "args")) (_o$7994 (jolt-vector))) (jolt-hash-map _o$7987 _o$7988 _o$7989 _o$7990 _o$7991 _o$7992 _o$7993 _o$7994))))))) analyze-field)))
+  (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec7997 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$7998 (keyword #f "op")) (_o$7999 (keyword #f "host-call")) (_o$8000 (keyword #f "method")) (_o$8001 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8002 (keyword #f "target")) (_o$8003 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8004 (keyword #f "args")) (_o$8005 (jolt-vector))) (jolt-hash-map _o$7998 _o$7999 _o$8000 _o$8001 _o$8002 _o$8003 _o$8004 _o$8005))))))) analyze-field)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec7995 ((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__144 (let* ((_a$7996 (var-deref "jolt.ir" "var-ref")) (_a$7997 (jolt-get r (keyword #f "ns"))) (_a$7998 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7996 _a$7997 _a$7998)))) (let* ((G__145 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__144 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__144))) G__145)) (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__146 (jolt-get r (keyword #f "kind")))) (if (jolt= G__146 (keyword #f "var")) (let* ((G__147 (let* ((_a$7999 (var-deref "jolt.ir" "var-ref")) (_a$8000 (jolt-get r (keyword #f "ns"))) (_a$8001 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7999 _a$8000 _a$8001)))) (let* ((G__148 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__147 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__147))) G__148)) (if (jolt= G__146 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__146 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol)))
+  (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8006 ((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__144 (let* ((_a$8007 (var-deref "jolt.ir" "var-ref")) (_a$8008 (jolt-get r (keyword #f "ns"))) (_a$8009 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8007 _a$8008 _a$8009)))) (let* ((G__145 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__144 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__144))) G__145)) (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__146 (jolt-get r (keyword #f "kind")))) (if (jolt= G__146 (keyword #f "var")) (let* ((G__147 (let* ((_a$8010 (var-deref "jolt.ir" "var-ref")) (_a$8011 (jolt-get r (keyword #f "ns"))) (_a$8012 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8010 _a$8011 _a$8012)))) (let* ((G__148 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__147 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__147))) G__148)) (if (jolt= G__146 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__146 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8002 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8003 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8004 ctx) (_a$8005 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8006 (jolt-rest items)) (_a$8007 env)) (jolt-invoke _a$8003 _a$8004 _a$8005 _a$8006 _a$8007)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8008 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8009 ctx) (_a$8010 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8011 (jolt-drop 2 items)) (_a$8012 env)) (jolt-invoke _a$8008 _a$8009 _a$8010 _a$8011 _a$8012)) (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$8017 (var-deref "jolt.ir" "invoke")) (_a$8018 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8019 (let* ((_a$8014 (var-deref "clojure.core" "mapv")) (_a$8015 (lambda (p__98_) (let fnrec8013 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8016 (jolt-rest items))) (jolt-invoke _a$8014 _a$8015 _a$8016)))) (jolt-invoke _a$8017 _a$8018 _a$8019))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil)))))))))))))))))) analyze-list)))
+  (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8013 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-nil? (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$8014 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8015 ctx) (_a$8016 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8017 (jolt-rest items)) (_a$8018 env)) (jolt-invoke _a$8014 _a$8015 _a$8016 _a$8017 _a$8018)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$8019 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8020 ctx) (_a$8021 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8022 (jolt-drop 2 items)) (_a$8023 env)) (jolt-invoke _a$8019 _a$8020 _a$8021 _a$8022 _a$8023)) (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$8028 (var-deref "jolt.ir" "invoke")) (_a$8029 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8030 (let* ((_a$8025 (var-deref "clojure.core" "mapv")) (_a$8026 (lambda (p__98_) (let fnrec8024 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8027 (jolt-rest items))) (jolt-invoke _a$8025 _a$8026 _a$8027)))) (jolt-invoke _a$8028 _a$8029 _a$8030))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil)))))))))))))))))) analyze-list)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8020 ((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$8023 (var-deref "jolt.ir" "invoke")) (_a$8024 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8025 (let* ((_o$8021 node) (_o$8022 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8021 _o$8022)))) (jolt-invoke _a$8023 _a$8024 _a$8025)))))))) with-coll-meta)))
+  (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8031 ((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$8034 (var-deref "jolt.ir" "invoke")) (_a$8035 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8036 (let* ((_o$8032 node) (_o$8033 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8032 _o$8033)))) (jolt-invoke _a$8034 _a$8035 _a$8036)))))))) with-coll-meta)))
 (guard (e (#t #f))
-  (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8026 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8027 ((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$8029 (var-deref "clojure.core" "mapv")) (_a$8030 (lambda (p__99_) (let fnrec8028 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8031 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8029 _a$8030 _a$8031)))) (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$8035 (var-deref "clojure.core" "mapv")) (_a$8036 (lambda (p) (let fnrec8032 ((p p)) (let* ((_o$8033 (analyze ctx (jolt-first p) env)) (_o$8034 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8033 _o$8034))))) (_a$8037 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8035 _a$8036 _a$8037)))) (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$8039 (var-deref "clojure.core" "mapv")) (_a$8040 (lambda (p__100_) (let fnrec8038 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8041 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8039 _a$8040 _a$8041)))) (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$8042 (keyword #f "op")) (_o$8043 (keyword #f "regex")) (_o$8044 (keyword #f "source")) (_o$8045 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8042 _o$8043 _o$8044 _o$8045)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8046 (keyword #f "op")) (_o$8047 (keyword #f "inst")) (_o$8048 (keyword #f "source")) (_o$8049 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8046 _o$8047 _o$8048 _o$8049)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8050 (keyword #f "op")) (_o$8051 (keyword #f "uuid")) (_o$8052 (keyword #f "source")) (_o$8053 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8050 _o$8051 _o$8052 _o$8053)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8054 (keyword #f "op")) (_o$8055 (keyword #f "bigdec")) (_o$8056 (keyword #f "source")) (_o$8057 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8054 _o$8055 _o$8056 _o$8057)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8058 (keyword #f "op")) (_o$8059 (keyword #f "the-ns")) (_o$8060 (keyword #f "name")) (_o$8061 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8058 _o$8059 _o$8060 _o$8061)) (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 fnrec8037 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8038 ((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$8040 (var-deref "clojure.core" "mapv")) (_a$8041 (lambda (p__99_) (let fnrec8039 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8042 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8040 _a$8041 _a$8042)))) (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$8046 (var-deref "clojure.core" "mapv")) (_a$8047 (lambda (p) (let fnrec8043 ((p p)) (let* ((_o$8044 (analyze ctx (jolt-first p) env)) (_o$8045 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8044 _o$8045))))) (_a$8048 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8046 _a$8047 _a$8048)))) (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$8050 (var-deref "clojure.core" "mapv")) (_a$8051 (lambda (p__100_) (let fnrec8049 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8052 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8050 _a$8051 _a$8052)))) (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$8053 (keyword #f "op")) (_o$8054 (keyword #f "regex")) (_o$8055 (keyword #f "source")) (_o$8056 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8053 _o$8054 _o$8055 _o$8056)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8057 (keyword #f "op")) (_o$8058 (keyword #f "inst")) (_o$8059 (keyword #f "source")) (_o$8060 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8057 _o$8058 _o$8059 _o$8060)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8061 (keyword #f "op")) (_o$8062 (keyword #f "uuid")) (_o$8063 (keyword #f "source")) (_o$8064 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8061 _o$8062 _o$8063 _o$8064)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8065 (keyword #f "op")) (_o$8066 (keyword #f "bigdec")) (_o$8067 (keyword #f "source")) (_o$8068 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8065 _o$8066 _o$8067 _o$8068)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8069 (keyword #f "op")) (_o$8070 (keyword #f "the-ns")) (_o$8071 (keyword #f "name")) (_o$8072 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8069 _o$8070 _o$8071 _o$8072)) (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$6475 "+") (_o$6476 "+") (_o$6477 "-") (_o$6478 "-") (_o$6479 "*") (_o$6480 "*") (_o$6481 "/") (_o$6482 "/") (_o$6483 "<") (_o$6484 "<") (_o$6485 ">") (_o$6486 ">") (_o$6487 "<=") (_o$6488 "<=") (_o$6489 ">=") (_o$6490 ">=") (_o$6491 "=") (_o$6492 "jolt=") (_o$6493 "inc") (_o$6494 "jolt-inc") (_o$6495 "dec") (_o$6496 "jolt-dec") (_o$6497 "not") (_o$6498 "jolt-not") (_o$6499 "min") (_o$6500 "min") (_o$6501 "max") (_o$6502 "max") (_o$6503 "mod") (_o$6504 "modulo") (_o$6505 "rem") (_o$6506 "remainder") (_o$6507 "quot") (_o$6508 "quotient") (_o$6509 "vector") (_o$6510 "jolt-vector") (_o$6511 "hash-map") (_o$6512 "jolt-hash-map") (_o$6513 "hash-set") (_o$6514 "jolt-hash-set") (_o$6515 "conj") (_o$6516 "jolt-conj") (_o$6517 "get") (_o$6518 "jolt-get") (_o$6519 "nth") (_o$6520 "jolt-nth") (_o$6521 "count") (_o$6522 "jolt-count") (_o$6523 "assoc") (_o$6524 "jolt-assoc") (_o$6525 "dissoc") (_o$6526 "jolt-dissoc") (_o$6527 "contains?") (_o$6528 "jolt-contains?") (_o$6529 "empty?") (_o$6530 "jolt-empty?") (_o$6531 "peek") (_o$6532 "jolt-peek") (_o$6533 "pop") (_o$6534 "jolt-pop") (_o$6535 "first") (_o$6536 "jolt-first") (_o$6537 "rest") (_o$6538 "jolt-rest") (_o$6539 "next") (_o$6540 "jolt-next") (_o$6541 "seq") (_o$6542 "jolt-seq") (_o$6543 "cons") (_o$6544 "jolt-cons") (_o$6545 "list") (_o$6546 "jolt-list") (_o$6547 "reverse") (_o$6548 "jolt-reverse") (_o$6549 "last") (_o$6550 "jolt-last") (_o$6551 "map") (_o$6552 "jolt-map") (_o$6553 "filter") (_o$6554 "jolt-filter") (_o$6555 "remove") (_o$6556 "jolt-remove") (_o$6557 "reduce") (_o$6558 "jolt-reduce") (_o$6559 "into") (_o$6560 "jolt-into") (_o$6561 "concat") (_o$6562 "jolt-concat") (_o$6563 "apply") (_o$6564 "jolt-apply") (_o$6565 "range") (_o$6566 "jolt-range") (_o$6567 "take") (_o$6568 "jolt-take") (_o$6569 "drop") (_o$6570 "jolt-drop") (_o$6571 "keys") (_o$6572 "jolt-keys") (_o$6573 "vals") (_o$6574 "jolt-vals") (_o$6575 "even?") (_o$6576 "jolt-even?") (_o$6577 "odd?") (_o$6578 "jolt-odd?") (_o$6579 "pos?") (_o$6580 "jolt-pos?") (_o$6581 "neg?") (_o$6582 "jolt-neg?") (_o$6583 "zero?") (_o$6584 "jolt-zero?") (_o$6585 "identity") (_o$6586 "jolt-identity") (_o$6587 "nil?") (_o$6588 "jolt-nil?") (_o$6589 "some?") (_o$6590 "jolt-some?") (_o$6591 "ex-info") (_o$6592 "jolt-ex-info") (_o$6593 "protocol-dispatch1") (_o$6594 "protocol-dispatch1") (_o$6595 "protocol-dispatch2") (_o$6596 "protocol-dispatch2") (_o$6597 "protocol-dispatch3") (_o$6598 "protocol-dispatch3")) (jolt-hash-map _o$6475 _o$6476 _o$6477 _o$6478 _o$6479 _o$6480 _o$6481 _o$6482 _o$6483 _o$6484 _o$6485 _o$6486 _o$6487 _o$6488 _o$6489 _o$6490 _o$6491 _o$6492 _o$6493 _o$6494 _o$6495 _o$6496 _o$6497 _o$6498 _o$6499 _o$6500 _o$6501 _o$6502 _o$6503 _o$6504 _o$6505 _o$6506 _o$6507 _o$6508 _o$6509 _o$6510 _o$6511 _o$6512 _o$6513 _o$6514 _o$6515 _o$6516 _o$6517 _o$6518 _o$6519 _o$6520 _o$6521 _o$6522 _o$6523 _o$6524 _o$6525 _o$6526 _o$6527 _o$6528 _o$6529 _o$6530 _o$6531 _o$6532 _o$6533 _o$6534 _o$6535 _o$6536 _o$6537 _o$6538 _o$6539 _o$6540 _o$6541 _o$6542 _o$6543 _o$6544 _o$6545 _o$6546 _o$6547 _o$6548 _o$6549 _o$6550 _o$6551 _o$6552 _o$6553 _o$6554 _o$6555 _o$6556 _o$6557 _o$6558 _o$6559 _o$6560 _o$6561 _o$6562 _o$6563 _o$6564 _o$6565 _o$6566 _o$6567 _o$6568 _o$6569 _o$6570 _o$6571 _o$6572 _o$6573 _o$6574 _o$6575 _o$6576 _o$6577 _o$6578 _o$6579 _o$6580 _o$6581 _o$6582 _o$6583 _o$6584 _o$6585 _o$6586 _o$6587 _o$6588 _o$6589 _o$6590 _o$6591 _o$6592 _o$6593 _o$6594 _o$6595 _o$6596 _o$6597 _o$6598)) (let* ((_o$6599 (keyword #f "private")) (_o$6600 #t)) (jolt-hash-map _o$6599 _o$6600))))
 (guard (e (#t #f))
@@ -237,33 +237,33 @@
 (guard (e (#t #f))
   (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7102 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "inc"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-inc"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "dec"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-dec"))) and__25__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__134 kind)) (if (jolt= G__134 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__134 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__134 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7103 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__134)) (_a$7104 (jolt-hash-map))) (jolt-ex-info _a$7103 _a$7104))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7105 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7106 ((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 fnrec7107 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7108 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7109 () (let* ((_a$7111 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7112 (jolt-cons fnode arg-nodes)) (_a$7113 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7114 (lambda (G__135) (let fnrec7110 ((G__135 G__135)) (let* ((G__136 G__135) (f (jolt-nth G__136 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__136 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$7111 _a$7112 _a$7113 _a$7114)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7115 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7116 (jolt-get node (keyword #f "num-kind"))) (_a$7117 (jolt-get fnode (keyword #f "name"))) (_a$7118 args) (_a$7119 order-args)) (jolt-invoke _a$7115 _a$7116 _a$7117 _a$7118 _a$7119)) (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 fnrec7120 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (jolt-invoke order-args (lambda (as) (let fnrec7121 ((as as)) (let* ((_a$7122 (var-deref "clojure.core" "str")) (_a$7123 "(jolt-get ") (_a$7124 (jolt-first as)) (_a$7125 " ") (_a$7126 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7127 (jolt-invoke defstr as)) (_a$7128 ")")) (jolt-invoke _a$7122 _a$7123 _a$7124 _a$7125 _a$7126 _a$7127 _a$7128))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7130 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7131 (jolt-cons fnode arg-nodes)) (_a$7132 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7133 (lambda (G__137) (let fnrec7129 ((G__137 G__137)) (let* ((G__138 G__137) (c (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7130 _a$7131 _a$7132 _a$7133)) (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$7140 (let* ((_a$7134 (var-deref "clojure.core" "str")) (_a$7135 "emit: unsupported stdlib fn `") (_a$7136 (jolt-get fnode (keyword #f "ns"))) (_a$7137 "/") (_a$7138 (jolt-get fnode (keyword #f "name"))) (_a$7139 "` (no core on Chez yet)")) (jolt-invoke _a$7134 _a$7135 _a$7136 _a$7137 _a$7138 _a$7139))) (_a$7141 (jolt-hash-map))) (jolt-ex-info _a$7140 _a$7141))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7142 ((as as)) (let* ((_a$7143 (var-deref "clojure.core" "str")) (_a$7144 "(host-static-call ") (_a$7145 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7146 " ") (_a$7147 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7148 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7149 ")")) (jolt-invoke _a$7143 _a$7144 _a$7145 _a$7146 _a$7147 _a$7148 _a$7149))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7150 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7151 (jolt-hash-map))) (jolt-ex-info _a$7150 _a$7151))) (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 fnrec7152 ((as as)) (let* ((_a$7153 (var-deref "clojure.core" "str")) (_a$7154 "(") (_a$7155 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7156 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7157 ")")) (jolt-invoke _a$7153 _a$7154 _a$7155 _a$7156 _a$7157))))) (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$7158 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7159 (jolt-get fnode (keyword #f "ns"))) (_a$7160 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7158 _a$7159 _a$7160)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7161 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7162 (jolt-get fnode (keyword #f "ns"))) (_a$7163 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7161 _a$7162 _a$7163)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7164 ((as as)) (let* ((_a$7168 (var-deref "clojure.core" "str")) (_a$7169 "(") (_a$7170 (let* ((_a$7165 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7166 (jolt-get fnode (keyword #f "ns"))) (_a$7167 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7165 _a$7166 _a$7167))) (_a$7171 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7172 ")")) (jolt-invoke _a$7168 _a$7169 _a$7170 _a$7171 _a$7172))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil))))))))))))))))))) emit-invoke)))
+  (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7106 ((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 fnrec7107 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7108 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7109 () (let* ((_a$7111 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7112 (jolt-cons fnode arg-nodes)) (_a$7113 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7114 (lambda (G__135) (let fnrec7110 ((G__135 G__135)) (let* ((G__136 G__135) (f (jolt-nth G__136 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__136 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$7111 _a$7112 _a$7113 _a$7114)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7115 ((as as)) (let* ((_a$7116 (var-deref "clojure.core" "str")) (_a$7117 "((find-protocol-method ") (_a$7118 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7119 " ") (_a$7120 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7121 " ") (_a$7122 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7123 ") ") (_a$7124 (jolt-invoke (var-deref "clojure.string" "join") " " as)) (_a$7125 ")")) (jolt-invoke _a$7116 _a$7117 _a$7118 _a$7119 _a$7120 _a$7121 _a$7122 _a$7123 _a$7124 _a$7125))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7126 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7127 (jolt-get node (keyword #f "num-kind"))) (_a$7128 (jolt-get fnode (keyword #f "name"))) (_a$7129 args) (_a$7130 order-args)) (jolt-invoke _a$7126 _a$7127 _a$7128 _a$7129 _a$7130)) (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 fnrec7131 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (jolt-invoke order-args (lambda (as) (let fnrec7132 ((as as)) (let* ((_a$7133 (var-deref "clojure.core" "str")) (_a$7134 "(jolt-get ") (_a$7135 (jolt-first as)) (_a$7136 " ") (_a$7137 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7138 (jolt-invoke defstr as)) (_a$7139 ")")) (jolt-invoke _a$7133 _a$7134 _a$7135 _a$7136 _a$7137 _a$7138 _a$7139))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7141 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7142 (jolt-cons fnode arg-nodes)) (_a$7143 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7144 (lambda (G__137) (let fnrec7140 ((G__137 G__137)) (let* ((G__138 G__137) (c (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7141 _a$7142 _a$7143 _a$7144)) (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$7151 (let* ((_a$7145 (var-deref "clojure.core" "str")) (_a$7146 "emit: unsupported stdlib fn `") (_a$7147 (jolt-get fnode (keyword #f "ns"))) (_a$7148 "/") (_a$7149 (jolt-get fnode (keyword #f "name"))) (_a$7150 "` (no core on Chez yet)")) (jolt-invoke _a$7145 _a$7146 _a$7147 _a$7148 _a$7149 _a$7150))) (_a$7152 (jolt-hash-map))) (jolt-ex-info _a$7151 _a$7152))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7153 ((as as)) (let* ((_a$7154 (var-deref "clojure.core" "str")) (_a$7155 "(host-static-call ") (_a$7156 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7157 " ") (_a$7158 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7159 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7160 ")")) (jolt-invoke _a$7154 _a$7155 _a$7156 _a$7157 _a$7158 _a$7159 _a$7160))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7161 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7162 (jolt-hash-map))) (jolt-ex-info _a$7161 _a$7162))) (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 fnrec7163 ((as as)) (let* ((_a$7164 (var-deref "clojure.core" "str")) (_a$7165 "(") (_a$7166 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7167 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7168 ")")) (jolt-invoke _a$7164 _a$7165 _a$7166 _a$7167 _a$7168))))) (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$7169 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7170 (jolt-get fnode (keyword #f "ns"))) (_a$7171 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7169 _a$7170 _a$7171)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7172 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7173 (jolt-get fnode (keyword #f "ns"))) (_a$7174 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7172 _a$7173 _a$7174)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7175 ((as as)) (let* ((_a$7179 (var-deref "clojure.core" "str")) (_a$7180 "(") (_a$7181 (let* ((_a$7176 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7177 (jolt-get fnode (keyword #f "ns"))) (_a$7178 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7176 _a$7177 _a$7178))) (_a$7182 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7183 ")")) (jolt-invoke _a$7179 _a$7180 _a$7181 _a$7182 _a$7183))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil)))))))))))))))))))) emit-invoke)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec7173 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$7174 (var-deref "clojure.core" "str")) (_a$7175 "(guard (") (_a$7176 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7177 " (else ") (_a$7178 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7179 ")) ") (_a$7180 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7181 ")")) (jolt-invoke _a$7174 _a$7175 _a$7176 _a$7177 _a$7178 _a$7179 _a$7180 _a$7181))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try)))
+  (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec7184 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$7185 (var-deref "clojure.core" "str")) (_a$7186 "(guard (") (_a$7187 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7188 " (else ") (_a$7189 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7190 ")) ") (_a$7191 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7192 ")")) (jolt-invoke _a$7185 _a$7186 _a$7187 _a$7188 _a$7189 _a$7190 _a$7191 _a$7192))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7182 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7183 ((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$7184 (var-deref "jolt.backend-scheme" "native-op")) (_a$7185 (jolt-get node (keyword #f "fn"))) (_a$7186 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7184 _a$7185 _a$7186)))) (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$7188 (lambda (s b) (let fnrec7187 ((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$7189 bools) (_a$7190 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7188 _a$7189 _a$7190)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?)))
+  (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7193 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7194 ((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$7195 (var-deref "jolt.backend-scheme" "native-op")) (_a$7196 (jolt-get node (keyword #f "fn"))) (_a$7197 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7195 _a$7196 _a$7197)))) (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$7199 (lambda (s b) (let fnrec7198 ((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$7200 bools) (_a$7201 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7199 _a$7200 _a$7201)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7191 ((node node)) (let* ((G__139 (jolt-get node (keyword #f "op")))) (if (jolt= G__139 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__139 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__139 (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$7192 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7193 (jolt-get node (keyword #f "ns"))) (_a$7194 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7192 _a$7193 _a$7194))) (let* ((_a$7195 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7196 (jolt-get node (keyword #f "ns"))) (_a$7197 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7195 _a$7196 _a$7197)) (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$7204 (let* ((_a$7198 (var-deref "clojure.core" "str")) (_a$7199 "emit: unsupported stdlib ref `") (_a$7200 (jolt-get node (keyword #f "ns"))) (_a$7201 "/") (_a$7202 (jolt-get node (keyword #f "name"))) (_a$7203 "` (no core on Chez yet)")) (jolt-invoke _a$7198 _a$7199 _a$7200 _a$7201 _a$7202 _a$7203))) (_a$7205 (jolt-hash-map))) (jolt-ex-info _a$7204 _a$7205))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7206 (var-deref "clojure.core" "str")) (_a$7207 "(var-deref ") (_a$7208 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7209 " ") (_a$7210 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7211 ")")) (jolt-invoke _a$7206 _a$7207 _a$7208 _a$7209 _a$7210 _a$7211)) jolt-nil))))) (if (jolt= G__139 (keyword #f "the-var")) (let* ((_a$7212 (var-deref "clojure.core" "str")) (_a$7213 "(jolt-var ") (_a$7214 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7215 " ") (_a$7216 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7217 ")")) (jolt-invoke _a$7212 _a$7213 _a$7214 _a$7215 _a$7216 _a$7217)) (if (jolt= G__139 (keyword #f "set-var")) (let* ((_a$7218 (var-deref "clojure.core" "str")) (_a$7219 "(jolt-var-set ") (_a$7220 (emit (jolt-get node (keyword #f "the-var")))) (_a$7221 " ") (_a$7222 (emit (jolt-get node (keyword #f "val")))) (_a$7223 ")")) (jolt-invoke _a$7218 _a$7219 _a$7220 _a$7221 _a$7222 _a$7223)) (if (jolt= G__139 (keyword #f "set-field")) (let* ((_a$7224 (var-deref "clojure.core" "str")) (_a$7225 "(jolt-set-field! ") (_a$7226 (emit (jolt-get node (keyword #f "obj")))) (_a$7227 " (keyword #f ") (_a$7228 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7229 ") ") (_a$7230 (emit (jolt-get node (keyword #f "val")))) (_a$7231 ")")) (jolt-invoke _a$7224 _a$7225 _a$7226 _a$7227 _a$7228 _a$7229 _a$7230 _a$7231)) (if (jolt= G__139 (keyword #f "defmacro")) (let* ((_a$7232 (var-deref "clojure.core" "str")) (_a$7233 "(begin (def-var! ") (_a$7234 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7235 " ") (_a$7236 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7237 " ") (_a$7238 (emit (jolt-get node (keyword #f "fn")))) (_a$7239 ") (mark-macro! ") (_a$7240 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7241 " ") (_a$7242 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7243 ") jolt-nil)")) (jolt-invoke _a$7232 _a$7233 _a$7234 _a$7235 _a$7236 _a$7237 _a$7238 _a$7239 _a$7240 _a$7241 _a$7242 _a$7243)) (if (jolt= G__139 (keyword #f "host")) (jolt-throw (let* ((_a$7244 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7245 (jolt-hash-map))) (jolt-ex-info _a$7244 _a$7245))) (if (jolt= G__139 (keyword #f "host-static")) (let* ((_a$7246 (var-deref "clojure.core" "str")) (_a$7247 "(host-static-ref ") (_a$7248 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7249 " ") (_a$7250 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7251 ")")) (jolt-invoke _a$7246 _a$7247 _a$7248 _a$7249 _a$7250 _a$7251)) (if (jolt= G__139 (keyword #f "host-new")) (let* ((_a$7252 (var-deref "clojure.core" "str")) (_a$7253 "(host-new ") (_a$7254 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7255 (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$7256 ")")) (jolt-invoke _a$7252 _a$7253 _a$7254 _a$7255 _a$7256)) (if (jolt= G__139 (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$7257 (var-deref "clojure.core" "str")) (_a$7258 "(if ") (_a$7259 t) (_a$7260 " ") (_a$7261 (emit (jolt-get node (keyword #f "then")))) (_a$7262 " ") (_a$7263 (emit (jolt-get node (keyword #f "else")))) (_a$7264 ")")) (jolt-invoke _a$7257 _a$7258 _a$7259 _a$7260 _a$7261 _a$7262 _a$7263 _a$7264))) (if (jolt= G__139 (keyword #f "do")) (let* ((_a$7265 (var-deref "clojure.core" "str")) (_a$7266 "(begin ") (_a$7267 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7268 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7269 (emit (jolt-get node (keyword #f "ret")))) (_a$7270 ")")) (jolt-invoke _a$7265 _a$7266 _a$7267 _a$7268 _a$7269 _a$7270)) (if (jolt= G__139 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__139 (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__139 (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__139 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7274 (var-deref "clojure.core" "mapcat")) (_a$7275 (lambda (p) (let fnrec7271 ((p p)) (let* ((_o$7272 (emit (jolt-nth p 0))) (_o$7273 (emit (jolt-nth p 1)))) (jolt-vector _o$7272 _o$7273))))) (_a$7276 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7274 _a$7275 _a$7276))) (if (jolt= G__139 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__139 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__139 (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__139 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__139 (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__139 (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__139 (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__139 (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__139 (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__139 (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$7277 (var-deref "clojure.core" "str")) (_a$7278 "(jolt-host-call ") (_a$7279 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7280 " ") (_a$7281 target) (_a$7282 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7283 ")")) (jolt-invoke _a$7277 _a$7278 _a$7279 _a$7280 _a$7281 _a$7282 _a$7283)) (let* ((_a$7284 (var-deref "clojure.core" "str")) (_a$7285 "(record-method-dispatch ") (_a$7286 target) (_a$7287 " ") (_a$7288 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7289 " (jolt-vector") (_a$7290 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7291 "))")) (jolt-invoke _a$7284 _a$7285 _a$7286 _a$7287 _a$7288 _a$7289 _a$7290 _a$7291)))) (if (jolt= G__139 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__139 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__139 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__139 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__139 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__139 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__139 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7292 (var-deref "clojure.core" "str")) (_a$7293 "(declare-var! ") (_a$7294 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7295 " ") (_a$7296 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7297 ")")) (jolt-invoke _a$7292 _a$7293 _a$7294 _a$7295 _a$7296 _a$7297)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7298 (var-deref "clojure.core" "str")) (_a$7299 "(def-var-with-meta! ") (_a$7300 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7301 " ") (_a$7302 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7303 " ") (_a$7304 (emit (jolt-get node (keyword #f "init")))) (_a$7305 " ") (_a$7306 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7307 ")")) (jolt-invoke _a$7298 _a$7299 _a$7300 _a$7301 _a$7302 _a$7303 _a$7304 _a$7305 _a$7306 _a$7307)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7308 (var-deref "clojure.core" "str")) (_a$7309 "(def-var! ") (_a$7310 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7311 " ") (_a$7312 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7313 " ") (_a$7314 (emit (jolt-get node (keyword #f "init")))) (_a$7315 ")")) (jolt-invoke _a$7308 _a$7309 _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315)) jolt-nil))) (jolt-throw (let* ((_a$7316 (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$7317 (jolt-hash-map))) (jolt-ex-info _a$7316 _a$7317))))))))))))))))))))))))))))))))))))))))) emit)))
+  (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7202 ((node node)) (let* ((G__139 (jolt-get node (keyword #f "op")))) (if (jolt= G__139 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__139 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__139 (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$7203 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7204 (jolt-get node (keyword #f "ns"))) (_a$7205 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7203 _a$7204 _a$7205))) (let* ((_a$7206 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7207 (jolt-get node (keyword #f "ns"))) (_a$7208 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7206 _a$7207 _a$7208)) (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$7215 (let* ((_a$7209 (var-deref "clojure.core" "str")) (_a$7210 "emit: unsupported stdlib ref `") (_a$7211 (jolt-get node (keyword #f "ns"))) (_a$7212 "/") (_a$7213 (jolt-get node (keyword #f "name"))) (_a$7214 "` (no core on Chez yet)")) (jolt-invoke _a$7209 _a$7210 _a$7211 _a$7212 _a$7213 _a$7214))) (_a$7216 (jolt-hash-map))) (jolt-ex-info _a$7215 _a$7216))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7217 (var-deref "clojure.core" "str")) (_a$7218 "(var-deref ") (_a$7219 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7220 " ") (_a$7221 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7222 ")")) (jolt-invoke _a$7217 _a$7218 _a$7219 _a$7220 _a$7221 _a$7222)) jolt-nil))))) (if (jolt= G__139 (keyword #f "the-var")) (let* ((_a$7223 (var-deref "clojure.core" "str")) (_a$7224 "(jolt-var ") (_a$7225 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7226 " ") (_a$7227 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7228 ")")) (jolt-invoke _a$7223 _a$7224 _a$7225 _a$7226 _a$7227 _a$7228)) (if (jolt= G__139 (keyword #f "set-var")) (let* ((_a$7229 (var-deref "clojure.core" "str")) (_a$7230 "(jolt-var-set ") (_a$7231 (emit (jolt-get node (keyword #f "the-var")))) (_a$7232 " ") (_a$7233 (emit (jolt-get node (keyword #f "val")))) (_a$7234 ")")) (jolt-invoke _a$7229 _a$7230 _a$7231 _a$7232 _a$7233 _a$7234)) (if (jolt= G__139 (keyword #f "set-field")) (let* ((_a$7235 (var-deref "clojure.core" "str")) (_a$7236 "(jolt-set-field! ") (_a$7237 (emit (jolt-get node (keyword #f "obj")))) (_a$7238 " (keyword #f ") (_a$7239 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7240 ") ") (_a$7241 (emit (jolt-get node (keyword #f "val")))) (_a$7242 ")")) (jolt-invoke _a$7235 _a$7236 _a$7237 _a$7238 _a$7239 _a$7240 _a$7241 _a$7242)) (if (jolt= G__139 (keyword #f "defmacro")) (let* ((_a$7243 (var-deref "clojure.core" "str")) (_a$7244 "(begin (def-var! ") (_a$7245 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7246 " ") (_a$7247 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7248 " ") (_a$7249 (emit (jolt-get node (keyword #f "fn")))) (_a$7250 ") (mark-macro! ") (_a$7251 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7252 " ") (_a$7253 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7254 ") jolt-nil)")) (jolt-invoke _a$7243 _a$7244 _a$7245 _a$7246 _a$7247 _a$7248 _a$7249 _a$7250 _a$7251 _a$7252 _a$7253 _a$7254)) (if (jolt= G__139 (keyword #f "host")) (jolt-throw (let* ((_a$7255 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7256 (jolt-hash-map))) (jolt-ex-info _a$7255 _a$7256))) (if (jolt= G__139 (keyword #f "host-static")) (let* ((_a$7257 (var-deref "clojure.core" "str")) (_a$7258 "(host-static-ref ") (_a$7259 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7260 " ") (_a$7261 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7262 ")")) (jolt-invoke _a$7257 _a$7258 _a$7259 _a$7260 _a$7261 _a$7262)) (if (jolt= G__139 (keyword #f "host-new")) (let* ((_a$7263 (var-deref "clojure.core" "str")) (_a$7264 "(host-new ") (_a$7265 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7266 (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$7267 ")")) (jolt-invoke _a$7263 _a$7264 _a$7265 _a$7266 _a$7267)) (if (jolt= G__139 (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$7268 (var-deref "clojure.core" "str")) (_a$7269 "(if ") (_a$7270 t) (_a$7271 " ") (_a$7272 (emit (jolt-get node (keyword #f "then")))) (_a$7273 " ") (_a$7274 (emit (jolt-get node (keyword #f "else")))) (_a$7275 ")")) (jolt-invoke _a$7268 _a$7269 _a$7270 _a$7271 _a$7272 _a$7273 _a$7274 _a$7275))) (if (jolt= G__139 (keyword #f "do")) (let* ((_a$7276 (var-deref "clojure.core" "str")) (_a$7277 "(begin ") (_a$7278 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7279 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7280 (emit (jolt-get node (keyword #f "ret")))) (_a$7281 ")")) (jolt-invoke _a$7276 _a$7277 _a$7278 _a$7279 _a$7280 _a$7281)) (if (jolt= G__139 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__139 (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__139 (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__139 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7285 (var-deref "clojure.core" "mapcat")) (_a$7286 (lambda (p) (let fnrec7282 ((p p)) (let* ((_o$7283 (emit (jolt-nth p 0))) (_o$7284 (emit (jolt-nth p 1)))) (jolt-vector _o$7283 _o$7284))))) (_a$7287 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7285 _a$7286 _a$7287))) (if (jolt= G__139 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__139 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__139 (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__139 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__139 (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__139 (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__139 (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__139 (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__139 (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__139 (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$7288 (var-deref "clojure.core" "str")) (_a$7289 "(jolt-host-call ") (_a$7290 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7291 " ") (_a$7292 target) (_a$7293 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7294 ")")) (jolt-invoke _a$7288 _a$7289 _a$7290 _a$7291 _a$7292 _a$7293 _a$7294)) (let* ((_a$7295 (var-deref "clojure.core" "str")) (_a$7296 "(record-method-dispatch ") (_a$7297 target) (_a$7298 " ") (_a$7299 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7300 " (jolt-vector") (_a$7301 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7302 "))")) (jolt-invoke _a$7295 _a$7296 _a$7297 _a$7298 _a$7299 _a$7300 _a$7301 _a$7302)))) (if (jolt= G__139 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__139 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__139 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__139 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__139 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__139 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__139 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7303 (var-deref "clojure.core" "str")) (_a$7304 "(declare-var! ") (_a$7305 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7306 " ") (_a$7307 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7308 ")")) (jolt-invoke _a$7303 _a$7304 _a$7305 _a$7306 _a$7307 _a$7308)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7309 (var-deref "clojure.core" "str")) (_a$7310 "(def-var-with-meta! ") (_a$7311 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7312 " ") (_a$7313 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7314 " ") (_a$7315 (emit (jolt-get node (keyword #f "init")))) (_a$7316 " ") (_a$7317 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7318 ")")) (jolt-invoke _a$7309 _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315 _a$7316 _a$7317 _a$7318)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7319 (var-deref "clojure.core" "str")) (_a$7320 "(def-var! ") (_a$7321 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7322 " ") (_a$7323 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7324 " ") (_a$7325 (emit (jolt-get node (keyword #f "init")))) (_a$7326 ")")) (jolt-invoke _a$7319 _a$7320 _a$7321 _a$7322 _a$7323 _a$7324 _a$7325 _a$7326)) jolt-nil))) (jolt-throw (let* ((_a$7327 (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$7328 (jolt-hash-map))) (jolt-ex-info _a$7327 _a$7328))))))))))))))))))))))))))))))))))))))))) emit)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7318 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?)))
+  (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7329 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?)))
 (guard (e (#t #f))
-  (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec7319 ((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$7320 (var-deref "clojure.core" "str")) (_a$7321 "(begin ") (_a$7322 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7323 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7324 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7325 ")")) (jolt-invoke _a$7320 _a$7321 _a$7322 _a$7323 _a$7324 _a$7325)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$7326 (var-deref "clojure.core" "str")) (_a$7327 " (jolt-register-source! ") (_a$7328 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7329 " ") (_a$7330 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7331 " ") (_a$7332 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7333 " ") (_a$7334 (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$7335 " ") (_a$7336 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7337 ")")) (jolt-invoke _a$7326 _a$7327 _a$7328 _a$7329 _a$7330 _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336 _a$7337)) jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7338 (var-deref "clojure.core" "str")) (_a$7339 "(begin (define ") (_a$7340 b) (_a$7341 " ") (_a$7342 init) (_a$7343 ") (def-var-with-meta! ") (_a$7344 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7345 " ") (_a$7346 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7347 " ") (_a$7348 b) (_a$7349 " ") (_a$7350 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7351 ")") (_a$7352 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7353 ")")) (jolt-invoke _a$7338 _a$7339 _a$7340 _a$7341 _a$7342 _a$7343 _a$7344 _a$7345 _a$7346 _a$7347 _a$7348 _a$7349 _a$7350 _a$7351 _a$7352 _a$7353)) (let* ((_a$7354 (var-deref "clojure.core" "str")) (_a$7355 "(begin (define ") (_a$7356 b) (_a$7357 " ") (_a$7358 init) (_a$7359 ") (def-var! ") (_a$7360 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7361 " ") (_a$7362 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7363 " ") (_a$7364 b) (_a$7365 ")") (_a$7366 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7367 ")")) (jolt-invoke _a$7354 _a$7355 _a$7356 _a$7357 _a$7358 _a$7359 _a$7360 _a$7361 _a$7362 _a$7363 _a$7364 _a$7365 _a$7366 _a$7367)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form)))
+  (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec7330 ((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$7331 (var-deref "clojure.core" "str")) (_a$7332 "(begin ") (_a$7333 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7334 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7335 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7336 ")")) (jolt-invoke _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336)) (if (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto)) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$7337 (var-deref "clojure.core" "str")) (_a$7338 " (jolt-register-source! ") (_a$7339 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7340 " ") (_a$7341 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7342 " ") (_a$7343 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7344 " ") (_a$7345 (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$7346 " ") (_a$7347 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7348 ")")) (jolt-invoke _a$7337 _a$7338 _a$7339 _a$7340 _a$7341 _a$7342 _a$7343 _a$7344 _a$7345 _a$7346 _a$7347 _a$7348)) jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7349 (var-deref "clojure.core" "str")) (_a$7350 "(begin (define ") (_a$7351 b) (_a$7352 " ") (_a$7353 init) (_a$7354 ") (def-var-with-meta! ") (_a$7355 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7356 " ") (_a$7357 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7358 " ") (_a$7359 b) (_a$7360 " ") (_a$7361 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7362 ")") (_a$7363 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7364 ")")) (jolt-invoke _a$7349 _a$7350 _a$7351 _a$7352 _a$7353 _a$7354 _a$7355 _a$7356 _a$7357 _a$7358 _a$7359 _a$7360 _a$7361 _a$7362 _a$7363 _a$7364)) (let* ((_a$7365 (var-deref "clojure.core" "str")) (_a$7366 "(begin (define ") (_a$7367 b) (_a$7368 " ") (_a$7369 init) (_a$7370 ") (def-var! ") (_a$7371 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7372 " ") (_a$7373 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7374 " ") (_a$7375 b) (_a$7376 ")") (_a$7377 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7378 ")")) (jolt-invoke _a$7365 _a$7366 _a$7367 _a$7368 _a$7369 _a$7370 _a$7371 _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$7368 "+") (_o$7369 jolt-add) (_o$7370 "-") (_o$7371 jolt-sub) (_o$7372 "*") (_o$7373 jolt-mul) (_o$7374 "/") (_o$7375 jolt-div) (_o$7376 "<") (_o$7377 <) (_o$7378 ">") (_o$7379 >) (_o$7380 "<=") (_o$7381 <=) (_o$7382 ">=") (_o$7383 >=) (_o$7384 "=") (_o$7385 jolt=) (_o$7386 "inc") (_o$7387 jolt-inc) (_o$7388 "dec") (_o$7389 jolt-dec) (_o$7390 "mod") (_o$7391 modulo) (_o$7392 "rem") (_o$7393 remainder) (_o$7394 "quot") (_o$7395 quotient) (_o$7396 "bit-and") (_o$7397 (var-deref "clojure.core" "__bit-and")) (_o$7398 "bit-or") (_o$7399 (var-deref "clojure.core" "__bit-or")) (_o$7400 "bit-xor") (_o$7401 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _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)) (let* ((_o$7402 (keyword #f "private")) (_o$7403 #t)) (jolt-hash-map _o$7402 _o$7403))))
+  (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$7379 "+") (_o$7380 jolt-add) (_o$7381 "-") (_o$7382 jolt-sub) (_o$7383 "*") (_o$7384 jolt-mul) (_o$7385 "/") (_o$7386 jolt-div) (_o$7387 "<") (_o$7388 <) (_o$7389 ">") (_o$7390 >) (_o$7391 "<=") (_o$7392 <=) (_o$7393 ">=") (_o$7394 >=) (_o$7395 "=") (_o$7396 jolt=) (_o$7397 "inc") (_o$7398 jolt-inc) (_o$7399 "dec") (_o$7400 jolt-dec) (_o$7401 "mod") (_o$7402 modulo) (_o$7403 "rem") (_o$7404 remainder) (_o$7405 "quot") (_o$7406 quotient) (_o$7407 "bit-and") (_o$7408 (var-deref "clojure.core" "__bit-and")) (_o$7409 "bit-or") (_o$7410 (var-deref "clojure.core" "__bit-or")) (_o$7411 "bit-xor") (_o$7412 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _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 _o$7405 _o$7406 _o$7407 _o$7408 _o$7409 _o$7410 _o$7411 _o$7412)) (let* ((_o$7413 (keyword #f "private")) (_o$7414 #t)) (jolt-hash-map _o$7413 _o$7414))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7404 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?)))
+  (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7415 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7405 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?)))
+  (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7416 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?)))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7406 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host")))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn)))
+  (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7417 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host")))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn)))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7407 ((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$catch1532 (else (let* ((e _r$catch1532)) jolt-nil))) (let* ((_o$7409 (keyword #f "op")) (_o$7410 (keyword #f "const")) (_o$7411 (keyword #f "val")) (_o$7412 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7408 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7409 _o$7410 _o$7411 _o$7412))) 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$7413 node) (_a$7414 (keyword #f "test")) (_a$7415 t) (_a$7416 (keyword #f "then")) (_a$7417 (const-fold (jolt-get node (keyword #f "then")))) (_a$7418 (keyword #f "else")) (_a$7419 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7413 _a$7414 _a$7415 _a$7416 _a$7417 _a$7418 _a$7419)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7420 (keyword #f "doc")) (_o$7421 "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$7420 _o$7421))))
+  (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7418 ((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$catch1533 (else (let* ((e _r$catch1533)) jolt-nil))) (let* ((_o$7420 (keyword #f "op")) (_o$7421 (keyword #f "const")) (_o$7422 (keyword #f "val")) (_o$7423 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7419 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7420 _o$7421 _o$7422 _o$7423))) 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$7424 node) (_a$7425 (keyword #f "test")) (_a$7426 t) (_a$7427 (keyword #f "then")) (_a$7428 (const-fold (jolt-get node (keyword #f "then")))) (_a$7429 (keyword #f "else")) (_a$7430 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7424 _a$7425 _a$7426 _a$7427 _a$7428 _a$7429 _a$7430)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7431 (keyword #f "doc")) (_o$7432 "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$7431 _o$7432))))
 (guard (e (#t #f))
-  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7422 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?)))
+  (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7433 ((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 fnrec7423 ((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$7424 (keyword #f "doc")) (_o$7425 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7424 _o$7425))))
+  (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec7434 ((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$7435 (keyword #f "doc")) (_o$7436 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7435 _o$7436))))
 (guard (e (#t #f))
-  (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7426 ((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$7427 (keyword #f "doc")) (_o$7428 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7427 _o$7428))))
+  (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7437 ((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$7438 (keyword #f "doc")) (_o$7439 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7438 _o$7439))))
 (guard (e (#t #f))
   (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6001 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__25__auto))) and__25__auto)))))) int-lit?)))
 (guard (e (#t #f))
diff --git a/jolt-core/jolt/backend_scheme.clj b/jolt-core/jolt/backend_scheme.clj
index d162fa2..762c162 100644
--- a/jolt-core/jolt/backend_scheme.clj
+++ b/jolt-core/jolt/backend_scheme.clj
@@ -498,6 +498,18 @@
                                (fn [[f & as]]
                                  (str "(jolt-invoke " f (if (seq as) (str " " (str/join " " as)) "") ")"))))]
     (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
+      ;; through the protocol var -> jolt-invoke -> protocol-resolve (which recomputes
+      ;; the tag and walks the type table). find-protocol-method does the same table
+      ;; lookup the dispatch would, but with no var-deref, no rest-cons, and no
+      ;; receiver-type computation. Fires only on a monomorphic site (a megamorphic
+      ;; receiver joins to :any and carries no :devirt-type).
+      (:devirt-type node)
+      (order-args (fn [as]
+                    (str "((find-protocol-method " (chez-str-lit (:devirt-type node)) " "
+                         (chez-str-lit (:devirt-proto node)) " " (chez-str-lit (:devirt-method node))
+                         ") " (str/join " " as) ")")))
       ;; hint-directed fast arithmetic: jolt.passes.numeric proved every operand a
       ;; flonum (^double) or fixnum (^long), so emit the Chez fl*/fx* op.
       (:num-kind node) (emit-numeric (:num-kind node) (:name fnode) args order-args)