From 4289d04ec3f17800973196b396abefaca764dcec Mon Sep 17 00:00:00 2001
From: Simon From Jakobsen <sfj@skov.dk>
Date: Mon, 22 Sep 2025 16:22:03 +0200
Subject: [PATCH] more compiler stuff

---
 compile.phi |  79 ++++-
 runtime.js  |   3 +-
 stage1.js   | 995 +++++++++++++++++++++++++++++++++++-----------------
 stage2.js   |   3 +
 4 files changed, 738 insertions(+), 342 deletions(-)
 create mode 100644 stage2.js

diff --git a/compile.phi b/compile.phi
index ac4b92b..d8716f5 100644
--- a/compile.phi
+++ b/compile.phi
@@ -2,7 +2,9 @@
 (fn Emitter (ast filename) (do
     (let output ())
 
-    (let (enter_scope leave_scope define_sym get_sym) (call Syms))
+    (let (enter_scope leave_scope define_sym get_sym print_syms) (call Syms))
+
+    (let (let_node_reg_count let_node_reg_increment) (call Counter))
 
     (fn generate () (do
         (call emit "#!/usr/bin/env node\n")
@@ -62,6 +64,7 @@
 
             (let sym (call get_sym value))
             (if (== sym null) (do
+                (call print_syms)
                 (call panic "undefined symbol '%' on line %" value line)
             ))
 
@@ -122,11 +125,11 @@
             (call leave_scope)
         ) (if (== id "let") (do
             (let (_ pat expr) s)
-            (call emit "let ")
-            (call emit_pat pat)
-            (call emit " = runtime.assignValue(")
+            (let reg (call let_node_reg_count))
+            (call let_node_reg_increment)
+            (call emit (call format "let r_% = " reg))
             (call emit_expr expr)
-            (call emit ")")
+            (call emit_let_node pat reg)
         ) (if (== id "do") (do
             (call enter_scope)
             (call discover_syms (call slice s 1))
@@ -139,7 +142,7 @@
             (call emit_pat pat)
             (call emit " of ")
             (call emit_expr expr)
-            (call emit ") {\n")
+            (call emit ".values) {\n")
             (call emit_expr body)
             (call emit "}")
             (call leave_scope)
@@ -251,6 +254,31 @@
         ))))))))))))))))))))))))
     ))
 
+    (fn emit_let_node (pat base_reg) (do
+        (let (pat_ty line) pat)
+        (if (== pat_ty "ident") (do
+            (let (_ _ ident) pat)
+
+            (if (== ident "_") (return))
+
+            (call emit (call format ";\nlet _% = r_%" ident base_reg))
+            (call define_sym ident ("let" line))
+        ) (if (== pat_ty "list") (do
+            (let (_ _ pats) pat)
+
+            (let i 0)
+            (for pat pats (do
+                (let reg (call let_node_reg_count))
+                (call let_node_reg_increment)
+                (call emit (call format ";\nlet r_% = r_%.values[%]" reg base_reg i))
+                (call emit_let_node pat reg)
+                (+= i 1)
+            ))
+        ) (do
+            (call panic "malformed pattern on line %" line)
+        )))
+    ))
+
     (fn emit_binary_op (s id) (do
         (let (_ left right) s)
         (call emit (call format "runtime.%(" id))
@@ -263,7 +291,6 @@
     (fn emit_assign_expr (s line id) (do
         (let (_ (target_type) expr) s)
         (if (!= target_type "ident") (do
-        ) (do
             (call panic "cannot assign to expression on line %" line)
         ))
         (let (_ (_ _ ident)) s)
@@ -327,6 +354,20 @@
     (return (generate))
 ))
 
+(fn Counter () (do
+    (let counter 0)
+
+    (fn count () (do
+        (return counter)
+    ))
+
+    (fn increment () (do
+        (+= counter 1)
+    ))
+
+    (return (count increment))
+))
+
 (fn Syms () (do
     (let syms (null (
         ("format" ("builtin" "builtinFormat"))
@@ -389,12 +430,27 @@
     (fn get (ident) (do
         (return (call find_sym syms ident))
     ))
+
+    (fn print_syms_node (syms depth) (do
+        (let (parent map) syms)
+        (for (ident sym) map (do
+            (call println "%- %: %" (call indent depth) ident sym)
+        ))
+        (if (!= parent null) (do
+            (call print_syms_node parent (+ depth 1))
+        ))
+    ))
+
+    (fn print_syms () (do
+        (call print_syms_node syms 0)
+    ))
     
     (return (
         enter_scope
         leave_scope
         define
         get
+        print_syms
     ))
 ))
 
@@ -581,7 +637,6 @@
             (call println "illegal char '%'" ch)
             (+= i 1)
         )))))))
-        
     ))
     (return tokens)
 ))
@@ -658,16 +713,18 @@
 (if (not silent) (call println "reading file..."))
 (let text (call read_text_file input_filename))
 
-//(call println "=== text ===")
-//(call println text)
+(call println "=== text ===")
+// (call println text)
+(call println (call len text))
 
 (if (not silent) (call println "tokenizing..."))
 (let tokens (call tokenize text))
 
-// (call println "=== tokens ===")
+(call println "=== tokens ===")
 // (for (tok line value) tokens (do
 //    (call println "%\t%\t%" line tok (if (!= value null) value ""))
 // ))
+(call println (call len tokens))
 
 (if (not silent) (call println "parsing..."))
 (let parser (call Parser tokens))
diff --git a/runtime.js b/runtime.js
index 43aa1e6..35f9485 100644
--- a/runtime.js
+++ b/runtime.js
@@ -2,8 +2,7 @@ import fs from "node:fs";
 import process from "node:process";
 
 export class Runtime {
-    constructor({ filename, args }) {
-        this.syms = { parent: undefined, map: new Map(this.builtins) };
+    constructor({ filename, args } = {}) {
         this.callStack = [{ name: "<entry>", line: 0 }];
         this.filename = filename;
         this.args = args ?? process.argv.slice(2);
diff --git a/stage1.js b/stage1.js
index 41d3b47..6ec5240 100644
--- a/stage1.js
+++ b/stage1.js
@@ -3,28 +3,44 @@ import { Runtime } from "./runtime.js"
 const runtime = new Runtime("compile.phi")
 function _Emitter(_ast, _filename) {
 runtime.pushCall("Emitter");
-let _output = runtime.assignValue(({ type: "list", values: [] }));
-let [_enter_scope, _leave_scope, _define_sym, _get_sym] = runtime.assignValue((runtime.setLine(5), _Syms()));
+let r_0 = ({ type: "list", values: [] });
+let _output = r_0;
+let r_1 = (runtime.setLine(5), _Syms());
+let r_2 = r_1.values[0];
+let _enter_scope = r_2;
+let r_3 = r_1.values[1];
+let _leave_scope = r_3;
+let r_4 = r_1.values[2];
+let _define_sym = r_4;
+let r_5 = r_1.values[3];
+let _get_sym = r_5;
+let r_6 = r_1.values[4];
+let _print_syms = r_6;
+let r_7 = (runtime.setLine(7), _Counter());
+let r_8 = r_7.values[0];
+let _let_node_reg_count = r_8;
+let r_9 = r_7.values[1];
+let _let_node_reg_increment = r_9;
 function _generate() {
 runtime.pushCall("generate");
-(runtime.setLine(8), _emit(({ type: "string", value: "#!/usr/bin/env node\n" })));
-(runtime.setLine(9), _emit(({ type: "string", value: "import { Runtime } from \"./runtime.js\"\n" })));
-(runtime.setLine(10), _emit(({ type: "string", value: "const runtime = new Runtime(\"" })));
-(runtime.setLine(11), _emit(_filename));
-(runtime.setLine(12), _emit(({ type: "string", value: "\")\n" })));
-(runtime.setLine(13), _discover_syms(_ast));
-(runtime.setLine(14), _emit_exprs(_ast));
+(runtime.setLine(10), _emit(({ type: "string", value: "#!/usr/bin/env node\n" })));
+(runtime.setLine(11), _emit(({ type: "string", value: "import { Runtime } from \"./runtime.js\"\n" })));
+(runtime.setLine(12), _emit(({ type: "string", value: "const runtime = new Runtime(\"" })));
+(runtime.setLine(13), _emit(_filename));
+(runtime.setLine(14), _emit(({ type: "string", value: "\")\n" })));
+(runtime.setLine(15), _discover_syms(_ast));
+(runtime.setLine(16), _emit_exprs(_ast));
 runtime.popCall();
-return (runtime.setLine(15), ((...args) => runtime.builtinStringsJoin(...args))(_output));
+return (runtime.setLine(17), ((...args) => runtime.builtinStringsJoin(...args))(_output));
 ;
 runtime.popCall();
 return { type: "null" };
 };
 function _emit_exprs(_exprs) {
 runtime.pushCall("emit_exprs");
-for (let _expr of _exprs) {
-(runtime.setLine(20), _emit_expr(_expr));
-(runtime.setLine(21), _emit(({ type: "string", value: ";\n" })));
+for (let _expr of _exprs.values) {
+(runtime.setLine(22), _emit_expr(_expr));
+(runtime.setLine(23), _emit(({ type: "string", value: ";\n" })));
 };
 ;
 runtime.popCall();
@@ -32,19 +48,45 @@ return { type: "null" };
 };
 function _discover_syms(_exprs) {
 runtime.pushCall("discover_syms");
-for (let _expr of _exprs) {
-let [_ty, _line] = runtime.assignValue(_expr);
+for (let _expr of _exprs.values) {
+let r_10 = _expr;
+let r_11 = r_10.values[0];
+let _ty = r_11;
+let r_12 = r_10.values[1];
+let _line = r_12;
 if (runtime.opNe(_ty, ({ type: "string", value: "list" }))) {
 runtime.popCall();
 return { type: "null" }};
-let [, , _s] = runtime.assignValue(_expr);
-if (runtime.opEq((runtime.setLine(30), ((...args) => runtime.builtinLen(...args))(_s)), ({ type: "int", value: 0 }))) {
+let r_13 = _expr;
+let r_14 = r_13.values[0];
+let r_15 = r_13.values[1];
+let r_16 = r_13.values[2];
+let _s = r_16;
+if (runtime.opEq((runtime.setLine(32), ((...args) => runtime.builtinLen(...args))(_s)), ({ type: "int", value: 0 }))) {
 runtime.popCall();
 return { type: "null" }};
-let [[, , _id]] = runtime.assignValue(_s);
+let r_17 = _s;
+let r_18 = r_17.values[0];
+let r_19 = r_18.values[0];
+let r_20 = r_18.values[1];
+let r_21 = r_18.values[2];
+let _id = r_21;
 if (runtime.opEq(_id, ({ type: "string", value: "fn" }))) {
-let [, [, , _name], [, , _params], _body] = runtime.assignValue(_s);
-(runtime.setLine(34), _define_sym(_name, ({ type: "list", values: [] })));
+let r_22 = _s;
+let r_23 = r_22.values[0];
+let r_24 = r_22.values[1];
+let r_25 = r_24.values[0];
+let r_26 = r_24.values[1];
+let r_27 = r_24.values[2];
+let _name = r_27;
+let r_28 = r_22.values[2];
+let r_29 = r_28.values[0];
+let r_30 = r_28.values[1];
+let r_31 = r_28.values[2];
+let _params = r_31;
+let r_32 = r_22.values[3];
+let _body = r_32;
+(runtime.setLine(36), _define_sym(_name, ({ type: "list", values: [] })));
 };
 };
 ;
@@ -53,53 +95,68 @@ return { type: "null" };
 };
 function _emit_expr(_expr) {
 runtime.pushCall("emit_expr");
-let [_ty, _line] = runtime.assignValue(_expr);
+let r_33 = _expr;
+let r_34 = r_33.values[0];
+let _ty = r_34;
+let r_35 = r_33.values[1];
+let _line = r_35;
 if (runtime.opEq(_ty, ({ type: "string", value: "list" }))) {
-(runtime.setLine(42), _emit_list(_expr));
+(runtime.setLine(44), _emit_list(_expr));
 } else {
 if (runtime.opEq(_ty, ({ type: "string", value: "int" }))) {
 ({ type: "list", values: [] })} else {
 if (runtime.opEq(_ty, ({ type: "string", value: "string" }))) {
 ({ type: "list", values: [] })} else {
 if (runtime.opEq(_ty, ({ type: "string", value: "ident" }))) {
-let [, , _value] = runtime.assignValue(_expr);
+let r_36 = _expr;
+let r_37 = r_36.values[0];
+let r_38 = r_36.values[1];
+let r_39 = r_36.values[2];
+let _value = r_39;
 if (runtime.opEq(_value, ({ type: "string", value: "null" }))) {
-(runtime.setLine(53), _emit(({ type: "string", value: "({ type: \"null\" })" })));
+(runtime.setLine(55), _emit(({ type: "string", value: "({ type: \"null\" })" })));
 runtime.popCall();
 return { type: "null" };
 } else {
 if (runtime.opEq(_value, ({ type: "string", value: "false" }))) {
-(runtime.setLine(56), _emit(({ type: "string", value: "({ type: \"bool\", value: false })" })));
+(runtime.setLine(58), _emit(({ type: "string", value: "({ type: \"bool\", value: false })" })));
 runtime.popCall();
 return { type: "null" };
 } else {
 if (runtime.opEq(_value, ({ type: "string", value: "true" }))) {
-(runtime.setLine(59), _emit(({ type: "string", value: "({ type: \"bool\", value: true })" })));
+(runtime.setLine(61), _emit(({ type: "string", value: "({ type: \"bool\", value: true })" })));
 runtime.popCall();
 return { type: "null" };
 }}};
-let _sym = runtime.assignValue((runtime.setLine(63), _get_sym(_value)));
+let r_40 = (runtime.setLine(65), _get_sym(_value));
+let _sym = r_40;
 if (runtime.opEq(_sym, ({ type: "null" }))) {
-(runtime.setLine(65), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "undefined symbol '%' on line %" }), _value, _line));
+(runtime.setLine(67), _print_syms());
+(runtime.setLine(68), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "undefined symbol '%' on line %" }), _value, _line));
 };
-let [_sym_ty] = runtime.assignValue(_sym);
+let r_41 = _sym;
+let r_42 = r_41.values[0];
+let _sym_ty = r_42;
 if (runtime.opEq(_sym_ty, ({ type: "string", value: "builtin" }))) {
-let [, _id] = runtime.assignValue(_sym);
-(runtime.setLine(71), _emit((runtime.setLine(71), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "((...args) => runtime.%(...args))" }), _id))));
+let r_43 = _sym;
+let r_44 = r_43.values[0];
+let r_45 = r_43.values[1];
+let _id = r_45;
+(runtime.setLine(74), _emit((runtime.setLine(74), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "((...args) => runtime.%(...args))" }), _id))));
 } else {
 if (runtime.opEq(_sym_ty, ({ type: "string", value: "fn" }))) {
-(runtime.setLine(73), _emit((runtime.setLine(73), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _value))));
+(runtime.setLine(76), _emit((runtime.setLine(76), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _value))));
 } else {
 if (runtime.opEq(_sym_ty, ({ type: "string", value: "param" }))) {
-(runtime.setLine(75), _emit((runtime.setLine(75), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _value))));
+(runtime.setLine(78), _emit((runtime.setLine(78), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _value))));
 } else {
 if (runtime.opEq(_sym_ty, ({ type: "string", value: "let" }))) {
-(runtime.setLine(77), _emit((runtime.setLine(77), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _value))));
+(runtime.setLine(80), _emit((runtime.setLine(80), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _value))));
 } else {
-(runtime.setLine(79), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "not implemented '%'" }), _sym_ty));
+(runtime.setLine(82), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "not implemented '%'" }), _sym_ty));
 }}}};
 } else {
-(runtime.setLine(82), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "unknown expr type '%' on line %" }), _ty, _line));
+(runtime.setLine(85), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "unknown expr type '%' on line %" }), _ty, _line));
 }}}};
 ;
 runtime.popCall();
@@ -107,232 +164,370 @@ return { type: "null" };
 };
 function _emit_list(_expr) {
 runtime.pushCall("emit_list");
-let [_ty, _line, _s] = runtime.assignValue(_expr);
-if (runtime.opEq((runtime.setLine(88), ((...args) => runtime.builtinLen(...args))(_s)), ({ type: "int", value: 0 }))) {
-(runtime.setLine(89), _emit(({ type: "string", value: "({ type: \"list\", values: [] })" })));
+let r_46 = _expr;
+let r_47 = r_46.values[0];
+let _ty = r_47;
+let r_48 = r_46.values[1];
+let _line = r_48;
+let r_49 = r_46.values[2];
+let _s = r_49;
+if (runtime.opEq((runtime.setLine(91), ((...args) => runtime.builtinLen(...args))(_s)), ({ type: "int", value: 0 }))) {
+(runtime.setLine(92), _emit(({ type: "string", value: "({ type: \"list\", values: [] })" })));
 runtime.popCall();
 return { type: "null" };
 };
-let [[_id_ty, , _id]] = runtime.assignValue(_s);
+let r_50 = _s;
+let r_51 = r_50.values[0];
+let r_52 = r_51.values[0];
+let _id_ty = r_52;
+let r_53 = r_51.values[1];
+let r_54 = r_51.values[2];
+let _id = r_54;
 if (runtime.opNe(_id_ty, ({ type: "string", value: "ident" }))) {
-(runtime.setLine(94), _emit(({ type: "string", value: "({ type: \"list\", values: [] })" })));
+(runtime.setLine(97), _emit(({ type: "string", value: "({ type: \"list\", values: [] })" })));
 runtime.popCall();
 return { type: "null" };
 };
 if (runtime.opEq(_id, ({ type: "string", value: "fn" }))) {
-let [, [, , _name], [, , _params], _body] = runtime.assignValue(_s);
-(runtime.setLine(99), _emit((runtime.setLine(99), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "function _%(" }), _name))));
-(runtime.setLine(101), _enter_scope());
-let _first = runtime.assignValue(({ type: "bool", value: true }));
-for (let [, , _name] of _params) {
+let r_55 = _s;
+let r_56 = r_55.values[0];
+let r_57 = r_55.values[1];
+let r_58 = r_57.values[0];
+let r_59 = r_57.values[1];
+let r_60 = r_57.values[2];
+let _name = r_60;
+let r_61 = r_55.values[2];
+let r_62 = r_61.values[0];
+let r_63 = r_61.values[1];
+let r_64 = r_61.values[2];
+let _params = r_64;
+let r_65 = r_55.values[3];
+let _body = r_65;
+(runtime.setLine(102), _emit((runtime.setLine(102), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "function _%(" }), _name))));
+(runtime.setLine(104), _enter_scope());
+let r_66 = ({ type: "bool", value: true });
+let _first = r_66;
+for (let [, , _name] of _params.values) {
 if (runtime.opNot(_first)) {
-(runtime.setLine(106), _emit(({ type: "string", value: ", " })));
+(runtime.setLine(109), _emit(({ type: "string", value: ", " })));
 };
-(_first = runtime.assignValue(({ type: "bool", value: false })));
-(runtime.setLine(110), _emit((runtime.setLine(110), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _name))));
-(runtime.setLine(112), _define_sym(_name, ({ type: "list", values: [] })));
+(_106 = runtime.assignValue(({ type: "bool", value: false })));
+(runtime.setLine(113), _emit((runtime.setLine(113), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _name))));
+(runtime.setLine(115), _define_sym(_name, ({ type: "list", values: [] })));
 };
-(runtime.setLine(116), _emit((runtime.setLine(116), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: ") {\n" }), _name))));
-(runtime.setLine(117), _emit((runtime.setLine(117), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.pushCall(\"%\");\n" }), _name))));
-(runtime.setLine(119), _emit_expr(_body));
-(runtime.setLine(120), _emit(({ type: "string", value: ";\nruntime.popCall();\nreturn { type: \"null\" };\n}" })));
-(runtime.setLine(122), _leave_scope());
+(runtime.setLine(119), _emit((runtime.setLine(119), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: ") {\n" }), _name))));
+(runtime.setLine(120), _emit((runtime.setLine(120), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.pushCall(\"%\");\n" }), _name))));
+(runtime.setLine(122), _emit_expr(_body));
+(runtime.setLine(123), _emit(({ type: "string", value: ";\nruntime.popCall();\nreturn { type: \"null\" };\n}" })));
+(runtime.setLine(125), _leave_scope());
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "let" }))) {
-let [, _pat, _expr] = runtime.assignValue(_s);
-(runtime.setLine(125), _emit(({ type: "string", value: "let " })));
-(runtime.setLine(126), _emit_pat(_pat));
-(runtime.setLine(127), _emit(({ type: "string", value: " = runtime.assignValue(" })));
-(runtime.setLine(128), _emit_expr(_expr));
-(runtime.setLine(129), _emit(({ type: "string", value: ")" })));
+let r_67 = _s;
+let r_68 = r_67.values[0];
+let r_69 = r_67.values[1];
+let _pat = r_69;
+let r_70 = r_67.values[2];
+let _expr = r_70;
+let r_71 = (runtime.setLine(128), _let_node_reg_count());
+let _reg = r_71;
+(runtime.setLine(129), _let_node_reg_increment());
+(runtime.setLine(130), _emit((runtime.setLine(130), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "let r_% = " }), _reg))));
+(runtime.setLine(131), _emit_expr(_expr));
+(runtime.setLine(132), _emit_let_node(_pat, _reg));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "do" }))) {
-(runtime.setLine(131), _enter_scope());
-(runtime.setLine(132), _discover_syms((runtime.setLine(132), _slice(_s, ({ type: "int", value: 1 })))));
-(runtime.setLine(133), _emit_exprs((runtime.setLine(133), _slice(_s, ({ type: "int", value: 1 })))));
-(runtime.setLine(134), _leave_scope());
+(runtime.setLine(134), _enter_scope());
+(runtime.setLine(135), _discover_syms((runtime.setLine(135), _slice(_s, ({ type: "int", value: 1 })))));
+(runtime.setLine(136), _emit_exprs((runtime.setLine(136), _slice(_s, ({ type: "int", value: 1 })))));
+(runtime.setLine(137), _leave_scope());
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "for" }))) {
-let [, _pat, _expr, _body] = runtime.assignValue(_s);
-(runtime.setLine(137), _enter_scope());
-(runtime.setLine(138), _emit(({ type: "string", value: "for (let " })));
-(runtime.setLine(139), _emit_pat(_pat));
-(runtime.setLine(140), _emit(({ type: "string", value: " of " })));
-(runtime.setLine(141), _emit_expr(_expr));
-(runtime.setLine(142), _emit(({ type: "string", value: ") {\n" })));
-(runtime.setLine(143), _emit_expr(_body));
-(runtime.setLine(144), _emit(({ type: "string", value: "}" })));
-(runtime.setLine(145), _leave_scope());
+let r_72 = _s;
+let r_73 = r_72.values[0];
+let r_74 = r_72.values[1];
+let _pat = r_74;
+let r_75 = r_72.values[2];
+let _expr = r_75;
+let r_76 = r_72.values[3];
+let _body = r_76;
+(runtime.setLine(140), _enter_scope());
+(runtime.setLine(141), _emit(({ type: "string", value: "for (let " })));
+(runtime.setLine(142), _emit_pat(_pat));
+(runtime.setLine(143), _emit(({ type: "string", value: " of " })));
+(runtime.setLine(144), _emit_expr(_expr));
+(runtime.setLine(145), _emit(({ type: "string", value: ".values) {\n" })));
+(runtime.setLine(146), _emit_expr(_body));
+(runtime.setLine(147), _emit(({ type: "string", value: "}" })));
+(runtime.setLine(148), _leave_scope());
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "loop" }))) {
-let [, _body] = runtime.assignValue(_s);
-(runtime.setLine(148), _emit(({ type: "string", value: "while (true) {\n" })));
-(runtime.setLine(149), _emit_expr(_body));
-(runtime.setLine(150), _emit(({ type: "string", value: "}" })));
+let r_77 = _s;
+let r_78 = r_77.values[0];
+let r_79 = r_77.values[1];
+let _body = r_79;
+(runtime.setLine(151), _emit(({ type: "string", value: "while (true) {\n" })));
+(runtime.setLine(152), _emit_expr(_body));
+(runtime.setLine(153), _emit(({ type: "string", value: "}" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "if" }))) {
-let [, _cond, _truthy, _falsy] = runtime.assignValue(_s);
-(runtime.setLine(153), _emit(({ type: "string", value: "if (" })));
-(runtime.setLine(154), _emit_expr(_cond));
-(runtime.setLine(155), _emit(({ type: "string", value: ") {\n" })));
-(runtime.setLine(156), _emit_expr(_truthy));
-(runtime.setLine(157), _emit(({ type: "string", value: "}" })));
+let r_80 = _s;
+let r_81 = r_80.values[0];
+let r_82 = r_80.values[1];
+let _cond = r_82;
+let r_83 = r_80.values[2];
+let _truthy = r_83;
+let r_84 = r_80.values[3];
+let _falsy = r_84;
+(runtime.setLine(156), _emit(({ type: "string", value: "if (" })));
+(runtime.setLine(157), _emit_expr(_cond));
+(runtime.setLine(158), _emit(({ type: "string", value: ") {\n" })));
+(runtime.setLine(159), _emit_expr(_truthy));
+(runtime.setLine(160), _emit(({ type: "string", value: "}" })));
 if (runtime.opNe(_falsy, ({ type: "null" }))) {
-(runtime.setLine(159), _emit(({ type: "string", value: " else {\n" })));
-(runtime.setLine(160), _emit_expr(_falsy));
-(runtime.setLine(161), _emit(({ type: "string", value: "}" })));
+(runtime.setLine(162), _emit(({ type: "string", value: " else {\n" })));
+(runtime.setLine(163), _emit_expr(_falsy));
+(runtime.setLine(164), _emit(({ type: "string", value: "}" })));
 };
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "return" }))) {
-let [, _value] = runtime.assignValue(_s);
-(runtime.setLine(165), _emit(({ type: "string", value: "runtime.popCall();\n" })));
-(runtime.setLine(166), _emit(({ type: "string", value: "return " })));
+let r_85 = _s;
+let r_86 = r_85.values[0];
+let r_87 = r_85.values[1];
+let _value = r_87;
+(runtime.setLine(168), _emit(({ type: "string", value: "runtime.popCall();\n" })));
+(runtime.setLine(169), _emit(({ type: "string", value: "return " })));
 if (runtime.opNe(_value, ({ type: "null" }))) {
-(runtime.setLine(168), _emit_expr(_value));
+(runtime.setLine(171), _emit_expr(_value));
 } else {
-(runtime.setLine(170), _emit(({ type: "string", value: "{ type: \"null\" }" })));
+(runtime.setLine(173), _emit(({ type: "string", value: "{ type: \"null\" }" })));
 };
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "break" }))) {
-let [, _value] = runtime.assignValue(_s);
-(runtime.setLine(174), _emit(({ type: "string", value: "break" })));
+let r_88 = _s;
+let r_89 = r_88.values[0];
+let r_90 = r_88.values[1];
+let _value = r_90;
+(runtime.setLine(177), _emit(({ type: "string", value: "break" })));
 if (runtime.opNe(_value, ({ type: "null" }))) {
-(runtime.setLine(176), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "not implemented" })));
+(runtime.setLine(179), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "not implemented" })));
 };
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "call" }))) {
-let [, _callee] = runtime.assignValue(_s);
-let _args = runtime.assignValue((runtime.setLine(180), _slice(_s, ({ type: "int", value: 2 }))));
-(runtime.setLine(181), _emit((runtime.setLine(181), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(runtime.setLine(%), " }), _line))));
-(runtime.setLine(182), _emit_expr(_callee));
-(runtime.setLine(183), _emit(({ type: "string", value: "(" })));
-let _first = runtime.assignValue(({ type: "bool", value: true }));
-for (let _arg of _args) {
+let r_91 = _s;
+let r_92 = r_91.values[0];
+let r_93 = r_91.values[1];
+let _callee = r_93;
+let r_94 = (runtime.setLine(183), _slice(_s, ({ type: "int", value: 2 })));
+let _args = r_94;
+(runtime.setLine(184), _emit((runtime.setLine(184), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(runtime.setLine(%), " }), _line))));
+(runtime.setLine(185), _emit_expr(_callee));
+(runtime.setLine(186), _emit(({ type: "string", value: "(" })));
+let r_95 = ({ type: "bool", value: true });
+let _first = r_95;
+for (let _arg of _args.values) {
 if (runtime.opNot(_first)) {
-(runtime.setLine(188), _emit(({ type: "string", value: ", " })));
+(runtime.setLine(191), _emit(({ type: "string", value: ", " })));
 };
-(_first = runtime.assignValue(({ type: "bool", value: false })));
-(runtime.setLine(192), _emit_expr(_arg));
+(_188 = runtime.assignValue(({ type: "bool", value: false })));
+(runtime.setLine(195), _emit_expr(_arg));
 };
-(runtime.setLine(195), _emit(({ type: "string", value: "))" })));
+(runtime.setLine(198), _emit(({ type: "string", value: "))" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "=" }))) {
-(runtime.setLine(197), _emit_assign_expr(_s, _line, ({ type: "string", value: "=" })));
+(runtime.setLine(200), _emit_assign_expr(_s, _line, ({ type: "string", value: "=" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "+=" }))) {
-(runtime.setLine(199), _emit_assign_expr(_s, _line, ({ type: "string", value: "+" })));
+(runtime.setLine(202), _emit_assign_expr(_s, _line, ({ type: "string", value: "+" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "-=" }))) {
-(runtime.setLine(201), _emit_assign_expr(_s, _line, ({ type: "string", value: "-" })));
+(runtime.setLine(204), _emit_assign_expr(_s, _line, ({ type: "string", value: "-" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "or" }))) {
-let [, _left, _right] = runtime.assignValue(_s);
-(runtime.setLine(204), _emit((runtime.setLine(204), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(runtime.setLine(%)" }), _line))));
-(runtime.setLine(205), _emit(({ type: "string", value: ", { type: \"bool\", value: this.runtime.truthy(" })));
-(runtime.setLine(206), _emit_expr(_left));
-(runtime.setLine(207), _emit(({ type: "string", value: ") || this.runtime.falsy(" })));
-(runtime.setLine(208), _emit_expr(_right));
-(runtime.setLine(209), _emit(({ type: "string", value: ") })" })));
+let r_96 = _s;
+let r_97 = r_96.values[0];
+let r_98 = r_96.values[1];
+let _left = r_98;
+let r_99 = r_96.values[2];
+let _right = r_99;
+(runtime.setLine(207), _emit((runtime.setLine(207), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(runtime.setLine(%)" }), _line))));
+(runtime.setLine(208), _emit(({ type: "string", value: ", { type: \"bool\", value: this.runtime.truthy(" })));
+(runtime.setLine(209), _emit_expr(_left));
+(runtime.setLine(210), _emit(({ type: "string", value: ") || this.runtime.falsy(" })));
+(runtime.setLine(211), _emit_expr(_right));
+(runtime.setLine(212), _emit(({ type: "string", value: ") })" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "and" }))) {
-let [, _left, _right] = runtime.assignValue(_s);
-(runtime.setLine(212), _emit((runtime.setLine(212), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(runtime.setLine(%)" }), _line))));
-(runtime.setLine(213), _emit(({ type: "string", value: ", { type: \"bool\", value: this.runtime.truthy(" })));
-(runtime.setLine(214), _emit_expr(_left));
-(runtime.setLine(215), _emit(({ type: "string", value: ") && this.runtime.falsy(" })));
-(runtime.setLine(216), _emit_expr(_right));
-(runtime.setLine(217), _emit(({ type: "string", value: ") })" })));
+let r_100 = _s;
+let r_101 = r_100.values[0];
+let r_102 = r_100.values[1];
+let _left = r_102;
+let r_103 = r_100.values[2];
+let _right = r_103;
+(runtime.setLine(215), _emit((runtime.setLine(215), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(runtime.setLine(%)" }), _line))));
+(runtime.setLine(216), _emit(({ type: "string", value: ", { type: \"bool\", value: this.runtime.truthy(" })));
+(runtime.setLine(217), _emit_expr(_left));
+(runtime.setLine(218), _emit(({ type: "string", value: ") && this.runtime.falsy(" })));
+(runtime.setLine(219), _emit_expr(_right));
+(runtime.setLine(220), _emit(({ type: "string", value: ") })" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "==" }))) {
-(runtime.setLine(219), _emit_binary_op(_s, ({ type: "string", value: "opEq" })));
+(runtime.setLine(222), _emit_binary_op(_s, ({ type: "string", value: "opEq" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "!=" }))) {
-(runtime.setLine(221), _emit_binary_op(_s, ({ type: "string", value: "opNe" })));
+(runtime.setLine(224), _emit_binary_op(_s, ({ type: "string", value: "opNe" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "<" }))) {
-(runtime.setLine(223), _emit_binary_op(_s, ({ type: "string", value: "opLt" })));
+(runtime.setLine(226), _emit_binary_op(_s, ({ type: "string", value: "opLt" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: ">" }))) {
-(runtime.setLine(225), _emit_binary_op(_s, ({ type: "string", value: "opGt" })));
+(runtime.setLine(228), _emit_binary_op(_s, ({ type: "string", value: "opGt" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "<=" }))) {
-(runtime.setLine(227), _emit_binary_op(_s, ({ type: "string", value: "opLte" })));
+(runtime.setLine(230), _emit_binary_op(_s, ({ type: "string", value: "opLte" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: ">=" }))) {
-(runtime.setLine(229), _emit_binary_op(_s, ({ type: "string", value: "opGte" })));
+(runtime.setLine(232), _emit_binary_op(_s, ({ type: "string", value: "opGte" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "+" }))) {
-(runtime.setLine(231), _emit_binary_op(_s, ({ type: "string", value: "opAdd" })));
+(runtime.setLine(234), _emit_binary_op(_s, ({ type: "string", value: "opAdd" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "-" }))) {
-(runtime.setLine(233), _emit_binary_op(_s, ({ type: "string", value: "opSub" })));
+(runtime.setLine(236), _emit_binary_op(_s, ({ type: "string", value: "opSub" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "not" }))) {
-let [, _expr] = runtime.assignValue(_s);
-(runtime.setLine(236), _emit(({ type: "string", value: "runtime.opNot(" })));
-(runtime.setLine(237), _emit_expr(_expr));
-(runtime.setLine(238), _emit(({ type: "string", value: ")" })));
+let r_104 = _s;
+let r_105 = r_104.values[0];
+let r_106 = r_104.values[1];
+let _expr = r_106;
+(runtime.setLine(239), _emit(({ type: "string", value: "runtime.opNot(" })));
+(runtime.setLine(240), _emit_expr(_expr));
+(runtime.setLine(241), _emit(({ type: "string", value: ")" })));
 } else {
-(runtime.setLine(240), _emit(({ type: "string", value: "({ type: \"list\", values: [" })));
-let _first = runtime.assignValue(({ type: "bool", value: true }));
-for (let _e of _s) {
+(runtime.setLine(243), _emit(({ type: "string", value: "({ type: \"list\", values: [" })));
+let r_107 = ({ type: "bool", value: true });
+let _first = r_107;
+for (let _e of _s.values) {
 if (runtime.opNot(_first)) {
-(runtime.setLine(244), _emit(({ type: "string", value: ", " })));
+(runtime.setLine(247), _emit(({ type: "string", value: ", " })));
 };
-(_first = runtime.assignValue(({ type: "bool", value: false })));
-(runtime.setLine(248), _emit_expr(_e));
+(_244 = runtime.assignValue(({ type: "bool", value: false })));
+(runtime.setLine(251), _emit_expr(_e));
 };
-(runtime.setLine(250), _emit(({ type: "string", value: "] })" })));
+(runtime.setLine(253), _emit(({ type: "string", value: "] })" })));
 }}}}}}}}}}}}}}}}}}}}}}};
 ;
 runtime.popCall();
 return { type: "null" };
 };
+function _emit_let_node(_pat, _base_reg) {
+runtime.pushCall("emit_let_node");
+let r_108 = _pat;
+let r_109 = r_108.values[0];
+let _pat_ty = r_109;
+let r_110 = r_108.values[1];
+let _line = r_110;
+if (runtime.opEq(_pat_ty, ({ type: "string", value: "ident" }))) {
+let r_111 = _pat;
+let r_112 = r_111.values[0];
+let r_113 = r_111.values[1];
+let r_114 = r_111.values[2];
+let _ident = r_114;
+if (runtime.opEq(_ident, ({ type: "string", value: "_" }))) {
+runtime.popCall();
+return { type: "null" }};
+(runtime.setLine(264), _emit((runtime.setLine(264), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: ";\nlet _% = r_%" }), _ident, _base_reg))));
+(runtime.setLine(265), _define_sym(_ident, ({ type: "list", values: [] })));
+} else {
+if (runtime.opEq(_pat_ty, ({ type: "string", value: "list" }))) {
+let r_115 = _pat;
+let r_116 = r_115.values[0];
+let r_117 = r_115.values[1];
+let r_118 = r_115.values[2];
+let _pats = r_118;
+let r_119 = ({ type: "int", value: 0 });
+let _i = r_119;
+for (let _pat of _pats.values) {
+let r_120 = (runtime.setLine(271), _let_node_reg_count());
+let _reg = r_120;
+(runtime.setLine(272), _let_node_reg_increment());
+(runtime.setLine(273), _emit((runtime.setLine(273), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: ";\nlet r_% = r_%.values[%]" }), _reg, _base_reg, _i))));
+(runtime.setLine(274), _emit_let_node(_pat, _reg));
+(_269 = runtime.assignValue(runtime.opAdd(_269, ({ type: "int", value: 1 }))));
+};
+} else {
+(runtime.setLine(278), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "malformed pattern on line %" }), _line));
+}};
+;
+runtime.popCall();
+return { type: "null" };
+};
 function _emit_binary_op(_s, _id) {
 runtime.pushCall("emit_binary_op");
-let [, _left, _right] = runtime.assignValue(_s);
-(runtime.setLine(256), _emit((runtime.setLine(256), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.%(" }), _id))));
-(runtime.setLine(257), _emit_expr(_left));
-(runtime.setLine(258), _emit(({ type: "string", value: ", " })));
-(runtime.setLine(259), _emit_expr(_right));
-(runtime.setLine(260), _emit(({ type: "string", value: ")" })));
+let r_121 = _s;
+let r_122 = r_121.values[0];
+let r_123 = r_121.values[1];
+let _left = r_123;
+let r_124 = r_121.values[2];
+let _right = r_124;
+(runtime.setLine(284), _emit((runtime.setLine(284), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.%(" }), _id))));
+(runtime.setLine(285), _emit_expr(_left));
+(runtime.setLine(286), _emit(({ type: "string", value: ", " })));
+(runtime.setLine(287), _emit_expr(_right));
+(runtime.setLine(288), _emit(({ type: "string", value: ")" })));
 ;
 runtime.popCall();
 return { type: "null" };
 };
 function _emit_assign_expr(_s, _line, _id) {
 runtime.pushCall("emit_assign_expr");
-let [, [_target_type], _expr] = runtime.assignValue(_s);
-if (runtime.opEq(_target_type, ({ type: "string", value: "ident" }))) {
-let [, [, , _ident]] = runtime.assignValue(_s);
-let _sym = runtime.assignValue((runtime.setLine(267), _get_sym(_ident)));
-if (runtime.opEq(_sym, ({ type: "null" }))) {
-(runtime.setLine(269), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "could not find symbol '%' on line %" }), _ident, _line));
+let r_125 = _s;
+let r_126 = r_125.values[0];
+let r_127 = r_125.values[1];
+let r_128 = r_127.values[0];
+let _target_type = r_128;
+let r_129 = r_125.values[2];
+let _expr = r_129;
+if (runtime.opNe(_target_type, ({ type: "string", value: "ident" }))) {
+(runtime.setLine(294), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "cannot assign to expression on line %" }), _line));
 };
-let [_sym_type, _sym_ident, ] = runtime.assignValue(_sym);
+let r_130 = _s;
+let r_131 = r_130.values[0];
+let r_132 = r_130.values[1];
+let r_133 = r_132.values[0];
+let r_134 = r_132.values[1];
+let r_135 = r_132.values[2];
+let _ident = r_135;
+let r_136 = (runtime.setLine(297), _get_sym(_ident));
+let _sym = r_136;
+if (runtime.opEq(_sym, ({ type: "null" }))) {
+(runtime.setLine(299), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "could not find symbol '%' on line %" }), _ident, _line));
+};
+let r_137 = _sym;
+let r_138 = r_137.values[0];
+let _sym_type = r_138;
+let r_139 = r_137.values[1];
+let _sym_ident = r_139;
+let r_140 = r_137.values[2];
 if (runtime.opEq(_sym_type, ({ type: "string", value: "let" }))) {
-(runtime.setLine(273), _emit((runtime.setLine(273), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(_% = runtime.assignValue(" }), _sym_ident))));
+(runtime.setLine(303), _emit((runtime.setLine(303), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "(_% = runtime.assignValue(" }), _sym_ident))));
 if (runtime.opEq(_id, ({ type: "string", value: "=" }))) {
-(runtime.setLine(275), _emit_expr(_expr));
+(runtime.setLine(305), _emit_expr(_expr));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "+" }))) {
-(runtime.setLine(277), _emit((runtime.setLine(277), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.opAdd(_%, " }), _sym_ident))));
-(runtime.setLine(278), _emit_expr(_expr));
-(runtime.setLine(279), _emit(({ type: "string", value: ")" })));
+(runtime.setLine(307), _emit((runtime.setLine(307), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.opAdd(_%, " }), _sym_ident))));
+(runtime.setLine(308), _emit_expr(_expr));
+(runtime.setLine(309), _emit(({ type: "string", value: ")" })));
 } else {
 if (runtime.opEq(_id, ({ type: "string", value: "-" }))) {
-(runtime.setLine(281), _emit((runtime.setLine(281), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.opSub(_%, " }), _sym_ident))));
-(runtime.setLine(282), _emit_expr(_expr));
-(runtime.setLine(283), _emit(({ type: "string", value: ")" })));
+(runtime.setLine(311), _emit((runtime.setLine(311), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "runtime.opSub(_%, " }), _sym_ident))));
+(runtime.setLine(312), _emit_expr(_expr));
+(runtime.setLine(313), _emit(({ type: "string", value: ")" })));
 } else {
-(runtime.setLine(285), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "not implemented" })));
+(runtime.setLine(315), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "not implemented" })));
 }}};
-(runtime.setLine(287), _emit(({ type: "string", value: "))" })));
+(runtime.setLine(317), _emit(({ type: "string", value: "))" })));
 } else {
-(runtime.setLine(289), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "cannot assign to symbol '%' on line %" }), _sym_ident, _line));
-};
-} else {
-(runtime.setLine(292), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "cannot assign to expression on line %" }), _line));
+(runtime.setLine(319), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "cannot assign to symbol '%' on line %" }), _sym_ident, _line));
 };
 ;
 runtime.popCall();
@@ -340,30 +535,42 @@ return { type: "null" };
 };
 function _emit_pat(_pat) {
 runtime.pushCall("emit_pat");
-let [_ty] = runtime.assignValue(_pat);
+let r_141 = _pat;
+let r_142 = r_141.values[0];
+let _ty = r_142;
 if (runtime.opEq(_ty, ({ type: "string", value: "ident" }))) {
-let [, _line, _name] = runtime.assignValue(_pat);
+let r_143 = _pat;
+let r_144 = r_143.values[0];
+let r_145 = r_143.values[1];
+let _line = r_145;
+let r_146 = r_143.values[2];
+let _name = r_146;
 if (runtime.opEq(_name, ({ type: "string", value: "_" }))) {
 runtime.popCall();
 return { type: "null" };
 };
-(runtime.setLine(303), _emit((runtime.setLine(303), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _name))));
-(runtime.setLine(304), _define_sym(_name, ({ type: "list", values: [] })));
+(runtime.setLine(330), _emit((runtime.setLine(330), ((...args) => runtime.builtinFormat(...args))(({ type: "string", value: "_%" }), _name))));
+(runtime.setLine(331), _define_sym(_name, ({ type: "list", values: [] })));
 } else {
 if (runtime.opEq(_ty, ({ type: "string", value: "list" }))) {
-let [, , _pats] = runtime.assignValue(_pat);
-(runtime.setLine(307), _emit(({ type: "string", value: "[" })));
-let _first = runtime.assignValue(({ type: "bool", value: true }));
-for (let _pat of _pats) {
+let r_147 = _pat;
+let r_148 = r_147.values[0];
+let r_149 = r_147.values[1];
+let r_150 = r_147.values[2];
+let _pats = r_150;
+(runtime.setLine(334), _emit(({ type: "string", value: "[" })));
+let r_151 = ({ type: "bool", value: true });
+let _first = r_151;
+for (let _pat of _pats.values) {
 if (runtime.opNot(_first)) {
-(runtime.setLine(311), _emit(({ type: "string", value: ", " })));
+(runtime.setLine(338), _emit(({ type: "string", value: ", " })));
 };
-(_first = runtime.assignValue(({ type: "bool", value: false })));
-(runtime.setLine(315), _emit_pat(_pat));
+(_335 = runtime.assignValue(({ type: "bool", value: false })));
+(runtime.setLine(342), _emit_pat(_pat));
 };
-(runtime.setLine(317), _emit(({ type: "string", value: "]" })));
+(runtime.setLine(344), _emit(({ type: "string", value: "]" })));
 } else {
-(runtime.setLine(319), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "cannot assign to '%'" }), _pat));
+(runtime.setLine(346), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "cannot assign to '%'" }), _pat));
 }};
 ;
 runtime.popCall();
@@ -371,7 +578,7 @@ return { type: "null" };
 };
 function _emit(_str) {
 runtime.pushCall("emit");
-(runtime.setLine(324), ((...args) => runtime.builtinPush(...args))(_output, _str));
+(runtime.setLine(351), ((...args) => runtime.builtinPush(...args))(_output, _str));
 ;
 runtime.popCall();
 return { type: "null" };
@@ -382,61 +589,106 @@ return ({ type: "list", values: [_generate] });
 runtime.popCall();
 return { type: "null" };
 };
+function _Counter() {
+runtime.pushCall("Counter");
+let r_152 = ({ type: "int", value: 0 });
+let _counter = r_152;
+function _count() {
+runtime.pushCall("count");
+runtime.popCall();
+return _counter;
+;
+runtime.popCall();
+return { type: "null" };
+};
+function _increment() {
+runtime.pushCall("increment");
+(_358 = runtime.assignValue(runtime.opAdd(_358, ({ type: "int", value: 1 }))));
+;
+runtime.popCall();
+return { type: "null" };
+};
+runtime.popCall();
+return ({ type: "list", values: [_count, _increment] });
+;
+runtime.popCall();
+return { type: "null" };
+};
 function _Syms() {
 runtime.pushCall("Syms");
-let _syms = runtime.assignValue(({ type: "list", values: [({ type: "null" }), ({ type: "list", values: [] })] }));
+let r_153 = ({ type: "list", values: [({ type: "null" }), ({ type: "list", values: [] })] });
+let _syms = r_153;
 function _enter_scope() {
 runtime.pushCall("enter_scope");
-(_syms = runtime.assignValue(({ type: "list", values: [_syms, ({ type: "list", values: [] })] })));
+(_372 = runtime.assignValue(({ type: "list", values: [_syms, ({ type: "list", values: [] })] })));
 ;
 runtime.popCall();
 return { type: "null" };
 };
 function _leave_scope() {
 runtime.pushCall("leave_scope");
-let [_parent, ] = runtime.assignValue(_syms);
-(_syms = runtime.assignValue(_parent));
+let r_154 = _syms;
+let r_155 = r_154.values[0];
+let _parent = r_155;
+let r_156 = r_154.values[1];
+(_372 = runtime.assignValue(_parent));
 ;
 runtime.popCall();
 return { type: "null" };
 };
 function _define(_ident, _sym) {
 runtime.pushCall("define");
-let [, _syms] = runtime.assignValue(_syms);
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
+let r_157 = _syms;
+let r_158 = r_157.values[0];
+let r_159 = r_157.values[1];
+let _syms = r_159;
+let r_160 = ({ type: "int", value: 0 });
+let _i = r_160;
 while (true) {
-if (runtime.opGte(_i, (runtime.setLine(361), ((...args) => runtime.builtinLen(...args))(_syms)))) {
+if (runtime.opGte(_i, (runtime.setLine(402), ((...args) => runtime.builtinLen(...args))(_syms)))) {
 break};
-let [_s_ident, ] = runtime.assignValue((runtime.setLine(362), ((...args) => runtime.builtinAt(...args))(_syms, _i)));
+let r_161 = (runtime.setLine(403), ((...args) => runtime.builtinAt(...args))(_syms, _i));
+let r_162 = r_161.values[0];
+let _s_ident = r_162;
+let r_163 = r_161.values[1];
 if (runtime.opEq(_ident, _s_ident)) {
-(runtime.setLine(364), ((...args) => runtime.builtinSet(...args))(_syms, _i, ({ type: "list", values: [_ident, _sym] })));
+(runtime.setLine(405), ((...args) => runtime.builtinSet(...args))(_syms, _i, ({ type: "list", values: [_ident, _sym] })));
 runtime.popCall();
 return { type: "null" };
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_400 = runtime.assignValue(runtime.opAdd(_400, ({ type: "int", value: 1 }))));
 };
-(runtime.setLine(369), ((...args) => runtime.builtinPush(...args))(_syms, ({ type: "list", values: [_ident, _sym] })));
+(runtime.setLine(410), ((...args) => runtime.builtinPush(...args))(_syms, ({ type: "list", values: [_ident, _sym] })));
 ;
 runtime.popCall();
 return { type: "null" };
 };
 function _find_sym(_syms, _ident) {
 runtime.pushCall("find_sym");
-let [_parent, _map] = runtime.assignValue(_syms);
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
+let r_164 = _syms;
+let r_165 = r_164.values[0];
+let _parent = r_165;
+let r_166 = r_164.values[1];
+let _map = r_166;
+let r_167 = ({ type: "int", value: 0 });
+let _i = r_167;
 while (true) {
-if (runtime.opGte(_i, (runtime.setLine(376), ((...args) => runtime.builtinLen(...args))(_map)))) {
+if (runtime.opGte(_i, (runtime.setLine(417), ((...args) => runtime.builtinLen(...args))(_map)))) {
 break};
-let [_s_ident, _s_sym] = runtime.assignValue((runtime.setLine(377), ((...args) => runtime.builtinAt(...args))(_map, _i)));
+let r_168 = (runtime.setLine(418), ((...args) => runtime.builtinAt(...args))(_map, _i));
+let r_169 = r_168.values[0];
+let _s_ident = r_169;
+let r_170 = r_168.values[1];
+let _s_sym = r_170;
 if (runtime.opEq(_ident, _s_ident)) {
 runtime.popCall();
 return _s_sym;
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_415 = runtime.assignValue(runtime.opAdd(_415, ({ type: "int", value: 1 }))));
 };
 if (runtime.opNe(_parent, ({ type: "null" }))) {
 runtime.popCall();
-return (runtime.setLine(384), _find_sym(_parent, _ident));
+return (runtime.setLine(425), _find_sym(_parent, _ident));
 };
 runtime.popCall();
 return ({ type: "null" });
@@ -447,47 +699,75 @@ return { type: "null" };
 function _get(_ident) {
 runtime.pushCall("get");
 runtime.popCall();
-return (runtime.setLine(390), _find_sym(_syms, _ident));
+return (runtime.setLine(431), _find_sym(_syms, _ident));
+;
+runtime.popCall();
+return { type: "null" };
+};
+function _print_syms_node(_syms, _depth) {
+runtime.pushCall("print_syms_node");
+let r_171 = _syms;
+let r_172 = r_171.values[0];
+let _parent = r_172;
+let r_173 = r_171.values[1];
+let _map = r_173;
+for (let [_ident, _sym] of _map.values) {
+(runtime.setLine(437), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%- %: %" }), (runtime.setLine(437), _indent(_depth)), _ident, _sym));
+};
+if (runtime.opNe(_parent, ({ type: "null" }))) {
+(runtime.setLine(440), _print_syms_node(_parent, runtime.opAdd(_depth, ({ type: "int", value: 1 }))));
+};
+;
+runtime.popCall();
+return { type: "null" };
+};
+function _print_syms() {
+runtime.pushCall("print_syms");
+(runtime.setLine(445), _print_syms_node(_syms, ({ type: "int", value: 0 })));
 ;
 runtime.popCall();
 return { type: "null" };
 };
 runtime.popCall();
-return ({ type: "list", values: [_enter_scope, _leave_scope, _define, _get] });
+return ({ type: "list", values: [_enter_scope, _leave_scope, _define, _get, _print_syms] });
 ;
 runtime.popCall();
 return { type: "null" };
 };
 function _string_escape(_str) {
 runtime.pushCall("string_escape");
-let _str_len = runtime.assignValue((runtime.setLine(403), ((...args) => runtime.builtinLen(...args))(_str)));
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
-let _result = runtime.assignValue(({ type: "string", value: "" }));
+let r_174 = (runtime.setLine(459), ((...args) => runtime.builtinLen(...args))(_str));
+let _str_len = r_174;
+let r_175 = ({ type: "int", value: 0 });
+let _i = r_175;
+let r_176 = ({ type: "string", value: "" });
+let _result = r_176;
 while (true) {
 if (runtime.opGte(_i, _str_len)) {
 break};
-let _ch = runtime.assignValue((runtime.setLine(408), ((...args) => runtime.builtinAt(...args))(_str, _i)));
+let r_177 = (runtime.setLine(464), ((...args) => runtime.builtinAt(...args))(_str, _i));
+let _ch = r_177;
 if (runtime.opEq(_ch, ({ type: "string", value: "\\" }))) {
-(_result = runtime.assignValue(runtime.opAdd(_result, ({ type: "string", value: "\\\\" }))));
+(_461 = runtime.assignValue(runtime.opAdd(_461, ({ type: "string", value: "\\\\" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "\"" }))) {
-(_result = runtime.assignValue(runtime.opAdd(_result, ({ type: "string", value: "\\\"" }))));
+(_461 = runtime.assignValue(runtime.opAdd(_461, ({ type: "string", value: "\\\"" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "\t" }))) {
-(_result = runtime.assignValue(runtime.opAdd(_result, ({ type: "string", value: "\\t" }))));
+(_461 = runtime.assignValue(runtime.opAdd(_461, ({ type: "string", value: "\\t" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "\r" }))) {
-(_result = runtime.assignValue(runtime.opAdd(_result, ({ type: "string", value: "\\r" }))));
+(_461 = runtime.assignValue(runtime.opAdd(_461, ({ type: "string", value: "\\r" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "\n" }))) {
-(_result = runtime.assignValue(runtime.opAdd(_result, ({ type: "string", value: "\\n" }))));
+(_461 = runtime.assignValue(runtime.opAdd(_461, ({ type: "string", value: "\\n" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "\n" }))) {
-(_result = runtime.assignValue(runtime.opAdd(_result, ({ type: "string", value: "\\0" }))));
+(_461 = runtime.assignValue(runtime.opAdd(_461, ({ type: "string", value: "\\0" }))));
 } else {
-(_result = runtime.assignValue(runtime.opAdd(_result, _ch)));
+(_461 = runtime.assignValue(runtime.opAdd(_461, _ch)));
 }}}}}};
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_460 = runtime.assignValue(runtime.opAdd(_460, ({ type: "int", value: 1 }))));
 };
 runtime.popCall();
 return _result;
@@ -497,15 +777,18 @@ return { type: "null" };
 };
 function _Parser(_tokens) {
 runtime.pushCall("Parser");
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
-let _tok = runtime.assignValue((runtime.setLine(431), ((...args) => runtime.builtinAt(...args))(_tokens, _i)));
+let r_178 = ({ type: "int", value: 0 });
+let _i = r_178;
+let r_179 = (runtime.setLine(487), ((...args) => runtime.builtinAt(...args))(_tokens, _i));
+let _tok = r_179;
 function _parse() {
 runtime.pushCall("parse");
-let _exprs = runtime.assignValue(({ type: "list", values: [] }));
+let r_180 = ({ type: "list", values: [] });
+let _exprs = r_180;
 while (true) {
-if ((runtime.setLine(436), _done())) {
+if ((runtime.setLine(492), _done())) {
 break};
-(runtime.setLine(437), ((...args) => runtime.builtinPush(...args))(_exprs, (runtime.setLine(437), _parse_expr())));
+(runtime.setLine(493), ((...args) => runtime.builtinPush(...args))(_exprs, (runtime.setLine(493), _parse_expr())));
 };
 runtime.popCall();
 return _exprs;
@@ -515,33 +798,40 @@ return { type: "null" };
 };
 function _parse_expr() {
 runtime.pushCall("parse_expr");
-let [_ty, _line, _value] = runtime.assignValue(_tok);
-if ((runtime.setLine(444), _eat(({ type: "string", value: "(" })))) {
-let _values = runtime.assignValue(({ type: "list", values: [] }));
+let r_181 = _tok;
+let r_182 = r_181.values[0];
+let _ty = r_182;
+let r_183 = r_181.values[1];
+let _line = r_183;
+let r_184 = r_181.values[2];
+let _value = r_184;
+if ((runtime.setLine(500), _eat(({ type: "string", value: "(" })))) {
+let r_185 = ({ type: "list", values: [] });
+let _values = r_185;
 while (true) {
-if ((runtime.setLine(447), _test(({ type: "string", value: ")" })))) {
+if ((runtime.setLine(503), _test(({ type: "string", value: ")" })))) {
 break};
-(runtime.setLine(448), ((...args) => runtime.builtinPush(...args))(_values, (runtime.setLine(448), _parse_expr())));
+(runtime.setLine(504), ((...args) => runtime.builtinPush(...args))(_values, (runtime.setLine(504), _parse_expr())));
 };
-if (runtime.opNot((runtime.setLine(450), _eat(({ type: "string", value: ")" }))))) {
-(runtime.setLine(451), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "expected ')' on line %" }), (runtime.setLine(451), ((...args) => runtime.builtinAt(...args))(_tok, ({ type: "int", value: 1 })))));
+if (runtime.opNot((runtime.setLine(506), _eat(({ type: "string", value: ")" }))))) {
+(runtime.setLine(507), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "expected ')' on line %" }), (runtime.setLine(507), ((...args) => runtime.builtinAt(...args))(_tok, ({ type: "int", value: 1 })))));
 };
 runtime.popCall();
 return ({ type: "list", values: [] });
 } else {
-if ((runtime.setLine(454), _eat(({ type: "string", value: "string" })))) {
+if ((runtime.setLine(510), _eat(({ type: "string", value: "string" })))) {
 runtime.popCall();
 return ({ type: "list", values: [] });
 } else {
-if ((runtime.setLine(456), _eat(({ type: "string", value: "int" })))) {
+if ((runtime.setLine(512), _eat(({ type: "string", value: "int" })))) {
 runtime.popCall();
 return ({ type: "list", values: [] });
 } else {
-if ((runtime.setLine(458), _eat(({ type: "string", value: "ident" })))) {
+if ((runtime.setLine(514), _eat(({ type: "string", value: "ident" })))) {
 runtime.popCall();
 return ({ type: "list", values: [] });
 } else {
-(runtime.setLine(461), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "expected expression, got '%' on line %" }), _ty, _line));
+(runtime.setLine(517), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "expected expression, got '%' on line %" }), _ty, _line));
 }}}};
 ;
 runtime.popCall();
@@ -549,10 +839,10 @@ return { type: "null" };
 };
 function _eat(_pat) {
 runtime.pushCall("eat");
-if (runtime.opNot((runtime.setLine(466), _test(_pat)))) {
+if (runtime.opNot((runtime.setLine(522), _test(_pat)))) {
 runtime.popCall();
 return ({ type: "bool", value: false })};
-(runtime.setLine(467), _step());
+(runtime.setLine(523), _step());
 runtime.popCall();
 return ({ type: "bool", value: true });
 ;
@@ -561,10 +851,11 @@ return { type: "null" };
 };
 function _step() {
 runtime.pushCall("step");
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
-if (runtime.opNot((runtime.setLine(473), _done()))) {
-let _new_tok = runtime.assignValue((runtime.setLine(474), ((...args) => runtime.builtinAt(...args))(_tokens, _i)));
-(_tok = runtime.assignValue(_new_tok));
+(_486 = runtime.assignValue(runtime.opAdd(_486, ({ type: "int", value: 1 }))));
+if (runtime.opNot((runtime.setLine(529), _done()))) {
+let r_186 = (runtime.setLine(530), ((...args) => runtime.builtinAt(...args))(_tokens, _i));
+let _new_tok = r_186;
+(_487 = runtime.assignValue(_new_tok));
 };
 ;
 runtime.popCall();
@@ -572,10 +863,12 @@ return { type: "null" };
 };
 function _test(_pat) {
 runtime.pushCall("test");
-if ((runtime.setLine(480), _done())) {
+if ((runtime.setLine(536), _done())) {
 runtime.popCall();
 return ({ type: "bool", value: false })};
-let [_ty] = runtime.assignValue(_tok);
+let r_187 = _tok;
+let r_188 = r_187.values[0];
+let _ty = r_188;
 runtime.popCall();
 return runtime.opEq(_pat, _ty);
 ;
@@ -585,7 +878,7 @@ return { type: "null" };
 function _done() {
 runtime.pushCall("done");
 runtime.popCall();
-return runtime.opGte(_i, (runtime.setLine(486), ((...args) => runtime.builtinLen(...args))(_tokens)));
+return runtime.opGte(_i, (runtime.setLine(542), ((...args) => runtime.builtinLen(...args))(_tokens)));
 ;
 runtime.popCall();
 return { type: "null" };
@@ -598,99 +891,108 @@ return { type: "null" };
 };
 function _tokenize(_text) {
 runtime.pushCall("tokenize");
-let _text_len = runtime.assignValue((runtime.setLine(493), ((...args) => runtime.builtinLen(...args))(_text)));
-let _tokens = runtime.assignValue(({ type: "list", values: [] }));
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
-let _line = runtime.assignValue(({ type: "int", value: 1 }));
-let _ident_chars = runtime.assignValue(runtime.opAdd(({ type: "string", value: "abcdefghijklmnopqrstuvwxyz" }), ({ type: "string", value: "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890+-*/%&|=?!<>'_" })));
+let r_189 = (runtime.setLine(549), ((...args) => runtime.builtinLen(...args))(_text));
+let _text_len = r_189;
+let r_190 = ({ type: "list", values: [] });
+let _tokens = r_190;
+let r_191 = ({ type: "int", value: 0 });
+let _i = r_191;
+let r_192 = ({ type: "int", value: 1 });
+let _line = r_192;
+let r_193 = runtime.opAdd(({ type: "string", value: "abcdefghijklmnopqrstuvwxyz" }), ({ type: "string", value: "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890+-*/%&|=?!<>'_" }));
+let _ident_chars = r_193;
 while (true) {
 if (runtime.opGte(_i, _text_len)) {
 break};
-let _ch = runtime.assignValue((runtime.setLine(505), ((...args) => runtime.builtinAt(...args))(_text, _i)));
-if ((runtime.setLine(507), _contains(({ type: "string", value: " \t\r\n" }), _ch))) {
+let r_194 = (runtime.setLine(561), ((...args) => runtime.builtinAt(...args))(_text, _i));
+let _ch = r_194;
+if ((runtime.setLine(563), _contains(({ type: "string", value: " \t\r\n" }), _ch))) {
 if (runtime.opEq(_ch, ({ type: "string", value: "\n" }))) {
-(_line = runtime.assignValue(runtime.opAdd(_line, ({ type: "int", value: 1 }))));
+(_553 = runtime.assignValue(runtime.opAdd(_553, ({ type: "int", value: 1 }))));
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 } else {
-if ((runtime.setLine(512), _slice_eq(_text, _i, ({ type: "string", value: "//" })))) {
+if ((runtime.setLine(568), _slice_eq(_text, _i, ({ type: "string", value: "//" })))) {
 while (true) {
-if ((runtime.setLine(514), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opEq((runtime.setLine(514), ((...args) => runtime.builtinAt(...args))(_text, _i)), ({ type: "string", value: "\n" }))) })) {
+if ((runtime.setLine(570), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opEq((runtime.setLine(570), ((...args) => runtime.builtinAt(...args))(_text, _i)), ({ type: "string", value: "\n" }))) })) {
 break;
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 };
 } else {
-if ((runtime.setLine(519), _contains(({ type: "string", value: "()" }), _ch))) {
-(runtime.setLine(520), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [_ch, _line] })));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+if ((runtime.setLine(575), _contains(({ type: "string", value: "()" }), _ch))) {
+(runtime.setLine(576), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [_ch, _line] })));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "\"" }))) {
-let _value = runtime.assignValue(({ type: "string", value: "" }));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
-(_ch = runtime.assignValue((runtime.setLine(525), ((...args) => runtime.builtinAt(...args))(_text, _i))));
+let r_195 = ({ type: "string", value: "" });
+let _value = r_195;
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
+(_561 = runtime.assignValue((runtime.setLine(581), ((...args) => runtime.builtinAt(...args))(_text, _i))));
 while (true) {
-if ((runtime.setLine(527), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opEq(_ch, ({ type: "string", value: "\"" }))) })) {
+if ((runtime.setLine(583), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opEq(_ch, ({ type: "string", value: "\"" }))) })) {
 break;
 };
 if (runtime.opEq(_ch, ({ type: "string", value: "\\" }))) {
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 if (runtime.opGte(_i, _text_len)) {
 break;
 };
-(_ch = runtime.assignValue((runtime.setLine(535), ((...args) => runtime.builtinAt(...args))(_text, _i))));
+(_561 = runtime.assignValue((runtime.setLine(591), ((...args) => runtime.builtinAt(...args))(_text, _i))));
 if (runtime.opEq(_ch, ({ type: "string", value: "t" }))) {
-(_value = runtime.assignValue(runtime.opAdd(_value, ({ type: "string", value: "\t" }))));
+(_579 = runtime.assignValue(runtime.opAdd(_579, ({ type: "string", value: "\t" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "r" }))) {
-(_value = runtime.assignValue(runtime.opAdd(_value, ({ type: "string", value: "\r" }))));
+(_579 = runtime.assignValue(runtime.opAdd(_579, ({ type: "string", value: "\r" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "n" }))) {
-(_value = runtime.assignValue(runtime.opAdd(_value, ({ type: "string", value: "\n" }))));
+(_579 = runtime.assignValue(runtime.opAdd(_579, ({ type: "string", value: "\n" }))));
 } else {
 if (runtime.opEq(_ch, ({ type: "string", value: "0" }))) {
-(_value = runtime.assignValue(runtime.opAdd(_value, ({ type: "string", value: "\n" }))));
+(_579 = runtime.assignValue(runtime.opAdd(_579, ({ type: "string", value: "\n" }))));
 } else {
-(_value = runtime.assignValue(runtime.opAdd(_value, _ch)));
+(_579 = runtime.assignValue(runtime.opAdd(_579, _ch)));
 }}}};
 } else {
-(_value = runtime.assignValue(runtime.opAdd(_value, _ch)));
+(_579 = runtime.assignValue(runtime.opAdd(_579, _ch)));
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
-(_ch = runtime.assignValue((runtime.setLine(551), ((...args) => runtime.builtinAt(...args))(_text, _i))));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
+(_561 = runtime.assignValue((runtime.setLine(607), ((...args) => runtime.builtinAt(...args))(_text, _i))));
 };
-if ((runtime.setLine(553), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opNe(_ch, ({ type: "string", value: "\"" }))) })) {
-(runtime.setLine(554), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "expected '\"' on line %" }), _line));
+if ((runtime.setLine(609), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opNe(_ch, ({ type: "string", value: "\"" }))) })) {
+(runtime.setLine(610), ((...args) => runtime.builtinPanic(...args))(({ type: "string", value: "expected '\"' on line %" }), _line));
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
-(runtime.setLine(557), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [] })));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
+(runtime.setLine(613), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [] })));
 } else {
-if ((runtime.setLine(558), _contains(({ type: "string", value: "0123456789" }), _ch))) {
-let _value = runtime.assignValue(({ type: "string", value: "" }));
+if ((runtime.setLine(614), _contains(({ type: "string", value: "0123456789" }), _ch))) {
+let r_196 = ({ type: "string", value: "" });
+let _value = r_196;
 while (true) {
-(_ch = runtime.assignValue((runtime.setLine(561), ((...args) => runtime.builtinAt(...args))(_text, _i))));
-if ((runtime.setLine(562), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opNot((runtime.setLine(562), _contains(({ type: "string", value: "0123456789" }), _ch)))) })) {
+(_561 = runtime.assignValue((runtime.setLine(617), ((...args) => runtime.builtinAt(...args))(_text, _i))));
+if ((runtime.setLine(618), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opNot((runtime.setLine(618), _contains(({ type: "string", value: "0123456789" }), _ch)))) })) {
 break;
 };
-(_value = runtime.assignValue(runtime.opAdd(_value, _ch)));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_615 = runtime.assignValue(runtime.opAdd(_615, _ch)));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 };
-(runtime.setLine(568), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [] })));
+(runtime.setLine(624), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [] })));
 } else {
-if ((runtime.setLine(569), _contains(_ident_chars, _ch))) {
-let _value = runtime.assignValue(({ type: "string", value: "" }));
+if ((runtime.setLine(625), _contains(_ident_chars, _ch))) {
+let r_197 = ({ type: "string", value: "" });
+let _value = r_197;
 while (true) {
-(_ch = runtime.assignValue((runtime.setLine(572), ((...args) => runtime.builtinAt(...args))(_text, _i))));
-if ((runtime.setLine(573), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opNot((runtime.setLine(573), _contains(_ident_chars, _ch)))) })) {
+(_561 = runtime.assignValue((runtime.setLine(628), ((...args) => runtime.builtinAt(...args))(_text, _i))));
+if ((runtime.setLine(629), { type: "bool", value: this.runtime.truthy(runtime.opGte(_i, _text_len)) || this.runtime.falsy(runtime.opNot((runtime.setLine(629), _contains(_ident_chars, _ch)))) })) {
 break;
 };
-(_value = runtime.assignValue(runtime.opAdd(_value, _ch)));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_626 = runtime.assignValue(runtime.opAdd(_626, _ch)));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 };
-(runtime.setLine(579), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [] })));
+(runtime.setLine(635), ((...args) => runtime.builtinPush(...args))(_tokens, ({ type: "list", values: [] })));
 } else {
-(runtime.setLine(581), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "illegal char '%'" }), _ch));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(runtime.setLine(637), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "illegal char '%'" }), _ch));
+(_552 = runtime.assignValue(runtime.opAdd(_552, ({ type: "int", value: 1 }))));
 }}}}}};
 };
 runtime.popCall();
@@ -701,16 +1003,18 @@ return { type: "null" };
 };
 function _contains(_text, _ch) {
 runtime.pushCall("contains");
-let _text_len = runtime.assignValue((runtime.setLine(590), ((...args) => runtime.builtinLen(...args))(_text)));
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
+let r_198 = (runtime.setLine(645), ((...args) => runtime.builtinLen(...args))(_text));
+let _text_len = r_198;
+let r_199 = ({ type: "int", value: 0 });
+let _i = r_199;
 while (true) {
 if (runtime.opGte(_i, _text_len)) {
 break};
-if (runtime.opEq((runtime.setLine(594), ((...args) => runtime.builtinAt(...args))(_text, _i)), _ch)) {
+if (runtime.opEq((runtime.setLine(649), ((...args) => runtime.builtinAt(...args))(_text, _i)), _ch)) {
 runtime.popCall();
 return ({ type: "bool", value: true });
 };
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_646 = runtime.assignValue(runtime.opAdd(_646, ({ type: "int", value: 1 }))));
 };
 runtime.popCall();
 return ({ type: "bool", value: false });
@@ -720,9 +1024,12 @@ return { type: "null" };
 };
 function _slice_eq(_str, _slice_idx, _substr) {
 runtime.pushCall("slice_eq");
-let _str_len = runtime.assignValue((runtime.setLine(603), ((...args) => runtime.builtinLen(...args))(_str)));
-let _substr_len = runtime.assignValue((runtime.setLine(604), ((...args) => runtime.builtinLen(...args))(_substr)));
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
+let r_200 = (runtime.setLine(658), ((...args) => runtime.builtinLen(...args))(_str));
+let _str_len = r_200;
+let r_201 = (runtime.setLine(659), ((...args) => runtime.builtinLen(...args))(_substr));
+let _substr_len = r_201;
+let r_202 = ({ type: "int", value: 0 });
+let _i = r_202;
 while (true) {
 if (runtime.opGte(_i, _substr_len)) {
 runtime.popCall();
@@ -730,10 +1037,10 @@ return ({ type: "bool", value: true })};
 if (runtime.opGte(runtime.opAdd(_slice_idx, _i), _str_len)) {
 runtime.popCall();
 return ({ type: "bool", value: false })};
-if (runtime.opNe((runtime.setLine(611), ((...args) => runtime.builtinAt(...args))(_str, runtime.opAdd(_slice_idx, _i))), (runtime.setLine(611), ((...args) => runtime.builtinAt(...args))(_substr, _i)))) {
+if (runtime.opNe((runtime.setLine(666), ((...args) => runtime.builtinAt(...args))(_str, runtime.opAdd(_slice_idx, _i))), (runtime.setLine(666), ((...args) => runtime.builtinAt(...args))(_substr, _i)))) {
 runtime.popCall();
 return ({ type: "bool", value: false })};
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_660 = runtime.assignValue(runtime.opAdd(_660, ({ type: "int", value: 1 }))));
 };
 runtime.popCall();
 return ({ type: "bool", value: true });
@@ -743,15 +1050,21 @@ return { type: "null" };
 };
 function _print_expr(_expr, _depth) {
 runtime.pushCall("print_expr");
-let [_ty, _line, _value] = runtime.assignValue(_expr);
+let r_203 = _expr;
+let r_204 = r_203.values[0];
+let _ty = r_204;
+let r_205 = r_203.values[1];
+let _line = r_205;
+let r_206 = r_203.values[2];
+let _value = r_206;
 if (runtime.opEq(_ty, ({ type: "string", value: "list" }))) {
-(runtime.setLine(621), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%(% %" }), (runtime.setLine(621), _indent(_depth)), _ty, _line));
-for (let _e of _value) {
-(runtime.setLine(623), _print_expr(_e, runtime.opAdd(_depth, ({ type: "int", value: 1 }))));
+(runtime.setLine(676), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%(% %" }), (runtime.setLine(676), _indent(_depth)), _ty, _line));
+for (let _e of _value.values) {
+(runtime.setLine(678), _print_expr(_e, runtime.opAdd(_depth, ({ type: "int", value: 1 }))));
 };
-(runtime.setLine(625), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%)" }), (runtime.setLine(625), _indent(_depth))));
+(runtime.setLine(680), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%)" }), (runtime.setLine(680), _indent(_depth))));
 } else {
-(runtime.setLine(627), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%%" }), (runtime.setLine(627), _indent(_depth)), _expr));
+(runtime.setLine(682), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "%%" }), (runtime.setLine(682), _indent(_depth)), _expr));
 };
 ;
 runtime.popCall();
@@ -759,13 +1072,15 @@ return { type: "null" };
 };
 function _indent(_depth) {
 runtime.pushCall("indent");
-let _space = runtime.assignValue(({ type: "string", value: "" }));
-let _i = runtime.assignValue(({ type: "int", value: 0 }));
+let r_207 = ({ type: "string", value: "" });
+let _space = r_207;
+let r_208 = ({ type: "int", value: 0 });
+let _i = r_208;
 while (true) {
 if (runtime.opGte(_i, _depth)) {
 break};
-(_space = runtime.assignValue(runtime.opAdd(_space, ({ type: "string", value: "  " }))));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(_687 = runtime.assignValue(runtime.opAdd(_687, ({ type: "string", value: "  " }))));
+(_688 = runtime.assignValue(runtime.opAdd(_688, ({ type: "int", value: 1 }))));
 };
 runtime.popCall();
 return _space;
@@ -775,14 +1090,17 @@ return { type: "null" };
 };
 function _slice(_list, _idx) {
 runtime.pushCall("slice");
-let _list_len = runtime.assignValue((runtime.setLine(643), ((...args) => runtime.builtinLen(...args))(_list)));
-let _elems = runtime.assignValue(({ type: "list", values: [] }));
-let _i = runtime.assignValue(_idx);
+let r_209 = (runtime.setLine(698), ((...args) => runtime.builtinLen(...args))(_list));
+let _list_len = r_209;
+let r_210 = ({ type: "list", values: [] });
+let _elems = r_210;
+let r_211 = _idx;
+let _i = r_211;
 while (true) {
 if (runtime.opGte(_i, _list_len)) {
 break};
-(runtime.setLine(648), ((...args) => runtime.builtinPush(...args))(_elems, (runtime.setLine(648), ((...args) => runtime.builtinAt(...args))(_list, _i))));
-(_i = runtime.assignValue(runtime.opAdd(_i, ({ type: "int", value: 1 }))));
+(runtime.setLine(703), ((...args) => runtime.builtinPush(...args))(_elems, (runtime.setLine(703), ((...args) => runtime.builtinAt(...args))(_list, _i))));
+(_700 = runtime.assignValue(runtime.opAdd(_700, ({ type: "int", value: 1 }))));
 };
 runtime.popCall();
 return _elems;
@@ -790,24 +1108,43 @@ return _elems;
 runtime.popCall();
 return { type: "null" };
 };
-let _silent = runtime.assignValue(({ type: "bool", value: true }));
-let [_input_filename, _output_filename] = runtime.assignValue((runtime.setLine(656), ((...args) => runtime.builtinGetArgs(...args))()));
+let r_212 = ({ type: "bool", value: true });
+let _silent = r_212;
+let r_213 = (runtime.setLine(711), ((...args) => runtime.builtinGetArgs(...args))());
+let r_214 = r_213.values[0];
+let _input_filename = r_214;
+let r_215 = r_213.values[1];
+let _output_filename = r_215;
 if (runtime.opNot(_silent)) {
-(runtime.setLine(658), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "reading file..." })))};
-let _text = runtime.assignValue((runtime.setLine(659), ((...args) => runtime.builtinReadTextFile(...args))(_input_filename)));
+(runtime.setLine(713), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "reading file..." })))};
+let r_216 = (runtime.setLine(714), ((...args) => runtime.builtinReadTextFile(...args))(_input_filename));
+let _text = r_216;
+(runtime.setLine(716), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "=== text ===" })));
+(runtime.setLine(718), ((...args) => runtime.builtinPrintln(...args))((runtime.setLine(718), ((...args) => runtime.builtinLen(...args))(_text))));
 if (runtime.opNot(_silent)) {
-(runtime.setLine(664), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "tokenizing..." })))};
-let _tokens = runtime.assignValue((runtime.setLine(665), _tokenize(_text)));
+(runtime.setLine(720), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "tokenizing..." })))};
+let r_217 = (runtime.setLine(721), _tokenize(_text));
+let _tokens = r_217;
+(runtime.setLine(723), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "=== tokens ===" })));
+(runtime.setLine(727), ((...args) => runtime.builtinPrintln(...args))((runtime.setLine(727), ((...args) => runtime.builtinLen(...args))(_tokens))));
 if (runtime.opNot(_silent)) {
-(runtime.setLine(672), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "parsing..." })))};
-let _parser = runtime.assignValue((runtime.setLine(673), _Parser(_tokens)));
-let [_parse] = runtime.assignValue(_parser);
-let _ast = runtime.assignValue((runtime.setLine(675), _parse()));
+(runtime.setLine(729), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "parsing..." })))};
+let r_218 = (runtime.setLine(730), _Parser(_tokens));
+let _parser = r_218;
+let r_219 = _parser;
+let r_220 = r_219.values[0];
+let _parse = r_220;
+let r_221 = (runtime.setLine(732), _parse());
+let _ast = r_221;
 if (runtime.opNot(_silent)) {
-(runtime.setLine(682), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "emitting..." })))};
-let _emitter = runtime.assignValue((runtime.setLine(683), _Emitter(_ast, _input_filename)));
-let [_emit] = runtime.assignValue(_emitter);
-let _js_code = runtime.assignValue((runtime.setLine(685), _emit()));
+(runtime.setLine(739), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "emitting..." })))};
+let r_222 = (runtime.setLine(740), _Emitter(_ast, _input_filename));
+let _emitter = r_222;
+let r_223 = _emitter;
+let r_224 = r_223.values[0];
+let _emit = r_224;
+let r_225 = (runtime.setLine(742), _emit());
+let _js_code = r_225;
 if (runtime.opNot(_silent)) {
-(runtime.setLine(690), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "writing file..." })))};
-(runtime.setLine(691), ((...args) => runtime.builtinWriteTextFile(...args))(_output_filename, _js_code));
+(runtime.setLine(747), ((...args) => runtime.builtinPrintln(...args))(({ type: "string", value: "writing file..." })))};
+(runtime.setLine(748), ((...args) => runtime.builtinWriteTextFile(...args))(_output_filename, _js_code));
diff --git a/stage2.js b/stage2.js
new file mode 100644
index 0000000..5274bff
--- /dev/null
+++ b/stage2.js
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Runtime } from "./runtime.js"
+const runtime = new Runtime("compile.phi")