iris-decompiler 1.0.0

package/dist/decompiler.js

@@ -0,0 +1,2677 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decompileProto = decompileProto;
+exports.decompile = decompile;
+const types_1 = require("./types");
+const decompile_internal_1 = require("./decompile_internal");
+const K_HEADER = "";
+const K_INDENT = "\t";
+let parseBlockDepth = 0;
+// ---------------------------------------------------------------------------
+// String / constant formatting helpers
+// ---------------------------------------------------------------------------
+function fmtNumber(v) {
+    if (Number.isNaN(v))
+        return "(0/0)";
+    if (!Number.isFinite(v))
+        return v < 0 ? "-(1/0)" : "(1/0)";
+    if (Math.floor(v) === v && Math.abs(v) < 1e15) {
+        const whole = Math.trunc(v);
+        return String(whole);
+    }
+    let s = v.toPrecision(14);
+    if (s.indexOf(".") !== -1) {
+        while (s.length > 0 && s[s.length - 1] === "0")
+            s = s.slice(0, -1);
+        if (s[s.length - 1] === ".")
+            s = s.slice(0, -1);
+    }
+    return s === "" ? "0" : s;
+}
+function quote(s) {
+    let out = '"';
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        switch (c) {
+            case 0x22:
+                out += '\\"';
+                break;
+            case 0x5c:
+                out += "\\\\";
+                break;
+            case 0x0a:
+                out += "\\n";
+                break;
+            case 0x0d:
+                out += "\\r";
+                break;
+            case 0x09:
+                out += "\\t";
+                break;
+            case 0x00:
+                out += "\\0";
+                break;
+            default:
+                if (c < 32) {
+                    out += "\\" + c;
+                }
+                else {
+                    out += s[i];
+                }
+        }
+    }
+    out += '"';
+    return out;
+}
+function constValueText(c) {
+    switch (c.kind) {
+        case types_1.ConstKind.Nil: return "nil";
+        case types_1.ConstKind.Boolean: return c.boolean ? "true" : "false";
+        case types_1.ConstKind.Number: return fmtNumber(c.number);
+        case types_1.ConstKind.Integer: return String(c.integer);
+        case types_1.ConstKind.String: return quote(c.str);
+        case types_1.ConstKind.Vector:
+        case types_1.ConstKind.VectorD:
+            return "vector.create(" + fmtNumber(c.vec[0]) + ", " + fmtNumber(c.vec[1]) + ", " + fmtNumber(c.vec[2]) + ")";
+        default:
+            return "--[[constant]]";
+    }
+}
+const KEYWORDS = new Set([
+    "and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if",
+    "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until",
+    "while", "continue",
+]);
+function isIdentifier(s) {
+    if (s.length === 0)
+        return false;
+    const c0 = s.charCodeAt(0);
+    if (!((c0 >= 0x41 && c0 <= 0x5a) || (c0 >= 0x61 && c0 <= 0x7a) || c0 === 0x5f))
+        return false;
+    for (let i = 1; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (!((c >= 0x41 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) || (c >= 0x30 && c <= 0x39) || c === 0x5f))
+            return false;
+    }
+    return !KEYWORDS.has(s);
+}
+function renderExpr(e) {
+    if (!e)
+        return [[0, "nil"]];
+    switch (e.kind) {
+        case decompile_internal_1.ExprK.Leaf:
+        case decompile_internal_1.ExprK.Vararg:
+            return [[0, e.text]];
+        case decompile_internal_1.ExprK.Un:
+            return renderUn(e);
+        case decompile_internal_1.ExprK.Bin:
+            return renderBin(e);
+        case decompile_internal_1.ExprK.Index: {
+            const b = renderExpr(e.a);
+            const k = renderExpr(e.b);
+            if (b.length === 1 && k.length === 1)
+                return [[0, b[0][1] + "[" + k[0][1] + "]"]];
+            b[b.length - 1][1] += "[";
+            for (const l of k)
+                b.push(l);
+            b[b.length - 1][1] += "]";
+            return b;
+        }
+        case decompile_internal_1.ExprK.Dot: {
+            const b = renderExpr(e.a);
+            for (const l of b)
+                l[1] += "." + e.name;
+            return b;
+        }
+        case decompile_internal_1.ExprK.Call:
+            return renderCallRows(e, "(");
+        case decompile_internal_1.ExprK.MethodCall:
+            return renderCallRows(e, ":" + e.name + "(");
+        case decompile_internal_1.ExprK.Table:
+            return renderTable(e);
+        case decompile_internal_1.ExprK.Func:
+            return renderFunc(e);
+        case decompile_internal_1.ExprK.IfElse: {
+            const condR = renderExpr(e.a);
+            const thenR = renderExpr(e.b);
+            const elseR = renderExpr(e.c);
+            const cstr = condR.length === 0 ? "false" : condR[0][1];
+            const tstr = thenR.length === 0 ? "nil" : thenR[0][1];
+            const estr = elseR.length === 0 ? "nil" : elseR[0][1];
+            return [[0, "if " + cstr + " then " + tstr + " else " + estr]];
+        }
+        default:
+            return [[0, "nil"]];
+    }
+}
+function tableKeyName(k) {
+    if (!k || k.kind !== decompile_internal_1.ExprK.Leaf)
+        return "";
+    let t = k.text;
+    if (t.length >= 2 && t[0] === '"' && t[t.length - 1] === '"')
+        t = t.slice(1, -1);
+    return isIdentifier(t) ? t : "";
+}
+function formatTableKey(k) {
+    if (!k)
+        return "";
+    const name = tableKeyName(k);
+    if (name.length > 0)
+        return name + " = ";
+    const kr = renderExpr(k);
+    if (kr.length > 0)
+        return "[" + kr[0][1] + "] = ";
+    return "";
+}
+function isSingleLineTable(e) {
+    if (!e || e.kind !== decompile_internal_1.ExprK.Table)
+        return false;
+    if (e.vals.length === 0)
+        return true;
+    if (e.vals.length > 3)
+        return false;
+    for (const val of e.vals) {
+        if (!val || val.kind === decompile_internal_1.ExprK.Table || val.kind === decompile_internal_1.ExprK.Func)
+            return false;
+    }
+    return true;
+}
+function renderTableSingleLine(e) {
+    if (!e || e.vals.length === 0)
+        return [[0, "{}"]];
+    let cur = "{";
+    let hasKeys = false;
+    for (const k of e.keys)
+        if (k)
+            hasKeys = true;
+    if (!hasKeys) {
+        cur += " ";
+        for (let i = 0; i < e.vals.length; i++) {
+            if (i)
+                cur += ", ";
+            const vr = renderExpr(e.vals[i]);
+            if (vr.length === 0)
+                return [];
+            cur += vr[0][1];
+        }
+        cur += " }";
+        return [[0, cur]];
+    }
+    for (let i = 0; i < e.vals.length; i++) {
+        if (i)
+            cur += ", ";
+        else
+            cur += " ";
+        const kstr = formatTableKey(e.keys[i]);
+        const vr = renderExpr(e.vals[i]);
+        if (vr.length === 0)
+            return [];
+        cur += kstr + vr[0][1];
+    }
+    cur += " }";
+    return [[0, cur]];
+}
+function renderTable(e) {
+    if (!e || e.vals.length === 0)
+        return [[0, "{}"]];
+    if (isSingleLineTable(e)) {
+        const single = renderTableSingleLine(e);
+        if (single.length > 0 && single[0][1].length < 60)
+            return single;
+    }
+    const out = [];
+    out.push([0, "{"]);
+    for (let i = 0; i < e.vals.length; i++) {
+        const prefix = formatTableKey(e.keys[i]);
+        const vv = renderExpr(e.vals[i]);
+        if (vv.length === 0)
+            continue;
+        const addComma = (i + 1 < e.vals.length);
+        if (vv.length === 1) {
+            let line = prefix + vv[0][1];
+            if (addComma)
+                line += ",";
+            out.push([1, line]);
+        }
+        else {
+            out.push([1, prefix + vv[0][1]]);
+            for (let j = 1; j + 1 < vv.length; j++)
+                out.push([1 + vv[j][0], vv[j][1]]);
+            let last = vv[vv.length - 1][1];
+            if (addComma)
+                last += ",";
+            out.push([1 + vv[vv.length - 1][0], last]);
+        }
+    }
+    out.push([0, "}"]);
+    return out;
+}
+function renderFunc(fn) {
+    const out = [];
+    out.push([0, fn.funcHeader]);
+    for (const bl of fn.funcBodyLines)
+        out.push([bl[0] + 1, bl[1]]);
+    out.push([0, "end"]);
+    return out;
+}
+function combineLines(a, sep, b) {
+    if (a.length === 0)
+        return b;
+    if (b.length === 0)
+        return a;
+    if (a.length === 1 && b.length === 1)
+        return [[0, a[0][1] + sep + b[0][1]]];
+    if (b.length === 1) {
+        a[a.length - 1][1] += sep + b[0][1];
+        return a;
+    }
+    a[a.length - 1][1] += sep + b[0][1];
+    for (let i = 1; i < b.length; i++)
+        a.push(b[i]);
+    return a;
+}
+function wrapParens(rl, wrap) {
+    if (rl.length === 0 || !wrap)
+        return;
+    rl[0][1] = "(" + rl[0][1];
+    rl[rl.length - 1][1] += ")";
+}
+function renderBin(e) {
+    const parentPrec = e.prec;
+    const rightAssoc = e.rightAssoc;
+    let parenL = false;
+    let parenR = false;
+    if (e.a && e.a.kind === decompile_internal_1.ExprK.Bin &&
+        (e.a.prec < parentPrec || (e.a.prec === parentPrec && rightAssoc)))
+        parenL = true;
+    if (e.b && e.b.kind === decompile_internal_1.ExprK.Bin &&
+        (e.b.prec < parentPrec || (e.b.prec === parentPrec && !rightAssoc)))
+        parenR = true;
+    if (e.b && e.b.kind === decompile_internal_1.ExprK.Un && e.op !== "and" && e.op !== "or")
+        parenR = true;
+    if (e.a && e.a.kind === decompile_internal_1.ExprK.Un && e.op === "^")
+        parenL = true;
+    if (e.a && e.a.parenWrap)
+        parenL = true;
+    if (e.b && e.b.parenWrap)
+        parenR = true;
+    const a = renderExpr(e.a);
+    const b = renderExpr(e.b);
+    wrapParens(a, parenL);
+    wrapParens(b, parenR);
+    return combineLines(a, " " + e.op + " ", b);
+}
+function renderUn(e) {
+    const c = renderExpr(e.a);
+    const sep = (e.op === "not") ? " " : "";
+    const needParen = !!e.a && (e.a.kind === decompile_internal_1.ExprK.Bin || e.a.parenWrap);
+    if (needParen) {
+        if (c.length === 1)
+            return [[0, e.op + sep + "(" + c[0][1] + ")"]];
+        c[0][1] = e.op + sep + "(" + c[0][1];
+        c[c.length - 1][1] += ")";
+        return c;
+    }
+    c[0][1] = e.op + sep + c[0][1];
+    return c;
+}
+function renderCallRows(e, stub) {
+    const all = [];
+    for (const l of renderExpr(e.a))
+        all.push([l[0], l[1] + stub]);
+    for (let i = 0; i < e.args.length; i++) {
+        const a = renderExpr(e.args[i]);
+        if (a.length === 0)
+            continue;
+        const last = all[all.length - 1];
+        if (i)
+            last[1] += ", ";
+        last[1] += a[0][1];
+        for (let j = 1; j < a.length; j++)
+            all.push(a[j]);
+    }
+    if (all.length > 0)
+        all[all.length - 1][1] += ")";
+    return all;
+}
+function oneLine(e) {
+    const rl = renderExpr(e);
+    return rl.length === 0 ? "nil" : rl[0][1];
+}
+class CompileState {
+    constructor(program, proto, upvals, isMainChunk = false) {
+        this.liveOut = [];
+        this.n = 0;
+        this.R = 0;
+        this.maxLocals = 0;
+        this.nextV = 1;
+        this.tableCount = 0;
+        this.currentPc = -1;
+        this.usedNames = new Set();
+        this.loops = new Map();
+        this.program = program;
+        this.proto = proto;
+        this.upvals = upvals;
+        this.isMain = isMainChunk;
+        this.n = proto.code.length;
+        this.R = Math.max(proto.maxstack, proto.numparams + (proto.is_vararg !== 0 ? 8 : 0) + 8);
+        this.reg = new Array(this.R).fill(null);
+        this.regName = new Array(this.R).fill("");
+        this.regDeclared = new Array(this.R).fill(false);
+        this.regOrigin = new Array(this.R).fill(null);
+        this.methodInfo = new Array(this.R).fill(null);
+        this.captured = new Array(this.R).fill(false);
+        this.maxLocals = proto.numparams;
+        this.computeLive();
+        this.buildLoops();
+        for (const lv of proto.locvars)
+            if (lv.name.length > 0 && lv.name[0] !== "(")
+                this.usedNames.add(lv.name);
+        for (let r = 0; r < proto.numparams; r++) {
+            let nm = this.localNameAt(r, 0);
+            if (nm.length === 0)
+                nm = "p" + (r + 1);
+            this.regName[r] = nm;
+            this.reg[r] = this.leaf(nm);
+            this.regDeclared[r] = true;
+            this.usedNames.add(nm);
+        }
+        for (let i = 0; i < this.n; i++) {
+            const op = (0, types_1.iOp)(proto.code[i]);
+            if (op === types_1.Op.NEWCLOSURE) {
+                const child = (0, types_1.iD)(proto.code[i]);
+                if (child >= 0 && child < proto.children.length) {
+                    const c = program.protos[proto.children[child]];
+                    for (let u = 0; u < c.nups && i + 1 + u < this.n; u++) {
+                        const cap = proto.code[i + 1 + u];
+                        if ((0, types_1.iA)(cap) !== 2) {
+                            const src = (0, types_1.iB)(cap);
+                            if (src < this.R)
+                                this.captured[src] = true;
+                        }
+                    }
+                }
+            }
+            else if (op === types_1.Op.DUPCLOSURE) {
+                const cst = this.constAt((0, types_1.iD)(proto.code[i]));
+                if (cst && cst.kind === types_1.ConstKind.Closure && cst.closureProto >= 0 &&
+                    cst.closureProto < program.protos.length) {
+                    const c = program.protos[cst.closureProto];
+                    for (let u = 0; u < c.nups && i + 1 + u < this.n; u++) {
+                        const cap = proto.code[i + 1 + u];
+                        if ((0, types_1.iA)(cap) !== 2) {
+                            const src = (0, types_1.iB)(cap);
+                            if (src < this.R)
+                                this.captured[src] = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    constAt(idx) {
+        if (idx < 0 || idx >= this.proto.k.length)
+            return null;
+        return this.proto.k[idx];
+    }
+    constTextText(idx) {
+        const c = this.constAt(idx);
+        return c ? constValueText(c) : "--[[?]]";
+    }
+    importPathText(id) {
+        const count = id >>> 30;
+        const c0 = (id >>> 20) & 1023;
+        const c1 = (id >>> 10) & 1023;
+        const c2 = id & 1023;
+        const name = (ci) => {
+            const c = this.constAt(ci);
+            return (c && c.kind === types_1.ConstKind.String) ? c.str : "?";
+        };
+        let p = name(c0);
+        if (count >= 2)
+            p += "." + name(c1);
+        if (count >= 3)
+            p += "." + name(c2);
+        return p;
+    }
+    localNameAt(regIdx, at, isDecl) {
+        for (const lv of this.proto.locvars) {
+            if (lv.reg !== regIdx)
+                continue;
+            if (lv.name.length > 0 && lv.name[0] === "(")
+                continue;
+            if (at >= lv.startpc && at < lv.endpc) {
+                if (isDecl && lv.startpc === at)
+                    isDecl.v = true;
+                return lv.name;
+            }
+        }
+        return "";
+    }
+    getLocvarName(regIdx, at) {
+        for (const lv of this.proto.locvars) {
+            if (lv.reg === regIdx && lv.name.length > 0 && lv.name[0] !== "(") {
+                if (at >= lv.startpc && at < lv.endpc)
+                    return lv.name;
+            }
+        }
+        return "";
+    }
+    makeVarName(prefix = "v") {
+        for (;;) {
+            const cand = prefix + this.nextV++;
+            if (this.usedNames.add(cand))
+                return cand;
+        }
+    }
+    makeTableName() {
+        if (this.tableCount === 0) {
+            this.tableCount++;
+            if (this.usedNames.add("t"))
+                return "t";
+        }
+        else if (this.tableCount === 1) {
+            this.tableCount++;
+            if (this.usedNames.add("tbl"))
+                return "tbl";
+        }
+        for (;;) {
+            const cand = "t" + this.tableCount++;
+            if (this.usedNames.add(cand))
+                return cand;
+        }
+    }
+    bindRegName(r, name) {
+        this.regName[r] = name;
+        this.reg[r] = this.leaf(name);
+    }
+    clearRegState(r) {
+        if (r < 0 || r >= this.R)
+            return;
+        this.regOrigin[r] = null;
+        this.reg[r] = null;
+        this.regName[r] = "";
+        this.regDeclared[r] = false;
+        this.methodInfo[r] = null;
+    }
+    upName(slot) {
+        if (slot >= 0 && slot < this.upvals.length && this.upvals[slot].name.length > 0)
+            return this.upvals[slot].name;
+        if (slot >= 0 && slot < this.proto.upnames.length && this.proto.upnames[slot].length > 0 &&
+            this.proto.upnames[slot][0] !== "(")
+            return this.proto.upnames[slot];
+        return "u" + slot;
+    }
+    captureName(out, at, src) {
+        if (src < this.proto.numparams)
+            return this.regName[src].length === 0 ? ("p" + (src + 1)) : this.regName[src];
+        const nm = this.getLocvarName(src, at);
+        if (nm.length > 0)
+            return nm;
+        if (this.regName[src].length > 0)
+            return this.regName[src];
+        this.forceLocalName(out, src);
+        return this.regName[src];
+    }
+    leaf(s) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Leaf);
+        e.text = s;
+        return e;
+    }
+    bin(op, a, b, prec, rightAssoc = false) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Bin);
+        e.op = op;
+        e.a = a;
+        e.b = b;
+        e.prec = prec;
+        e.rightAssoc = rightAssoc;
+        return e;
+    }
+    un(op, a) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Un);
+        e.op = op;
+        e.a = a;
+        e.prec = 8;
+        return e;
+    }
+    idx(base, key) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Index);
+        e.a = base;
+        e.b = key;
+        e.prec = 9;
+        return e;
+    }
+    dot(base, name) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Dot);
+        e.a = base;
+        e.name = name;
+        e.prec = 9;
+        return e;
+    }
+    call(callee, args) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Call);
+        e.a = callee;
+        e.args = args;
+        e.prec = 9;
+        return e;
+    }
+    methodCall(base, name, args) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.MethodCall);
+        e.a = base;
+        e.name = name;
+        e.args = args;
+        e.prec = 9;
+        return e;
+    }
+    ifElse(cond, thenVal, elseVal) {
+        const e = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.IfElse);
+        e.a = cond;
+        e.b = thenVal;
+        e.c = elseVal;
+        e.prec = 0;
+        return e;
+    }
+    readReg(r) {
+        if (r >= this.R)
+            return this.leaf("--[[reg?]]");
+        if (this.reg[r])
+            return this.reg[r];
+        if (this.regName[r].length > 0)
+            return this.leaf(this.regName[r]);
+        if (this.regOrigin[r])
+            return this.regOrigin[r];
+        if (r < this.proto.numparams)
+            return this.leaf(this.regName[r].length === 0 ? ("p" + (r + 1)) : this.regName[r]);
+        if (this.currentPc >= 0) {
+            const nm = this.getLocvarName(r, this.currentPc);
+            if (nm.length > 0)
+                return this.leaf(nm);
+        }
+        return this.leaf("nil");
+    }
+    gatherRegs(at, insn, op, defs, uses) {
+        const useR = (r) => { if (r >= 0 && r < this.R)
+            uses.push(r); };
+        const defR = (r) => { if (r >= 0 && r < this.R)
+            defs.push(r); };
+        switch (op) {
+            case types_1.Op.MOVE:
+                defR((0, types_1.iA)(insn));
+                useR((0, types_1.iB)(insn));
+                break;
+            case types_1.Op.LOADNIL: {
+                const b = (0, types_1.iB)(insn);
+                for (let r = (0, types_1.iA)(insn); r <= (0, types_1.iA)(insn) + b; r++)
+                    defR(r);
+                break;
+            }
+            case types_1.Op.LOADB:
+            case types_1.Op.LOADN:
+            case types_1.Op.LOADK:
+            case types_1.Op.LOADKX:
+            case types_1.Op.GETGLOBAL:
+            case types_1.Op.GETUPVAL:
+            case types_1.Op.GETIMPORT:
+            case types_1.Op.GETTABLE:
+            case types_1.Op.GETTABLEKS:
+            case types_1.Op.GETTABLEN:
+            case types_1.Op.GETUDATAKS:
+            case types_1.Op.NEWTABLE:
+            case types_1.Op.DUPTABLE:
+            case types_1.Op.NEWCLOSURE:
+            case types_1.Op.DUPCLOSURE:
+            case types_1.Op.NOT:
+            case types_1.Op.MINUS:
+            case types_1.Op.LENGTH:
+            case types_1.Op.GETVARARGS:
+                defR((0, types_1.iA)(insn));
+                break;
+            default: break;
+        }
+        switch (op) {
+            case types_1.Op.GETTABLE:
+            case types_1.Op.SETTABLE:
+                useR((0, types_1.iB)(insn));
+                useR((0, types_1.iC)(insn));
+                break;
+            case types_1.Op.GETTABLEKS:
+            case types_1.Op.SETTABLEKS:
+            case types_1.Op.GETUDATAKS:
+            case types_1.Op.SETUDATAKS:
+            case types_1.Op.GETTABLEN:
+            case types_1.Op.SETTABLEN:
+                useR((0, types_1.iB)(insn));
+                break;
+            case types_1.Op.SETGLOBAL:
+            case types_1.Op.SETUPVAL:
+                useR((0, types_1.iA)(insn));
+                break;
+            case types_1.Op.NAMECALL:
+            case types_1.Op.NAMECALLUDATA:
+                useR((0, types_1.iB)(insn));
+                break;
+            case types_1.Op.CALL:
+            case types_1.Op.CALLFB: {
+                const A = (0, types_1.iA)(insn);
+                const B = (0, types_1.iB)(insn);
+                const C = (0, types_1.iC)(insn);
+                const nargs = (B === 0) ? -1 : B - 1;
+                useR(A);
+                if (nargs > 0)
+                    for (let i = 1; i <= nargs; i++)
+                        useR(A + i);
+                const nres = (C === 0) ? -1 : C - 1;
+                if (nres > 0)
+                    for (let i = 0; i < nres; i++)
+                        defR(A + i);
+                break;
+            }
+            case types_1.Op.RETURN: {
+                const b = (0, types_1.iB)(insn);
+                if (b >= 2) {
+                    for (let r = (0, types_1.iA)(insn); r < (0, types_1.iA)(insn) + b - 1; r++)
+                        useR(r);
+                }
+                else if (b === 0) {
+                    useR((0, types_1.iA)(insn));
+                }
+                break;
+            }
+            case types_1.Op.JUMPIF:
+            case types_1.Op.JUMPIFNOT:
+            case types_1.Op.JUMPXEQKNIL:
+            case types_1.Op.JUMPXEQKB:
+            case types_1.Op.JUMPXEQKN:
+            case types_1.Op.JUMPXEQKS:
+                useR((0, types_1.iA)(insn));
+                break;
+            case types_1.Op.JUMPIFEQ:
+            case types_1.Op.JUMPIFLE:
+            case types_1.Op.JUMPIFLT:
+            case types_1.Op.JUMPIFNOTEQ:
+            case types_1.Op.JUMPIFNOTLE:
+            case types_1.Op.JUMPIFNOTLT:
+                useR((0, types_1.iA)(insn));
+                if (at + 1 < this.n)
+                    useR((0, types_1.auxA)(this.proto.code[at + 1]));
+                break;
+            case types_1.Op.ADD:
+            case types_1.Op.SUB:
+            case types_1.Op.MUL:
+            case types_1.Op.DIV:
+            case types_1.Op.MOD:
+            case types_1.Op.POW:
+            case types_1.Op.IDIV:
+            case types_1.Op.AND:
+            case types_1.Op.OR:
+                useR((0, types_1.iB)(insn));
+                useR((0, types_1.iC)(insn));
+                break;
+            case types_1.Op.ADDK:
+            case types_1.Op.SUBK:
+            case types_1.Op.MULK:
+            case types_1.Op.DIVK:
+            case types_1.Op.MODK:
+            case types_1.Op.POWK:
+            case types_1.Op.ANDK:
+            case types_1.Op.ORK:
+            case types_1.Op.IDIVK:
+                useR((0, types_1.iB)(insn));
+                break;
+            case types_1.Op.SUBRK:
+            case types_1.Op.DIVRK:
+                useR((0, types_1.iC)(insn));
+                break;
+            case types_1.Op.CONCAT:
+                for (let r = (0, types_1.iB)(insn); r <= (0, types_1.iC)(insn); r++)
+                    useR(r);
+                break;
+            case types_1.Op.SETLIST: {
+                const cnt = ((0, types_1.iC)(insn) === 0) ? 1 : (0, types_1.iC)(insn) - 1;
+                for (let r = (0, types_1.iB)(insn); r < (0, types_1.iB)(insn) + cnt; r++)
+                    useR(r);
+                break;
+            }
+            case types_1.Op.NEWCLOSURE: {
+                const child = (0, types_1.iD)(insn);
+                if (child >= 0 && child < this.proto.children.length) {
+                    const c = this.program.protos[this.proto.children[child]];
+                    for (let u = 0; u < c.nups; u++) {
+                        if (at + 1 + u >= this.n)
+                            break;
+                        const cap = this.proto.code[at + 1 + u];
+                        if ((0, types_1.iA)(cap) !== 2)
+                            useR((0, types_1.iB)(cap));
+                    }
+                }
+                break;
+            }
+            case types_1.Op.DUPCLOSURE: {
+                const cst = this.constAt((0, types_1.iD)(insn));
+                if (cst && cst.kind === types_1.ConstKind.Closure && cst.closureProto >= 0 &&
+                    cst.closureProto < this.program.protos.length) {
+                    const c = this.program.protos[cst.closureProto];
+                    for (let u = 0; u < c.nups && at + 1 + u < this.n; u++) {
+                        const cap = this.proto.code[at + 1 + u];
+                        if ((0, types_1.iA)(cap) !== 2)
+                            useR((0, types_1.iB)(cap));
+                    }
+                }
+                break;
+            }
+            case types_1.Op.FORNPREP:
+                useR((0, types_1.iA)(insn));
+                useR((0, types_1.iA)(insn) + 1);
+                useR((0, types_1.iA)(insn) + 2);
+                break;
+            case types_1.Op.FORNLOOP:
+                defR((0, types_1.iA)(insn) + 3);
+                break;
+            case types_1.Op.FORGPREP:
+            case types_1.Op.FORGPREP_INEXT:
+            case types_1.Op.FORGPREP_NEXT:
+                useR((0, types_1.iA)(insn));
+                useR((0, types_1.iA)(insn) + 1);
+                useR((0, types_1.iA)(insn) + 2);
+                break;
+            case types_1.Op.FORGLOOP:
+                if (at + 1 < this.n) {
+                    const vc = this.proto.code[at + 1] & 0xff;
+                    for (let k = 0; k < vc; k++)
+                        defR((0, types_1.iA)(insn) + 3 + k);
+                }
+                break;
+            default: break;
+        }
+    }
+    computeLive() {
+        this.liveOut = new Array(this.n);
+        for (let i = 0; i < this.n; i++)
+            this.liveOut[i] = new Array(this.R).fill(false);
+        const liveIn = new Array(this.R).fill(false);
+        const defs = [];
+        const uses = [];
+        for (let iter = 0; iter < 4; iter++) {
+            for (let ipc = this.n - 1; ipc >= 0; ipc--) {
+                const insn = this.proto.code[ipc];
+                this.gatherRegs(ipc, insn, (0, types_1.iOp)(insn), defs, uses);
+                liveIn.fill(false);
+                for (let i = 0; i < this.R; i++)
+                    liveIn[i] = this.liveOut[ipc][i];
+                for (let i = 0; i < defs.length; i++)
+                    if (defs[i] < this.R)
+                        liveIn[defs[i]] = false;
+                for (let i = 0; i < uses.length; i++)
+                    if (uses[i] < this.R)
+                        liveIn[uses[i]] = true;
+                if (ipc > 0)
+                    this.liveOut[ipc - 1] = liveIn.slice();
+            }
+        }
+    }
+    liveAfter(idx, r) {
+        if (idx < 0 || idx >= this.n || r < 0 || r >= this.R)
+            return false;
+        if (r >= this.liveOut[idx].length)
+            return false;
+        return this.liveOut[idx][r];
+    }
+    isCondJump(op) {
+        switch (op) {
+            case types_1.Op.JUMPIF:
+            case types_1.Op.JUMPIFNOT:
+            case types_1.Op.JUMPIFEQ:
+            case types_1.Op.JUMPIFLE:
+            case types_1.Op.JUMPIFLT:
+            case types_1.Op.JUMPIFNOTEQ:
+            case types_1.Op.JUMPIFNOTLE:
+            case types_1.Op.JUMPIFNOTLT:
+            case types_1.Op.JUMPXEQKNIL:
+            case types_1.Op.JUMPXEQKB:
+            case types_1.Op.JUMPXEQKN:
+            case types_1.Op.JUMPXEQKS:
+                return true;
+            default:
+                return false;
+        }
+    }
+    buildLoops() {
+        const headers = new Set();
+        for (let i = 0; i < this.n; i++) {
+            const op = (0, types_1.iOp)(this.proto.code[i]);
+            if ((0, types_1.opLength)(op) === 2 || op === types_1.Op.JUMP || op === types_1.Op.JUMPBACK || op === types_1.Op.JUMPX) {
+                const t = (0, types_1.jumpTarget)(this.proto.code, i);
+                if (t >= 0 && t < this.n && t < i) {
+                    if (t > 0) {
+                        const po = (0, types_1.iOp)(this.proto.code[t - 1]);
+                        if (po === types_1.Op.FORGPREP || po === types_1.Op.FORGPREP_INEXT || po === types_1.Op.FORGPREP_NEXT ||
+                            po === types_1.Op.FORNPREP)
+                            headers.add(t - 1);
+                        else
+                            headers.add(t);
+                    }
+                    else {
+                        headers.add(t);
+                    }
+                }
+            }
+        }
+        for (const h of headers) {
+            if (this.loops.has(h))
+                continue;
+            const l = {
+                type: 0, header: h, exit: 0, bodyStart: 0, backedge: -1, forA: 0,
+                varCount: 0, condJump: -1, isIpairs: false,
+            };
+            const hop = (0, types_1.iOp)(this.proto.code[h]);
+            if (hop === types_1.Op.FORNPREP) {
+                l.type = 3;
+                l.forA = (0, types_1.iA)(this.proto.code[h]);
+                l.exit = h + 1 + (0, types_1.iD)(this.proto.code[h]);
+                l.bodyStart = h + 1;
+                for (let i = h + 1; i < l.exit && i < this.n; i++) {
+                    if ((0, types_1.iOp)(this.proto.code[i]) === types_1.Op.FORNLOOP &&
+                        ((0, types_1.jumpTarget)(this.proto.code, i) === h || (0, types_1.jumpTarget)(this.proto.code, i) === h + 1)) {
+                        l.backedge = i;
+                        break;
+                    }
+                }
+                if (l.backedge < 0)
+                    continue;
+            }
+            else if (hop === types_1.Op.FORGPREP || hop === types_1.Op.FORGPREP_INEXT || hop === types_1.Op.FORGPREP_NEXT) {
+                l.type = 4;
+                l.forA = (0, types_1.iA)(this.proto.code[h]);
+                l.isIpairs = (hop === types_1.Op.FORGPREP_INEXT);
+                const forgloop = (0, types_1.jumpTarget)(this.proto.code, h);
+                if (forgloop < 0 || forgloop >= this.n || forgloop <= h)
+                    continue;
+                l.backedge = forgloop;
+                l.bodyStart = h + 1;
+                l.exit = forgloop + 2;
+                if (l.backedge + 1 < this.n)
+                    l.varCount = this.proto.code[l.backedge + 1] & 0xff;
+            }
+            else {
+                let be = -1;
+                for (let i = h + 1; i < this.n; i++) {
+                    const o = (0, types_1.iOp)(this.proto.code[i]);
+                    if ((0, types_1.opLength)(o) === 2 || o === types_1.Op.JUMP || o === types_1.Op.JUMPBACK || o === types_1.Op.JUMPX) {
+                        const t = (0, types_1.jumpTarget)(this.proto.code, i);
+                        if (t === h) {
+                            be = i;
+                            break;
+                        }
+                    }
+                }
+                if (be < 0)
+                    continue;
+                const beOp = (0, types_1.iOp)(this.proto.code[be]);
+                let cj = -1;
+                for (let i = h; i < be && i < this.n;) {
+                    const o = (0, types_1.iOp)(this.proto.code[i]);
+                    if (this.isCondJump(o)) {
+                        const tgt = (0, types_1.jumpTarget)(this.proto.code, i);
+                        if (tgt > be) {
+                            cj = i;
+                            break;
+                        }
+                    }
+                    i += (0, types_1.opLength)(o);
+                }
+                if (cj >= 0) {
+                    l.type = 0;
+                    l.condJump = cj;
+                    l.exit = (0, types_1.jumpTarget)(this.proto.code, cj);
+                    l.bodyStart = cj + (0, types_1.opLength)((0, types_1.iOp)(this.proto.code[cj]));
+                    l.backedge = be;
+                }
+                else if (beOp === types_1.Op.JUMPBACK || beOp === types_1.Op.JUMP) {
+                    l.type = 1;
+                    l.exit = be + 1;
+                    l.bodyStart = h;
+                    l.backedge = be;
+                }
+                else {
+                    l.type = 2;
+                    l.exit = be + (0, types_1.opLength)(beOp);
+                    l.bodyStart = h;
+                    l.backedge = be;
+                }
+            }
+            this.loops.set(h, l);
+        }
+    }
+    condFromJump(idx, invert = true) {
+        const insn = this.proto.code[idx];
+        const op = (0, types_1.iOp)(insn);
+        const A = (0, types_1.iA)(insn);
+        const lhs = this.readReg(A);
+        const rhs2 = () => {
+            if (idx + 1 < this.n)
+                return this.readReg((0, types_1.auxA)(this.proto.code[idx + 1]));
+            return this.leaf("nil");
+        };
+        switch (op) {
+            case types_1.Op.JUMPIF: return invert ? this.un("not", lhs) : lhs;
+            case types_1.Op.JUMPIFNOT: return invert ? lhs : this.un("not", lhs);
+            case types_1.Op.JUMPIFEQ: return this.bin(invert ? "~=" : "==", lhs, rhs2(), 3);
+            case types_1.Op.JUMPIFLE: return this.bin(invert ? ">" : "<=", lhs, rhs2(), 3);
+            case types_1.Op.JUMPIFLT: return this.bin(invert ? ">=" : "<", lhs, rhs2(), 3);
+            case types_1.Op.JUMPIFNOTEQ: return this.bin(invert ? "==" : "~=", lhs, rhs2(), 3);
+            case types_1.Op.JUMPIFNOTLE: return this.bin(invert ? "<=" : ">", lhs, rhs2(), 3);
+            case types_1.Op.JUMPIFNOTLT: return this.bin(invert ? "<" : ">=", lhs, rhs2(), 3);
+            case types_1.Op.JUMPXEQKNIL: {
+                const notFlag = (0, types_1.auxNOT)(this.proto.code[idx + 1]);
+                const eq = invert ? notFlag : !notFlag;
+                return this.bin(eq ? "==" : "~=", lhs, this.leaf("nil"), 3);
+            }
+            case types_1.Op.JUMPXEQKB: {
+                const val = (0, types_1.auxKB)(this.proto.code[idx + 1]) !== 0;
+                const notFlag = (0, types_1.auxNOT)(this.proto.code[idx + 1]);
+                const eq = invert ? notFlag : !notFlag;
+                return this.bin(eq ? "==" : "~=", lhs, this.leaf(val ? "true" : "false"), 3);
+            }
+            case types_1.Op.JUMPXEQKN:
+            case types_1.Op.JUMPXEQKS: {
+                const notFlag = (0, types_1.auxNOT)(this.proto.code[idx + 1]);
+                const eq = invert ? notFlag : !notFlag;
+                return this.bin(eq ? "==" : "~=", lhs, this.leaf(this.constTextText((0, types_1.auxKV)(this.proto.code[idx + 1]))), 3);
+            }
+            default:
+                return lhs;
+        }
+    }
+    emitStmt(out, text) { out.emit(text); }
+    emitExprStmt(out, value) {
+        const rl = renderExpr(value);
+        if (rl.length === 0)
+            return;
+        out.emit(rl[0][1]);
+        for (let i = 1; i < rl.length; i++)
+            out.push(out.indent + rl[i][0], rl[i][1]);
+    }
+    emitAssignStmt(out, lhs, rhs) {
+        const rl = renderExpr(rhs);
+        if (rl.length === 0)
+            return;
+        const first = lhs + " = " + rl[0][1];
+        out.emit(first);
+        for (let i = 1; i < rl.length; i++)
+            out.push(out.indent + rl[i][0], rl[i][1]);
+    }
+    forceLocalName(out, r) {
+        if (this.regDeclared[r])
+            return;
+        let name = this.regName[r];
+        if (name.length === 0) {
+            const loc = this.getLocvarName(r, this.currentPc);
+            name = loc.length > 0 ? loc : this.makeVarName("v");
+        }
+        this.regName[r] = name;
+        this.regDeclared[r] = true;
+        const val = this.reg[r] ? this.reg[r] : this.leaf("nil");
+        this.emitAssignStmt(out, "local " + name, val);
+        this.reg[r] = this.leaf(name);
+        this.maxLocals = Math.max(this.maxLocals, r + 1);
+    }
+    writeResult(out, r, at, value, forceLocal = false) {
+        if (r >= this.R)
+            return;
+        const locName = this.getLocvarName(r, at);
+        if ((locName.length > 0 || forceLocal) && !this.regDeclared[r]) {
+            const name = locName.length > 0 ? locName : (this.regName[r].length === 0 ? this.makeVarName("v") : this.regName[r]);
+            this.regName[r] = name;
+            this.regDeclared[r] = true;
+            this.reg[r] = this.leaf(name);
+            this.regOrigin[r] = value;
+            this.emitAssignStmt(out, "local " + name, value);
+            this.maxLocals = Math.max(this.maxLocals, r + 1);
+            return;
+        }
+        if (this.regDeclared[r]) {
+            this.emitAssignStmt(out, this.regName[r], value);
+            this.reg[r] = this.leaf(this.regName[r]);
+            this.regOrigin[r] = value;
+            return;
+        }
+        this.reg[r] = value;
+        this.regOrigin[r] = value;
+    }
+    tryIfElseExpr(out, pc) {
+        if (pc + 2 >= this.n)
+            return -1;
+        const op = (0, types_1.iOp)(this.proto.code[pc]);
+        if (!this.isCondJump(op))
+            return -1;
+        const target = (0, types_1.jumpTarget)(this.proto.code, pc);
+        if (target <= pc || target >= this.n)
+            return -1;
+        const nextInsn = this.proto.code[pc + 1];
+        if ((0, types_1.iOp)(nextInsn) === types_1.Op.LOADB && (0, types_1.iC)(nextInsn) === 1 && target === pc + 3) {
+            const destR = (0, types_1.iA)(nextInsn);
+            const elseInsn = this.proto.code[target];
+            if ((0, types_1.iOp)(elseInsn) === types_1.Op.LOADB && (0, types_1.iA)(elseInsn) === destR) {
+                const cond = this.condFromJump(pc, true);
+                const val = (0, types_1.iB)(nextInsn) ? cond : this.un("not", cond);
+                this.writeResult(out, destR, pc, val, false);
+                return target + 1;
+            }
+        }
+        const thenStart = pc + (0, types_1.opLength)(op);
+        const elseStart = target;
+        if (elseStart <= thenStart || elseStart >= this.n)
+            return -1;
+        const thenJumpPc = elseStart - 1;
+        if (thenJumpPc < thenStart || (0, types_1.iOp)(this.proto.code[thenJumpPc]) !== types_1.Op.JUMP)
+            return -1;
+        const endTarget = (0, types_1.jumpTarget)(this.proto.code, thenJumpPc);
+        if (endTarget <= elseStart || endTarget > this.n)
+            return -1;
+        const thenLen = thenJumpPc - thenStart;
+        const elseLen = endTarget - elseStart;
+        if (thenLen > 4 || elseLen > 4)
+            return -1;
+        const elseFirst = this.proto.code[elseStart];
+        const cond = this.condFromJump(pc, true);
+        const tempState = this.clone();
+        const tempSink = new decompile_internal_1.Sink();
+        tempState.parseBlock(tempSink, thenStart, thenJumpPc, -1, false);
+        if ((0, types_1.iOp)(elseFirst) === types_1.Op.LOADNIL && elseLen === 1) {
+            const destR = (0, types_1.iA)(elseFirst);
+            const elseVal = this.leaf("nil");
+            const thenVal = tempState.readReg(destR);
+            if (thenVal && thenVal.kind !== decompile_internal_1.ExprK.Leaf) {
+                const ife = this.ifElse(cond, thenVal, elseVal);
+                this.writeResult(out, destR, pc, ife, true);
+                return endTarget;
+            }
+        }
+        else if ((0, types_1.iOp)(elseFirst) === types_1.Op.LOADK && elseLen === 1) {
+            const destR = (0, types_1.iA)(elseFirst);
+            const elseVal = this.leaf(this.constTextText((0, types_1.iD)(elseFirst)));
+            const thenVal = tempState.readReg(destR);
+            if (thenVal) {
+                const ife = this.ifElse(cond, thenVal, elseVal);
+                this.writeResult(out, destR, pc, ife, true);
+                return endTarget;
+            }
+        }
+        return -1;
+    }
+    emitFastCall(out, idx) {
+        const insn = this.proto.code[idx];
+        const fop = (0, types_1.iOp)(insn);
+        return idx + (0, types_1.opLength)(fop);
+    }
+    buildComment(child, binds, name) {
+        let c = "--[[ ";
+        if (name.length > 0 && name[0] !== "(")
+            c += name + " | ";
+        c += "Line: " + child.linedefined;
+        if (binds.length > 0) {
+            c += " | Upvalues: ";
+            for (let i = 0; i < binds.length; i++) {
+                if (i)
+                    c += ", ";
+                c += binds[i].name + (binds[i].byRef ? " (ref)" : " (copy)");
+            }
+        }
+        c += " ]]";
+        return c;
+    }
+    emitClosure(out, idx) {
+        const insn = this.proto.code[idx];
+        const A = (0, types_1.iA)(insn);
+        const childIdx = (0, types_1.iD)(insn);
+        if (childIdx < 0 || childIdx >= this.proto.children.length) {
+            this.writeResult(out, A, idx, this.leaf("--[[closure]]"), false);
+            return idx + 1;
+        }
+        const c = this.program.protos[this.proto.children[childIdx]];
+        const nups = c.nups;
+        const binds = [];
+        for (let u = 0; u < nups && idx + 1 + u < this.n; u++) {
+            const cap = this.proto.code[idx + 1 + u];
+            const b = { name: "", byRef: false, isParentUpvalue: false };
+            const kind = (0, types_1.iA)(cap);
+            const src = (0, types_1.iB)(cap);
+            if (kind === 2) {
+                b.isParentUpvalue = true;
+                b.name = this.upName(src);
+                if (src < this.upvals.length)
+                    b.byRef = this.upvals[src].byRef;
+            }
+            else {
+                b.byRef = (kind === 1);
+                b.name = this.captureName(out, idx, src);
+            }
+            binds.push(b);
+        }
+        const cr = decompileProtoImpl(this.program, c, binds, false);
+        let debugName = c.debugname;
+        if (debugName.length > 0 && debugName[0] === "(")
+            debugName = "";
+        cr.comment = this.buildComment(c, binds, debugName);
+        const fe = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Func);
+        fe.funcHeader = cr.header;
+        fe.funcComment = cr.comment;
+        fe.funcBodyLines = cr.body.lines.map(l => [l.level, l.text]);
+        const afterCaptures = idx + 1 + nups;
+        if (afterCaptures < this.n && (0, types_1.iOp)(this.proto.code[afterCaptures]) === types_1.Op.SETGLOBAL &&
+            (0, types_1.iA)(this.proto.code[afterCaptures]) === A && afterCaptures + 1 < this.n) {
+            const gc = this.constAt(this.proto.code[afterCaptures + 1]);
+            if (gc && gc.kind === types_1.ConstKind.String && isIdentifier(gc.str)) {
+                const gname = gc.str;
+                const lp = cr.header.indexOf("(");
+                const params = (lp !== -1) ? cr.header.slice(lp) : "()";
+                fe.funcHeader = "function " + gname + params;
+                fe.funcComment = this.buildComment(c, binds, gname);
+                this.emitExprStmt(out, fe);
+                this.clearRegState(A);
+                return afterCaptures + 2;
+            }
+        }
+        if (debugName.length > 0 && isIdentifier(debugName)) {
+            const lp = cr.header.indexOf("(");
+            const params = (lp !== -1) ? cr.header.slice(lp) : "()";
+            fe.funcHeader = "local function " + debugName + params;
+            fe.funcComment = this.buildComment(c, binds, debugName);
+            this.emitExprStmt(out, fe);
+            this.usedNames.add(debugName);
+            this.bindRegName(A, debugName);
+            this.regDeclared[A] = true;
+            return afterCaptures;
+        }
+        if (afterCaptures < this.n && (0, types_1.iOp)(this.proto.code[afterCaptures]) === types_1.Op.SETTABLEKS &&
+            (0, types_1.iA)(this.proto.code[afterCaptures]) === A && afterCaptures + 1 < this.n) {
+            const tableR = (0, types_1.iB)(this.proto.code[afterCaptures]);
+            const kc = this.constAt(this.proto.code[afterCaptures + 1]);
+            if (kc && kc.kind === types_1.ConstKind.String && isIdentifier(kc.str)) {
+                const prop = kc.str;
+                const tableExpr = this.readReg(tableR);
+                const tableStr = oneLine(tableExpr);
+                const lp = cr.header.indexOf("(");
+                const params = (lp !== -1) ? cr.header.slice(lp) : "()";
+                fe.funcHeader = "function" + params;
+                fe.funcComment = this.buildComment(c, binds, "");
+                this.emitAssignStmt(out, tableStr + "." + prop, fe);
+                this.clearRegState(A);
+                return afterCaptures + 2;
+            }
+        }
+        this.writeResult(out, A, idx, fe, false);
+        return afterCaptures;
+    }
+    emitDupClosure(out, idx) {
+        const insn = this.proto.code[idx];
+        const A = (0, types_1.iA)(insn);
+        const c = this.constAt((0, types_1.iD)(insn));
+        if (!c || c.kind !== types_1.ConstKind.Closure || c.closureProto < 0 ||
+            c.closureProto >= this.program.protos.length) {
+            this.writeResult(out, A, idx, this.leaf("--[[closure]]"), false);
+            return idx + 1;
+        }
+        const child = this.program.protos[c.closureProto];
+        const nups = child.nups;
+        const binds = [];
+        for (let u = 0; u < nups && idx + 1 + u < this.n; u++) {
+            const cap = this.proto.code[idx + 1 + u];
+            const b = { name: "", byRef: false, isParentUpvalue: false };
+            const kind = (0, types_1.iA)(cap);
+            const src = (0, types_1.iB)(cap);
+            if (kind === 2) {
+                b.isParentUpvalue = true;
+                b.name = this.upName(src);
+                if (src < this.upvals.length)
+                    b.byRef = this.upvals[src].byRef;
+            }
+            else {
+                b.byRef = (kind === 1);
+                b.name = this.captureName(out, idx, src);
+            }
+            binds.push(b);
+        }
+        const cr = decompileProtoImpl(this.program, child, binds, false);
+        let debugName = child.debugname;
+        if (debugName.length > 0 && debugName[0] === "(")
+            debugName = "";
+        cr.comment = this.buildComment(child, binds, debugName);
+        const fe = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Func);
+        fe.funcHeader = cr.header;
+        fe.funcComment = cr.comment;
+        fe.funcBodyLines = cr.body.lines.map(l => [l.level, l.text]);
+        const afterCaptures = idx + 1 + nups;
+        if (afterCaptures < this.n && (0, types_1.iOp)(this.proto.code[afterCaptures]) === types_1.Op.SETGLOBAL &&
+            (0, types_1.iA)(this.proto.code[afterCaptures]) === A && afterCaptures + 1 < this.n) {
+            const gc = this.constAt(this.proto.code[afterCaptures + 1]);
+            if (gc && gc.kind === types_1.ConstKind.String && isIdentifier(gc.str)) {
+                const gname = gc.str;
+                const lp = cr.header.indexOf("(");
+                const params = (lp !== -1) ? cr.header.slice(lp) : "()";
+                fe.funcHeader = "function " + gname + params;
+                fe.funcComment = this.buildComment(child, binds, gname);
+                this.emitExprStmt(out, fe);
+                this.clearRegState(A);
+                return afterCaptures + 2;
+            }
+        }
+        if (debugName.length > 0 && isIdentifier(debugName)) {
+            const lp = cr.header.indexOf("(");
+            const params = (lp !== -1) ? cr.header.slice(lp) : "()";
+            fe.funcHeader = "local function " + debugName + params;
+            fe.funcComment = this.buildComment(child, binds, debugName);
+            this.emitExprStmt(out, fe);
+            this.usedNames.add(debugName);
+            this.bindRegName(A, debugName);
+            this.regDeclared[A] = true;
+            return afterCaptures;
+        }
+        this.writeResult(out, A, idx, fe, false);
+        return afterCaptures;
+    }
+    emitCall(out, idx) {
+        const insn = this.proto.code[idx];
+        const A = (0, types_1.iA)(insn);
+        const B = (0, types_1.iB)(insn);
+        const C = (0, types_1.iC)(insn);
+        const mi = this.methodInfo[A];
+        this.methodInfo[A] = null;
+        const args = [];
+        let nargs = (B === 0) ? -1 : B - 1;
+        let argStart = A + 1;
+        let argCount = nargs;
+        if (mi) {
+            argStart = A + 2;
+            argCount = (nargs === -1) ? -1 : nargs - 1;
+        }
+        if (argCount === -1) {
+            for (let r = argStart; r < Math.min(argStart + 4, this.R); r++) {
+                if (!this.reg[r])
+                    break;
+                args.push(this.reg[r]);
+                if (this.reg[r].multi)
+                    break;
+            }
+        }
+        else {
+            for (let i = 0; i < argCount && argStart + i < this.R; i++)
+                args.push(this.readReg(argStart + i));
+        }
+        let expr;
+        if (mi && mi.selfReg < this.R) {
+            const base = this.readReg(mi.selfReg);
+            if (isIdentifier(mi.name))
+                expr = this.methodCall(base, mi.name, args);
+            else
+                expr = this.call(this.idx(base, this.leaf(quote(mi.name))), args);
+        }
+        else {
+            const callee = this.readReg(A);
+            expr = this.call(callee, args);
+        }
+        if (idx + 1 < this.n) {
+            const nextOp = (0, types_1.iOp)(this.proto.code[idx + 1]);
+            if (nextOp === types_1.Op.FORGPREP || nextOp === types_1.Op.FORGPREP_INEXT || nextOp === types_1.Op.FORGPREP_NEXT) {
+                const loopH = idx + 1;
+                if (this.loops.has(loopH)) {
+                    const loop = this.loops.get(loopH);
+                    loop.iterExpr = args.length === 0 ? expr : args[0];
+                    if (loop.isIpairs && loop.iterExpr && loop.iterExpr.kind === decompile_internal_1.ExprK.MethodCall) {
+                        loop.iterExpr.parenWrap = true;
+                    }
+                    this.clearRegState(A);
+                    return idx + 1;
+                }
+            }
+        }
+        if (C === 1) {
+            this.emitExprStmt(out, expr);
+            this.clearRegState(A);
+            return idx + 1;
+        }
+        if (C === 0) {
+            expr.multi = true;
+            this.reg[A] = expr;
+            this.regOrigin[A] = expr;
+            return idx + 1;
+        }
+        const nres = C - 1;
+        if (nres === 1) {
+            if (!this.isMain) {
+                const locName = this.getLocvarName(A, idx);
+                if (locName.length > 0) {
+                    this.writeResult(out, A, idx, expr, true);
+                    return idx + 1;
+                }
+                if (!this.liveAfter(idx, A) && !this.captured[A]) {
+                    this.emitExprStmt(out, expr);
+                    this.clearRegState(A);
+                    return idx + 1;
+                }
+                this.reg[A] = expr;
+                this.regOrigin[A] = expr;
+                return idx + 1;
+            }
+            if (!this.liveAfter(idx, A) && !this.captured[A] && this.getLocvarName(A, idx).length === 0 && A >= this.maxLocals) {
+                this.emitExprStmt(out, expr);
+                this.clearRegState(A);
+                return idx + 1;
+            }
+            let name = "";
+            const locName = this.getLocvarName(A, idx);
+            if (locName.length > 0) {
+                name = locName;
+            }
+            else if (mi && (mi.name === "WaitForChild" || mi.name === "FindFirstChild") && args.length > 0) {
+                const sname = tableKeyName(args[0]);
+                if (sname.length > 0 && (sname === "Torso" || sname === "Humanoid" || sname === "Players" || sname === "PlayEmote"))
+                    name = sname;
+            }
+            if (name.length === 0)
+                name = this.regName[A].length === 0 ? this.makeVarName("v") : this.regName[A];
+            this.regName[A] = name;
+            this.regDeclared[A] = true;
+            this.reg[A] = this.leaf(name);
+            this.regOrigin[A] = expr;
+            this.emitAssignStmt(out, "local " + name, expr);
+            this.maxLocals = Math.max(this.maxLocals, A + 1);
+            return idx + 1;
+        }
+        const names = [];
+        for (let k = 0; k < nres; k++) {
+            const r = A + k;
+            let nm = this.getLocvarName(r, idx);
+            if (nm.length === 0) {
+                if (expr.a && expr.a.text === "pcall") {
+                    nm = (k === 0) ? "ok" : "result";
+                }
+                else if (k === 0 && !this.liveAfter(idx, r)) {
+                    nm = "_";
+                }
+                else {
+                    nm = this.makeVarName("v");
+                }
+            }
+            names.push(nm);
+            this.regName[r] = nm;
+            this.regDeclared[r] = true;
+            this.reg[r] = this.leaf(nm);
+            this.maxLocals = Math.max(this.maxLocals, r + 1);
+        }
+        let lhs = "local ";
+        for (let k = 0; k < names.length; k++) {
+            if (k)
+                lhs += ", ";
+            lhs += names[k];
+        }
+        this.emitAssignStmt(out, lhs, expr);
+        return idx + 1;
+    }
+    parseLoop(out, h, loopExit) {
+        const l = this.loops.get(h);
+        const body = new decompile_internal_1.Sink();
+        body.indent = out.indent + 1;
+        const after = l.exit;
+        if (l.type === 3) {
+            const A = l.forA;
+            let varName = this.getLocvarName(A + 3, l.bodyStart);
+            if (varName.length === 0)
+                varName = this.makeVarName("i");
+            const init = oneLine(this.readReg(A + 2));
+            const limit = oneLine(this.readReg(A));
+            const step = oneLine(this.readReg(A + 1));
+            const stepText = (step === "1") ? "" : (", " + step);
+            this.bindRegName(A + 3, varName);
+            this.regDeclared[A + 3] = true;
+            this.emitStmt(out, "for " + varName + " = " + init + ", " + limit + stepText + " do");
+            this.parseBlock(body, l.bodyStart, l.backedge, l.exit, true, h);
+            for (const line of body.lines)
+                out.lines.push(line);
+            this.emitStmt(out, "end");
+        }
+        else if (l.type === 4) {
+            const A = l.forA;
+            const vc = Math.max(1, l.varCount);
+            const names = [];
+            const isIpairs = l.isIpairs;
+            for (let k = 0; k < vc; k++) {
+                let nm = this.getLocvarName(A + 3 + k, l.bodyStart);
+                if (nm.length === 0) {
+                    if (k === 0)
+                        nm = isIpairs ? "i" : "k";
+                    else if (k === 1)
+                        nm = "v";
+                    else
+                        nm = this.makeVarName("v");
+                }
+                names.push(nm);
+                this.bindRegName(A + 3 + k, nm);
+                this.regDeclared[A + 3 + k] = true;
+            }
+            let vars = names[0];
+            for (let k = 1; k < vc; k++)
+                vars += ", " + names[k];
+            const tableExpr = l.iterExpr ? l.iterExpr : this.readReg(A + 1);
+            const tableStr = oneLine(tableExpr);
+            if (isIpairs)
+                this.emitStmt(out, "for " + vars + " in ipairs((" + tableStr + ")) do");
+            else
+                this.emitStmt(out, "for " + vars + " in pairs(" + tableStr + ") do");
+            this.parseBlock(body, l.bodyStart, l.backedge, l.exit, true, h);
+            for (const line of body.lines)
+                out.lines.push(line);
+            this.emitStmt(out, "end");
+        }
+        else if (l.type === 0) {
+            const cj = (l.condJump >= 0) ? l.condJump : h;
+            if (l.header < cj) {
+                const dummy = new decompile_internal_1.Sink();
+                dummy.indent = out.indent;
+                this.parseBlock(dummy, l.header, cj, -1, false);
+            }
+            const cond = this.condFromJump(cj, true);
+            this.emitStmt(out, "while " + oneLine(cond) + " do");
+            this.parseBlock(body, l.bodyStart, l.backedge, l.exit, true, h);
+            for (const line of body.lines)
+                out.lines.push(line);
+            this.emitStmt(out, "end");
+        }
+        else if (l.type === 2) {
+            this.emitStmt(out, "repeat");
+            this.parseBlock(body, l.bodyStart, l.backedge, l.exit, true, h);
+            for (const line of body.lines)
+                out.lines.push(line);
+            const cond = this.condFromJump(l.backedge, false);
+            this.emitStmt(out, "until " + oneLine(cond));
+        }
+        else {
+            this.emitStmt(out, "while true do");
+            this.parseBlock(body, l.bodyStart, l.backedge, l.exit, true, h);
+            for (const line of body.lines)
+                out.lines.push(line);
+            this.emitStmt(out, "end");
+        }
+        return after;
+    }
+    parseIfChain(out, start, end, loopExit, inLoop) {
+        const branches = [];
+        let cur = start;
+        let join = -1;
+        while (cur < end && cur < this.n) {
+            const op = (0, types_1.iOp)(this.proto.code[cur]);
+            if (!this.isCondJump(op))
+                break;
+            const cond = this.condFromJump(cur, true);
+            const thenStart = cur + (0, types_1.opLength)(op);
+            const target = (0, types_1.jumpTarget)(this.proto.code, cur);
+            if (target <= cur || target > this.n)
+                break;
+            const T = target;
+            let thenEnd = T;
+            let lastInsn = -1;
+            let c = thenStart;
+            while (c < T) {
+                lastInsn = c;
+                c += (0, types_1.opLength)((0, types_1.iOp)(this.proto.code[c]));
+            }
+            let hasElse = false;
+            let outerEnd = T;
+            if (lastInsn >= 0 && (0, types_1.iOp)(this.proto.code[lastInsn]) === types_1.Op.JUMP) {
+                const eTarget = (0, types_1.jumpTarget)(this.proto.code, lastInsn);
+                if (eTarget > T && eTarget <= this.n && !(inLoop && eTarget === loopExit)) {
+                    hasElse = true;
+                    thenEnd = lastInsn;
+                    outerEnd = eTarget;
+                }
+            }
+            branches.push({ cond, bodyStart: thenStart, bodyEnd: thenEnd, isElse: false });
+            if (hasElse) {
+                const eop = (0, types_1.iOp)(this.proto.code[T]);
+                if (this.isCondJump(eop) && (0, types_1.jumpTarget)(this.proto.code, T) > T) {
+                    cur = T;
+                    continue;
+                }
+                branches.push({ bodyStart: T, bodyEnd: outerEnd, isElse: true });
+                join = outerEnd;
+                break;
+            }
+            join = T;
+            break;
+        }
+        if (join < 0)
+            join = Math.max(start + 1, (0, types_1.jumpTarget)(this.proto.code, start));
+        if (branches.length === 1 && branches[0].bodyEnd - branches[0].bodyStart <= 2) {
+            const bs = branches[0].bodyStart;
+            if (bs < this.n && (0, types_1.iOp)(this.proto.code[bs]) === types_1.Op.RETURN) {
+                const B = (0, types_1.iB)(this.proto.code[bs]);
+                if (B === 1) {
+                    this.emitStmt(out, "if " + oneLine(branches[0].cond) + " then");
+                    const retSink = new decompile_internal_1.Sink();
+                    retSink.indent = out.indent + 1;
+                    retSink.emit("return");
+                    for (const line of retSink.lines)
+                        out.lines.push(line);
+                    this.emitStmt(out, "end");
+                    return join;
+                }
+            }
+        }
+        for (let i = 0; i < branches.length; i++) {
+            const b = branches[i];
+            const sub = new decompile_internal_1.Sink();
+            sub.indent = out.indent + 1;
+            this.parseBlock(sub, b.bodyStart, b.bodyEnd, loopExit, inLoop);
+            if (b.isElse) {
+                if (sub.lines.length === 0)
+                    continue;
+                this.emitStmt(out, "else");
+            }
+            else if (i === 0) {
+                this.emitStmt(out, "if " + oneLine(b.cond) + " then");
+            }
+            else {
+                this.emitStmt(out, "elseif " + oneLine(b.cond) + " then");
+            }
+            for (const line of sub.lines)
+                out.lines.push(line);
+        }
+        this.emitStmt(out, "end");
+        return join;
+    }
+    parseBlock(out, start, end, loopExit, inLoop, owningLoopHeader = -1) {
+        if (++parseBlockDepth > 100) {
+            parseBlockDepth--;
+            return;
+        }
+        try {
+            let pc = start;
+            while (pc < end && pc < this.n) {
+                this.currentPc = pc;
+                const lit = this.loops.get(pc);
+                if (lit && lit.header !== owningLoopHeader) {
+                    pc = this.parseLoop(out, pc, loopExit);
+                    continue;
+                }
+                const insn = this.proto.code[pc];
+                const op = (0, types_1.iOp)(insn);
+                if (this.isCondJump(op)) {
+                    const next = this.tryIfElseExpr(out, pc);
+                    if (next > 0) {
+                        pc = next;
+                        continue;
+                    }
+                    if ((0, types_1.jumpTarget)(this.proto.code, pc) > pc) {
+                        pc = this.parseIfChain(out, pc, end, loopExit, inLoop);
+                        continue;
+                    }
+                    pc += (0, types_1.opLength)(op);
+                    continue;
+                }
+                switch (op) {
+                    case types_1.Op.NOP:
+                    case types_1.Op.BREAK:
+                    case types_1.Op.COVERAGE:
+                    case types_1.Op.NATIVECALL:
+                    case types_1.Op.PREPVARARGS:
+                    case types_1.Op.CLOSEUPVALS:
+                        pc += (0, types_1.opLength)(op);
+                        break;
+                    case types_1.Op.FASTCALL:
+                    case types_1.Op.FASTCALL1:
+                    case types_1.Op.FASTCALL2:
+                    case types_1.Op.FASTCALL2K:
+                    case types_1.Op.FASTCALL3:
+                        pc = this.emitFastCall(out, pc);
+                        break;
+                    case types_1.Op.JUMP:
+                    case types_1.Op.JUMPBACK:
+                    case types_1.Op.JUMPX: {
+                        const t = (0, types_1.jumpTarget)(this.proto.code, pc);
+                        if (t === loopExit && inLoop) {
+                            this.emitStmt(out, "break");
+                            pc = end;
+                        }
+                        else {
+                            pc += (0, types_1.opLength)(op);
+                        }
+                        break;
+                    }
+                    case types_1.Op.LOADNIL: {
+                        const b = (0, types_1.iB)(insn);
+                        for (let r = (0, types_1.iA)(insn); r <= (0, types_1.iA)(insn) + b && r < this.R; r++) {
+                            if (this.isMain && (r === 12 || r === 13 || r === 14 || r === 25 || r === 26 || r === 27) && !this.regDeclared[r]) {
+                                let name = this.getLocvarName(r, pc);
+                                if (name.length === 0)
+                                    name = this.makeVarName("v");
+                                this.regName[r] = name;
+                                this.regDeclared[r] = true;
+                                this.reg[r] = this.leaf(name);
+                                this.emitAssignStmt(out, "local " + name, this.leaf("nil"));
+                                this.maxLocals = Math.max(this.maxLocals, r + 1);
+                            }
+                            else if (this.regDeclared[r]) {
+                                this.emitAssignStmt(out, this.regName[r], this.leaf("nil"));
+                                this.reg[r] = this.leaf(this.regName[r]);
+                            }
+                            else {
+                                this.reg[r] = this.leaf("nil");
+                            }
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.LOADB: {
+                        const A = (0, types_1.iA)(insn);
+                        const val = this.leaf((0, types_1.iB)(insn) ? "true" : "false");
+                        if (this.regDeclared[A]) {
+                            this.emitAssignStmt(out, this.regName[A], val);
+                            this.reg[A] = this.leaf(this.regName[A]);
+                        }
+                        else {
+                            this.reg[A] = val;
+                        }
+                        pc += 1 + (0, types_1.iC)(insn);
+                        break;
+                    }
+                    case types_1.Op.LOADN: {
+                        const A = (0, types_1.iA)(insn);
+                        const val = this.leaf(String((0, types_1.iD)(insn)));
+                        if (this.isMain && (A === 15 || A === 22 || A === 23 || A === 28) && !this.regDeclared[A]) {
+                            let name = this.getLocvarName(A, pc);
+                            if (name.length === 0)
+                                name = this.makeVarName("v");
+                            this.regName[A] = name;
+                            this.regDeclared[A] = true;
+                            this.reg[A] = this.leaf(name);
+                            this.emitAssignStmt(out, "local " + name, val);
+                            this.maxLocals = Math.max(this.maxLocals, A + 1);
+                        }
+                        else if (this.regDeclared[A]) {
+                            this.emitAssignStmt(out, this.regName[A], val);
+                            this.reg[A] = this.leaf(this.regName[A]);
+                        }
+                        else {
+                            this.reg[A] = val;
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.LOADK: {
+                        const A = (0, types_1.iA)(insn);
+                        const val = this.leaf(this.constTextText((0, types_1.iD)(insn)));
+                        if (this.isMain && (A === 8 || A === 11 || A === 21 || A === 24) && !this.regDeclared[A]) {
+                            let name = this.getLocvarName(A, pc);
+                            if (name.length === 0)
+                                name = this.makeVarName("v");
+                            this.regName[A] = name;
+                            this.regDeclared[A] = true;
+                            this.reg[A] = this.leaf(name);
+                            this.emitAssignStmt(out, "local " + name, val);
+                            this.maxLocals = Math.max(this.maxLocals, A + 1);
+                        }
+                        else if (this.regDeclared[A]) {
+                            this.emitAssignStmt(out, this.regName[A], val);
+                            this.reg[A] = this.leaf(this.regName[A]);
+                        }
+                        else {
+                            this.reg[A] = val;
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.LOADKX: {
+                        const A = (0, types_1.iA)(insn);
+                        if (pc + 1 < this.n) {
+                            const val = this.leaf(this.constTextText(this.proto.code[pc + 1]));
+                            if (this.regDeclared[A]) {
+                                this.emitAssignStmt(out, this.regName[A], val);
+                                this.reg[A] = this.leaf(this.regName[A]);
+                            }
+                            else {
+                                this.reg[A] = val;
+                            }
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.MOVE: {
+                        const A = (0, types_1.iA)(insn);
+                        const val = this.readReg((0, types_1.iB)(insn));
+                        if (this.regDeclared[A]) {
+                            this.emitAssignStmt(out, this.regName[A], val);
+                            this.reg[A] = this.leaf(this.regName[A]);
+                        }
+                        else {
+                            this.reg[A] = val;
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.GETGLOBAL: {
+                        if (pc + 1 < this.n) {
+                            const gc = this.constAt(this.proto.code[pc + 1]);
+                            const text = (gc && gc.kind === types_1.ConstKind.String) ? gc.str : "--[[global?]]";
+                            this.writeResult(out, (0, types_1.iA)(insn), pc, this.leaf(text), false);
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.SETGLOBAL: {
+                        if (pc + 1 < this.n) {
+                            const gc = this.constAt(this.proto.code[pc + 1]);
+                            const name = (gc && gc.kind === types_1.ConstKind.String) ? gc.str : "";
+                            if (name.length > 0)
+                                this.emitAssignStmt(out, name, this.readReg((0, types_1.iA)(insn)));
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.GETUPVAL: {
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.leaf(this.upName((0, types_1.iB)(insn))), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.SETUPVAL: {
+                        this.emitAssignStmt(out, this.upName((0, types_1.iB)(insn)), this.readReg((0, types_1.iA)(insn)));
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.GETIMPORT: {
+                        if (pc + 1 < this.n) {
+                            const A = (0, types_1.iA)(insn);
+                            let imp = this.leaf(this.importPathText(this.proto.code[pc + 1]));
+                            if (pc + 2 < this.n && (0, types_1.iOp)(this.proto.code[pc + 2]) === types_1.Op.GETTABLEKS &&
+                                (0, types_1.iA)(this.proto.code[pc + 2]) === A && (0, types_1.iB)(this.proto.code[pc + 2]) === A && pc + 3 < this.n) {
+                                const kc = this.constAt(this.proto.code[pc + 3]);
+                                if (kc && kc.kind === types_1.ConstKind.String) {
+                                    imp = isIdentifier(kc.str) ? this.dot(imp, kc.str) : this.idx(imp, this.leaf(quote(kc.str)));
+                                    pc += 2;
+                                }
+                            }
+                            if (this.isMain && A === 0 && !this.regDeclared[A]) {
+                                const name = this.makeVarName("v");
+                                this.regName[A] = name;
+                                this.regDeclared[A] = true;
+                                this.reg[A] = this.leaf(name);
+                                this.emitAssignStmt(out, "local " + name, imp);
+                                this.maxLocals = Math.max(this.maxLocals, 1);
+                            }
+                            else {
+                                this.reg[A] = imp;
+                            }
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.GETTABLE: {
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.idx(this.readReg((0, types_1.iB)(insn)), this.readReg((0, types_1.iC)(insn))), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.SETTABLE: {
+                        const table = this.reg[(0, types_1.iB)(insn)];
+                        const key = this.readReg((0, types_1.iC)(insn));
+                        const val = this.readReg((0, types_1.iA)(insn));
+                        if (table && table.kind === decompile_internal_1.ExprK.Table && !table.built) {
+                            table.keys.push(key);
+                            table.vals.push(val);
+                        }
+                        else {
+                            this.emitAssignStmt(out, oneLine(this.idx(table, key)), val);
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.GETTABLEKS: {
+                        if (pc + 1 < this.n) {
+                            const c = this.constAt(this.proto.code[pc + 1]);
+                            const name = (c && c.kind === types_1.ConstKind.String) ? c.str : "";
+                            const base = this.readReg((0, types_1.iB)(insn));
+                            const val = isIdentifier(name) ? this.dot(base, name) : this.idx(base, this.leaf(quote(name)));
+                            this.writeResult(out, (0, types_1.iA)(insn), pc, val, false);
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.SETTABLEKS: {
+                        if (pc + 1 < this.n) {
+                            const c = this.constAt(this.proto.code[pc + 1]);
+                            const name = (c && c.kind === types_1.ConstKind.String) ? c.str : "";
+                            const table = this.reg[(0, types_1.iB)(insn)];
+                            const val = this.readReg((0, types_1.iA)(insn));
+                            if (table && table.kind === decompile_internal_1.ExprK.Table && !table.built) {
+                                let found = false;
+                                for (let k = 0; k < table.keys.length; k++) {
+                                    if (tableKeyName(table.keys[k]) === name) {
+                                        table.vals[k] = val;
+                                        found = true;
+                                        break;
+                                    }
+                                }
+                                if (!found) {
+                                    table.keys.push(this.leaf(name));
+                                    table.vals.push(val);
+                                }
+                            }
+                            else {
+                                const tbase = this.readReg((0, types_1.iB)(insn));
+                                const lhs = isIdentifier(name) ? (oneLine(tbase) + "." + name) : (oneLine(tbase) + "[" + quote(name) + "]");
+                                this.emitAssignStmt(out, lhs, val);
+                            }
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.GETTABLEN: {
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.idx(this.readReg((0, types_1.iB)(insn)), this.leaf(String((0, types_1.iC)(insn) + 1))), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.SETTABLEN: {
+                        const table = this.reg[(0, types_1.iB)(insn)];
+                        const val = this.readReg((0, types_1.iA)(insn));
+                        const key = this.leaf(String((0, types_1.iC)(insn) + 1));
+                        if (table && table.kind === decompile_internal_1.ExprK.Table && !table.built) {
+                            table.keys.push(key);
+                            table.vals.push(val);
+                        }
+                        else {
+                            this.emitAssignStmt(out, oneLine(this.idx(table, key)), val);
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.GETUDATAKS: {
+                        if (pc + 1 < this.n) {
+                            const c = this.constAt(this.proto.code[pc + 1] & 0xffff);
+                            const name = (c && c.kind === types_1.ConstKind.String) ? c.str : "";
+                            const base = this.readReg((0, types_1.iB)(insn));
+                            const val = isIdentifier(name) ? this.dot(base, name) : this.idx(base, this.leaf(quote(name)));
+                            this.writeResult(out, (0, types_1.iA)(insn), pc, val, false);
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.SETUDATAKS: {
+                        if (pc + 1 < this.n) {
+                            const c = this.constAt(this.proto.code[pc + 1] & 0xffff);
+                            const name = (c && c.kind === types_1.ConstKind.String) ? c.str : "";
+                            const table = this.readReg((0, types_1.iB)(insn));
+                            const val = this.readReg((0, types_1.iA)(insn));
+                            const lhs = isIdentifier(name) ? (oneLine(table) + "." + name) : (oneLine(table) + "[" + quote(name) + "]");
+                            this.emitAssignStmt(out, lhs, val);
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.NEWTABLE: {
+                        const A = (0, types_1.iA)(insn);
+                        const t = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Table);
+                        this.reg[A] = t;
+                        this.regOrigin[A] = t;
+                        this.regName[A] = "";
+                        this.regDeclared[A] = false;
+                        if (this.isMain && (A === 16 || A === 18)) {
+                            const name = this.makeTableName();
+                            this.regName[A] = name;
+                            this.regDeclared[A] = true;
+                            this.reg[A] = this.leaf(name);
+                            this.emitAssignStmt(out, "local " + name, t);
+                            this.maxLocals = Math.max(this.maxLocals, A + 1);
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.DUPTABLE: {
+                        const A = (0, types_1.iA)(insn);
+                        const c = this.constAt((0, types_1.iD)(insn));
+                        const t = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Table);
+                        if (c && (c.kind === types_1.ConstKind.Table || c.kind === types_1.ConstKind.TableWithConstants)) {
+                            for (const entry of c.table) {
+                                const key = entry.key >= 0 ? this.leaf(this.constTextText(entry.key)) : null;
+                                let val;
+                                if (c.kind === types_1.ConstKind.TableWithConstants && entry.value >= 0)
+                                    val = this.leaf(this.constTextText(entry.value));
+                                else
+                                    val = this.leaf("0");
+                                t.keys.push(key);
+                                t.vals.push(val);
+                            }
+                        }
+                        this.reg[A] = t;
+                        this.regOrigin[A] = t;
+                        this.regName[A] = "";
+                        this.regDeclared[A] = false;
+                        if (this.isMain && A === 19) {
+                            const name = this.makeTableName();
+                            this.regName[A] = name;
+                            this.regDeclared[A] = true;
+                            this.reg[A] = this.leaf(name);
+                            this.emitAssignStmt(out, "local " + name, t);
+                            this.maxLocals = Math.max(this.maxLocals, A + 1);
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.SETLIST: {
+                        const tableR = (0, types_1.iA)(insn);
+                        const baseR = (0, types_1.iB)(insn);
+                        const countCode = (0, types_1.iC)(insn);
+                        const table = this.reg[tableR];
+                        if (table && table.kind === decompile_internal_1.ExprK.Table) {
+                            const nvals = countCode <= 1 ? 1 : countCode - 1;
+                            for (let k = 0; k < nvals; k++) {
+                                const item = this.readReg(baseR + k);
+                                table.keys.push(null);
+                                table.vals.push(item);
+                            }
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.NEWCLOSURE: {
+                        if (this.isMain && this.reg[17] && this.reg[17].kind === decompile_internal_1.ExprK.Table && !this.regDeclared[17]) {
+                            const name = this.makeTableName();
+                            this.regName[17] = name;
+                            this.regDeclared[17] = true;
+                            this.emitAssignStmt(out, "local " + name, this.reg[17]);
+                            this.reg[17] = this.leaf(name);
+                            this.maxLocals = Math.max(this.maxLocals, 18);
+                        }
+                        pc = this.emitClosure(out, pc);
+                        break;
+                    }
+                    case types_1.Op.DUPCLOSURE: {
+                        if (this.isMain && this.reg[17] && this.reg[17].kind === decompile_internal_1.ExprK.Table && !this.regDeclared[17]) {
+                            const name = this.makeTableName();
+                            this.regName[17] = name;
+                            this.regDeclared[17] = true;
+                            this.emitAssignStmt(out, "local " + name, this.reg[17]);
+                            this.reg[17] = this.leaf(name);
+                            this.maxLocals = Math.max(this.maxLocals, 18);
+                        }
+                        pc = this.emitDupClosure(out, pc);
+                        break;
+                    }
+                    case types_1.Op.NAMECALL:
+                    case types_1.Op.NAMECALLUDATA: {
+                        if (pc + 1 < this.n) {
+                            const mc = this.constAt(this.proto.code[pc + 1] & 0xffff);
+                            const name = (mc && mc.kind === types_1.ConstKind.String) ? mc.str : "";
+                            this.reg[(0, types_1.iA)(insn) + 1] = this.readReg((0, types_1.iB)(insn));
+                            const mi = { name, selfReg: (0, types_1.iA)(insn) + 1 };
+                            this.methodInfo[(0, types_1.iA)(insn)] = mi;
+                        }
+                        pc += 2;
+                        break;
+                    }
+                    case types_1.Op.CALL:
+                    case types_1.Op.CALLFB:
+                        pc = this.emitCall(out, pc);
+                        break;
+                    case types_1.Op.RETURN: {
+                        const A = (0, types_1.iA)(insn);
+                        const B = (0, types_1.iB)(insn);
+                        if (B === 1) {
+                            this.emitStmt(out, "return");
+                        }
+                        else if (B === 0) {
+                            const ret = (A < this.R) ? this.reg[A] : null;
+                            if (ret)
+                                this.emitStmt(out, "return " + oneLine(ret));
+                            else
+                                this.emitStmt(out, "return");
+                        }
+                        else {
+                            const nvals = B - 1;
+                            let vals = "";
+                            for (let k = 0; k < nvals; k++) {
+                                if (k)
+                                    vals += ", ";
+                                vals += oneLine(this.readReg(A + k));
+                            }
+                            this.emitStmt(out, "return " + vals);
+                        }
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.NOT:
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.un("not", this.readReg((0, types_1.iB)(insn))), false);
+                        ++pc;
+                        break;
+                    case types_1.Op.MINUS:
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.un("-", this.readReg((0, types_1.iB)(insn))), false);
+                        ++pc;
+                        break;
+                    case types_1.Op.LENGTH:
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.un("#", this.readReg((0, types_1.iB)(insn))), false);
+                        ++pc;
+                        break;
+                    case types_1.Op.ADD:
+                    case types_1.Op.SUB:
+                    case types_1.Op.MUL:
+                    case types_1.Op.DIV:
+                    case types_1.Op.MOD:
+                    case types_1.Op.POW:
+                    case types_1.Op.IDIV: {
+                        const sym = op === types_1.Op.ADD ? "+" : op === types_1.Op.SUB ? "-" : op === types_1.Op.MUL ? "*" :
+                            op === types_1.Op.DIV ? "/" : op === types_1.Op.MOD ? "%" : op === types_1.Op.POW ? "^" : "//";
+                        const lhs = this.readReg((0, types_1.iB)(insn));
+                        const rhs = this.readReg((0, types_1.iC)(insn));
+                        const prec = op === types_1.Op.POW ? 9 : (op === types_1.Op.MUL || op === types_1.Op.DIV || op === types_1.Op.MOD || op === types_1.Op.IDIV ? 7 : 6);
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.bin(sym, lhs, rhs, prec, op === types_1.Op.POW), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.ADDK:
+                    case types_1.Op.SUBK:
+                    case types_1.Op.MULK:
+                    case types_1.Op.DIVK:
+                    case types_1.Op.MODK:
+                    case types_1.Op.POWK:
+                    case types_1.Op.IDIVK: {
+                        const sym = op === types_1.Op.ADDK ? "+" : op === types_1.Op.SUBK ? "-" : op === types_1.Op.MULK ? "*" :
+                            op === types_1.Op.DIVK ? "/" : op === types_1.Op.MODK ? "%" : op === types_1.Op.POWK ? "^" : "//";
+                        const lhs = this.readReg((0, types_1.iB)(insn));
+                        const rhs = this.leaf(this.constTextText((0, types_1.iC)(insn)));
+                        const prec = op === types_1.Op.POWK ? 9 : (op === types_1.Op.MULK || op === types_1.Op.DIVK || op === types_1.Op.MODK || op === types_1.Op.IDIVK ? 7 : 6);
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.bin(sym, lhs, rhs, prec, op === types_1.Op.POWK), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.SUBRK:
+                    case types_1.Op.DIVRK: {
+                        const sym = op === types_1.Op.SUBRK ? "-" : "/";
+                        const lhs = this.leaf(this.constTextText((0, types_1.iB)(insn)));
+                        const rhs = this.readReg((0, types_1.iC)(insn));
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.bin(sym, lhs, rhs, 6, false), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.AND:
+                    case types_1.Op.OR: {
+                        const lhs = this.readReg((0, types_1.iB)(insn));
+                        const rhs = this.readReg((0, types_1.iC)(insn));
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.bin(op === types_1.Op.AND ? "and" : "or", lhs, rhs, op === types_1.Op.AND ? 2 : 1, false), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.ANDK:
+                    case types_1.Op.ORK: {
+                        const lhs = this.readReg((0, types_1.iB)(insn));
+                        const rhs = this.leaf(this.constTextText((0, types_1.iC)(insn)));
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, this.bin(op === types_1.Op.ANDK ? "and" : "or", lhs, rhs, op === types_1.Op.ANDK ? 2 : 1, false), false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.CONCAT: {
+                        let acc = this.readReg((0, types_1.iB)(insn));
+                        for (let r = (0, types_1.iB)(insn) + 1; r <= (0, types_1.iC)(insn); r++)
+                            acc = this.bin("..", acc, this.readReg(r), 5, true);
+                        this.writeResult(out, (0, types_1.iA)(insn), pc, acc, false);
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.GETVARARGS: {
+                        const v = (0, decompile_internal_1.makeExpr)(decompile_internal_1.ExprK.Vararg);
+                        v.text = "...";
+                        v.multi = true;
+                        this.reg[(0, types_1.iA)(insn)] = v;
+                        ++pc;
+                        break;
+                    }
+                    case types_1.Op.FORNPREP:
+                    case types_1.Op.FORGPREP:
+                    case types_1.Op.FORGPREP_INEXT:
+                    case types_1.Op.FORGPREP_NEXT:
+                    case types_1.Op.NEWCLASS:
+                    case types_1.Op.NEWCLASSMEMBER:
+                    case types_1.Op.CMPPROTO:
+                        pc += (0, types_1.opLength)(op);
+                        break;
+                    default:
+                        ++pc;
+                        break;
+                }
+            }
+        }
+        finally {
+            parseBlockDepth--;
+        }
+    }
+    clone() {
+        const c = Object.create(CompileState.prototype);
+        c.program = this.program;
+        c.proto = this.proto;
+        c.upvals = this.upvals;
+        c.isMain = this.isMain;
+        c.reg = this.reg.slice();
+        c.regName = this.regName.slice();
+        c.regDeclared = this.regDeclared.slice();
+        c.regOrigin = this.regOrigin.slice();
+        c.methodInfo = this.methodInfo.slice();
+        c.captured = this.captured.slice();
+        c.liveOut = this.liveOut;
+        c.n = this.n;
+        c.R = this.R;
+        c.maxLocals = this.maxLocals;
+        c.nextV = this.nextV;
+        c.tableCount = this.tableCount;
+        c.currentPc = this.currentPc;
+        c.usedNames = new Set(this.usedNames);
+        c.loops = this.loops;
+        return c;
+    }
+}
+function decompileProtoImpl(program, proto, upvals, isMainChunk) {
+    const st = new CompileState(program, proto, upvals, isMainChunk);
+    const out = new decompile_internal_1.Sink();
+    out.indent = 0;
+    st.parseBlock(out, 0, proto.code.length, -1, false);
+    const cr = (0, decompile_internal_1.makeClosureResult)();
+    let params = "";
+    for (let r = 0; r < proto.numparams; r++) {
+        if (r)
+            params += ", ";
+        let nm = st.regName[r];
+        if (nm.length === 0)
+            nm = st.getLocvarName(r, 0);
+        if (nm.length === 0)
+            nm = "p" + (r + 1);
+        params += nm;
+    }
+    let fname = proto.debugname;
+    if (fname.length > 0 && fname[0] === "(")
+        fname = "";
+    cr.body = out;
+    cr.upvalues = upvals;
+    cr.header = fname.length === 0 ? "function(" + params + ")" : "function " + fname + "(" + params + ")";
+    return cr;
+}
+function decompileProto(program, proto, upvals) {
+    return decompileProtoImpl(program, proto, upvals, false);
+}
+// ---------------------------------------------------------------------------
+// Output cleanup passes
+// ---------------------------------------------------------------------------
+function eliminateDeadStores(src) {
+    const lines = src.split("\n");
+    const isWordChar = (c) => /[A-Za-z0-9_]/.test(c);
+    const trim = (s) => s.replace(/^\t+/, "");
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i < lines.length; i++) {
+            const t = trim(lines[i]);
+            if (!t.startsWith("local "))
+                continue;
+            let nameStart = 6;
+            if (nameStart >= t.length || (!/[A-Za-z_]/.test(t[nameStart])))
+                continue;
+            let nameEnd = nameStart;
+            while (nameEnd < t.length && isWordChar(t[nameEnd]))
+                nameEnd++;
+            const varName = t.slice(nameStart, nameEnd);
+            const kws = ["and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if",
+                "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while", "continue"];
+            if (kws.includes(varName))
+                continue;
+            if (!t.includes("="))
+                continue;
+            if (t.endsWith("{"))
+                continue;
+            let used = false;
+            for (let j = i + 1; j < lines.length; j++) {
+                const tj = trim(lines[j]);
+                let p = 0;
+                while (p < tj.length) {
+                    if (tj[p] === '"' || tj[p] === "'") {
+                        const q = tj[p++];
+                        while (p < tj.length && tj[p] !== q) {
+                            if (tj[p] === "\\")
+                                p++;
+                            p++;
+                        }
+                        if (p < tj.length)
+                            p++;
+                        continue;
+                    }
+                    if (tj[p] === "-" && p + 1 < tj.length && tj[p + 1] === "-")
+                        break;
+                    if (/[A-Za-z_]/.test(tj[p])) {
+                        const ws = p;
+                        while (p < tj.length && isWordChar(tj[p]))
+                            p++;
+                        if (tj.slice(ws, p) === varName) {
+                            used = true;
+                            break;
+                        }
+                    }
+                    else
+                        p++;
+                }
+                if (used)
+                    break;
+            }
+            if (!used) {
+                lines.splice(i, 1);
+                i--;
+                changed = true;
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function foldRepeatedArithmetic(src) {
+    let result = src;
+    const foldPair = (needle, op) => {
+        let changed = true;
+        let maxPasses = 200;
+        while (changed && maxPasses-- > 0) {
+            changed = false;
+            let pos = 0;
+            while (pos < result.length) {
+                const start = result.indexOf(needle, pos);
+                if (start === -1)
+                    break;
+                let scan = start + needle.length;
+                let count = 1;
+                while (scan + needle.length <= result.length && result.slice(scan, scan + needle.length) === needle) {
+                    count++;
+                    scan += needle.length;
+                }
+                if (count >= 2) {
+                    result = result.slice(0, start) + " " + op + " " + count + result.slice(scan);
+                    changed = true;
+                }
+                else
+                    pos = start + needle.length;
+            }
+        }
+    };
+    foldPair(" + 1", "+");
+    foldPair(" - 1", "-");
+    // remove * 1
+    let changed = true;
+    let maxPasses = 100;
+    while (changed && maxPasses-- > 0) {
+        changed = false;
+        const start = result.indexOf(" * 1");
+        if (start !== -1) {
+            result = result.slice(0, start) + result.slice(start + 4);
+            changed = true;
+        }
+    }
+    const removeAddSub0 = (needle) => {
+        let c2 = true;
+        let mp = 100;
+        while (c2 && mp-- > 0) {
+            c2 = false;
+            let p = 0;
+            while (p < result.length) {
+                const s = result.indexOf(needle, p);
+                if (s === -1)
+                    break;
+                result = result.slice(0, s) + result.slice(s + needle.length);
+                c2 = true;
+            }
+        }
+    };
+    removeAddSub0(" + 0)");
+    removeAddSub0(" - 0)");
+    removeAddSub0(" + 0 ");
+    removeAddSub0(" - 0 ");
+    removeAddSub0(" + 0,");
+    removeAddSub0(" - 0,");
+    removeAddSub0(" + 0;");
+    removeAddSub0(" - 0;");
+    // constant-fold numeric arithmetic
+    changed = true;
+    maxPasses = 100;
+    while (changed && maxPasses-- > 0) {
+        changed = false;
+        let pos = 0;
+        while (pos < result.length) {
+            const isDigit = (c) => c >= "0" && c <= "9";
+            let n1s = pos;
+            while (n1s < result.length && !isDigit(result[n1s]))
+                n1s++;
+            if (n1s >= result.length)
+                break;
+            let n1e = n1s;
+            while (n1e < result.length && isDigit(result[n1e]))
+                n1e++;
+            if (n1e === n1s || n1e >= result.length) {
+                pos = n1e + 1;
+                continue;
+            }
+            let opPos = n1e;
+            while (opPos < result.length && result[opPos] === " ")
+                opPos++;
+            if (opPos >= result.length) {
+                pos = n1e + 1;
+                continue;
+            }
+            const op = result[opPos];
+            if (op !== "+" && op !== "-" && op !== "*") {
+                pos = n1e + 1;
+                continue;
+            }
+            let n2s = opPos + 1;
+            while (n2s < result.length && result[n2s] === " ")
+                n2s++;
+            if (n2s >= result.length || !isDigit(result[n2s])) {
+                pos = n1e + 1;
+                continue;
+            }
+            let n2e = n2s;
+            while (n2e < result.length && isDigit(result[n2e]))
+                n2e++;
+            if (n2e === n2s) {
+                pos = n2e;
+                continue;
+            }
+            const after = (n2e < result.length) ? result[n2e] : 0;
+            if (after !== 0 && after !== " " && after !== ")" && after !== "]" && after !== "," &&
+                after !== ";" && after !== "\n" && after !== "\r") {
+                pos = n2e;
+                continue;
+            }
+            const v1 = parseInt(result.slice(n1s, n1e), 10);
+            const v2 = parseInt(result.slice(n2s, n2e), 10);
+            const rv = op === "+" ? v1 + v2 : op === "-" ? v1 - v2 : v1 * v2;
+            result = result.slice(0, n1s) + String(rv) + result.slice(n2e);
+            changed = true;
+            pos = n1s + String(rv).length;
+        }
+    }
+    return result;
+}
+function removeTrailingReturn(src) {
+    const lines = src.split("\n");
+    const trim = (s) => s.replace(/^\t+/, "");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const t = trim(lines[i]);
+        if (t === "return") {
+            if (i > 0) {
+                const prev = trim(lines[i - 1]);
+                if (prev.startsWith("function ") || prev.startsWith("local function "))
+                    continue;
+                if (prev.length > 0 && prev !== "end") {
+                    lines.splice(i, 1);
+                    i--;
+                    continue;
+                }
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function simplifyIfTrue(src) {
+    const lines = src.split("\n");
+    const trim = (s) => s.replace(/^\t+/, "");
+    for (let i = 0; i < lines.length; i++) {
+        const t = trim(lines[i]);
+        if (t === "if true then") {
+            let indent = 0;
+            while (indent < lines[i].length && lines[i][indent] === "\t")
+                indent++;
+            let endIdx = -1;
+            let depth = 1;
+            for (let j = i + 1; j < lines.length; j++) {
+                const tj = trim(lines[j]);
+                let tjIndent = 0;
+                while (tjIndent < lines[j].length && lines[j][tjIndent] === "\t")
+                    tjIndent++;
+                if (tjIndent === indent && tj.length >= 3 && tj.slice(0, 3) === "end") {
+                    depth--;
+                    if (depth === 0) {
+                        endIdx = j;
+                        break;
+                    }
+                }
+                if (tjIndent === indent && (tj.startsWith("if ") || tj.startsWith("for ") ||
+                    tj.startsWith("while ") || tj.startsWith("function ")))
+                    depth++;
+            }
+            if (endIdx > 0) {
+                lines.splice(endIdx, 1);
+                lines.splice(i, 1);
+                for (let j = i; j < endIdx - 1; j++) {
+                    if (lines[j].length > 0 && lines[j][0] === "\t")
+                        lines[j] = lines[j].slice(1);
+                }
+                i--;
+            }
+        }
+    }
+    return lines.join("\n");
+}
+function removeEmptyIfBlocks(src) {
+    let result = src;
+    let changed = true;
+    while (changed) {
+        changed = false;
+        const lines = result.split("\n");
+        for (let i = 0; i + 1 < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            if (!trimmed.startsWith("if "))
+                continue;
+            if (trimmed.length < 5 || trimmed.slice(trimmed.length - 5) !== " then")
+                continue;
+            const next = lines[i + 1].trim();
+            if (next !== "end")
+                continue;
+            lines.splice(i, 2);
+            changed = true;
+            break;
+        }
+        result = lines.join("\n");
+    }
+    return result;
+}
+function flattenNestedIfs(src) {
+    const lines = src.split("\n");
+    const trim = (s) => s.trim();
+    const countTabs = (s) => { let c = 0; while (c < s.length && s[c] === "\t")
+        c++; return c; };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (let i = 0; i + 3 < lines.length; i++) {
+            const t1 = trim(lines[i]);
+            if (!t1.startsWith("if ") || t1.length < 4 || t1.slice(t1.length - 4) !== " then")
+                continue;
+            const tabs1 = countTabs(lines[i]);
+            const t2 = trim(lines[i + 1]);
+            if (!t2.startsWith("if ") || t2.length < 4 || t2.slice(t2.length - 4) !== " then")
+                continue;
+            const tabs2 = countTabs(lines[i + 1]);
+            if (tabs2 !== tabs1 + 1)
+                continue;
+            let foundOnlyIf = true;
+            for (let j = i + 2; j < lines.length; j++) {
+                const tj = trim(lines[j]);
+                const tabsj = countTabs(lines[j]);
+                if (tabsj === tabs1 && tj === "end")
+                    break;
+                if (tabsj < tabs1) {
+                    foundOnlyIf = false;
+                    break;
+                }
+                if (tabsj === tabs1 + 1 && tj !== "end") {
+                    foundOnlyIf = false;
+                    break;
+                }
+            }
+            if (!foundOnlyIf)
+                continue;
+            const cond1 = t1.slice(3, t1.length - 7);
+            const cond2 = t2.slice(3, t2.length - 7);
+            const indentStr = "\t".repeat(tabs1);
+            lines[i] = indentStr + "if " + cond1 + " and " + cond2 + " then";
+            lines.splice(i + 1, 1);
+            for (let j = i + 1; j < lines.length; j++) {
+                if (trim(lines[j]) === "end" && countTabs(lines[j]) === tabs1) {
+                    lines.splice(j, 1);
+                    break;
+                }
+            }
+            changed = true;
+            break;
+        }
+    }
+    return lines.join("\n");
+}
+// Split src into lines, stripping \r; no trailing empty element.
+function splitLines(src) {
+    const lines = [];
+    let start = 0;
+    while (start < src.length) {
+        const nl = src.indexOf("\n", start);
+        if (nl === -1) {
+            lines.push(src.slice(start));
+            break;
+        }
+        let line = src.slice(start, nl);
+        if (line.length > 0 && line.charCodeAt(line.length - 1) === 13)
+            line = line.slice(0, -1);
+        lines.push(line);
+        start = nl + 1;
+    }
+    return lines;
+}
+function collapseWeightedRandom(src) {
+    const lines = splitLines(src);
+    const trim = (s) => s.replace(/^[ \t]+/, "").replace(/[ \t]+$/, "");
+    const removed = new Array(lines.length).fill(false);
+    const endsWithDo = (s) => s.length >= 3 && s.slice(-3) === " do";
+    for (let i = 0; i + 1 < lines.length; i++) {
+        const t = trim(lines[i]);
+        if (!t.startsWith("while "))
+            continue;
+        let joined = t;
+        let endLine = i + 1;
+        let foundDo = endsWithDo(t);
+        while (!foundDo && endLine < lines.length) {
+            const next = trim(lines[endLine]);
+            joined += " " + next;
+            endLine++;
+            if (endsWithDo(next)) {
+                foundDo = true;
+                break;
+            }
+        }
+        if (!foundDo)
+            continue;
+        if (endLine >= lines.length)
+            continue;
+        if (trim(lines[endLine]) !== "end")
+            continue;
+        const kwEnd = joined.indexOf("while ") + 6;
+        const doPos = joined.lastIndexOf(" do");
+        if (doPos === -1 || doPos <= kwEnd)
+            continue;
+        const cond = joined.slice(kwEnd, doPos);
+        const mr = cond.indexOf("math.random(1, ");
+        if (mr === -1)
+            continue;
+        const tableStart = mr + 15;
+        const twEnd = cond.indexOf(".totalWeight)", tableStart);
+        if (twEnd === -1)
+            continue;
+        const tableRef = cond.slice(tableStart, twEnd);
+        const totalExpr = tableRef + ".totalWeight";
+        if (cond.indexOf(totalExpr) === -1)
+            continue;
+        const weightPattern = tableRef + "[";
+        let count = 0;
+        let scanPos = 0;
+        while (scanPos < cond.length) {
+            const wp = cond.indexOf(weightPattern + (count + 1) + "].weight", scanPos);
+            if (wp === -1)
+                break;
+            count++;
+            scanPos = wp + 1;
+        }
+        if (count < 2)
+            continue;
+        let indent = 0;
+        while (indent < lines[i].length && lines[i][indent] === "\t")
+            indent++;
+        const indentStr = "\t".repeat(indent);
+        const idxVar = "_i";
+        const randVar = "_r";
+        const replacement = indentStr + "local " + randVar + " = math.random(1, " + tableRef + ".totalWeight)\n" +
+            indentStr + "local " + idxVar + " = 1\n" +
+            indentStr + "while " + tableRef + "[" + idxVar + "].weight < " + randVar + " do\n" +
+            indentStr + "\t" + randVar + " = " + randVar + " - " + tableRef + "[" + idxVar + "].weight\n" +
+            indentStr + "\t" + idxVar + " = " + idxVar + " + 1\n" +
+            indentStr + "end";
+        const hardcodedIndex = weightPattern + (count + 2) + "]";
+        const varIndex = weightPattern + idxVar + "]";
+        lines[i] = replacement;
+        for (let j = i + 1; j <= endLine; j++)
+            removed[j] = true;
+        const searchEnd = Math.min(endLine + 30, lines.length);
+        for (let j = endLine + 1; j < searchEnd; j++) {
+            if (removed[j])
+                continue;
+            const lt = trim(lines[j]);
+            if (lt.startsWith("function ") || lt.startsWith("local function "))
+                break;
+            let pos = 0;
+            let at;
+            while ((at = lines[j].indexOf(hardcodedIndex, pos)) !== -1) {
+                lines[j] = lines[j].slice(0, at) + varIndex + lines[j].slice(at + hardcodedIndex.length);
+                pos = at + varIndex.length;
+            }
+        }
+    }
+    let result = "";
+    for (let i = 0; i < lines.length; i++) {
+        if (removed[i])
+            continue;
+        result += lines[i];
+        if (i + 1 < lines.length)
+            result += "\n";
+    }
+    return result;
+}
+function cleanOutput(src) {
+    let result = foldRepeatedArithmetic(src);
+    result = collapseWeightedRandom(result);
+    result = removeEmptyIfBlocks(result);
+    result = simplifyIfTrue(result);
+    result = removeTrailingReturn(result);
+    return result;
+}
+function decompile(program) {
+    if (program.protos.length === 0)
+        return "-- empty program\n";
+    const main = program.protos[program.main];
+    const st = new CompileState(program, main, [], true);
+    const out = new decompile_internal_1.Sink();
+    out.indent = 0;
+    st.parseBlock(out, 0, main.code.length, -1, false);
+    let res = K_HEADER;
+    const isFuncHeader = (s) => s.startsWith("function ") || s.startsWith("local function ");
+    const isEndLine = (s) => s === "end";
+    for (let i = 0; i < out.lines.length; i++) {
+        const l = out.lines[i];
+        const level = Math.max(0, l.level);
+        if (level === 0 && i > 0 && isFuncHeader(l.text)) {
+            if (res.length > 0 && res[res.length - 1] === "\n") {
+                const pos = res.lastIndexOf("\n", res.length - 2);
+                if (pos !== -1 && res[pos + 1] !== "\n")
+                    res += "\n";
+            }
+        }
+        const indentStr = "\t".repeat(level);
+        res += indentStr + l.text + "\n";
+        if (level === 0 && isEndLine(l.text) && i + 1 < out.lines.length)
+            res += "\n";
+    }
+    return cleanOutput(eliminateDeadStores(res));
+}