jseption 0.0.0-stage → 0.0.2

package/dist/jit.js

@@ -0,0 +1,3440 @@
+/*
+ * Compiled tier: translates a JSFunctionBytecode (final bytecode, after
+ * resolve_labels) into host JavaScript source and evaluates it once with
+ * `new Function`. See docs/HOST_VALUES.md ("Compiled tier").
+ *
+ * Pipeline:
+ *   1. decode        - split the byte code into instructions
+ *   2. analyze       - abstract interpretation of the operand stack: the
+ *                      depth and the *kind* of every slot (value, catch
+ *                      offset, for-of iterator marker, gosub return address)
+ *                      are static at every pc
+ *   3. blocks        - basic blocks + control flow graph; blocks are also
+ *                      split where the set of active exception handlers
+ *                      changes, so every block belongs to exactly one
+ *                      try-region
+ *   4. emit blocks   - stack slots become locals ($s<depth>); each block is
+ *                      translated with a pending-expression model so that
+ *                      `a[i] = b[i] * 2` becomes one host statement
+ *   5. reloop        - a relooper turns the CFG into labeled blocks/loops
+ *                      and nests try-regions as host try/catch statements;
+ *                      a `for(;;) switch` fallback exists for debugging
+ *                      (JSEPTION_JIT_CFG=switch)
+ *
+ * Calling convention of compiled functions (and of everything the runtime
+ * adapter exposes): `fn($this, $new_target, ...args)`. `this` and
+ * new.target are explicit parameters so that guest-to-guest calls are
+ * plain host calls (no Function.prototype.call / Reflect.apply, which are
+ * 30-50x slower and would need the guest-visible `call` property).
+ * A constructor call passes `$this = undefined` and a defined
+ * `$new_target`; the callee creates `this` and returns the object.
+ *
+ * Generated code never contains free identifiers other than the `$`-prefixed
+ * names created here. Guest globals, closures, classes, regexps, spread,
+ * iteration and every operation on a primitive base go through the `$RT`
+ * object (src/jit_runtime.ts).
+ */
+import { JSFunctionBytecode, JS_AtomGetStr, __JS_AtomIsTaggedInt, __JS_AtomToUInt32 } from "./quickjs.js";
+import { JS_MODE_STRICT, JS_CALL_FLAG_CONSTRUCTOR, new_var_ref_cell, JS_IsCatchOffset } from "./values.js";
+import { short_opcode_info, get_u8, get_i8, get_u16, get_i16, get_u32, get_i32 } from "./opcodes.js";
+import { jit_hooks, JIT_NOT_COMPILED } from "./jit_hook.js";
+import { jit_set_osr_threshold } from "./interpreter.js";
+import { make_jit_runtime, jit_runtime_call_compiled, jit_runtime_call_priv, jit_runtime_make_wrapper, jit_runtime_factory_args, JIT_FACTORY_PARAMS } from "./jit_runtime.js";
+import { js_direct, JS_GetFunctionData, js_host_exception_to_guest } from "./quickjs.js";
+import { jit_stack_alloc_id, jit_stack_register, jit_stack_install } from "./jit_stack.js";
+function env(name) {
+    return globalThis.process?.env?.[name];
+}
+/* 'hot' is the default (measured with bench/inproc.ts, see docs/JIT.md): compiling every
+   function that runs ('always') costs 300-400 us per function in Bun, most of it the host
+   compiling the generated source, which made code that runs once (application start-up, the
+   cold bundles) 3-5x slower than interpreting it; hot mode leaves such code interpreted, and
+   with retargetable wrappers, closures compiled at creation by compiled code and on-stack
+   replacement of hot loops its steady state is mostly within 1.15x of 'always'. */
+/* the mode used when JSEPTION_JIT is unset (or `1`) */
+export const jit_default_mode = 'hot';
+function parse_mode(v) {
+    if (v === undefined || v === '' || v === '1')
+        return jit_default_mode;
+    if (v === 'always')
+        return 'always';
+    if (v === '0' || v === 'off' || v === 'false')
+        return 'off';
+    if (v === 'hot')
+        return 'hot';
+    return jit_default_mode;
+}
+export const jit_config = {
+    mode: parse_mode(env('JSEPTION_JIT')),
+    unavailable: false,
+    unavailable_reason: '',
+    threshold: 2,
+    cfg: env('JSEPTION_JIT_CFG') === 'switch' ? 'switch' : 'reloop',
+    dump: env('JSEPTION_JIT_DUMP') === '1',
+    conv: env('JSEPTION_JIT_CONV') === 'forwarder' ? 'forwarder' : 'natural',
+    osr: env('JSEPTION_JIT_OSR') !== '0',
+    osr_threshold: Number(env('JSEPTION_JIT_OSR') ?? '') > 0 ? Number(env('JSEPTION_JIT_OSR')) : 500,
+};
+if (env('JSEPTION_JIT_THRESHOLD') !== undefined && Number(env('JSEPTION_JIT_THRESHOLD')) > 0) {
+    jit_config.threshold = Number(env('JSEPTION_JIT_THRESHOLD'));
+}
+/* Does the host allow code generation from strings? Probed once (or again with `force`); when
+   it does not, the tier turns itself off and the interpreter runs everything. Never throws. */
+let probed = false;
+export function jit_probe(force = false) {
+    if (probed && !force)
+        return !jit_config.unavailable;
+    probed = true;
+    try {
+        new Function('return 1');
+        jit_config.unavailable = false;
+        jit_config.unavailable_reason = '';
+        jit_stats.unavailable = null;
+        return true;
+    }
+    catch (e) {
+        const reason = String(e?.message ?? e);
+        jit_config.unavailable = true;
+        jit_config.unavailable_reason = reason;
+        jit_config.mode = 'off';
+        jit_stats.unavailable = reason;
+        jit_stack_install(false);
+        return false;
+    }
+}
+/* change the configuration at run time; returns it (`mode` is 'off' and `unavailable` is set
+   when the host forbids code generation) */
+export function jit_configure(c) {
+    Object.assign(jit_config, c);
+    if (jit_config.mode !== 'off' && !jit_probe())
+        jit_config.mode = 'off';
+    jit_stack_install(jit_config.mode !== 'off');
+    jit_set_osr_threshold(jit_config.osr_threshold);
+    return jit_config;
+}
+/* statistics (for tests and debugging) */
+export const jit_stats = {
+    compiled: 0, bailed: 0, bail_reasons: new Map(),
+    /* static counts of method call sites: native member call vs direct-entry/slow path */
+    method_calls_fused: 0, method_calls_unfused: 0,
+    /* on-stack replacement: variants compiled, and frames replaced */
+    osr_compiled: 0, osr_entered: 0,
+    /* the host's message when code generation from strings is forbidden (the tier is off) */
+    unavailable: null,
+};
+export class JitBail extends Error {
+}
+function bail(msg) { throw new JitBail(msg); }
+function decode(b) {
+    const buf = b.byte_code_buf;
+    const len = b.byte_code_len;
+    const insns = [];
+    let pos = 0;
+    while (pos < len) {
+        const op = buf[pos];
+        const oi = short_opcode_info(op);
+        if (!oi || op === 0 /* OP.invalid */)
+            bail(`invalid opcode ${op} at ${pos}`);
+        const p = pos + 1;
+        const insn = { pc: pos, op, size: oi.size, next: pos + oi.size, name: oi.name, fmt: oi.fmt, a: 0, b: 0, label: -1 };
+        switch (oi.fmt) {
+            case 0 /* OpFmt.none */: break;
+            case 1 /* OpFmt.none_int */:
+                insn.a = op - 183 /* OP.push_0 */;
+                break;
+            case 2 /* OpFmt.none_loc */:
+                insn.a = (op - 199 /* OP.get_loc0 */) % 4;
+                break;
+            case 3 /* OpFmt.none_arg */:
+                insn.a = (op - 211 /* OP.get_arg0 */) % 4;
+                break;
+            case 4 /* OpFmt.none_var_ref */:
+                insn.a = (op - 223 /* OP.get_var_ref0 */) % 4;
+                break;
+            case 5 /* OpFmt.u8 */:
+            case 7 /* OpFmt.loc8 */:
+            case 8 /* OpFmt.const8 */:
+                insn.a = get_u8(buf, p);
+                break;
+            case 6 /* OpFmt.i8 */:
+                insn.a = get_i8(buf, p);
+                break;
+            case 9 /* OpFmt.label8 */:
+                insn.label = p + get_i8(buf, p);
+                break;
+            case 10 /* OpFmt.u16 */:
+            case 13 /* OpFmt.npop */:
+            case 16 /* OpFmt.loc */:
+            case 17 /* OpFmt.arg */:
+            case 18 /* OpFmt.var_ref */:
+                insn.a = get_u16(buf, p);
+                break;
+            case 14 /* OpFmt.npopx */:
+                insn.a = op - 240 /* OP.call0 */;
+                break;
+            case 11 /* OpFmt.i16 */:
+                insn.a = get_i16(buf, p);
+                break;
+            case 12 /* OpFmt.label16 */:
+                insn.label = p + get_i16(buf, p);
+                break;
+            case 15 /* OpFmt.npop_u16 */:
+                insn.a = get_u16(buf, p);
+                insn.b = get_u16(buf, p + 2);
+                break;
+            case 19 /* OpFmt.u32 */:
+                insn.a = get_u32(buf, p);
+                break;
+            case 20 /* OpFmt.i32 */:
+                insn.a = get_i32(buf, p);
+                break;
+            case 21 /* OpFmt.const */:
+                insn.a = get_u32(buf, p);
+                break;
+            case 22 /* OpFmt.label */:
+                insn.label = p + get_i32(buf, p);
+                break;
+            case 23 /* OpFmt.atom */:
+                insn.a = get_u32(buf, p);
+                break;
+            case 24 /* OpFmt.atom_u8 */:
+                insn.a = get_u32(buf, p);
+                insn.b = get_u8(buf, p + 4);
+                break;
+            case 25 /* OpFmt.atom_u16 */:
+                insn.a = get_u32(buf, p);
+                insn.b = get_u16(buf, p + 4);
+                break;
+            case 26 /* OpFmt.atom_label_u8 */:
+                insn.a = get_u32(buf, p);
+                insn.label = p + 4 + get_i32(buf, p + 4);
+                insn.b = get_u8(buf, p + 8);
+                break;
+            case 27 /* OpFmt.atom_label_u16 */:
+                insn.a = get_u32(buf, p);
+                insn.label = p + 4 + get_i32(buf, p + 4);
+                insn.b = get_u16(buf, p + 8);
+                break;
+            case 28 /* OpFmt.label_u16 */:
+                insn.label = p + get_i32(buf, p);
+                insn.a = get_u16(buf, p + 4);
+                break;
+            default: bail(`unknown operand format for ${oi.name}`);
+        }
+        insns.push(insn);
+        pos += oi.size;
+    }
+    return insns;
+}
+const KV = { t: 0 /* KT.V */, origin: -1, handler: -1, sites: null };
+function kinds_equal(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i], y = b[i];
+        if (x.t !== y.t)
+            return false;
+        if (x.t === 1 /* KT.CATCH */ || x.t === 2 /* KT.CATCH0 */) {
+            if (x.origin !== y.origin)
+                return false;
+        }
+        if (x.t === 4 /* KT.REF */) {
+            if (x.ref_kind !== y.ref_kind || x.ref_idx !== y.ref_idx)
+                return false;
+        }
+    }
+    return true;
+}
+/* merge ret sites; returns true if `into` changed */
+function kinds_merge(into, from) {
+    let changed = false;
+    for (let i = 0; i < into.length; i++) {
+        if (into[i].t === 3 /* KT.RET */) {
+            const a = into[i].sites, bs = from[i].sites;
+            for (const s of bs)
+                if (!a.includes(s)) {
+                    a.push(s);
+                    changed = true;
+                }
+        }
+    }
+    return changed;
+}
+function analyze(b, insns) {
+    const len = b.byte_code_len;
+    const states = new Array(len).fill(null);
+    const insnAt = new Array(len);
+    for (const i of insns)
+        insnAt[i.pc] = i;
+    const sites = [];
+    const siteByPc = new Map();
+    const A = { states, sites, insnAt, uses_arguments: false, uses_this: false, uses_mapped_arguments: false, is_ctor: false };
+    const work = [];
+    const visit = (pc, st) => {
+        if (pc < 0 || pc >= len)
+            bail(`jump out of range: ${pc}`);
+        if (insnAt[pc] === undefined)
+            bail(`jump into the middle of an instruction: ${pc}`);
+        const cur = states[pc];
+        if (cur === null) {
+            let has_ret = false;
+            for (let i = 0; i < st.length; i++)
+                if (st[i].t === 3 /* KT.RET */) {
+                    has_ret = true;
+                    break;
+                }
+            states[pc] = has_ret ? st.map(k => k.t === 3 /* KT.RET */ ? { ...k, sites: k.sites.slice() } : k) : st.slice();
+            work.push(pc);
+        }
+        else {
+            if (!kinds_equal(cur, st))
+                bail(`inconsistent stack at ${pc}`);
+            if (kinds_merge(cur, st))
+                work.push(pc);
+        }
+    };
+    visit(0, []);
+    /* the instruction being analyzed and its (copied) input stack; the helpers are created once */
+    let pc = 0;
+    let insn = insns[0];
+    let st = [];
+    const pop = (n) => {
+        if (st.length < n)
+            bail(`stack underflow at ${pc} (${insn.name})`);
+        return st.splice(st.length - n, n);
+    };
+    const push = (k) => { st.push(k); };
+    const pushV = (n) => { for (let i = 0; i < n; i++)
+        st.push(KV); };
+    const top = (i = 1) => st[st.length - i];
+    while (work.length) {
+        pc = work.pop();
+        insn = insnAt[pc];
+        st = states[pc].slice();
+        const oi = short_opcode_info(insn.op);
+        let n_pop = oi.n_pop;
+        if (oi.fmt === 13 /* OpFmt.npop */ || oi.fmt === 15 /* OpFmt.npop_u16 */)
+            n_pop += insn.a;
+        else if (oi.fmt === 14 /* OpFmt.npopx */)
+            n_pop += insn.a;
+        switch (insn.op) {
+            /* unsupported in the first version */
+            case 117 /* OP.with_get_var */:
+            case 118 /* OP.with_put_var */:
+            case 119 /* OP.with_delete_var */:
+            case 120 /* OP.with_make_ref */:
+            case 121 /* OP.with_get_ref */:
+                bail('with statement');
+            case 50 /* OP.eval */:
+            case 51 /* OP.apply_eval */:
+                bail('direct eval');
+            case 141 /* OP.await */:
+            case 138 /* OP.yield */:
+            case 139 /* OP.yield_star */:
+            case 140 /* OP.async_yield_star */:
+            case 137 /* OP.initial_yield */:
+            case 47 /* OP.return_async */:
+            case 128 /* OP.for_await_of_start */:
+            case 131 /* OP.for_await_of_next */:
+            case 133 /* OP.iterator_get_value_done */:
+                bail('generator/async');
+            case 54 /* OP.import */:
+                bail('dynamic import');
+            case 122 /* OP.make_loc_ref */:
+            case 123 /* OP.make_arg_ref */:
+            case 124 /* OP.make_var_ref_ref */:
+                push({ t: 4 /* KT.REF */, origin: pc, handler: -1, sites: null,
+                    ref_kind: insn.op === 122 /* OP.make_loc_ref */ ? 0 /* RefKind.LOC */ : insn.op === 123 /* OP.make_arg_ref */ ? 1 /* RefKind.ARG */ : 2 /* RefKind.VAR_REF */,
+                    ref_idx: insn.b });
+                pushV(1);
+                break;
+            /* instructions that keep their lower operands (iterator triples carry catch kinds) */
+            case 130 /* OP.for_of_next */:
+            case 129 /* OP.for_in_next */:
+                pushV(2);
+                break;
+            case 135 /* OP.iterator_next */:
+                pop(1);
+                pushV(1);
+                break;
+            case 136 /* OP.iterator_call */:
+                pushV(1);
+                break;
+            case 132 /* OP.iterator_check_object */: break;
+            case 12 /* OP.special_object */:
+                if (insn.a === 6 /* OPSpecialObject.IMPORT_META */)
+                    bail('import.meta');
+                if (insn.a === 0 /* OPSpecialObject.ARGUMENTS */)
+                    A.uses_arguments = true;
+                if (insn.a === 1 /* OPSpecialObject.MAPPED_ARGUMENTS */) {
+                    A.uses_arguments = true;
+                    A.uses_mapped_arguments = true;
+                }
+                pushV(1);
+                break;
+            case 13 /* OP.rest */:
+            case 44 /* OP.init_ctor */:
+                A.uses_arguments = true;
+                if (insn.op === 44 /* OP.init_ctor */)
+                    A.is_ctor = true;
+                pushV(1);
+                break;
+            case 43 /* OP.check_ctor */:
+                A.is_ctor = true;
+                break;
+            case 8 /* OP.push_this */:
+                A.uses_this = true;
+                pushV(1);
+                break;
+            /* terminators */
+            case 40 /* OP.return */:
+            case 41 /* OP.return_undef */:
+            case 48 /* OP.throw */:
+            case 49 /* OP.throw_error */:
+            case 35 /* OP.tail_call */:
+            case 37 /* OP.tail_call_method */:
+                continue;
+            case 109 /* OP.goto */:
+            case 238 /* OP.goto8 */:
+            case 239 /* OP.goto16 */:
+                visit(insn.label, st);
+                continue;
+            case 108 /* OP.if_true */:
+            case 107 /* OP.if_false */:
+            case 237 /* OP.if_true8 */:
+            case 236 /* OP.if_false8 */:
+                pop(1);
+                visit(insn.label, st);
+                visit(insn.next, st);
+                continue;
+            case 110 /* OP.catch */: {
+                /* handler: the catch slot is replaced by the exception */
+                const hst = st.slice();
+                hst.push(KV);
+                visit(insn.label, hst);
+                push({ t: 1 /* KT.CATCH */, origin: pc, handler: insn.label, sites: null });
+                break;
+            }
+            case 111 /* OP.gosub */: {
+                let site = siteByPc.get(pc);
+                if (!site) {
+                    site = { id: sites.length, pc, cont: insn.next };
+                    sites.push(site);
+                    siteByPc.set(pc, site);
+                }
+                push({ t: 3 /* KT.RET */, origin: pc, handler: -1, sites: [site.id] });
+                visit(insn.label, st);
+                continue;
+            }
+            case 112 /* OP.ret */: {
+                const k = pop(1)[0];
+                if (k.t !== 3 /* KT.RET */)
+                    bail('ret without gosub');
+                for (const sid of k.sites)
+                    visit(sites[sid].cont, st);
+                continue;
+            }
+            case 127 /* OP.for_of_start */:
+                pop(1);
+                pushV(2);
+                push({ t: 2 /* KT.CATCH0 */, origin: pc, handler: 0, sites: null });
+                break;
+            case 134 /* OP.iterator_close */:
+                pop(3);
+                break;
+            case 113 /* OP.nip_catch */: {
+                const rv = pop(1)[0];
+                let found = false;
+                while (st.length > 0) {
+                    const k = st.pop();
+                    if (k.t === 1 /* KT.CATCH */ || k.t === 2 /* KT.CATCH0 */) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (!found)
+                    bail('nip_catch without catch');
+                push(rv.t === 0 /* KT.V */ ? KV : rv);
+                break;
+            }
+            /* stack manipulation (kinds move with the values) */
+            case 14 /* OP.drop */:
+                pop(1);
+                break;
+            case 15 /* OP.nip */: {
+                const [, y] = pop(2);
+                push(y);
+                break;
+            }
+            case 16 /* OP.nip1 */: {
+                const [, y, z] = pop(3);
+                push(y);
+                push(z);
+                break;
+            }
+            case 17 /* OP.dup */: {
+                const x = top();
+                push(x);
+                break;
+            }
+            case 18 /* OP.dup1 */: {
+                const [x, y] = pop(2);
+                push(x);
+                push(x);
+                push(y);
+                break;
+            }
+            case 19 /* OP.dup2 */: {
+                const x = top(2), y = top(1);
+                push(x);
+                push(y);
+                break;
+            }
+            case 20 /* OP.dup3 */: {
+                const x = top(3), y = top(2), z = top(1);
+                push(x);
+                push(y);
+                push(z);
+                break;
+            }
+            case 21 /* OP.insert2 */: {
+                const [x, y] = pop(2);
+                push(y);
+                push(x);
+                push(y);
+                break;
+            }
+            case 22 /* OP.insert3 */: {
+                const [x, y, z] = pop(3);
+                push(z);
+                push(x);
+                push(y);
+                push(z);
+                break;
+            }
+            case 23 /* OP.insert4 */: {
+                const [w, x, y, z] = pop(4);
+                push(z);
+                push(w);
+                push(x);
+                push(y);
+                push(z);
+                break;
+            }
+            case 24 /* OP.perm3 */: {
+                const [x, y, z] = pop(3);
+                push(y);
+                push(x);
+                push(z);
+                break;
+            }
+            case 25 /* OP.perm4 */: {
+                const [w, x, y, z] = pop(4);
+                push(y);
+                push(w);
+                push(x);
+                push(z);
+                break;
+            }
+            case 26 /* OP.perm5 */: {
+                const [v, w, x, y, z] = pop(5);
+                push(y);
+                push(v);
+                push(w);
+                push(x);
+                push(z);
+                break;
+            }
+            case 27 /* OP.swap */: {
+                const [x, y] = pop(2);
+                push(y);
+                push(x);
+                break;
+            }
+            case 28 /* OP.swap2 */: {
+                const [w, x, y, z] = pop(4);
+                push(y);
+                push(z);
+                push(w);
+                push(x);
+                break;
+            }
+            case 29 /* OP.rot3l */: {
+                const [x, y, z] = pop(3);
+                push(y);
+                push(z);
+                push(x);
+                break;
+            }
+            case 30 /* OP.rot3r */: {
+                const [x, y, z] = pop(3);
+                push(z);
+                push(x);
+                push(y);
+                break;
+            }
+            case 31 /* OP.rot4l */: {
+                const [w, x, y, z] = pop(4);
+                push(x);
+                push(y);
+                push(z);
+                push(w);
+                break;
+            }
+            case 32 /* OP.rot5l */: {
+                const [v, w, x, y, z] = pop(5);
+                push(w);
+                push(x);
+                push(y);
+                push(z);
+                push(v);
+                break;
+            }
+            default:
+                if (st.length < n_pop)
+                    bail(`stack underflow at ${pc} (${insn.name})`);
+                st.length -= n_pop;
+                for (let i = 0; i < oi.n_push; i++)
+                    st.push(KV);
+                break;
+        }
+        visit(insn.next, st);
+    }
+    return A;
+}
+class Block {
+    id;
+    start;
+    insns = [];
+    stateIn;
+    region = null;
+    code = ''; /* statements (without the terminator) */
+    term = { kind: 'fall' };
+    succs = []; /* block ids (deduplicated, in terminator order) */
+    dead = false; /* unreachable from an on-stack replacement entry: not emitted */
+    constructor(id, start, stateIn) { this.id = id; this.start = start; this.stateIn = stateIn; }
+}
+class Region {
+    id;
+    origin; /* pc of OP.catch / OP.for_of_start, -1 for the root */
+    parent;
+    kind; /* CATCH, CATCH0 or V for the root */
+    slot; /* stack index of the catch slot */
+    handler; /* CATCH: handler pc */
+    blocks = [];
+    children = [];
+    entry = null;
+    /* on-stack replacement: the region contains the entry (the loop header), which is its entry
+       node (a block id, or the node id of the child region containing it) */
+    entry_node = null;
+    osr_chain = false;
+    exits = new Set(); /* block ids outside this region targeted from inside */
+    constructor(id, origin, parent, kind, slot, handler) {
+        this.id = id;
+        this.origin = origin;
+        this.parent = parent;
+        this.kind = kind;
+        this.slot = slot;
+        this.handler = handler;
+    }
+}
+function handler_chain(st) {
+    const r = [];
+    for (let i = 0; i < st.length; i++)
+        if (st[i].t === 1 /* KT.CATCH */ || st[i].t === 2 /* KT.CATCH0 */)
+            r.push({ kind: st[i], slot: i });
+    return r;
+}
+/* same handler chain (catch kinds, in order) without allocating */
+function same_chain(a, b) {
+    let i = 0, j = 0;
+    for (;;) {
+        while (i < a.length && a[i].t !== 1 /* KT.CATCH */ && a[i].t !== 2 /* KT.CATCH0 */)
+            i++;
+        while (j < b.length && b[j].t !== 1 /* KT.CATCH */ && b[j].t !== 2 /* KT.CATCH0 */)
+            j++;
+        if (i === a.length || j === b.length)
+            return i === a.length && j === b.length;
+        if (a[i].origin !== b[j].origin)
+            return false;
+        i++;
+        j++;
+    }
+}
+function is_terminator(op) {
+    switch (op) {
+        case 40 /* OP.return */:
+        case 41 /* OP.return_undef */:
+        case 48 /* OP.throw */:
+        case 49 /* OP.throw_error */:
+        case 35 /* OP.tail_call */:
+        case 37 /* OP.tail_call_method */:
+        case 109 /* OP.goto */:
+        case 238 /* OP.goto8 */:
+        case 239 /* OP.goto16 */:
+        case 108 /* OP.if_true */:
+        case 107 /* OP.if_false */:
+        case 237 /* OP.if_true8 */:
+        case 236 /* OP.if_false8 */:
+        case 111 /* OP.gosub */:
+        case 112 /* OP.ret */:
+            return true;
+    }
+    return false;
+}
+function build_blocks(insns, A) {
+    const leaders = new Set([0]);
+    for (const insn of insns) {
+        if (A.states[insn.pc] === null)
+            continue;
+        if (insn.label >= 0)
+            leaders.add(insn.label);
+        if (is_terminator(insn.op)) {
+            if (insn.next < insns[insns.length - 1].next)
+                leaders.add(insn.next);
+        }
+        /* handler chain change */
+        const nextState = A.states[insn.next];
+        if (nextState !== null && nextState !== undefined && !same_chain(A.states[insn.pc], nextState))
+            leaders.add(insn.next);
+        if (insn.op === 110 /* OP.catch */ || insn.op === 127 /* OP.for_of_start */)
+            leaders.add(insn.next);
+    }
+    for (const s of A.sites)
+        leaders.add(s.cont);
+    const blocks = [];
+    const byPc = new Map();
+    let cur = null;
+    for (const insn of insns) {
+        if (A.states[insn.pc] === null) {
+            cur = null;
+            continue;
+        }
+        if (leaders.has(insn.pc)) {
+            cur = new Block(blocks.length, insn.pc, A.states[insn.pc]);
+            blocks.push(cur);
+            byPc.set(insn.pc, cur);
+        }
+        if (cur === null)
+            bail(`reachable code without a leader at ${insn.pc}`);
+        cur.insns.push(insn);
+    }
+    /* regions */
+    const root = new Region(0, -1, null, 0 /* KT.V */, -1, -1);
+    const regions = [root];
+    const byOrigin = new Map();
+    for (const blk of blocks) {
+        let parent = root;
+        for (const { kind, slot } of handler_chain(blk.stateIn)) {
+            let r = byOrigin.get(kind.origin);
+            if (!r) {
+                r = new Region(regions.length, kind.origin, parent, kind.t, slot, kind.handler);
+                regions.push(r);
+                byOrigin.set(kind.origin, r);
+                parent.children.push(r);
+            }
+            else if (r.parent !== parent || r.slot !== slot) {
+                bail('inconsistent try-region nesting');
+            }
+            parent = r;
+        }
+        blk.region = parent;
+        parent.blocks.push(blk);
+    }
+    for (const r of regions) {
+        if (r.origin < 0) {
+            r.entry = blocks[0];
+            continue;
+        }
+        const originInsn = A.insnAt[r.origin];
+        const e = byPc.get(originInsn.next);
+        if (!e || e.region !== r)
+            bail('try-region without entry');
+        r.entry = e;
+    }
+    return { blocks, byPc, root, regions };
+}
+/* On-stack replacement: make the loop header at `H` the entry of the function. Blocks that are
+   unreachable from it are dropped, try-regions without live blocks disappear, and every region
+   containing the header takes it (or the child region containing it) as its entry node. A
+   region containing the header that can also be entered normally (e.g. a try statement inside
+   an outer loop) is not supported (Relooper.build bails). */
+function osr_prepare(cfg, A, H) {
+    const hb = cfg.byPc.get(H);
+    if (!hb)
+        bail('osr: the loop header is not a block');
+    for (const k of hb.stateIn) {
+        if (k.t !== 0 /* KT.V */ && k.t !== 1 /* KT.CATCH */ && k.t !== 2 /* KT.CATCH0 */)
+            bail('osr: unsupported stack at the loop header');
+    }
+    const live = new Set([hb]);
+    const work = [hb];
+    const add = (pc) => {
+        const t = cfg.byPc.get(pc);
+        if (t !== undefined && !live.has(t)) {
+            live.add(t);
+            work.push(t);
+        }
+    };
+    while (work.length) {
+        const blk = work.pop();
+        const last = blk.insns[blk.insns.length - 1];
+        switch (last.op) {
+            case 40 /* OP.return */:
+            case 41 /* OP.return_undef */:
+            case 48 /* OP.throw */:
+            case 49 /* OP.throw_error */:
+            case 35 /* OP.tail_call */:
+            case 37 /* OP.tail_call_method */:
+            case 112 /* OP.ret */: /* its continuations are added at the gosub sites */
+                break;
+            case 109 /* OP.goto */:
+            case 238 /* OP.goto8 */:
+            case 239 /* OP.goto16 */:
+                add(last.label);
+                break;
+            case 108 /* OP.if_true */:
+            case 107 /* OP.if_false */:
+            case 237 /* OP.if_true8 */:
+            case 236 /* OP.if_false8 */:
+                add(last.label);
+                add(last.next);
+                break;
+            case 111 /* OP.gosub */: {
+                add(last.label);
+                const site = A.sites.find(st => st.pc === last.pc);
+                if (site)
+                    add(site.cont);
+                break;
+            }
+            default:
+                add(last.next);
+                if (last.op === 110 /* OP.catch */)
+                    add(last.label);
+                break;
+        }
+        /* exception edges */
+        for (let r = blk.region; r !== null; r = r.parent)
+            if (r.kind === 1 /* KT.CATCH */)
+                add(r.handler);
+    }
+    for (const blk of cfg.blocks)
+        if (!live.has(blk))
+            blk.dead = true;
+    for (const r of cfg.regions)
+        r.blocks = r.blocks.filter(blk => !blk.dead);
+    const kept = new Set();
+    const keep = (r) => {
+        r.children = r.children.filter(keep);
+        const k = r.origin < 0 || r.blocks.length > 0 || r.children.length > 0;
+        if (k)
+            kept.add(r);
+        return k;
+    };
+    keep(cfg.root);
+    cfg.regions = cfg.regions.filter(r => kept.has(r));
+    let child = null;
+    for (let r = hb.region; r !== null; r = r.parent) {
+        r.entry_node = child === null ? hb.id : -child.id - 1;
+        r.osr_chain = true;
+        child = r;
+    }
+    /* the arguments object (and rest parameters) are created from the call's `arguments`, which
+       the replacement entry does not have */
+    for (const blk of live)
+        for (const insn of blk.insns) {
+            if (insn.op === 13 /* OP.rest */ || insn.op === 44 /* OP.init_ctor */ ||
+                (insn.op === 12 /* OP.special_object */ && (insn.a === 0 /* OPSpecialObject.ARGUMENTS */ || insn.a === 1 /* OPSpecialObject.MAPPED_ARGUMENTS */))) {
+                bail('osr: arguments object created after the loop header');
+            }
+        }
+}
+/* stack temps referenced by a pending expression (cached: push() asks for every live slot) */
+function temps_of(p) {
+    if (p.trefs_code === p.code)
+        return p.trefs;
+    const code = p.code;
+    const r = [];
+    let i = code.indexOf('$s');
+    while (i >= 0) {
+        let j = i + 2, n = 0, c = code.charCodeAt(j);
+        if (c >= 48 && c <= 57) {
+            do {
+                n = n * 10 + (c - 48);
+                c = code.charCodeAt(++j);
+            } while (c >= 48 && c <= 57);
+            r.push(n);
+        }
+        i = code.indexOf('$s', j);
+    }
+    p.trefs_code = code;
+    p.trefs = r;
+    return r;
+}
+function P(code, kind, extra) {
+    /* explicit fields (an object spread here was a measurable part of code generation) */
+    const p = { code, kind, cpool: -1, local: '', method: undefined, fresh: undefined, mkeys: undefined };
+    if (extra !== undefined) {
+        if (extra.cpool !== undefined)
+            p.cpool = extra.cpool;
+        if (extra.local !== undefined)
+            p.local = extra.local;
+        if (extra.method !== undefined)
+            p.method = extra.method;
+        if (extra.fresh !== undefined)
+            p.fresh = extra.fresh;
+        if (extra.mkeys !== undefined)
+            p.mkeys = extra.mkeys;
+    }
+    return p;
+}
+/* the interrupt poll emitted at every function entry and loop head: the interpreter's
+   counter, decremented in place (`$C` is the context); the handler is asked when it runs out */
+const POLL = 'if (--$C.interrupt_counter <= 0) $RT.poll_handler();\n';
+const IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED = new Set(['__proto__']);
+function fmt_number(n) {
+    if (Number.isNaN(n))
+        return '(0/0)';
+    if (n === Infinity)
+        return '(1/0)';
+    if (n === -Infinity)
+        return '(-1/0)';
+    if (n === 0 && 1 / n < 0)
+        return '(-0)';
+    const s = String(n);
+    return n < 0 ? `(${s})` : s;
+}
+function fmt_const(v, cpool_index) {
+    switch (typeof v) {
+        case 'number': return P(fmt_number(v), 0 /* PK.LIT */, { cpool: cpool_index });
+        case 'string': return P(JSON.stringify(v), 0 /* PK.LIT */, { cpool: cpool_index });
+        case 'boolean': return P(v ? 'true' : 'false', 0 /* PK.LIT */, { cpool: cpool_index });
+        case 'bigint': return P(v < 0n ? `(${v}n)` : `${v}n`, 0 /* PK.LIT */, { cpool: cpool_index });
+        case 'undefined': return P('undefined', 0 /* PK.LIT */, { cpool: cpool_index });
+        default:
+            if (v === null)
+                return P('null', 0 /* PK.LIT */, { cpool: cpool_index });
+            return null;
+    }
+}
+/* property key text for a static atom: `.name` or `[..]` */
+function key_access(fi, atom) {
+    if (__JS_AtomIsTaggedInt(atom))
+        return `[${__JS_AtomToUInt32(atom)}]`;
+    if (fi.atom_is_symbol(atom))
+        bail('symbol atom in static property access');
+    const name = fi.atom_name(atom);
+    if (IDENT_RE.test(name) && !RESERVED.has(name))
+        return `.${name}`;
+    return `[${JSON.stringify(name)}]`;
+}
+/* property key value for a static atom (string/number literal) */
+function key_value(fi, atom) {
+    if (__JS_AtomIsTaggedInt(atom))
+        return String(__JS_AtomToUInt32(atom));
+    if (fi.atom_is_symbol(atom))
+        bail('symbol atom as property key');
+    return JSON.stringify(fi.atom_name(atom));
+}
+/* references to stack temps `$s<n>` in generated code (manual scans: these run for every push) */
+function refs_temp_above(code, idx) {
+    let i = code.indexOf('$s');
+    while (i >= 0) {
+        let j = i + 2, n = 0, c = code.charCodeAt(j);
+        if (c >= 48 && c <= 57) {
+            do {
+                n = n * 10 + (c - 48);
+                c = code.charCodeAt(++j);
+            } while (c >= 48 && c <= 57);
+            if (n > idx)
+                return true;
+        }
+        i = code.indexOf('$s', j);
+    }
+    return false;
+}
+function refs_temp(code, idx) {
+    let i = code.indexOf('$s');
+    while (i >= 0) {
+        let j = i + 2, n = 0, c = code.charCodeAt(j);
+        if (c >= 48 && c <= 57) {
+            do {
+                n = n * 10 + (c - 48);
+                c = code.charCodeAt(++j);
+            } while (c >= 48 && c <= 57);
+            if (n === idx)
+                return true;
+        }
+        i = code.indexOf('$s', j);
+    }
+    return false;
+}
+const TEMP_NAMES = [];
+function temp_name(i) {
+    let n = TEMP_NAMES[i];
+    if (n === undefined) {
+        n = `$s${i}`;
+        TEMP_NAMES[i] = n;
+    }
+    return n;
+}
+/* position markers are emitted as comments `/*@<pc>*\/` (see src/jit_stack.ts) */
+function starts_with_marker(code) {
+    return code.charCodeAt(0) === 47 && code.charCodeAt(1) === 42 && code.charCodeAt(2) === 64;
+}
+/* a statement `$name = /*@<pc>*\/...`: the pc of the expression it assigns, else -1 */
+function stmt_expr_pc(stmt) {
+    if (stmt.charCodeAt(0) !== 36 /* $ */)
+        return -1;
+    let i = 1, c = stmt.charCodeAt(1);
+    if (!(c === 36 || c === 95 || (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122)))
+        return -1;
+    while (c === 36 || c === 95 || (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122))
+        c = stmt.charCodeAt(++i);
+    if (c !== 32 || stmt.charCodeAt(i + 1) !== 61 || stmt.charCodeAt(i + 2) !== 32 ||
+        stmt.charCodeAt(i + 3) !== 47 || stmt.charCodeAt(i + 4) !== 42 || stmt.charCodeAt(i + 5) !== 64)
+        return -1;
+    let j = i + 6, pc = 0;
+    c = stmt.charCodeAt(j);
+    if (!(c >= 48 && c <= 57))
+        return -1;
+    while (c >= 48 && c <= 57) {
+        pc = pc * 10 + (c - 48);
+        c = stmt.charCodeAt(++j);
+    }
+    return c === 42 ? pc : -1;
+}
+/* a primitive literal (never an object): property operations go straight to the runtime */
+const PRIM_LIT_RE = /^(?:-?\d|\(|"|'|true$|false$|null$|undefined$|\d)/;
+function is_prim_literal(code) {
+    return PRIM_LIT_RE.test(code) && !code.startsWith('$');
+}
+function is_obj_guard(x) {
+    return `(typeof ${x} === 'object' ? ${x} !== null : typeof ${x} === 'function')`;
+}
+class BlockEmitter {
+    fi;
+    blk;
+    slots = [];
+    out = [];
+    scratch = 0;
+    /* temps `$s<k>` that may occur in pending code of this block: those of the input stack and
+       every temp slot pushed or materialized since (a pending expression can only mention a temp
+       that existed as a slot). Lets push() skip scanning expression strings, which would make the
+       host flatten every nested expression. */
+    temp_seen = [];
+    max_seen = -1;
+    see_temp(i) {
+        if (this.temp_seen[i] !== true) {
+            this.temp_seen[i] = true;
+            if (i > this.max_seen)
+                this.max_seen = i;
+        }
+    }
+    constructor(fi, blk) {
+        this.fi = fi;
+        this.blk = blk;
+        for (let i = 0; i < blk.stateIn.length; i++) {
+            this.slots.push(P(temp_name(i), 1 /* PK.TEMP */));
+            this.see_temp(i);
+        }
+    }
+    get depth() { return this.slots.length; }
+    /* every statement starts with a position marker (see M): that of the expression it assigns,
+       else of the current instruction */
+    emit(stmt) {
+        if (starts_with_marker(stmt)) {
+            this.out.push(stmt);
+            return;
+        }
+        const pc = stmt_expr_pc(stmt);
+        this.out.push((pc >= 0 ? `/*@${pc}*/` : this.M()) + stmt);
+    }
+    /* Position marker: a comment "/*@<pc>*\/" that the host parses as whitespace; the table
+       (line, column) -> pc is built from the source when a backtrace needs it (src/jit_stack.ts),
+       so that a host stack frame of the compiled function maps back to the guest operation. Every pushed expression starts with
+       one; property accesses and calls carry one before their `.`/`[`/`(` and one at their end,
+       binary operators one at the operator: the hosts report one of those points. */
+    M(pc = this.cur_pc) { return `/*@${pc}*/`; }
+    /* a fresh scratch variable (declared at function level as $x0, $x1, ...) */
+    tmp() { return `$x${this.scratch++}`; }
+    /* materialize slot i into its canonical temp. Pending expressions below i are evaluated
+       first so that the evaluation order of the original code is preserved. */
+    materialize(i) {
+        const p = this.slots[i];
+        if (p.kind === 1 /* PK.TEMP */ && p.code === `$s${i}`)
+            return;
+        if (p.kind === 3 /* PK.EXPR */) {
+            for (let j = 0; j < i; j++)
+                if (this.slots[j].kind === 3 /* PK.EXPR */)
+                    this.materialize(j);
+        }
+        this.emit(`$s${i} = ${p.code};`);
+        this.slots[i] = P(temp_name(i), 1 /* PK.TEMP */, { fresh: p.fresh, mkeys: p.mkeys });
+        this.see_temp(i);
+    }
+    /* materialize every pending expression that is not trivially duplicable, in order */
+    flush_exprs(upto = this.depth) {
+        for (let i = 0; i < upto; i++)
+            if (this.slots[i].kind === 3 /* PK.EXPR */)
+                this.materialize(i);
+    }
+    /* materialize all pending reads of a local before writing it */
+    flush_local(name) {
+        for (let i = 0; i < this.depth; i++)
+            if (this.slots[i].kind === 2 /* PK.LOCAL */ && this.slots[i].local === name)
+                this.materialize(i);
+    }
+    /* materialize everything so that slot i holds `$s<i>` */
+    finalize() {
+        /* 1. expressions and literals that are not in canonical form */
+        const moves = [];
+        for (let i = 0; i < this.depth; i++) {
+            const p = this.slots[i];
+            if (p.kind === 1 /* PK.TEMP */) {
+                if (p.code !== `$s${i}`)
+                    moves.push({ i, from: p.code });
+            }
+            else if (p.kind === 3 /* PK.EXPR */)
+                this.materialize(i);
+        }
+        /* 2. literal/local assignments: the sources are not temps, no ordering issue, but they must
+              happen after the temp moves if a temp move reads a slot they overwrite... simplest: do
+              temp moves first via a parallel-move resolver, then the others. */
+        this.parallel_moves(moves);
+        for (let i = 0; i < this.depth; i++) {
+            const p = this.slots[i];
+            if (p.kind === 0 /* PK.LIT */ || p.kind === 2 /* PK.LOCAL */)
+                this.materialize(i);
+        }
+    }
+    parallel_moves(moves) {
+        /* moves: $s<i> = from, where from is some $s<j>. Resolve cycles with $x scratch. */
+        const pending = new Map(); /* dest -> src */
+        for (const m of moves)
+            pending.set(m.i, m.from);
+        const isRead = (name) => { for (const s of pending.values())
+            if (s === name)
+                return true; return false; };
+        while (pending.size) {
+            let progress = false;
+            for (const [dest, src] of [...pending]) {
+                if (!isRead(`$s${dest}`)) {
+                    this.emit(`$s${dest} = ${src};`);
+                    this.slots[dest] = P(temp_name(dest), 1 /* PK.TEMP */);
+                    this.see_temp(dest);
+                    pending.delete(dest);
+                    progress = true;
+                }
+            }
+            if (!progress) {
+                /* break a cycle */
+                const [dest, src] = pending.entries().next().value;
+                const t = this.tmp();
+                this.emit(`${t} = ${src};`);
+                for (const [d2, s2] of pending)
+                    if (s2 === src)
+                        pending.set(d2, t);
+                void dest;
+            }
+        }
+    }
+    push(p) {
+        const idx = this.depth;
+        /* a live slot below may still hold the temp `$s<idx>` (after dup/permutations): save it first */
+        if (this.temp_seen[idx] === true) {
+            const mine = temp_name(idx);
+            for (let j = 0; j < idx; j++) {
+                const q = this.slots[j];
+                if ((q.kind === 1 /* PK.TEMP */ && q.code === mine) || (q.kind === 3 /* PK.EXPR */ && temps_of(q).includes(idx)))
+                    this.materialize(j);
+            }
+        }
+        if (p.kind === 3 /* PK.EXPR */ && p.marked !== true) {
+            p.code = this.M() + p.code;
+            p.marked = true;
+        }
+        else if (p.kind === 1 /* PK.TEMP */) {
+            /* a temp slot: `$s<k>` (k may differ from idx after permutations) */
+            const code = p.code;
+            if (code.length > 2 && code.charCodeAt(0) === 36 && code.charCodeAt(1) === 115) {
+                const k = Number(code.slice(2));
+                if (Number.isInteger(k))
+                    this.see_temp(k);
+            }
+        }
+        this.slots.push(p);
+        /* an expression that reads temps above its own slot must be evaluated now, before those
+           temps are reused */
+        if (p.kind === 3 /* PK.EXPR */ && this.max_seen > idx) {
+            const t = temps_of(p);
+            for (let k = 0; k < t.length; k++)
+                if (t[k] > idx) {
+                    this.materialize(idx);
+                    break;
+                }
+        }
+    }
+    /* make every slot a canonical temp (used after permutations) */
+    canonicalize() { this.finalize(); }
+    pop() {
+        if (!this.slots.length)
+            bail('emit: stack underflow');
+        return this.slots.pop();
+    }
+    top(i = 1) { return this.slots[this.slots.length - i]; }
+    /* drop a slot: its side effects must still happen */
+    drop_value(p) {
+        if (p.kind === 3 /* PK.EXPR */)
+            this.emit(`${p.code};`);
+    }
+    /* make the slot duplicable (temp/local/lit) and return its code */
+    dup_code(i) {
+        const p = this.slots[i];
+        if (p.kind === 3 /* PK.EXPR */)
+            this.materialize(i);
+        return this.slots[i].code;
+    }
+    /* the value of a store that is written into two branches (fast native store / runtime
+       fallback): an expression is evaluated once into `$w` first. Order-preserving: the statement
+       follows immediately and the guard between them evaluates nothing. */
+    store_value(v) {
+        if (v.kind !== 3 /* PK.EXPR */)
+            return v.code;
+        this.fi.uses_w = true;
+        this.emit(`$w = ${v.code};`);
+        return '$w';
+    }
+    /* code of an operand for use inside a larger expression */
+    par(p) {
+        if (p.kind === 3 /* PK.EXPR */)
+            return `(${p.code})`;
+        return p.code;
+    }
+    /* before emitting a statement with side effects */
+    before_stmt() { this.flush_exprs(); }
+    /* --- variable access --- */
+    arg_read(i) {
+        const fi = this.fi;
+        if (i >= fi.argName.length)
+            return P('undefined', 0 /* PK.LIT */);
+        return fi.argCell[i] ? P(`${fi.argName[i]}.get()`, 3 /* PK.EXPR */) : P(fi.argName[i], 2 /* PK.LOCAL */, { local: fi.argName[i] });
+    }
+    var_read(i) {
+        const fi = this.fi;
+        if (i >= fi.varName.length)
+            bail(`bad local index ${i}`);
+        return fi.varCell[i] ? P(`${fi.varName[i]}.get()`, 3 /* PK.EXPR */) : P(fi.varName[i], 2 /* PK.LOCAL */, { local: fi.varName[i] });
+    }
+    write_local(is_arg, i, value) {
+        const fi = this.fi;
+        const name = is_arg ? fi.argName[i] : fi.varName[i];
+        const cell = is_arg ? fi.argCell[i] : fi.varCell[i];
+        if (name === undefined)
+            bail(`bad variable index ${i}`);
+        if (cell) {
+            this.before_stmt();
+            this.emit(`${name}.set(${value});`);
+        }
+        else {
+            this.flush_local(name);
+            this.emit(`${name} = ${value};`);
+        }
+    }
+    /* current value expression of a local (duplicable) */
+    local_value(is_arg, i) {
+        const fi = this.fi;
+        const name = is_arg ? fi.argName[i] : fi.varName[i];
+        const cell = is_arg ? fi.argCell[i] : fi.varCell[i];
+        return cell ? `${name}.get()` : name;
+    }
+    /* --- property access and calls --- */
+    guard_obj(x) { return is_obj_guard(x); }
+    get_field(obj, atom) {
+        if (is_prim_literal(obj))
+            return `$RT.get_field(${obj}, ${atom})`;
+        const M = this.M();
+        return `(${this.guard_obj(obj)} ? ${obj}${M}${key_access(this.fi, atom)}${M} : $RT.get_field(${obj}, ${atom}))`;
+    }
+    get_el(obj, key) {
+        if (is_prim_literal(obj))
+            return `$RT.get_el(${obj}, ${key})`;
+        const M = this.M();
+        return `(${this.guard_obj(obj)} ? ${obj}${M}[${key}]${M} : $RT.get_el(${obj}, ${key}))`;
+    }
+    put_field_stmt(obj, atom, val) {
+        const fi = this.fi;
+        const M = this.M();
+        if (is_prim_literal(obj))
+            return `$RT.put_field(${obj}, ${atom}, ${val}, ${fi.strict});`;
+        if (fi.strict)
+            return `if (${this.guard_obj(obj)}) ${obj}${M}${key_access(fi, atom)} = ${val}; else $RT.put_field${M}(${obj}, ${atom}, ${val}, true);`;
+        /* sloppy assignment semantics (no throw) come from a non-strict helper in the factory scope */
+        let idx = fi.sloppy_props.get(atom);
+        if (idx === undefined) {
+            idx = fi.sloppy_props.size;
+            fi.sloppy_props.set(atom, idx);
+        }
+        return `if (${this.guard_obj(obj)}) $sp${idx}${M}(${obj}, ${val}); else $RT.put_field${M}(${obj}, ${atom}, ${val}, false);`;
+    }
+    put_el_stmt(obj, key, val) {
+        const fi = this.fi;
+        const M = this.M();
+        if (is_prim_literal(obj))
+            return `$RT.put_el(${obj}, ${key}, ${val}, ${fi.strict});`;
+        if (fi.strict)
+            return `if (${this.guard_obj(obj)}) ${obj}${M}[${key}] = ${val}; else $RT.put_el${M}(${obj}, ${key}, ${val}, true);`;
+        fi.uses_spe = true;
+        return `if (${this.guard_obj(obj)}) $spe${M}(${obj}, ${key}, ${val}); else $RT.put_el${M}(${obj}, ${key}, ${val}, false);`;
+    }
+    /* call with an explicit `this`: the direct entry of guest functions, else the engine */
+    call_with_this(fn, thisv, args) {
+        this.fi.uses_direct = true;
+        const a = args.join(', ');
+        const M = this.M();
+        return `(($d = $DIRECT.get(${fn})) !== undefined ? $d${M}(${thisv}, undefined${a ? ', ' + a : ''})${M} : $RT.call_slow${M}(${fn}, ${thisv}, [${a}])${M})`;
+    }
+    construct_with_target(fn, nt, args) {
+        this.fi.uses_direct = true;
+        const a = args.join(', ');
+        const M = this.M();
+        return `(($d = $DIRECT.get(${fn})) !== undefined ? $d${M}(undefined, ${nt}${a ? ', ' + a : ''})${M} : $RT.construct_slow${M}(${fn}, ${nt}, [${a}])${M})`;
+    }
+    /* returns true if the instruction terminated the block */
+    translate(insn, last) {
+        const fi = this.fi;
+        const op = insn.op;
+        switch (op) {
+            /* --- constants --- */
+            case 1 /* OP.push_i32 */:
+            case 191 /* OP.push_i8 */:
+            case 192 /* OP.push_i16 */:
+            case 182 /* OP.push_minus1 */:
+            case 183 /* OP.push_0 */:
+            case 184 /* OP.push_1 */:
+            case 185 /* OP.push_2 */:
+            case 186 /* OP.push_3 */:
+            case 187 /* OP.push_4 */:
+            case 188 /* OP.push_5 */:
+            case 189 /* OP.push_6 */:
+            case 190 /* OP.push_7 */:
+                this.push(P(fmt_number(insn.a), 0 /* PK.LIT */));
+                return false;
+            case 180 /* OP.push_bigint_i32 */:
+                /* a negative literal is parenthesized: `-1n ** 2n` is a syntax error */
+                this.push(P(insn.a < 0 ? `(${insn.a}n)` : `${insn.a}n`, 0 /* PK.LIT */));
+                return false;
+            case 2 /* OP.push_const */:
+            case 193 /* OP.push_const8 */: {
+                const v = fi.b.cpool[insn.a];
+                const lit = v instanceof JSFunctionBytecode ? null : fmt_const(v, insn.a);
+                this.push(lit ?? P(`$cpool[${insn.a}]`, 0 /* PK.LIT */, { cpool: insn.a }));
+                return false;
+            }
+            case 195 /* OP.push_empty_string */:
+                this.push(P('""', 0 /* PK.LIT */));
+                return false;
+            case 6 /* OP.undefined */:
+                this.push(P('undefined', 0 /* PK.LIT */));
+                return false;
+            case 7 /* OP.null */:
+                this.push(P('null', 0 /* PK.LIT */));
+                return false;
+            case 9 /* OP.push_false */:
+                this.push(P('false', 0 /* PK.LIT */));
+                return false;
+            case 10 /* OP.push_true */:
+                this.push(P('true', 0 /* PK.LIT */));
+                return false;
+            case 4 /* OP.push_atom_value */:
+                if (fi.atom_is_symbol(insn.a))
+                    this.push(P(`$RT.atom_value(${insn.a})`, 3 /* PK.EXPR */));
+                else if (__JS_AtomIsTaggedInt(insn.a))
+                    this.push(P(String(__JS_AtomToUInt32(insn.a)), 0 /* PK.LIT */));
+                else
+                    this.push(P(JSON.stringify(fi.atom_name(insn.a)), 0 /* PK.LIT */));
+                return false;
+            case 5 /* OP.private_symbol */:
+                this.push(P(`$RT.private_symbol(${insn.a})`, 3 /* PK.EXPR */));
+                return false;
+            case 8 /* OP.push_this */:
+                if (fi.strict)
+                    this.push(P('$t', 2 /* PK.LOCAL */, { local: '$t' }));
+                else
+                    this.push(P(`(($t === undefined || $t === null) ? $G : ((typeof $t === 'object' || typeof $t === 'function') ? $t : $RT.to_object($t)))`, 3 /* PK.EXPR */));
+                return false;
+            case 11 /* OP.object */:
+                this.push(P('new $Obj()', 3 /* PK.EXPR */, { fresh: true, mkeys: null }));
+                return false;
+            case 12 /* OP.special_object */:
+                switch (insn.a) {
+                    case 0 /* OPSpecialObject.ARGUMENTS */:
+                        this.push(P(`$RT.arguments(arguments, ${fi.arg_off})`, 3 /* PK.EXPR */));
+                        break;
+                    case 1 /* OPSpecialObject.MAPPED_ARGUMENTS */:
+                        this.push(P(`$RT.mapped_arguments(arguments, ${fi.arg_off}, [${fi.argName.join(', ')}], $fo)`, 3 /* PK.EXPR */));
+                        break;
+                    case 2 /* OPSpecialObject.THIS_FUNC */:
+                        this.push(P('$fo', 2 /* PK.LOCAL */, { local: '$fo' }));
+                        break;
+                    case 3 /* OPSpecialObject.NEW_TARGET */:
+                        /* a non constructible function (method, arrow body) is never constructed */
+                        if (fi.constructible)
+                            this.push(P('$nt', 2 /* PK.LOCAL */, { local: '$nt' }));
+                        else
+                            this.push(P('undefined', 0 /* PK.LIT */));
+                        break;
+                    case 4 /* OPSpecialObject.HOME_OBJECT */:
+                        this.push(P('$RT.home_object($fo)', 3 /* PK.EXPR */));
+                        break;
+                    case 5 /* OPSpecialObject.VAR_OBJECT */:
+                        this.push(P('$RT.new_object_null()', 3 /* PK.EXPR */));
+                        break;
+                    default: bail('special object ' + insn.a);
+                }
+                return false;
+            case 13 /* OP.rest */:
+                this.push(P(`$RT.rest(arguments, ${fi.arg_off}, ${insn.a})`, 3 /* PK.EXPR */));
+                return false;
+            /* --- stack manipulation --- */
+            case 14 /* OP.drop */:
+                this.drop_value(this.pop());
+                return false;
+            case 15 /* OP.nip */: {
+                const y = this.pop();
+                const x = this.pop();
+                this.drop_value(x);
+                this.push(y);
+                return false;
+            }
+            case 16 /* OP.nip1 */: {
+                const z = this.pop();
+                const y = this.pop();
+                const x = this.pop();
+                this.drop_value(x);
+                this.push(y);
+                this.push(z);
+                return false;
+            }
+            case 17 /* OP.dup */: {
+                const c = this.dup_code(this.depth - 1);
+                this.push({ ...this.top(), code: c });
+                return false;
+            }
+            case 18 /* OP.dup1 */: { /* a b -> a a b */
+                this.dup_code(this.depth - 2);
+                this.dup_code(this.depth - 1);
+                const b = this.pop();
+                const a = this.pop();
+                this.push(a);
+                this.push({ ...a });
+                this.push(b);
+                return false;
+            }
+            case 19 /* OP.dup2 */: {
+                this.dup_code(this.depth - 2);
+                this.dup_code(this.depth - 1);
+                const a = this.top(2), b = this.top(1);
+                this.push({ ...a });
+                this.push({ ...b });
+                return false;
+            }
+            case 20 /* OP.dup3 */: {
+                this.dup_code(this.depth - 3);
+                this.dup_code(this.depth - 2);
+                this.dup_code(this.depth - 1);
+                const a = this.top(3), b = this.top(2), c = this.top(1);
+                this.push({ ...a });
+                this.push({ ...b });
+                this.push({ ...c });
+                return false;
+            }
+            case 21 /* OP.insert2 */:
+            case 22 /* OP.insert3 */:
+            case 23 /* OP.insert4 */:
+            case 24 /* OP.perm3 */:
+            case 25 /* OP.perm4 */:
+            case 26 /* OP.perm5 */:
+            case 27 /* OP.swap */:
+            case 28 /* OP.swap2 */:
+            case 29 /* OP.rot3l */:
+            case 30 /* OP.rot3r */:
+            case 31 /* OP.rot4l */:
+            case 32 /* OP.rot5l */: {
+                const oi = short_opcode_info(op);
+                const n = oi.n_pop;
+                for (let i = this.depth - n; i < this.depth; i++)
+                    this.dup_code(i);
+                const v = this.slots.splice(this.depth - n, n);
+                let r;
+                switch (op) {
+                    case 21 /* OP.insert2 */:
+                        r = [v[1], v[0], v[1]];
+                        break;
+                    case 22 /* OP.insert3 */:
+                        r = [v[2], v[0], v[1], v[2]];
+                        break;
+                    case 23 /* OP.insert4 */:
+                        r = [v[3], v[0], v[1], v[2], v[3]];
+                        break;
+                    case 24 /* OP.perm3 */:
+                        r = [v[1], v[0], v[2]];
+                        break;
+                    case 25 /* OP.perm4 */:
+                        r = [v[2], v[0], v[1], v[3]];
+                        break;
+                    case 26 /* OP.perm5 */:
+                        r = [v[3], v[0], v[1], v[2], v[4]];
+                        break;
+                    case 27 /* OP.swap */:
+                        r = [v[1], v[0]];
+                        break;
+                    case 28 /* OP.swap2 */:
+                        r = [v[2], v[3], v[0], v[1]];
+                        break;
+                    case 29 /* OP.rot3l */:
+                        r = [v[1], v[2], v[0]];
+                        break;
+                    case 30 /* OP.rot3r */:
+                        r = [v[2], v[0], v[1]];
+                        break;
+                    case 31 /* OP.rot4l */:
+                        r = [v[1], v[2], v[3], v[0]];
+                        break;
+                    default:
+                        r = [v[1], v[2], v[3], v[4], v[0]];
+                        break;
+                }
+                for (const p of r)
+                    this.slots.push({ ...p });
+                this.canonicalize();
+                return false;
+            }
+            /* --- closures --- */
+            case 3 /* OP.fclosure */:
+            case 194 /* OP.fclosure8 */: {
+                const child = fi.b.cpool[insn.a];
+                if (!(child instanceof JSFunctionBytecode))
+                    bail('fclosure without bytecode');
+                this.push(P(`$RT.closure($cpool[${insn.a}], ${this.closure_refs(child)}, $fo)`, 3 /* PK.EXPR */));
+                return false;
+            }
+            /* --- calls --- */
+            case 240 /* OP.call0 */:
+            case 241 /* OP.call1 */:
+            case 242 /* OP.call2 */:
+            case 243 /* OP.call3 */:
+            case 34 /* OP.call */:
+            case 35 /* OP.tail_call */: {
+                /* plain call: native (this = undefined, strict callees) */
+                const argc = insn.a;
+                const args = this.pop_args(argc);
+                const fn = this.pop();
+                const M = this.M();
+                const e = `${this.par(fn)}${M}(${args.join(', ')})${M}`;
+                if (op === 35 /* OP.tail_call */) {
+                    this.before_stmt();
+                    this.emit_return(e);
+                    return true;
+                }
+                this.push(P(e, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 36 /* OP.call_method */:
+            case 37 /* OP.tail_call_method */: {
+                const argc = insn.a;
+                const args = this.pop_args(argc);
+                const fn = this.top(1), thisv = this.top(2);
+                let e;
+                const a = args.join(', ');
+                if (fn.method && fn.method.recv === thisv.code && a.length <= 400) {
+                    /* fused member call: evaluation order (receiver, property, arguments) is the
+                       bytecode's since the arguments are still pending expressions */
+                    this.pop();
+                    this.pop();
+                    const r = fn.method.recv;
+                    const M = this.M();
+                    e = `(${this.guard_obj(r)} ? ${r}${this.M(fn.method.pc)}${fn.method.access}${M}(${a})${M} : ${fn.method.prim}${M}(${fn.method.prim_args}, [${a}])${M})`;
+                    jit_stats.method_calls_fused++;
+                }
+                else {
+                    const f = this.dup_code(this.depth - 1);
+                    const t = this.dup_code(this.depth - 2);
+                    this.pop();
+                    this.pop();
+                    e = this.call_with_this(f, t, args);
+                    jit_stats.method_calls_unfused++;
+                }
+                if (op === 37 /* OP.tail_call_method */) {
+                    this.before_stmt();
+                    this.emit_return(e);
+                    return true;
+                }
+                this.push(P(e, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 33 /* OP.call_constructor */: {
+                const argc = insn.a;
+                const args = this.pop_args(argc);
+                const nt = this.top(1), fn = this.top(2);
+                let e;
+                if ((nt.kind === 1 /* PK.TEMP */ || nt.kind === 2 /* PK.LOCAL */) && nt.kind === fn.kind && nt.code === fn.code) {
+                    /* `new C(args)`: new.target is the constructor itself */
+                    this.pop();
+                    this.pop();
+                    e = `new ${fn.code}${this.M()}(${args.join(', ')})${this.M()}`;
+                }
+                else {
+                    const t = this.dup_code(this.depth - 1);
+                    const f = this.dup_code(this.depth - 2);
+                    this.pop();
+                    this.pop();
+                    e = this.construct_with_target(f, t, args);
+                }
+                this.push(P(e, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 38 /* OP.array_from */: {
+                const args = this.pop_args(insn.a);
+                this.push(P(`$RT.array([${args.join(', ')}])`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 39 /* OP.apply */: {
+                const arr = this.pop();
+                const thisv = this.pop();
+                const fn = this.pop();
+                this.push(P(`$RT.apply(${this.par(fn)}, ${this.par(thisv)}, ${this.par(arr)}, ${insn.a})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 40 /* OP.return */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit_return(v.code);
+                return true;
+            }
+            case 41 /* OP.return_undef */:
+                this.before_stmt();
+                this.emit_return('undefined');
+                return true;
+            case 42 /* OP.check_ctor_return */: {
+                const r = this.dup_code(this.depth - 1);
+                this.before_stmt();
+                this.emit(`if (!${this.guard_obj(r)} && ${r} !== undefined) $RT.throw_type_error("derived class constructor must return an object or undefined");`);
+                this.push(P(`!${this.guard_obj(r)}`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 43 /* OP.check_ctor */:
+                this.before_stmt();
+                this.emit(`if ($nt === undefined) $RT.throw_type_error("class constructors must be invoked with 'new'");`);
+                return false;
+            case 44 /* OP.init_ctor */:
+                this.push(P(`$RT.init_ctor($fo, $nt, arguments, ${fi.arg_off})`, 3 /* PK.EXPR */));
+                return false;
+            case 45 /* OP.check_brand */: {
+                const f = this.dup_code(this.depth - 1), o = this.dup_code(this.depth - 2);
+                this.before_stmt();
+                this.emit(`$RT.check_brand(${o}, ${f});`);
+                return false;
+            }
+            case 46 /* OP.add_brand */: {
+                const f = this.pop(), o = this.pop();
+                this.before_stmt();
+                this.emit(`$RT.add_brand(${this.par(o)}, ${this.par(f)});`);
+                return false;
+            }
+            case 48 /* OP.throw */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`throw ${v.code};`);
+                this.blk.term = { kind: 'none' };
+                return true;
+            }
+            case 49 /* OP.throw_error */:
+                this.before_stmt();
+                this.emit(`$RT.throw_error(${insn.a}, ${insn.b});`);
+                this.blk.term = { kind: 'none' };
+                return true;
+            case 52 /* OP.regexp */: {
+                const flags = this.pop(), pat = this.pop();
+                this.push(P(`$RT.regexp(${this.par(pat)}, ${this.par(flags)})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 53 /* OP.get_super */: {
+                const o = this.dup_code(this.depth - 1);
+                this.pop();
+                this.push(P(`(${this.guard_obj(o)} ? $getproto(${o}) : $RT.get_prototype(${o}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            /* --- globals --- */
+            case 55 /* OP.check_var */:
+                this.push(P(`$RT.check_var(${insn.a})`, 3 /* PK.EXPR */));
+                return false;
+            case 56 /* OP.get_var_undef */:
+            case 57 /* OP.get_var */: {
+                /* inline fast path: the global variable table ($GV, lexical globals, TDZ sentinel $U)
+                   then the global object ($G); the runtime handles the slow cases (undefined values,
+                   missing variables, errors) */
+                const acc = this.global_access(insn.a);
+                if (acc === null) {
+                    this.push(P(`$RT.get_global(${insn.a}, ${op === 57 /* OP.get_var */})`, 3 /* PK.EXPR */));
+                    return false;
+                }
+                fi.uses_global = true;
+                const slow = `$RT.get_global(${insn.a}, ${op === 57 /* OP.get_var */})`;
+                const g = op === 57 /* OP.get_var */ ? `(($g = $G${acc}) !== undefined ? $g : ${slow})` : `$G${acc}`;
+                this.push(P(`(($g = $GV${acc}) !== undefined ? ($g === $U ? ${slow} : $g) : ${g})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 58 /* OP.put_var */:
+            case 59 /* OP.put_var_init */: {
+                const acc = this.global_access(insn.a);
+                if (op === 59 /* OP.put_var_init */ || acc === null) {
+                    const v = this.pop();
+                    this.before_stmt();
+                    this.emit(`$RT.put_global(${insn.a}, ${v.code}, ${op - 58 /* OP.put_var */}, ${fi.strict});`);
+                    return false;
+                }
+                const v = this.dup_code(this.depth - 1);
+                this.pop();
+                this.before_stmt();
+                const key = key_value(fi, insn.a);
+                if (fi.strict) {
+                    this.emit(`if (${key} in $GV || !(${key} in $G)) $RT.put_global(${insn.a}, ${v}, 0, true); else $G${acc} = ${v};`);
+                }
+                else {
+                    /* sloppy assignment semantics (no throw) come from a non-strict helper in the factory scope */
+                    let idx = fi.sloppy_sets.get(insn.a);
+                    if (idx === undefined) {
+                        idx = fi.sloppy_sets.size;
+                        fi.sloppy_sets.set(insn.a, idx);
+                    }
+                    this.emit(`$ss${idx}(${v});`);
+                }
+                return false;
+            }
+            case 60 /* OP.put_var_strict */: {
+                const v = this.pop();
+                const flag = this.pop();
+                this.before_stmt();
+                this.emit(`$RT.put_global_strict(${insn.a}, ${this.par(flag)}, ${v.code});`);
+                return false;
+            }
+            case 64 /* OP.check_define_var */:
+                this.before_stmt();
+                this.emit(`$RT.check_define_var(${insn.a}, ${insn.b});`);
+                return false;
+            case 63 /* OP.define_var */:
+                this.before_stmt();
+                this.emit(`$RT.define_var(${insn.a}, ${insn.b});`);
+                return false;
+            case 65 /* OP.define_func */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`$RT.define_func(${insn.a}, ${v.code}, ${insn.b});`);
+                return false;
+            }
+            case 122 /* OP.make_loc_ref */:
+            case 123 /* OP.make_arg_ref */:
+            case 124 /* OP.make_var_ref_ref */: {
+                /* the reference object is static (see KT.REF); only the property name is a value */
+                this.push(P('undefined', 0 /* PK.LIT */));
+                if (fi.atom_is_symbol(insn.a))
+                    this.push(P(`$RT.atom_value(${insn.a})`, 3 /* PK.EXPR */));
+                else
+                    this.push(P(JSON.stringify(fi.atom_name(insn.a)), 0 /* PK.LIT */));
+                return false;
+            }
+            case 125 /* OP.make_var_ref */: {
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = $RT.get_global_ref(${insn.a}); $s${d + 1} = $s${d}[1]; $s${d} = $s${d}[0];`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                this.push(P(`$s${d + 1}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            case 155 /* OP.delete_var */:
+                this.push(P(`$RT.delete_global(${insn.a})`, 3 /* PK.EXPR */));
+                return false;
+            /* --- locals --- */
+            case 89 /* OP.get_loc */:
+            case 196 /* OP.get_loc8 */:
+            case 199 /* OP.get_loc0 */:
+            case 200 /* OP.get_loc1 */:
+            case 201 /* OP.get_loc2 */:
+            case 202 /* OP.get_loc3 */:
+                this.push(this.var_read(insn.a));
+                return false;
+            case 90 /* OP.put_loc */:
+            case 197 /* OP.put_loc8 */:
+            case 203 /* OP.put_loc0 */:
+            case 204 /* OP.put_loc1 */:
+            case 205 /* OP.put_loc2 */:
+            case 206 /* OP.put_loc3 */: {
+                const v = this.pop();
+                this.write_local(false, insn.a, v.code);
+                return false;
+            }
+            case 91 /* OP.set_loc */:
+            case 198 /* OP.set_loc8 */:
+            case 207 /* OP.set_loc0 */:
+            case 208 /* OP.set_loc1 */:
+            case 209 /* OP.set_loc2 */:
+            case 210 /* OP.set_loc3 */: {
+                const c = this.dup_code(this.depth - 1);
+                this.write_local(false, insn.a, c);
+                return false;
+            }
+            case 92 /* OP.get_arg */:
+            case 211 /* OP.get_arg0 */:
+            case 212 /* OP.get_arg1 */:
+            case 213 /* OP.get_arg2 */:
+            case 214 /* OP.get_arg3 */:
+                this.push(this.arg_read(insn.a));
+                return false;
+            case 93 /* OP.put_arg */:
+            case 215 /* OP.put_arg0 */:
+            case 216 /* OP.put_arg1 */:
+            case 217 /* OP.put_arg2 */:
+            case 218 /* OP.put_arg3 */: {
+                const v = this.pop();
+                this.write_local(true, insn.a, v.code);
+                return false;
+            }
+            case 94 /* OP.set_arg */:
+            case 219 /* OP.set_arg0 */:
+            case 220 /* OP.set_arg1 */:
+            case 221 /* OP.set_arg2 */:
+            case 222 /* OP.set_arg3 */: {
+                const c = this.dup_code(this.depth - 1);
+                this.write_local(true, insn.a, c);
+                return false;
+            }
+            case 95 /* OP.get_var_ref */:
+            case 223 /* OP.get_var_ref0 */:
+            case 224 /* OP.get_var_ref1 */:
+            case 225 /* OP.get_var_ref2 */:
+            case 226 /* OP.get_var_ref3 */:
+                this.push(P(`$vr[${insn.a}].get()`, 3 /* PK.EXPR */));
+                return false;
+            case 96 /* OP.put_var_ref */:
+            case 227 /* OP.put_var_ref0 */:
+            case 228 /* OP.put_var_ref1 */:
+            case 229 /* OP.put_var_ref2 */:
+            case 230 /* OP.put_var_ref3 */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`$vr[${insn.a}].set(${v.code});`);
+                return false;
+            }
+            case 97 /* OP.set_var_ref */:
+            case 231 /* OP.set_var_ref0 */:
+            case 232 /* OP.set_var_ref1 */:
+            case 233 /* OP.set_var_ref2 */:
+            case 234 /* OP.set_var_ref3 */: {
+                const c = this.dup_code(this.depth - 1);
+                this.before_stmt();
+                this.emit(`$vr[${insn.a}].set(${c});`);
+                return false;
+            }
+            case 103 /* OP.get_var_ref_check */: {
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = $vr[${insn.a}].get(); if ($s${d} === $U) $RT.throw_uninitialized($b, ${insn.a}, true);`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            case 104 /* OP.put_var_ref_check */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`if ($vr[${insn.a}].get() === $U) $RT.throw_uninitialized($b, ${insn.a}, true); $vr[${insn.a}].set(${v.code});`);
+                return false;
+            }
+            case 105 /* OP.put_var_ref_check_init */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`if ($vr[${insn.a}].get() !== $U) $RT.throw_uninitialized($b, ${insn.a}, true); $vr[${insn.a}].set(${v.code});`);
+                return false;
+            }
+            case 98 /* OP.set_loc_uninitialized */:
+                this.write_local(false, insn.a, '$U');
+                return false;
+            case 99 /* OP.get_loc_check */:
+            case 102 /* OP.get_loc_checkthis */: {
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = ${this.local_value(false, insn.a)}; if ($s${d} === $U) $RT.throw_uninitialized($b, ${insn.a}, false);`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            case 100 /* OP.put_loc_check */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`if (${this.local_value(false, insn.a)} === $U) $RT.throw_uninitialized($b, ${insn.a}, false);`);
+                this.write_local(false, insn.a, v.code);
+                return false;
+            }
+            case 101 /* OP.put_loc_check_init */: {
+                const v = this.pop();
+                this.before_stmt();
+                this.emit(`if (${this.local_value(false, insn.a)} !== $U) $RT.throw_reference_error("'this' can be initialized only once");`);
+                this.write_local(false, insn.a, v.code);
+                return false;
+            }
+            case 106 /* OP.close_loc */:
+                if (fi.varCell[insn.a]) {
+                    this.before_stmt();
+                    this.emit(`${fi.varName[insn.a]} = $RT.new_cell(${fi.varName[insn.a]}.get());`);
+                }
+                return false;
+            /* --- control flow --- */
+            case 109 /* OP.goto */:
+            case 238 /* OP.goto8 */:
+            case 239 /* OP.goto16 */:
+                this.finalize();
+                this.blk.term = { kind: 'jump', target: insn.label };
+                return true;
+            case 108 /* OP.if_true */:
+            case 107 /* OP.if_false */:
+            case 237 /* OP.if_true8 */:
+            case 236 /* OP.if_false8 */: {
+                let cond = this.pop();
+                if (this.needs_moves() && cond.kind !== 0 /* PK.LIT */) {
+                    const t = this.tmp();
+                    this.flush_exprs();
+                    this.emit(`${t} = ${cond.code};`);
+                    cond = P(t, 1 /* PK.TEMP */);
+                }
+                this.finalize();
+                const isTrue = (op === 108 /* OP.if_true */ || op === 237 /* OP.if_true8 */);
+                this.blk.term = { kind: 'cond', cond: cond.code, tTrue: isTrue ? insn.label : insn.next, tFalse: isTrue ? insn.next : insn.label };
+                return true;
+            }
+            case 110 /* OP.catch */:
+                this.push(P('undefined', 0 /* PK.LIT */));
+                return false;
+            case 111 /* OP.gosub */: {
+                const d = this.depth;
+                const site = fi.A.sites.find(s => s.pc === insn.pc);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                this.finalize();
+                this.emit(`$s${d} = ${site.id};`);
+                this.blk.term = { kind: 'jump', target: insn.label };
+                return true;
+            }
+            case 112 /* OP.ret */: {
+                const k = fi.A.states[insn.pc][this.depth - 1];
+                if (!k || k.t !== 3 /* KT.RET */)
+                    bail('ret without return address');
+                this.pop();
+                this.finalize();
+                const d = this.depth;
+                this.blk.term = { kind: 'multi', multi: { expr: `$s${d}`, cases: k.sites.map(id => ({ value: id, target: fi.A.sites[id].cont })) } };
+                return true;
+            }
+            case 113 /* OP.nip_catch */: {
+                const rv = this.pop();
+                let i = this.depth - 1;
+                while (i >= 0 && this.blk_kind(i).t !== 1 /* KT.CATCH */ && this.blk_kind(i).t !== 2 /* KT.CATCH0 */)
+                    i--;
+                if (i < 0)
+                    bail('nip_catch');
+                /* drop everything above the catch slot (their effects, if pending) and the catch slot */
+                const dropped = this.slots.splice(i, this.depth - i);
+                this.flush_exprs();
+                for (const p of dropped)
+                    this.drop_value(p);
+                this.push(rv);
+                return false;
+            }
+            /* --- iteration --- */
+            case 126 /* OP.for_in_start */: {
+                const o = this.pop();
+                this.push(P(`$RT.for_in_start(${this.par(o)})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 129 /* OP.for_in_next */: {
+                const it = this.dup_code(this.depth - 1);
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = $RT.for_in_next(${it}); if ($s${d} === $D) { $s${d} = undefined; $s${d + 1} = true; } else $s${d + 1} = false;`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                this.push(P(`$s${d + 1}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            case 127 /* OP.for_of_start */: {
+                const o = this.pop();
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = $RT.get_iterator(${this.par(o)}); $s${d + 1} = ${this.get_field_atom(`$s${d}`, 'next')};`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                this.push(P(`$s${d + 1}`, 1 /* PK.TEMP */));
+                this.push(P('undefined', 0 /* PK.LIT */));
+                return false;
+            }
+            case 130 /* OP.for_of_next */: {
+                const offset = -3 - insn.a;
+                const iter = this.depth + offset;
+                if (iter < 0)
+                    bail('for_of_next offset');
+                this.materialize(iter);
+                this.materialize(iter + 1);
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = $RT.for_of_next($s${iter}, $s${iter + 1}); if ($s${d} === $D) { $s${iter} = undefined; $s${d} = undefined; $s${d + 1} = true; } else $s${d + 1} = false;`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                this.push(P(`$s${d + 1}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            case 132 /* OP.iterator_check_object */: {
+                const v = this.dup_code(this.depth - 1);
+                this.before_stmt();
+                this.emit(`if (!${this.guard_obj(v)}) $RT.throw_type_error("iterator must return an object");`);
+                return false;
+            }
+            case 134 /* OP.iterator_close */: {
+                const c = this.pop();
+                const nx = this.pop();
+                const it = this.pop();
+                this.before_stmt();
+                this.drop_value(c);
+                this.drop_value(nx);
+                const itc = it.kind === 3 /* PK.EXPR */ ? (() => { const t = this.tmp(); this.emit(`${t} = ${it.code};`); return t; })() : it.code;
+                this.emit(`if (${itc} !== undefined) $RT.iterator_close(${itc});`);
+                return false;
+            }
+            case 135 /* OP.iterator_next */: {
+                /* iter next catch val -> iter next catch ret */
+                const val = this.pop();
+                const it = this.dup_code(this.depth - 3), nx = this.dup_code(this.depth - 2);
+                this.push(P(this.call_with_this(nx, it, [this.par(val)]), 3 /* PK.EXPR */));
+                return false;
+            }
+            case 136 /* OP.iterator_call */: {
+                const val = this.dup_code(this.depth - 1);
+                const it = this.dup_code(this.depth - 4);
+                const d = this.depth;
+                this.before_stmt();
+                const t = this.tmp();
+                this.emit(`${t} = $RT.iterator_call(${it}, ${val}, ${insn.a}); if (${t} === $D) $s${d} = true; else { $s${d - 1} = ${t}; $s${d} = false; }`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            /* --- properties --- */
+            case 66 /* OP.get_field */: {
+                const o = this.dup_code(this.depth - 1);
+                this.pop();
+                this.push(P(this.get_field(o, insn.a), 3 /* PK.EXPR */));
+                return false;
+            }
+            case 67 /* OP.get_field2 */: {
+                const o = this.dup_code(this.depth - 1);
+                const method = is_prim_literal(o) ? null
+                    : { recv: o, access: key_access(fi, insn.a), prim: '$RT.call_method_prim', prim_args: `${o}, ${insn.a}`, pc: this.cur_pc };
+                this.push(P(this.get_field(o, insn.a), 3 /* PK.EXPR */, { method }));
+                return false;
+            }
+            case 235 /* OP.get_length */: {
+                const o = this.dup_code(this.depth - 1);
+                this.pop();
+                this.push(P(is_prim_literal(o) ? `$RT.get_length(${o})` : `(${this.guard_obj(o)} ? ${o}${this.M()}.length${this.M()} : $RT.get_length(${o}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 68 /* OP.put_field */: {
+                const v = this.pop();
+                const o = this.dup_code(this.depth - 1);
+                this.pop();
+                this.before_stmt();
+                this.emit(this.put_field_stmt(o, insn.a, is_prim_literal(o) ? v.code : this.store_value(v)));
+                return false;
+            }
+            case 72 /* OP.get_array_el */: {
+                const k = this.dup_code(this.depth - 1);
+                const o = this.dup_code(this.depth - 2);
+                this.pop();
+                this.pop();
+                this.push(P(this.get_el(o, k), 3 /* PK.EXPR */));
+                return false;
+            }
+            case 73 /* OP.get_array_el2 */: {
+                const k = this.dup_code(this.depth - 1);
+                const o = this.dup_code(this.depth - 2);
+                this.pop();
+                const method = is_prim_literal(o) ? null
+                    : { recv: o, access: `[${k}]`, prim: '$RT.call_method_prim_key', prim_args: `${o}, ${k}`, pc: this.cur_pc };
+                this.push(P(this.get_el(o, k), 3 /* PK.EXPR */, { method }));
+                return false;
+            }
+            case 74 /* OP.put_array_el */: {
+                const v = this.pop();
+                const k = this.dup_code(this.depth - 1);
+                const o = this.dup_code(this.depth - 2);
+                this.pop();
+                this.pop();
+                this.before_stmt();
+                this.emit(this.put_el_stmt(o, k, is_prim_literal(o) ? v.code : this.store_value(v)));
+                return false;
+            }
+            case 61 /* OP.get_ref_value */: {
+                const rk = this.kind_at(this.depth - 2);
+                if (rk.t === 4 /* KT.REF */) {
+                    this.push(this.ref_read(rk));
+                    return false;
+                }
+                const k = this.dup_code(this.depth - 1);
+                const o = this.dup_code(this.depth - 2);
+                this.push(P(`$RT.get_ref_value(${o}, ${k}, ${fi.strict})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 62 /* OP.put_ref_value */: {
+                const rk = this.kind_at(this.depth - 3);
+                const v = this.pop();
+                const k = this.pop();
+                const o = this.pop();
+                if (rk.t === 4 /* KT.REF */) {
+                    this.drop_value(k);
+                    this.ref_write(rk, v.code);
+                    return false;
+                }
+                this.before_stmt();
+                this.emit(`$RT.put_ref_value(${this.par(o)}, ${this.par(k)}, ${v.code}, ${fi.strict});`);
+                return false;
+            }
+            case 75 /* OP.get_super_value */: {
+                const k = this.pop();
+                const o = this.pop();
+                const t = this.pop();
+                this.push(P(`$RT.get_super_value(${this.par(t)}, ${this.par(o)}, ${this.par(k)})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 76 /* OP.put_super_value */: {
+                const v = this.pop();
+                const k = this.pop();
+                const o = this.pop();
+                const t = this.pop();
+                this.before_stmt();
+                this.emit(`$RT.put_super_value(${this.par(t)}, ${this.par(o)}, ${this.par(k)}, ${v.code});`);
+                return false;
+            }
+            case 77 /* OP.define_field */: {
+                const v = this.pop();
+                const o = this.dup_code(this.depth - 1);
+                const slot = this.top();
+                this.before_stmt();
+                const name = __JS_AtomIsTaggedInt(insn.a) ? null : fi.atom_name(insn.a);
+                if (slot.fresh && name !== null && name !== '__proto__' && !(slot.mkeys && slot.mkeys.has(name))) {
+                    /* fresh object literal: a plain assignment while Object.prototype has no accessors */
+                    const vc = this.store_value(v);
+                    this.emit(`if ($P.ok) ${o}${key_access(fi, insn.a)} = ${vc}; else $RT.define_field(${o}, ${insn.a}, ${vc});`);
+                }
+                else {
+                    this.emit(`$RT.define_field(${o}, ${insn.a}, ${v.code});`);
+                }
+                return false;
+            }
+            case 82 /* OP.define_array_el */: {
+                const v = this.pop();
+                const pos = this.dup_code(this.depth - 1);
+                const arr = this.dup_code(this.depth - 2);
+                this.before_stmt();
+                this.emit(`$RT.define_array_el(${arr}, ${pos}, ${v.code});`);
+                return false;
+            }
+            case 83 /* OP.append */: {
+                const src = this.pop();
+                const pos = this.depth - 1;
+                this.materialize(pos);
+                const arr = this.dup_code(this.depth - 2);
+                this.before_stmt();
+                this.emit(`$s${pos} = $RT.append(${arr}, $s${pos}, ${src.code});`);
+                return false;
+            }
+            case 84 /* OP.copy_data_properties */: {
+                const mask = insn.a;
+                const d = this.depth;
+                const tgt = this.dup_code(d - 1 - (mask & 3)), src = this.dup_code(d - 1 - ((mask >> 2) & 7)), excl = this.dup_code(d - 1 - ((mask >> 5) & 7));
+                this.before_stmt();
+                this.emit(`$RT.copy_data_properties(${tgt}, ${src}, ${excl});`);
+                return false;
+            }
+            case 69 /* OP.get_private_field */: {
+                const name = this.pop();
+                const o = this.pop();
+                this.push(P(`$RT.get_private_field(${this.par(o)}, ${this.par(name)})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 70 /* OP.put_private_field */: { /* obj value prop -> */
+                const name = this.pop();
+                const v = this.pop();
+                const o = this.pop();
+                this.before_stmt();
+                this.emit(`$RT.put_private_field(${this.par(o)}, ${this.par(name)}, ${this.par(v)});`);
+                return false;
+            }
+            case 71 /* OP.define_private_field */: { /* obj prop value -> obj */
+                const v = this.pop();
+                const name = this.pop();
+                const o = this.dup_code(this.depth - 1);
+                this.before_stmt();
+                this.emit(`$RT.define_private_field(${o}, ${this.par(name)}, ${v.code});`);
+                return false;
+            }
+            case 179 /* OP.private_in */: {
+                const name = this.pop();
+                const o = this.pop();
+                this.push(P(`$RT.private_in(${this.par(o)}, ${this.par(name)})`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 78 /* OP.set_name */: {
+                const f = this.dup_code(this.depth - 1);
+                this.before_stmt();
+                this.emit(`$RT.set_name(${f}, ${insn.a});`);
+                return false;
+            }
+            case 79 /* OP.set_name_computed */: {
+                const f = this.dup_code(this.depth - 1), name = this.dup_code(this.depth - 2);
+                this.before_stmt();
+                this.emit(`$RT.set_name_computed(${f}, ${name});`);
+                return false;
+            }
+            case 80 /* OP.set_proto */: {
+                const p = this.pop();
+                const o = this.dup_code(this.depth - 1);
+                this.top().fresh = false;
+                this.before_stmt();
+                this.emit(`$RT.set_proto(${o}, ${p.code});`);
+                return false;
+            }
+            case 81 /* OP.set_home_object */: {
+                const f = this.dup_code(this.depth - 1), home = this.dup_code(this.depth - 2);
+                this.before_stmt();
+                this.emit(`$RT.set_home_object(${f}, ${home});`);
+                return false;
+            }
+            case 85 /* OP.define_method */: {
+                const f = this.pop();
+                const o = this.dup_code(this.depth - 1);
+                const slot = this.top();
+                if (slot.fresh) {
+                    if (!slot.mkeys)
+                        slot.mkeys = new Set();
+                    slot.mkeys.add(fi.atom_name(insn.a));
+                }
+                this.before_stmt();
+                this.emit(`$RT.define_method(${o}, ${insn.a}, ${f.code}, ${insn.b}, false);`);
+                return false;
+            }
+            case 86 /* OP.define_method_computed */: {
+                const f = this.pop();
+                const name = this.pop();
+                const o = this.dup_code(this.depth - 1);
+                this.top().fresh = false;
+                this.before_stmt();
+                this.emit(`$RT.define_method(${o}, ${this.par(name)}, ${f.code}, ${insn.a}, true);`);
+                return false;
+            }
+            case 87 /* OP.define_class */:
+            case 88 /* OP.define_class_computed */: {
+                /* [name] parent ctor_bytecode -> [name] ctor proto */
+                const bf = this.pop();
+                const parent = this.pop();
+                if (bf.cpool < 0 || !(fi.b.cpool[bf.cpool] instanceof JSFunctionBytecode))
+                    bail('define_class without constructor bytecode');
+                const child = fi.b.cpool[bf.cpool];
+                const computed = op === 88 /* OP.define_class_computed */;
+                const name = computed ? this.dup_code(this.depth - 1) : String(insn.a);
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = $RT.define_class(${name}, ${this.par(parent)}, $cpool[${bf.cpool}], ${insn.b}, ${this.closure_refs(child)}, ${computed}); $s${d + 1} = $s${d}[1]; $s${d} = $s${d}[0];`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                this.push(P(`$s${d + 1}`, 1 /* PK.TEMP */));
+                return false;
+            }
+            case 114 /* OP.to_object */: {
+                const v = this.dup_code(this.depth - 1);
+                this.pop();
+                this.push(P(is_prim_literal(v) ? `$RT.to_object(${v})` : `(${this.guard_obj(v)} ? ${v} : $RT.to_object(${v}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 115 /* OP.to_propkey */: {
+                const v = this.dup_code(this.depth - 1);
+                this.pop();
+                this.push(P(`(typeof ${v} === 'string' || typeof ${v} === 'number' || typeof ${v} === 'symbol' ? ${v} : $RT.to_propkey(${v}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 116 /* OP.to_propkey2 */: {
+                const k = this.dup_code(this.depth - 1);
+                const o = this.dup_code(this.depth - 2);
+                this.pop();
+                this.before_stmt();
+                this.emit(`if (${o} === undefined || ${o} === null) $RT.throw_type_error("value has no property");`);
+                this.push(P(`(typeof ${k} === 'string' || typeof ${k} === 'number' || typeof ${k} === 'symbol' ? ${k} : $RT.to_propkey(${k}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 154 /* OP.delete */: {
+                const k = this.dup_code(this.depth - 1);
+                const o = this.dup_code(this.depth - 2);
+                this.pop();
+                this.pop();
+                if (is_prim_literal(o))
+                    this.push(P(`$RT.delete(${o}, ${k}, ${fi.strict})`, 3 /* PK.EXPR */));
+                else if (fi.strict)
+                    this.push(P(`(${this.guard_obj(o)} ? delete ${o}[${k}] : $RT.delete(${o}, ${k}, true))`, 3 /* PK.EXPR */));
+                else {
+                    fi.uses_sdel = true;
+                    this.push(P(`(${this.guard_obj(o)} ? $sdel(${o}, ${k}) : $RT.delete(${o}, ${k}, false))`, 3 /* PK.EXPR */));
+                }
+                return false;
+            }
+            /* --- operators --- */
+            case 159 /* OP.add */: return this.binop('+');
+            case 160 /* OP.sub */: return this.binop('-');
+            case 156 /* OP.mul */: return this.binop('*');
+            case 157 /* OP.div */: return this.binop('/');
+            case 158 /* OP.mod */: return this.binop('%');
+            case 161 /* OP.pow */: return this.binop('**');
+            case 162 /* OP.shl */: return this.binop('<<');
+            case 163 /* OP.sar */: return this.binop('>>');
+            case 164 /* OP.shr */: return this.binop('>>>');
+            case 175 /* OP.and */: return this.binop('&');
+            case 177 /* OP.or */: return this.binop('|');
+            case 176 /* OP.xor */: return this.binop('^');
+            case 165 /* OP.lt */: return this.binop('<');
+            case 166 /* OP.lte */: return this.binop('<=');
+            case 167 /* OP.gt */: return this.binop('>');
+            case 168 /* OP.gte */: return this.binop('>=');
+            case 171 /* OP.eq */: return this.binop('==');
+            case 172 /* OP.neq */: return this.binop('!=');
+            case 173 /* OP.strict_eq */: return this.binop('===');
+            case 174 /* OP.strict_neq */: return this.binop('!==');
+            case 150 /* OP.add_loc */: {
+                const v = this.pop();
+                const cur = this.local_value(false, insn.a);
+                this.write_local(false, insn.a, `${cur} + ${this.par(v)}`);
+                return false;
+            }
+            case 149 /* OP.inc_loc */:
+            case 148 /* OP.dec_loc */: {
+                const cur = this.local_value(false, insn.a);
+                const o = op === 149 /* OP.inc_loc */ ? '+' : '-';
+                this.write_local(false, insn.a, `(typeof ${cur} === 'number' ? ${cur} ${o} 1 : $RT.${op === 149 /* OP.inc_loc */ ? 'inc' : 'dec'}(${cur}))`);
+                return false;
+            }
+            case 145 /* OP.inc */:
+            case 144 /* OP.dec */: {
+                const x = this.dup_code(this.depth - 1);
+                this.pop();
+                const o = op === 145 /* OP.inc */ ? '+' : '-';
+                this.push(P(`(typeof ${x} === 'number' ? ${x} ${o} 1 : $RT.${op === 145 /* OP.inc */ ? 'inc' : 'dec'}(${x}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 147 /* OP.post_inc */:
+            case 146 /* OP.post_dec */: {
+                const x = this.dup_code(this.depth - 1);
+                this.pop();
+                const d = this.depth;
+                this.before_stmt();
+                this.emit(`$s${d} = typeof ${x} === 'number' ? ${x} : $RT.to_numeric(${x});`);
+                this.push(P(`$s${d}`, 1 /* PK.TEMP */));
+                const o = op === 147 /* OP.post_inc */ ? '+' : '-';
+                this.push(P(`(typeof $s${d} === 'number' ? $s${d} ${o} 1 : $RT.${op === 147 /* OP.post_inc */ ? 'inc' : 'dec'}($s${d}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 142 /* OP.neg */:
+            case 143 /* OP.plus */:
+            case 151 /* OP.not */: {
+                const x = this.pop();
+                const o = op === 142 /* OP.neg */ ? '-' : op === 143 /* OP.plus */ ? '+' : '~';
+                this.push(P(`${o}${this.par(x)}`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 152 /* OP.lnot */: {
+                const x = this.pop();
+                this.push(P(`!${this.par(x)}`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 153 /* OP.typeof */: {
+                const x = this.pop();
+                this.push(P(`typeof ${this.par(x)}`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 246 /* OP.typeof_is_undefined */: {
+                const x = this.pop();
+                this.push(P(`(typeof ${this.par(x)} === 'undefined')`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 247 /* OP.typeof_is_function */: {
+                const x = this.pop();
+                this.push(P(`(typeof ${this.par(x)} === 'function')`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 244 /* OP.is_undefined */: {
+                const x = this.pop();
+                this.push(P(`(${this.par(x)} === undefined)`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 245 /* OP.is_null */: {
+                const x = this.pop();
+                this.push(P(`(${this.par(x)} === null)`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 178 /* OP.is_undefined_or_null */: {
+                const x = this.dup_code(this.depth - 1);
+                this.pop();
+                this.push(P(`(${x} === undefined || ${x} === null)`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 170 /* OP.in */: {
+                const o = this.dup_code(this.depth - 1);
+                const k = this.dup_code(this.depth - 2);
+                this.pop();
+                this.pop();
+                if (is_prim_literal(o))
+                    this.push(P(`$RT.in(${k}, ${o})`, 3 /* PK.EXPR */));
+                else
+                    this.push(P(`(${this.guard_obj(o)} ? (${k} in ${o}) : $RT.in(${k}, ${o}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 169 /* OP.instanceof */: {
+                const c = this.dup_code(this.depth - 1);
+                const v = this.dup_code(this.depth - 2);
+                this.pop();
+                this.pop();
+                if (is_prim_literal(c))
+                    this.push(P(`$RT.instanceof(${v}, ${c})`, 3 /* PK.EXPR */));
+                else
+                    this.push(P(`(${this.guard_obj(c)} ? (${v} instanceof ${c}) : $RT.instanceof(${v}, ${c}))`, 3 /* PK.EXPR */));
+                return false;
+            }
+            case 181 /* OP.nop */: return false;
+            default:
+                bail(`unsupported opcode ${insn.name}`);
+        }
+    }
+    binop(o) {
+        const b = this.pop();
+        const a = this.pop();
+        /* JSC reports a binary expression at its start (the marker push() adds), V8 at the operator */
+        this.push(P(`${this.par(a)} ${this.M()}${o} ${this.par(b)}`, 3 /* PK.EXPR */));
+        return false;
+    }
+    /* kind of slot i before the current instruction */
+    kind_at(i) {
+        const st = this.fi.A.states[this.cur_pc];
+        return st[i] ?? KV;
+    }
+    blk_kind(i) { return this.kind_at(i); }
+    cur_pc = 0;
+    ref_read(k) {
+        switch (k.ref_kind) {
+            case 0 /* RefKind.LOC */: return this.var_read(k.ref_idx);
+            case 1 /* RefKind.ARG */: return this.arg_read(k.ref_idx);
+            default: return P(`$vr[${k.ref_idx}].get()`, 3 /* PK.EXPR */);
+        }
+    }
+    ref_write(k, value) {
+        switch (k.ref_kind) {
+            case 0 /* RefKind.LOC */:
+                this.write_local(false, k.ref_idx, value);
+                break;
+            case 1 /* RefKind.ARG */:
+                this.write_local(true, k.ref_idx, value);
+                break;
+            default:
+                this.before_stmt();
+                this.emit(`$vr[${k.ref_idx}].set(${value});`);
+                break;
+        }
+    }
+    needs_moves() {
+        for (let i = 0; i < this.depth; i++) {
+            const p = this.slots[i];
+            if (!(p.kind === 1 /* PK.TEMP */ && p.code === `$s${i}`))
+                return true;
+        }
+        return false;
+    }
+    pop_args(argc) {
+        const args = [];
+        for (let i = 0; i < argc; i++)
+            args.push(this.pop().code);
+        return args.reverse();
+    }
+    get_field_atom(obj, name) {
+        if (is_prim_literal(obj))
+            return `$RT.get_field_str(${obj}, ${JSON.stringify(name)})`;
+        return `(${this.guard_obj(obj)} ? ${obj}${this.M()}.${name}${this.M()} : $RT.get_field_str(${obj}, ${JSON.stringify(name)}))`;
+    }
+    emit_return(value) {
+        const fi = this.fi;
+        if (fi.constructible && !fi.derived) {
+            const t = this.tmp();
+            this.emit(`${t} = ${value}; return $nt !== undefined ? (${this.guard_obj(t)} ? ${t} : $t) : ${t};`);
+        }
+        else if (value.indexOf('(') >= 0) {
+            /* never `return f()`: JavaScriptCore elides the frame of a strict-mode tail call, which
+               would hide the function from backtraces and turn tail recursion into an endless loop
+               instead of a stack overflow */
+            this.emit(`$r = ${value}; return $r;`);
+        }
+        else {
+            this.emit(`return ${value};`);
+        }
+        this.blk.term = { kind: 'none' };
+    }
+    /* `.name` / `["name"]` access text for a global variable atom, or null for a symbol */
+    global_access(atom) {
+        if (__JS_AtomIsTaggedInt(atom) || this.fi.atom_is_symbol(atom))
+            return null;
+        return key_access(this.fi, atom);
+    }
+    /* the var_refs array expression for a child closure */
+    closure_refs(child) {
+        const fi = this.fi;
+        const refs = [];
+        for (const cv of child.closure_var) {
+            if (cv.is_local) {
+                if (cv.is_arg) {
+                    if (!fi.argCell[cv.var_idx])
+                        bail('closure captures an argument that is not a cell');
+                    refs.push(fi.argName[cv.var_idx]);
+                }
+                else {
+                    if (!fi.varCell[cv.var_idx])
+                        bail('closure captures a local that is not a cell');
+                    refs.push(fi.varName[cv.var_idx]);
+                }
+            }
+            else {
+                refs.push(`$vr[${cv.var_idx}]`);
+            }
+        }
+        return `[${refs.join(', ')}]`;
+    }
+}
+class Relooper {
+    fi;
+    cfg;
+    labelCount = 0;
+    nodeMap = new Map(); /* all nodes of all regions, by node id */
+    blockNode = new Map(); /* block id -> node id representing it in its parent's graph (block or region) */
+    constructor(fi, cfg) {
+        this.fi = fi;
+        this.cfg = cfg;
+    }
+    label(prefix) { return `${prefix}${this.labelCount++}`; }
+    /* region whose graph is being emitted */
+    curRegion = null;
+    /* node id representing the block at `pc` inside the current region graph: the block itself,
+       or the child region that contains it */
+    target_node(pc) {
+        const tb = this.cfg.byPc.get(pc);
+        if (!tb)
+            bail(`branch to unknown block ${pc}`);
+        const r = this.curRegion;
+        if (tb.region === r)
+            return tb.id;
+        let d = tb.region;
+        while (d && d.parent !== r)
+            d = d.parent;
+        if (d)
+            return this.region_node_id(d);
+        /* exit to an enclosing region: the block id (resolved through the context stack) */
+        return tb.id;
+    }
+    region_node_id(r) { return -r.id - 1; }
+    /* build the node graph of every region */
+    build() {
+        const { blocks, byPc } = this.cfg;
+        /* block successors */
+        for (const blk of blocks) {
+            if (blk.dead)
+                continue;
+            const t = blk.term;
+            const targets = [];
+            const add = (pc) => {
+                if (pc === undefined)
+                    return;
+                const tb = byPc.get(pc);
+                if (!tb)
+                    bail(`branch to unknown block ${pc}`);
+                targets.push(tb.id);
+            };
+            switch (t.kind) {
+                case 'fall':
+                case 'jump':
+                    add(t.target);
+                    break;
+                case 'cond':
+                    add(t.tTrue);
+                    add(t.tFalse);
+                    break;
+                case 'multi':
+                    for (const c of t.multi.cases)
+                        add(c.target);
+                    break;
+                case 'none': break;
+            }
+            blk.succs = [...new Set(targets)];
+        }
+        /* region exits and node graphs */
+        for (const r of this.cfg.regions) {
+            for (const blk of r.blocks) {
+                for (const s of blk.succs) {
+                    const tb = blocks[s];
+                    if (tb.region === r)
+                        continue;
+                    /* descendant? */
+                    let d = tb.region;
+                    while (d && d.parent !== r)
+                        d = d.parent;
+                    if (d) {
+                        if (d.osr_chain)
+                            bail('osr: a try-region containing the loop header is re-entered');
+                        if (d.entry !== tb)
+                            bail('jump into the middle of a try-region');
+                        continue;
+                    }
+                    /* exit: must be in the parent region */
+                    if (!r.parent || tb.region !== r.parent)
+                        bail('try-region exit skips a level');
+                    r.exits.add(tb.id);
+                }
+            }
+        }
+        for (const r of this.cfg.regions) {
+            for (const blk of r.blocks) {
+                const succs = [];
+                for (const s of blk.succs) {
+                    const tb = blocks[s];
+                    if (tb.region === r)
+                        succs.push(tb.id);
+                    else {
+                        let d = tb.region;
+                        while (d && d.parent !== r)
+                            d = d.parent;
+                        if (d)
+                            succs.push(this.region_node_id(d));
+                        /* else: exit, not an internal edge */
+                    }
+                }
+                this.nodeMap.set(blk.id, { id: blk.id, block: blk, region: null, succs });
+            }
+            for (const c of r.children) {
+                const succs = [...c.exits];
+                if (c.kind === 1 /* KT.CATCH */) {
+                    const hb = byPc.get(c.handler);
+                    if (!hb || hb.region !== r)
+                        bail('catch handler outside the parent region');
+                    if (!succs.includes(hb.id))
+                        succs.push(hb.id);
+                }
+                this.nodeMap.set(this.region_node_id(c), { id: this.region_node_id(c), block: null, region: c, succs });
+            }
+        }
+    }
+    /* node successors restricted to `nodes` and excluding loop back-edges */
+    succs_in(n, nodes, loopEntries) {
+        const r = [];
+        for (const s of n.succs)
+            if (nodes.has(s) && !(loopEntries && loopEntries.has(s)))
+                r.push(s);
+        return r;
+    }
+    reach(from, nodes, loopEntries) {
+        const seen = new Set();
+        const stack = [from];
+        while (stack.length) {
+            const succs = this.nodeMap.get(stack.pop()).succs;
+            for (let i = 0; i < succs.length; i++) {
+                const s = succs[i];
+                if (nodes.has(s) && !(loopEntries !== null && loopEntries.has(s)) && !seen.has(s)) {
+                    seen.add(s);
+                    stack.push(s);
+                }
+            }
+        }
+        return seen;
+    }
+    /* nodes of `nodes` from which an entry is reachable (the entries included): one backward
+       search instead of a forward search from every node. Same edges as reach(). */
+    reaching(entries, nodes, loopEntries) {
+        const preds = new Map();
+        for (const id of nodes) {
+            const succs = this.nodeMap.get(id).succs;
+            for (let i = 0; i < succs.length; i++) {
+                const s = succs[i];
+                if (!nodes.has(s) || (loopEntries !== null && loopEntries.has(s)))
+                    continue;
+                let l = preds.get(s);
+                if (l === undefined) {
+                    l = [];
+                    preds.set(s, l);
+                }
+                l.push(id);
+            }
+        }
+        const found = new Set(entries);
+        const stack = [...entries];
+        while (stack.length) {
+            const l = preds.get(stack.pop());
+            if (l === undefined)
+                continue;
+            for (let i = 0; i < l.length; i++)
+                if (!found.has(l[i])) {
+                    found.add(l[i]);
+                    stack.push(l[i]);
+                }
+        }
+        /* entries first, then the other nodes in the order of `nodes` (emission follows set order) */
+        const inner = new Set(entries);
+        for (const id of nodes)
+            if (found.has(id))
+                inner.add(id);
+        return inner;
+    }
+    /* --- branch emission --- */
+    branch_to(target, ctx, fallthroughOk) {
+        /* prefer continue to an enclosing loop */
+        for (let i = ctx.length - 1; i >= 0; i--) {
+            const s = ctx[i];
+            if (s.kind === 'loop' && s.entries.has(target)) {
+                return (s.entries.size > 1 ? `$l = ${target}; ` : '') + `continue ${s.label};`;
+            }
+        }
+        for (let i = ctx.length - 1; i >= 0; i--) {
+            const s = ctx[i];
+            if (s.kind === 'switch') {
+                if (s.nodes.has(target))
+                    return `$l = ${target}; continue ${s.label};`;
+                continue;
+            }
+            if (s.kind === 'tryswitch') {
+                if (s.nextEntries.has(target))
+                    return `$l = ${target}; break ${s.label};`;
+                continue;
+            }
+            if (s.nextEntries.has(target)) {
+                if (fallthroughOk && fallthroughOk.has(target) && i === ctx.length - 1)
+                    return s.nextIsMulti ? `$l = ${target};` : '';
+                return (s.nextIsMulti ? `$l = ${target}; ` : '') + `break ${s.label};`;
+            }
+        }
+        bail(`unstructured branch to ${target}`);
+    }
+    /* the terminator of a block, given how each target is reached */
+    emit_term(blk, ctx, fallthroughOk) {
+        const t = blk.term;
+        const idOf = (pc) => this.target_node(pc);
+        switch (t.kind) {
+            case 'none': return '';
+            case 'fall':
+            case 'jump': return this.branch_to(idOf(t.target), ctx, fallthroughOk);
+            case 'cond': {
+                const a = idOf(t.tTrue), b = idOf(t.tFalse);
+                if (a === b)
+                    return this.branch_to(a, ctx, fallthroughOk);
+                const ba = this.branch_to(a, ctx, null), bb = this.branch_to(b, ctx, fallthroughOk);
+                return `if (${t.cond}) { ${ba} } ${bb}`;
+            }
+            case 'multi': {
+                const parts = [];
+                const cases = t.multi.cases;
+                for (let i = 0; i < cases.length; i++) {
+                    const c = cases[i];
+                    const br = this.branch_to(idOf(c.target), ctx, i === cases.length - 1 ? fallthroughOk : null);
+                    if (i === cases.length - 1)
+                        parts.push(`{ ${br} }`);
+                    else
+                        parts.push(`if (${t.multi.expr} === ${c.value}) { ${br} } else `);
+                }
+                return parts.join('');
+            }
+        }
+    }
+    /* --- structured emission of a region graph --- */
+    emit_region(r, ctx) {
+        const nodes = new Set();
+        for (const b of r.blocks)
+            nodes.add(b.id);
+        for (const c of r.children)
+            nodes.add(this.region_node_id(c));
+        const saved = this.curRegion;
+        this.curRegion = r;
+        try {
+            if (jit_config.cfg === 'switch')
+                return this.emit_switch(r, nodes, ctx);
+            return this.reloop(nodes, [r.entry_node ?? r.entry.id], ctx, null);
+        }
+        finally {
+            this.curRegion = saved;
+        }
+    }
+    reloop(nodes, entries, ctx, loopEntries) {
+        if (entries.length === 0 || nodes.size === 0)
+            return '';
+        if (entries.length === 1) {
+            const e = entries[0];
+            let hasPred = false;
+            for (const id of nodes) {
+                if (this.succs_in(this.nodeMap.get(id), nodes, loopEntries).includes(e)) {
+                    hasPred = true;
+                    break;
+                }
+            }
+            if (!hasPred)
+                return this.emit_simple(e, nodes, ctx, loopEntries);
+        }
+        /* loop: can some entry reach itself? */
+        let isLoop = false;
+        for (const e of entries)
+            if (this.reach(e, nodes, loopEntries).has(e)) {
+                isLoop = true;
+                break;
+            }
+        if (isLoop) {
+            const entrySet = new Set(entries);
+            /* inner: nodes that can reach an entry */
+            const inner = this.reaching(entries, nodes, loopEntries);
+            const outer = new Set();
+            for (const id of nodes)
+                if (!inner.has(id))
+                    outer.add(id);
+            const nextEntries = new Set();
+            for (const id of inner)
+                for (const s of this.succs_in(this.nodeMap.get(id), nodes, loopEntries))
+                    if (outer.has(s))
+                        nextEntries.add(s);
+            const label = this.label('$L');
+            const st = { kind: 'loop', label, entries: entrySet, nextEntries, nextIsMulti: nextEntries.size > 1 };
+            const body = this.reloop(inner, entries, [...ctx, st], entrySet);
+            return `${label}: for (;;) {\n${POLL}${body}\n}\n` + this.reloop(outer, [...nextEntries], ctx, loopEntries);
+        }
+        /* multiple */
+        return this.emit_multiple(nodes, entries.map(e => ({ cond: `$l === ${e}`, entry: e })), ctx, loopEntries, '');
+    }
+    /* groups: nodes reachable from exactly one entry */
+    groups(nodes, entries, loopEntries) {
+        const reachFrom = new Map();
+        for (const e of entries) {
+            const s = this.reach(e, nodes, loopEntries);
+            s.add(e);
+            reachFrom.set(e, s);
+        }
+        const g = new Map();
+        for (const e of entries) {
+            const set = new Set();
+            for (const id of reachFrom.get(e)) {
+                let only = true;
+                for (const e2 of entries)
+                    if (e2 !== e && reachFrom.get(e2).has(id)) {
+                        only = false;
+                        break;
+                    }
+                if (only)
+                    set.add(id);
+            }
+            /* an entry that is reachable from another entry has no group of its own */
+            if (!set.has(e))
+                set.clear();
+            g.set(e, set);
+        }
+        return g;
+    }
+    /* emit a dispatch on `conds` (if/else chain), each arm containing the independent group of
+       its entry; `prefix` is code emitted before the dispatch (the preceding block) */
+    emit_multiple(nodes, arms, ctx, loopEntries, prefix) {
+        const isInternal = (e) => nodes.has(e) && !(loopEntries && loopEntries.has(e));
+        const entries = [...new Set(arms.map(a => a.entry))].filter(isInternal);
+        const g = this.groups(nodes, entries, loopEntries);
+        const handled = new Set();
+        for (const s of g.values())
+            for (const id of s)
+                handled.add(id);
+        const remaining = new Set();
+        for (const id of nodes)
+            if (!handled.has(id))
+                remaining.add(id);
+        const remEntries = new Set();
+        for (const e of entries)
+            if (g.get(e).size === 0)
+                remEntries.add(e);
+        for (const id of handled)
+            for (const s of this.succs_in(this.nodeMap.get(id), nodes, loopEntries))
+                if (remaining.has(s))
+                    remEntries.add(s);
+        const label = this.label('$M');
+        const st = { kind: 'block', label, entries: new Set(), nextEntries: remEntries, nextIsMulti: remEntries.size > 1 };
+        const innerCtx = [...ctx, st];
+        let code = '';
+        for (let i = 0; i < arms.length; i++) {
+            const arm = arms[i];
+            const grp = isInternal(arm.entry) ? g.get(arm.entry) : null;
+            let body;
+            if (grp === null)
+                body = this.branch_to(arm.entry, innerCtx, null);
+            else if (grp.size === 0)
+                body = this.branch_to(arm.entry, innerCtx, remEntries);
+            else
+                body = this.reloop(grp, [arm.entry], innerCtx, loopEntries);
+            if (arm.cond === null) {
+                code += i > 0 ? `else {\n${body}\n}\n` : `{\n${body}\n}\n`;
+            }
+            else {
+                code += `${i > 0 ? 'else ' : ''}if (${arm.cond}) {\n${body}\n}\n`;
+            }
+        }
+        const out = `${prefix}${label}: {\n${code}\n}\n` + this.reloop(remaining, [...remEntries], ctx, loopEntries);
+        return out;
+    }
+    emit_simple(e, nodes, ctx, loopEntries) {
+        const node = this.nodeMap.get(e);
+        const rest = new Set(nodes);
+        rest.delete(e);
+        const internal = this.succs_in(node, rest, loopEntries);
+        const nextEntries = new Set(internal);
+        if (node.region) {
+            /* nested try-region */
+            const r = node.region;
+            const label = this.label('$T');
+            const st = { kind: 'try', label, entries: new Set(), nextEntries, nextIsMulti: nextEntries.size > 1 };
+            const innerCtx = [...ctx, st];
+            const body = this.emit_region(r, innerCtx);
+            let handler;
+            if (r.kind === 1 /* KT.CATCH */) {
+                const hb = this.cfg.byPc.get(r.handler);
+                handler = `$s${r.slot} = $e; ${this.branch_to(hb.id, innerCtx, null)}`;
+            }
+            else {
+                handler = `$RT.iterator_close_exc($s${r.slot - 2}); throw $e;`;
+            }
+            const code = `${label}: try {\n${body}\n} catch ($e) {\n$e = $RT.catchable($e); ${handler}\n}\n`;
+            return code + this.reloop(rest, [...nextEntries], ctx, loopEntries);
+        }
+        const blk = node.block;
+        const t = blk.term;
+        const idOf = (pc) => this.target_node(pc);
+        let code = blk.code;
+        switch (t.kind) {
+            case 'none':
+                return code;
+            case 'fall':
+            case 'jump': {
+                const target = idOf(t.target);
+                if (rest.has(target) && !(loopEntries && loopEntries.has(target))) {
+                    /* fallthrough into the next structure */
+                    return code + this.reloop(rest, [target], ctx, loopEntries);
+                }
+                return code + this.branch_to(target, ctx, null) + '\n';
+            }
+            case 'cond': {
+                const a = idOf(t.tTrue), b = idOf(t.tFalse);
+                const aIn = rest.has(a) && !(loopEntries && loopEntries.has(a));
+                const bIn = rest.has(b) && !(loopEntries && loopEntries.has(b));
+                if (aIn && bIn && a !== b) {
+                    return this.emit_multiple(rest, [{ cond: t.cond, entry: a }, { cond: null, entry: b }], ctx, loopEntries, code);
+                }
+                if (aIn && !bIn) {
+                    return code + `if (!(${t.cond})) { ${this.branch_to(b, ctx, null)} }\n` + this.reloop(rest, [a], ctx, loopEntries);
+                }
+                if (bIn && !aIn) {
+                    return code + `if (${t.cond}) { ${this.branch_to(a, ctx, null)} }\n` + this.reloop(rest, [b], ctx, loopEntries);
+                }
+                if (a === b) {
+                    if (aIn)
+                        return code + this.reloop(rest, [a], ctx, loopEntries);
+                    return code + this.branch_to(a, ctx, null) + '\n';
+                }
+                return code + `if (${t.cond}) { ${this.branch_to(a, ctx, null)} }\n${this.branch_to(b, ctx, null)}\n`;
+            }
+            case 'multi': {
+                const cases = t.multi.cases;
+                const arms = cases.map((c, i) => ({ cond: i === cases.length - 1 ? null : `${t.multi.expr} === ${c.value}`, entry: idOf(c.target) }));
+                const anyIn = arms.some(a => rest.has(a.entry) && !(loopEntries && loopEntries.has(a.entry)));
+                if (anyIn && new Set(arms.map(a => a.entry)).size === arms.length) {
+                    return this.emit_multiple(rest, arms, ctx, loopEntries, code);
+                }
+                return code + this.emit_term(blk, ctx, null) + '\n';
+            }
+        }
+    }
+    /* --- state machine fallback --- */
+    emit_switch(r, nodes, ctx) {
+        const label = this.label('$S');
+        const st = { kind: 'switch', label, entries: new Set(), nextEntries: new Set(), nextIsMulti: true, nodes };
+        const innerCtx = [...ctx, st];
+        let cases = '';
+        for (const id of nodes) {
+            const node = this.nodeMap.get(id);
+            if (node.region) {
+                const c = node.region;
+                const tl = this.label('$T');
+                const tst = { kind: 'tryswitch', label: tl, entries: new Set(), nextEntries: new Set(node.succs), nextIsMulti: true };
+                const body = this.emit_region(c, [...innerCtx, tst]);
+                let handler;
+                if (c.kind === 1 /* KT.CATCH */) {
+                    const hb = this.cfg.byPc.get(c.handler);
+                    handler = `$s${c.slot} = $e; $l = ${hb.id}; break ${tl};`;
+                }
+                else {
+                    handler = `$RT.iterator_close_exc($s${c.slot - 2}); throw $e;`;
+                }
+                cases += `case ${id}: ${tl}: try {\n${body}\n} catch ($e) {\n$e = $RT.catchable($e); ${handler}\n}\ncontinue ${label};\n`;
+            }
+            else {
+                const blk = node.block;
+                cases += `case ${blk.id}: {\n${blk.code}${this.emit_term(blk, innerCtx, null)}\n}\n`;
+            }
+        }
+        return `$l = ${r.entry_node ?? r.entry.id};\n${label}: for (;;) {\n${POLL}switch ($l) {\n${cases}default: $RT.throw_internal_error("jit: bad state " + $l);\n}\n}\n`;
+    }
+}
+/* used by the runtime adapter when compiled code creates a closure: the compiled form if the
+   function is (or should now be) compiled, else null (interpreter wrapper, tiered up later) */
+function jit_closure_compile(ctx, b) {
+    if (b.compiled)
+        return b.compiled;
+    if (b.no_jit || jit_config.mode === 'off')
+        return null;
+    /* closures created by compiled code are compiled when created in hot mode too: the creating
+       code is hot, so its closures are likely to run, and a compiled function object is cheaper
+       to call than a wrapper (closures created by the interpreter stay lazy) */
+    return jit_compile(ctx, b);
+}
+function func_name(ctx, b) {
+    return b.func_name ? JS_AtomGetStr(ctx, b.func_name) : '';
+}
+export function jit_generate_source(ctx, b, id = 0, opts = {}) {
+    if (b.func_kind !== 0 /* JSFunctionKind.NORMAL */)
+        bail('generator or async function');
+    const insns = decode(b);
+    const A = analyze(b, insns);
+    const cfg = build_blocks(insns, A);
+    const osr = opts.osr;
+    if (osr !== undefined) {
+        if ((opts.conv ?? jit_config.conv) !== 'forwarder')
+            bail('osr: needs the explicit convention');
+        osr_prepare(cfg, A, osr);
+    }
+    const strict = (b.js_mode & JS_MODE_STRICT) !== 0;
+    const constructible = b.has_prototype || b.is_derived_class_constructor || A.is_ctor;
+    const fi = {
+        ctx, b, A, strict, constructible, derived: b.is_derived_class_constructor, uses_direct: false, uses_global: false, uses_w: false,
+        natural: (opts.conv ?? jit_config.conv) === 'natural', arg_off: (opts.conv ?? jit_config.conv) === 'natural' ? 0 : 2,
+        sloppy_sets: new Map(), sloppy_props: new Map(), uses_spe: false, uses_sdel: false,
+        argName: [], argCell: [], varName: [], varCell: [],
+        atom_name: (atom) => JS_AtomGetStr(ctx, atom),
+        atom_is_symbol: (atom) => ctx.rt.atoms.isSymbol(atom),
+    };
+    for (let i = 0; i < b.arg_count; i++) {
+        const vd = b.vardefs[i];
+        const cell = (vd?.is_captured ?? false) || A.uses_mapped_arguments;
+        fi.argCell.push(cell);
+        fi.argName.push(cell ? `$c${i}` : `$a${i}`);
+    }
+    for (let i = 0; i < b.var_count; i++) {
+        const vd = b.vardefs[b.arg_count + i];
+        const cell = vd?.is_captured ?? false;
+        fi.varCell.push(cell);
+        fi.varName.push(`$v${i}`);
+    }
+    /* variables referenced by child closures must be cells even if the parser did not flag them */
+    for (const c of b.cpool) {
+        if (!(c instanceof JSFunctionBytecode))
+            continue;
+        for (const cv of c.closure_var) {
+            if (!cv.is_local)
+                continue;
+            if (cv.is_arg) {
+                if (cv.var_idx < fi.argCell.length) {
+                    fi.argCell[cv.var_idx] = true;
+                    fi.argName[cv.var_idx] = `$c${cv.var_idx}`;
+                }
+            }
+            else if (cv.var_idx < fi.varCell.length)
+                fi.varCell[cv.var_idx] = true;
+        }
+    }
+    /* blocks */
+    let maxDepth = 0;
+    let scratch = 0;
+    for (const blk of cfg.blocks) {
+        if (blk.dead)
+            continue;
+        const em = new BlockEmitter(fi, blk);
+        /* translate instruction by instruction, tracking the pc for kind lookups */
+        const n = blk.insns.length;
+        let terminated = false;
+        for (let idx = 0; idx < n; idx++) {
+            const insn = blk.insns[idx];
+            em.cur_pc = insn.pc;
+            maxDepth = Math.max(maxDepth, em.depth + 4);
+            if (em.translate(insn, idx === n - 1)) {
+                if (idx !== n - 1)
+                    bail('terminator in the middle of a block');
+                terminated = true;
+                break;
+            }
+            maxDepth = Math.max(maxDepth, em.depth + 2);
+        }
+        if (!terminated) {
+            em.finalize();
+            blk.term = { kind: 'fall', target: blk.insns[n - 1].next };
+        }
+        blk.code = em.out.length ? em.out.join('\n') + '\n' : '';
+        scratch = Math.max(scratch, em.scratch);
+    }
+    maxDepth = Math.max(maxDepth, b.stack_size + 2);
+    const rl = new Relooper(fi, cfg);
+    rl.build();
+    const body = rl.emit_region(cfg.root, []);
+    /* assemble */
+    const name = func_name(ctx, b);
+    const decls = [];
+    for (let i = 0; i < maxDepth; i++)
+        decls.push(`$s${i}`);
+    for (let i = 0; i < scratch; i++)
+        decls.push(`$x${i}`);
+    decls.push('$l', '$e', '$r');
+    if (fi.uses_direct)
+        decls.push('$d');
+    if (fi.uses_global)
+        decls.push('$g');
+    if (fi.uses_w)
+        decls.push('$w');
+    const params = ['$t', '$nt'];
+    const fwparams = [];
+    for (let i = 0; i < b.arg_count; i++) {
+        params.push(`$a${i}`);
+        fwparams.push(`$a${i}`);
+    }
+    /* every entry polls, as every loop head does: recursion can run unbounded without a back edge */
+    let prologue = POLL;
+    const natural = fi.natural;
+    if (osr !== undefined) {
+        /* replacement entry: the interpreter frame's state (cells for captured variables) */
+        params.length = 2;
+        params.push('$S');
+        for (let i = 0; i < b.arg_count; i++)
+            prologue += `let ${fi.argName[i]} = $S.a[${i}];\n`;
+        for (let i = 0; i < b.var_count; i++)
+            prologue += `let $v${i} = $S.v[${i}];\n`;
+        const depth = cfg.byPc.get(osr).stateIn.length;
+        for (let d = 0; d < depth; d++)
+            prologue += `$s${d} = $S.s[${d}];\n`;
+    }
+    else {
+        for (let i = 0; i < b.arg_count; i++)
+            if (fi.argCell[i])
+                prologue += `let $c${i} = $RT.new_cell($a${i});\n`;
+        for (let i = 0; i < b.var_count; i++)
+            prologue += fi.varCell[i] ? `let $v${i} = $RT.new_cell(undefined);\n` : `let $v${i};\n`;
+        if (constructible) {
+            if (!b.is_derived_class_constructor) {
+                /* construct call: create `this` unless the caller already did (the host, for `new fw()`
+                   with an object prototype, or the interpreter's legacy constructor path) */
+                if (natural)
+                    prologue += `if ($nt !== undefined && (typeof ($xp = $nt.prototype) === 'object' ? $xp === null : typeof $xp !== 'function')) $t = $RT.create_this($nt);\n`;
+                else
+                    prologue += `if ($nt !== undefined && $t === undefined) $t = $RT.create_this($nt);\n`;
+            }
+        }
+        else if (!natural) {
+            prologue += `if ($nt !== undefined) $RT.throw_not_a_constructor($fo);\n`;
+        }
+    }
+    const safe = name && IDENT_RE.test(name) ? name : '';
+    const fname = safe ? `$f_${safe}` : '$f';
+    const fwname = safe ? `$fw_${safe}` : '$fw';
+    /* the forwarder is the guest-visible function object (natural host convention); it passes
+       the declared parameters, or every argument when the body looks at `arguments`/rest */
+    /* a rest parameter would forbid the "use strict" directive: forward `arguments` instead */
+    const fwargs = A.uses_arguments ? [] : fwparams;
+    const fwpass = A.uses_arguments ? ['...arguments'] : fwparams;
+    const call = (t, nt) => `$direct(${[t, nt, ...fwpass].join(', ')})`;
+    let forwarder;
+    if (constructible) {
+        /* `new fw(...)`: the host already created `this` from new.target.prototype; keep it when
+           that prototype is an object (the direct entry creates `this` itself otherwise) */
+        const host_this = `((typeof ($xp = new.target.prototype) === 'object' ? $xp !== null : typeof $xp === 'function') ? this : undefined)`;
+        forwarder = `function ${fwname}(${fwargs.join(', ')}) { "use strict"; let $xp; return new.target === undefined ? ${call('this', 'undefined')} : ${call(host_this, 'new.target')}; }`;
+    }
+    else {
+        forwarder = `({ ${fwname}(${fwargs.join(', ')}) { "use strict"; return ${call('this', 'undefined')}; } }).${fwname}`;
+    }
+    /* non-strict helpers for sloppy global assignments (the factory body itself is not strict) */
+    let helpers = '';
+    for (const [atom, idx] of fi.sloppy_sets) {
+        helpers += `function $ss${idx}($v) { if (${key_value(fi, atom)} in $GV) $RT.put_global(${atom}, $v, 0, false); else $G${key_access(fi, atom)} = $v; }\n`;
+    }
+    for (const [atom, idx] of fi.sloppy_props)
+        helpers += `function $sp${idx}($o, $v) { $o${key_access(fi, atom)} = $v; }\n`;
+    if (fi.uses_spe)
+        helpers += `function $spe($o, $k, $v) { $o[$k] = $v; }\n`;
+    if (fi.uses_sdel)
+        helpers += `function $sdel($o, $k) { return delete $o[$k]; }\n`;
+    let source;
+    if (!natural) {
+        source =
+            `${helpers}return function $make($vr, $fo) {
+  const $direct = function ${fname}(${params.join(', ')}) {
+"use strict";
+let ${decls.join(', ')};
+${prologue}${body}};
+  if ($fo === undefined) $fo = ${forwarder};
+  return [$fo, $direct, null];
+};`;
+    }
+    else {
+        /* natural convention: the body is the guest function object itself; the direct entry is
+           an adapter used by the engine and by calls with an explicit this/new.target */
+        const nparams = params.slice(2);
+        const head = `"use strict";\nlet ${decls.join(', ')}, $xp;\nlet $t = this;\n${constructible ? 'const $nt = new.target;\n' : ''}`;
+        const fn = constructible
+            ? `function ${fname}(${nparams.join(', ')}) {\n${head}${prologue}${body}}`
+            : `({ ${fname}(${nparams.join(', ')}) {\n${head}${prologue}${body}} }).${fname}`;
+        /* the private copy (`$mkpriv`, created on demand from the same literal, so it shares the
+           host's code and type feedback) keeps the host Function.prototype and is never reachable
+           from guest code: `priv.apply(t, args)` is the host intrinsic, unlike `$CALL.call` on the
+           guest-visible object (~35 ns). With an existing function object (`$fo`, the tier-up of an
+           interpreter wrapper) `$fn` itself is private. */
+        const direct = constructible
+            ? `function ($t, $nt, ...$a) { return $nt === undefined ? $mkpriv().apply($t, $a) : $CONSTRUCT($fn, $a, $nt); }`
+            : `function ($t, $nt, ...$a) { if ($nt !== undefined) $RT.throw_not_a_constructor($fo); return $mkpriv().apply($t, $a); }`;
+        source =
+            `${helpers}return function $make($vr, $fo) {
+  const $lit = function () { return ${fn}; };
+  const $fn = $lit();
+  if ($fo === undefined) $fo = $fn;
+  let $priv = $fn === $fo ? null : $fn;
+  const $mkpriv = function () { return $priv !== null ? $priv : ($priv = $lit()); };
+  const $direct = ${direct};
+  return [$fo, $direct, $mkpriv];
+};`;
+    }
+    /* the url names the function for host stack traces; its id leads to the position table */
+    source += `\n//# sourceURL=jseption:${id}:${url_part(jit_file_name(ctx, b))}:${url_part(name || '<anonymous>')}`;
+    const res = { source, name };
+    if (osr !== undefined)
+        res.osr = { arg_cell: fi.argCell.slice(), var_cell: fi.varCell.slice(), depth: cfg.byPc.get(osr).stateIn.length };
+    return res;
+}
+/* a file or function name as it goes into the generated code's `sourceURL` comment: the file
+   name is the embedder's and the function name the guest's, so a line terminator in either
+   would end the comment and make the rest host code (a function declaration there is hoisted
+   into the compiled code's scope). Control characters and line terminators become `_`. */
+function url_part(s) {
+    return s.replace(/[\u0000-\u001f\u007f\u2028\u2029]/g, '_');
+}
+function jit_file_name(ctx, b) {
+    return (b.has_debug && JS_AtomGetStr(ctx, b.debug.filename)) || '<eval>';
+}
+/* variant: 'main' = the function's own convention (jit_config.conv), stored in b.compiled;
+   'ctor' = explicit convention `(this | undefined, new_target, ...args)` for construct calls
+   through retargetable wrappers, stored in b.compiled_ctor */
+export function jit_compile(ctx, b, variant = 'main') {
+    if (variant === 'main' ? b.compiled : b.compiled_ctor)
+        return (variant === 'main' ? b.compiled : b.compiled_ctor);
+    if (b.no_jit || (variant === 'ctor' && b.compiled_ctor === false))
+        return null;
+    const c = compile_variant(ctx, b, variant === 'ctor' ? { conv: 'forwarder' } : {});
+    if (c === null) {
+        /* a bail of the function's own variant keeps it interpreted (a failed constructor variant
+           only disables that variant); a host that refuses code generation leaves no trace */
+        if (!jit_config.unavailable) {
+            if (variant === 'main')
+                b.no_jit = true;
+            else
+                b.compiled_ctor = false;
+        }
+        return null;
+    }
+    if (variant === 'main')
+        b.compiled = c;
+    else
+        b.compiled_ctor = c;
+    return c;
+}
+/* the on-stack replacement variant of `b` entered at the loop header `pc` (cached; null when
+   the compiler bails for that header) */
+export function jit_compile_osr(ctx, b, pc) {
+    if (b.osr === null)
+        b.osr = new Map();
+    let c = b.osr.get(pc);
+    if (c !== undefined)
+        return c;
+    c = b.no_jit ? null : compile_variant(ctx, b, { conv: 'forwarder', osr: pc });
+    b.osr.set(pc, c);
+    return c;
+}
+function compile_variant(ctx, b, opts) {
+    if (!jit_probe())
+        return null;
+    try {
+        const id = jit_stack_alloc_id();
+        const gen = jit_generate_source(ctx, b, id, opts);
+        const { source, name } = gen;
+        if (jit_config.dump)
+            console.log(`--- jit${opts.osr !== undefined ? ` (osr at ${opts.osr})` : opts.conv === 'forwarder' && jit_config.conv !== 'forwarder' ? ' (ctor)' : ''}: ${name || '<anonymous>'} ---\n${source}`);
+        const RT = make_jit_runtime(ctx, (bb) => jit_closure_compile(ctx, bb));
+        let factory;
+        try {
+            factory = new Function(...JIT_FACTORY_PARAMS, source);
+        }
+        catch (e) {
+            /* code generation from strings forbidden by the host: the tier turns itself off and the
+               interpreter takes over (a SyntaxError is a compiler bug: reported below) */
+            if (!(e instanceof SyntaxError) && !jit_probe(true))
+                return null;
+            throw e;
+        }
+        const make = factory(...jit_runtime_factory_args(RT, b));
+        const stack = { b, name, file: jit_file_name(ctx, b), source, lines: null };
+        jit_stack_register(id, stack);
+        const compiled = { make, source, name, stack, osr: gen.osr };
+        jit_stats.compiled++;
+        if (opts.osr !== undefined)
+            jit_stats.osr_compiled++;
+        return compiled;
+    }
+    catch (e) {
+        jit_stats.bailed++;
+        const msg = e instanceof JitBail ? e.message : `internal: ${e?.message ?? e}`;
+        jit_stats.bail_reasons.set(msg, (jit_stats.bail_reasons.get(msg) ?? 0) + 1);
+        if (jit_config.dump || !(e instanceof JitBail))
+            console.log(`--- jit bail: ${func_name(ctx, b) || '<anonymous>'}: ${msg}`);
+        if (!(e instanceof JitBail) && jit_config.dump)
+            console.log(e.stack);
+        return null;
+    }
+}
+export function jit_should_compile(b) {
+    if (jit_config.mode === 'off' || b.no_jit)
+        return false;
+    if (b.compiled)
+        return true;
+    if (jit_config.mode === 'always')
+        return true;
+    return ++b.call_count >= jit_config.threshold;
+}
+/* backtraces of compiled frames (src/jit_stack.ts) while the tier is on */
+jit_stack_install(jit_config.mode !== 'off');
+/* JS_CallInternal entry hook (see src/jit_hook.ts) */
+jit_hooks.try_call = (ctx, func_obj, func_data, b, this_obj, new_target, argv, flags) => {
+    let direct = func_data.compiled;
+    if (direct === null) {
+        if (jit_config.mode === 'off')
+            return JIT_NOT_COMPILED;
+        if (!jit_should_compile(b))
+            return JIT_NOT_COMPILED;
+        const compiled = jit_compile(ctx, b);
+        if (!compiled)
+            return JIT_NOT_COMPILED;
+        /* tier-up of an existing function object (an interpreter wrapper): give the closure a
+           compiled direct entry and its private copy; a retargetable wrapper calls the copy from
+           now on, and a generic one reaches it through here */
+        const [, d, mkpriv] = compiled.make(func_data.var_refs, func_obj);
+        direct = d;
+        func_data.compiled = d;
+        func_data.mkpriv = mkpriv;
+        func_data.priv = mkpriv !== null ? mkpriv() : null;
+        if (!jit_is_wrapper(func_obj))
+            js_direct.set(func_obj, d);
+    }
+    if ((flags & JS_CALL_FLAG_CONSTRUCTOR) !== 0 || new_target !== undefined) {
+        /* construct call: the explicit-convention body (shared with the wrapper's construct path) */
+        let c = func_data.ctor;
+        if (c === null)
+            c = jit_closure_ctor(ctx, func_obj, func_data, b);
+        return jit_runtime_call_compiled(ctx, c ?? direct, this_obj, new_target, argv, flags);
+    }
+    let p = func_data.priv;
+    if (p === null && func_data.mkpriv !== null)
+        p = func_data.priv = func_data.mkpriv();
+    if (p !== null)
+        return jit_runtime_call_priv(ctx, p, this_obj, argv);
+    return jit_runtime_call_compiled(ctx, direct, this_obj, new_target, argv, flags);
+};
+/* the explicit-convention constructor body of a closure (compiled on its first construct call
+   through the engine or a wrapper), or null when the compiler bails */
+function jit_closure_ctor(ctx, func_obj, fd, b) {
+    if (jit_config.conv === 'forwarder')
+        return fd.compiled; /* the direct entry is the body */
+    const c = jit_compile(ctx, b, 'ctor');
+    if (c === null)
+        return null;
+    fd.ctor = c.make(fd.var_refs, func_obj)[1];
+    return fd.ctor;
+}
+/* On-stack replacement (see JitHooks.osr): the interpreter frame `sf` of `func_obj` has taken
+   enough backward jumps; its loop header is `pc` and its stack depth `sp`. Runs the rest of the
+   frame in the OSR variant and returns its result (JS_EXCEPTION with the exception pending), or
+   JIT_NOT_COMPILED to continue interpreting. */
+jit_set_osr_threshold(jit_config.osr_threshold);
+jit_hooks.osr = (ctx, func_obj, b, sf, pc, sp) => {
+    if (jit_config.mode === 'off' || !jit_config.osr || b.no_jit) {
+        b.loop_count = 0;
+        return JIT_NOT_COMPILED;
+    }
+    const c = jit_compile_osr(ctx, b, pc);
+    if (c === null || c.osr === undefined || c.osr.depth !== sp) {
+        /* the compiler bailed for this header: back to counting (other headers may work) */
+        b.loop_count = 0;
+        return JIT_NOT_COMPILED;
+    }
+    const fd = JS_GetFunctionData(func_obj);
+    const { arg_cell, var_cell, depth } = c.osr;
+    /* captured variables: the frame's own variable references, detached (their values move into
+       them) so that closures created so far stay connected to the compiled code */
+    const cell = (is_arg, idx, v) => {
+        const refs = sf.var_refs;
+        for (let i = 0; i < refs.length; i++) {
+            const vr = refs[i];
+            if (!vr.is_detached && vr.is_arg === is_arg && vr.var_idx === idx) {
+                vr.detach();
+                return vr;
+            }
+        }
+        return new_var_ref_cell(v);
+    };
+    const a = new Array(b.arg_count);
+    for (let i = 0; i < b.arg_count; i++) {
+        const v = i < sf.arg_buf.length ? sf.arg_buf[i] : undefined;
+        a[i] = arg_cell[i] ? cell(true, i, v) : v;
+    }
+    const v = new Array(b.var_count);
+    for (let i = 0; i < b.var_count; i++)
+        v[i] = var_cell[i] ? cell(false, i, sf.var_buf[i]) : sf.var_buf[i];
+    /* catch slots hold catch offsets in the interpreter and nothing in compiled code */
+    const st = new Array(depth);
+    for (let d = 0; d < depth; d++) {
+        const x = sf.stack_buf[d];
+        st[d] = JS_IsCatchOffset(x) ? undefined : x;
+    }
+    const direct = c.make(fd.var_refs, func_obj)[1];
+    sf.osr = true;
+    jit_stats.osr_entered++;
+    const rt = ctx.rt;
+    try {
+        return direct(sf.this_obj, sf.new_target, { a, v, s: st });
+    }
+    catch (e) {
+        return js_host_exception_to_guest(ctx, e);
+    }
+    finally {
+        rt.current_stack_frame = sf;
+    }
+};
+/* function objects created by jit_runtime_make_wrapper */
+const wrappers = new WeakSet();
+export function jit_is_wrapper(f) { return wrappers.has(f); }
+/* interpreted closures of normal functions are retargetable wrappers while the tier is on */
+jit_hooks.make_wrapper = (ctx, b, var_refs, proto, is_ctor) => {
+    if (jit_config.mode === 'off')
+        return null;
+    const w = jit_runtime_make_wrapper(ctx, b, var_refs, proto, is_ctor);
+    if (w !== null)
+        wrappers.add(w);
+    return w;
+};
+//# sourceMappingURL=jit.js.map