@markw65/monkeyc-optimizer 1.1.21 → 1.1.22

package/build/{chunk-ZDTW2QRS.cjs → chunk-563GVBVT.cjs}

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_ZDTW2QRS_exports = {};
-__export(chunk_ZDTW2QRS_exports, {
+var chunk_563GVBVT_exports = {};
+__export(chunk_563GVBVT_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -125,7 +125,7 @@ __export(chunk_ZDTW2QRS_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_ZDTW2QRS_exports);
+module.exports = __toCommonJS(chunk_563GVBVT_exports);
 var import_chunk_HHQDDCTP = require("./chunk-HHQDDCTP.cjs");
 var import_prettier_plugin_monkeyc = require("@markw65/prettier-plugin-monkeyc");
 var import_node_assert = __toESM(require("node:assert"));
@@ -13663,6 +13663,23 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
   );
   const deadStores = /* @__PURE__ */ new Set();
   const copyPropStores = /* @__PURE__ */ new Map();
+  const copyPropRef = (curState, key, node) => {
+    if (findCopyPropCandidates && declIsLocal(key)) {
+      if (!curState.anticipated) {
+        curState.anticipated = /* @__PURE__ */ new Map();
+      }
+      addAnt(curState.anticipated, key, node);
+      if (!curState.partiallyAnticipated) {
+        curState.partiallyAnticipated = /* @__PURE__ */ new Map();
+      }
+      addAnt(curState.partiallyAnticipated, key, node);
+      if (logThisRun) {
+        console.log(
+          `  antrefs: ${curState.partiallyAnticipated.get(key) !== false} ${curState.anticipated.get(key) !== false}`
+        );
+      }
+    }
+  };
   order.forEach((block) => {
     if (!block.succs) {
       queue.enqueue(block);
@@ -13694,31 +13711,21 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
           case "ref":
             if (isTypeStateKey(event.decl)) {
               if (logThisRun) {
-                console.log(describeEvent(event));
+                console.log(
+                  `${describeEvent(event)} (${sourceLocation(event.node.loc)})`
+                );
                 console.log(`  kill => ${tsKey(event.decl)}`);
               }
-              if (findCopyPropCandidates && declIsLocal(event.decl)) {
-                if (!curState.anticipated) {
-                  curState.anticipated = /* @__PURE__ */ new Map();
-                }
-                addAnt(curState.anticipated, event.decl, event.node);
-                if (!curState.partiallyAnticipated) {
-                  curState.partiallyAnticipated = /* @__PURE__ */ new Map();
-                }
-                addAnt(curState.partiallyAnticipated, event.decl, event.node);
-                if (logThisRun) {
-                  console.log(
-                    `  antrefs: ${curState.partiallyAnticipated.get(event.decl) !== false} ${curState.anticipated.get(event.decl) !== false}`
-                  );
-                }
-              }
+              copyPropRef(curState, event.decl, event.node);
               curState.dead.delete(event.decl);
             }
             break;
           case "def":
             if (isTypeStateKey(event.decl) && (event.node.type !== "VariableDeclarator" || event.node.init)) {
               if (logThisRun) {
-                console.log(describeEvent(event));
+                console.log(
+                  `${describeEvent(event)} (${sourceLocation(event.node.loc)})`
+                );
               }
               const assignNode = event.node.type === "AssignmentExpression" && event.node.operator === "=" && event.node.right || event.node.type === "VariableDeclarator" && event.node.init;
               if (curState.dead.has(event.decl)) {
@@ -13764,6 +13771,8 @@ function findDeadStores(func, graph, nodeEquivs, findCopyPropCandidates, logThis
                 if (logThisRun) {
                   console.log(`  anticipated => ${tsKey(event.decl)}`);
                 }
+              } else if (event.node.type === "UpdateExpression") {
+                copyPropRef(curState, event.decl, event.node.argument);
               }
             }
             break;
@@ -21382,178 +21391,6 @@ var init_opcodes = (0, import_chunk_HHQDDCTP.__esm)({
     })(Opcodes || {});
   }
 });
-function optimizeArrayInit(func, block, index, stackPreserving, context) {
-  (0, import_node_assert6.default)(
-    block.bytecodes[index].op === 20
-    /* newa */
-  );
-  const putvStarts = [];
-  let i;
-  let initVal = null;
-  for (i = index; ++i < block.bytecodes.length - 1; ) {
-    const dup = block.bytecodes[i];
-    if (dup.op !== 46 || dup.arg !== 0) {
-      break;
-    }
-    const ipush = block.bytecodes[i + 1];
-    if (ipush.op !== 37 || ipush.arg !== putvStarts.length) {
-      break;
-    }
-    let found = i;
-    for (let k = i + 1, depth = 0; ++k < block.bytecodes.length; ) {
-      const bc = block.bytecodes[k];
-      if (bc.op === 17 && depth === 1) {
-        found = k;
-        break;
-      }
-      const { pop, push } = getOpInfo(bc);
-      depth += push - pop;
-      if (depth < 0 || bc.op === 46 && bc.arg >= depth) {
-        break;
-      }
-    }
-    if (found === i)
-      break;
-    if (initVal !== false) {
-      if (found === i + 3) {
-        const bc = block.bytecodes[i + 2];
-        if (initVal === null) {
-          initVal = bc;
-        } else if (initVal.op !== bc.op || initVal.arg !== bc.arg) {
-          initVal = false;
-        }
-      } else {
-        initVal = false;
-      }
-    }
-    putvStarts.push(i);
-    i = found;
-  }
-  if (block.bytecodes[i]?.op === 2) {
-    const convertAputv = (i2) => {
-      const bc = block.bytecodes[i2];
-      const op = bc.op;
-      bc.op = 2;
-      bc.size = 1;
-      delete bc.arg;
-      (0, import_node_assert6.default)(
-        op === 17
-        /* aputv */
-      );
-    };
-    convertAputv(i - 1);
-    for (i = putvStarts.length; i--; ) {
-      const offset = putvStarts[i];
-      block.bytecodes.splice(offset, 2);
-      if (i) {
-        convertAputv(offset - 1);
-      }
-    }
-    (0, import_chunk_HHQDDCTP.logger)(
-      "array-init",
-      1,
-      `Optimizing unused ${putvStarts.length} element array init at block ${offsetToString(
-        block.offset
-      )}, starting at index ${index}, at offset ${offsetToString(
-        block.bytecodes[index].offset
-      )}`
-    );
-    if ((0, import_chunk_HHQDDCTP.wouldLog)("array-init", 5)) {
-      (0, import_chunk_HHQDDCTP.log)(blockToString(block, context));
-    }
-    return true;
-  }
-  const bytecode = (op, arg) => {
-    const bc = { op, arg, size: opcodeSize(op), offset: context.nextOffset++ };
-    if (arg == null)
-      delete bc.arg;
-    return bc;
-  };
-  if (initVal) {
-    if (putvStarts.length < 3)
-      return false;
-    (0, import_chunk_HHQDDCTP.logger)(
-      "array-init",
-      1,
-      `Optimizing ${putvStarts.length} element array init with constant initializer ${bytecodeToString(
-        initVal,
-        null
-      )} at block ${offsetToString(
-        block.offset
-      )}, starting at index ${index}, at offset ${offsetToString(
-        block.bytecodes[index].offset
-      )}`
-    );
-    block.bytecodes.splice(
-      putvStarts[1],
-      putvStarts[putvStarts.length - 1] - putvStarts[0]
-    );
-    block.bytecodes.splice(putvStarts[0], 1);
-    block.bytecodes[putvStarts[0]].arg = putvStarts.length;
-    const loopOffset2 = context.nextOffset;
-    block.bytecodes.splice(
-      index + 2,
-      0,
-      bytecode(37, 1),
-      bytecode(4, void 0),
-      bytecode(46, 1),
-      bytecode(46, 1)
-    );
-    block.bytecodes.splice(
-      index + 8,
-      0,
-      bytecode(46, 0),
-      bytecode(40, loopOffset2),
-      bytecode(2, void 0)
-    );
-    splitBlock(func, block, index + 10);
-    splitBlock(func, block, index + 2);
-    const loop2 = func.blocks.get(loopOffset2);
-    loop2.preds.add(loopOffset2);
-    loop2.taken = loopOffset2;
-    return true;
-  }
-  if (stackPreserving || putvStarts.length < 4)
-    return false;
-  for (i = putvStarts.length; i-- > 1; ) {
-    block.bytecodes.splice(putvStarts[i], 2);
-  }
-  (0, import_chunk_HHQDDCTP.logger)(
-    "array-init",
-    1,
-    `Optimizing ${putvStarts.length} element array init at block ${offsetToString(
-      block.offset
-    )}, starting at index ${index}, at offset ${offsetToString(
-      block.bytecodes[index].offset
-    )}`
-  );
-  block.bytecodes[index + 2].arg = putvStarts.length - 1;
-  const loopOffset = context.nextOffset;
-  block.bytecodes.splice(
-    index + 3,
-    0,
-    bytecode(46, 1),
-    bytecode(46, 1),
-    bytecode(37, 1),
-    bytecode(4, void 0),
-    bytecode(46, 0),
-    bytecode(40, loopOffset)
-  );
-  splitBlock(func, block, index + 9);
-  splitBlock(func, block, index + 3);
-  const loop = func.blocks.get(loopOffset);
-  loop.preds.add(loopOffset);
-  loop.taken = loopOffset;
-  return true;
-}
-var init_array_init = (0, import_chunk_HHQDDCTP.__esm)({
-  "src/readprg/array-init.ts"() {
-    "use strict";
-    (0, import_chunk_HHQDDCTP.init_util)();
-    init_bytecode();
-    init_opcodes();
-  }
-});
 function postOrderTraverse2(func, visitor) {
   const visited = /* @__PURE__ */ new Set();
   const helper = (offset) => {
@@ -21621,7 +21458,7 @@ function postOrderPropagate(func, preBlock, processBc, postBlock, merge) {
     top.preds?.forEach((pred) => {
       const predBlock = func.blocks.get(pred);
       const isExPred = predBlock.next !== top.offset && predBlock.taken !== top.offset;
-      (0, import_node_assert7.default)(!isExPred || predBlock.exsucc === top.offset);
+      (0, import_node_assert6.default)(!isExPred || predBlock.exsucc === top.offset);
       merge(localState, predBlock, isExPred) && queue.enqueue(predBlock);
       const jsrPreds = jsrMap.get(pred);
       if (jsrPreds) {
@@ -21640,7 +21477,7 @@ function computeRetMap(func) {
   const retMap = /* @__PURE__ */ new Map();
   jsrMap.forEach((retBlocks, jsrBlock) => {
     const jsrNext = func.blocks.get(jsrBlock).next;
-    (0, import_node_assert7.default)(jsrNext);
+    (0, import_node_assert6.default)(jsrNext);
     retBlocks.forEach((retBlock) => {
       const retSuccs = retMap.get(retBlock);
       if (retSuccs) {
@@ -21670,20 +21507,40 @@ function rpoPropagate(func, preBlock, processBc, postBlock, merge) {
     const top = queue.dequeue();
     const localState = preBlock(top);
     const doMerge = (to, isExSucc) => {
-      if (to == null)
-        return;
       const toBlock = func.blocks.get(to);
       merge(top, localState, toBlock, isExSucc) && queue.enqueue(toBlock);
     };
-    top.bytecodes.forEach((bc) => {
-      processBc(top, bc, localState);
+    let flags;
+    for (let i = 0; i < top.bytecodes.length; i++) {
+      const bc = top.bytecodes[i];
+      flags = processBc(top, bc, localState);
+      if (flags != null && flags & 16) {
+        i = -1;
+        continue;
+      }
       if (top.exsucc && (bc.op === 15 || bc.op === 51)) {
         doMerge(top.exsucc, true);
       }
-    });
+    }
     postBlock(top, localState);
-    doMerge(top.next, false);
-    doMerge(top.taken, false);
+    if (flags == null)
+      flags = 0;
+    if (top.next != null) {
+      if (!(flags & 8)) {
+        doMerge(top.next, false);
+      }
+      if (flags & 2) {
+        queue.enqueue(func.blocks.get(top.next));
+      }
+    }
+    if (top.taken) {
+      if (!(flags & 4)) {
+        doMerge(top.taken, false);
+      }
+      if (flags & 1) {
+        queue.enqueue(func.blocks.get(top.taken));
+      }
+    }
     retMap.get(top.offset)?.forEach((retSucc) => doMerge(retSucc, false));
   }
 }
@@ -21694,257 +21551,10 @@ var init_cflow = (0, import_chunk_HHQDDCTP.__esm)({
     init_opcodes();
   }
 });
-function localDCE(func, context) {
-  if ((0, import_chunk_HHQDDCTP.wouldLog)("dce", 5)) {
-    (0, import_chunk_HHQDDCTP.setBanner)(
-      functionBanner(
-        func,
-        context,
-        "local-dce-start",
-        (block, footer) => footer ? `liveOutLocals: ${Array.from(
-          liveOutLocals.get(block.offset) ?? []
-        ).join(" ")}
-` : ""
-      )
-    );
-  }
-  const { liveInLocals, liveOutLocals } = computeLiveLocals(func);
-  let anyChanges = false;
-  let changes = false;
-  const makeNop = (bc) => {
-    changes = true;
-    makeArgless(
-      bc,
-      0
-      /* nop */
-    );
-  };
-  const makePopv = (bc) => {
-    changes = true;
-    makeArgless(
-      bc,
-      2
-      /* popv */
-    );
-  };
-  func.blocks.forEach((block) => {
-    const reportPopv = (i, item, kill) => {
-      (0, import_chunk_HHQDDCTP.logger)(
-        "dce",
-        2,
-        `${func.name}: Convert ${i}:${bytecodeToString(
-          block.bytecodes[i],
-          context.symbolTable
-        )} to popv for ${item.deps.map(
-          (i2) => `${i2}:${bytecodeToString(
-            block.bytecodes[i2],
-            context.symbolTable
-          )}${kill ? "=>nop" : ""}`
-        ).join(", ")} }`
-      );
-    };
-    const reportNop = (item) => {
-      (0, import_chunk_HHQDDCTP.logger)(
-        "dce",
-        2,
-        `${func.name}: Kill ${item.deps.map((i) => bytecodeToString(block.bytecodes[i], context.symbolTable)).join(", ")}`
-      );
-    };
-    changes = false;
-    const dceInfo = {
-      stack: [],
-      locals: new Set(liveOutLocals.get(block.offset))
-    };
-    for (let i = block.bytecodes.length; i--; ) {
-      const bytecode = block.bytecodes[i];
-      switch (bytecode.op) {
-        case 19: {
-          const liveLocal = dceInfo.locals.has(bytecode.arg);
-          if (!liveLocal) {
-            (0, import_chunk_HHQDDCTP.logger)(
-              "dce",
-              2,
-              `${func.name}: Killing store to unused local ${bytecode.arg} at ${offsetToString(block.offset)}:${i}`
-            );
-            makePopv(bytecode);
-            dceInfo.stack.push({ dead: true, deps: [i] });
-          } else {
-            dceInfo.stack.push({ dead: false });
-          }
-          dceInfo.locals.delete(bytecode.arg);
-          break;
-        }
-        case 2:
-          dceInfo.stack.push({ dead: true, deps: [i] });
-          break;
-        case 46: {
-          const item = dceInfo.stack.pop();
-          if (item?.dead) {
-            item.deps.push(i);
-            reportNop(item);
-            item.deps.forEach((index) => makeNop(block.bytecodes[index]));
-          } else {
-            if (dceInfo.stack.length > bytecode.arg) {
-              dceInfo.stack[dceInfo.stack.length - 1 - bytecode.arg].dead = false;
-            }
-          }
-          break;
-        }
-        case 18:
-        case 44:
-        case 43:
-        case 24:
-        case 37:
-        case 38:
-        case 39:
-        case 52:
-        case 49:
-        case 50: {
-          const item = dceInfo.stack.pop();
-          if (item?.dead) {
-            item.deps.push(i);
-            reportNop(item);
-            item.deps.forEach((index) => makeNop(block.bytecodes[index]));
-          } else if (bytecode.op === 18) {
-            dceInfo.locals.add(bytecode.arg);
-          }
-          break;
-        }
-        case 3:
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-        case 8:
-        case 9:
-        case 10:
-        case 11:
-        case 12:
-        case 26:
-        case 27:
-        case 28:
-        case 29:
-        case 30:
-        case 31:
-        case 34:
-        case 33:
-        case 16:
-        case 13: {
-          const item = dceInfo.stack.pop();
-          if (item?.dead) {
-            reportPopv(i, item, false);
-            makePopv(bytecode);
-            dceInfo.stack.push({ dead: true, deps: item.deps.slice() });
-            dceInfo.stack.push({ dead: true, deps: [i] });
-          } else {
-            dceInfo.stack.push({ dead: false });
-            dceInfo.stack.push({ dead: false });
-          }
-          break;
-        }
-        case 21:
-        case 32:
-        case 45:
-        case 48:
-        case 20:
-        case 54:
-        case 47: {
-          const item = dceInfo.stack.pop();
-          if (item?.dead) {
-            reportPopv(i, item, true);
-            makePopv(bytecode);
-            item.deps.forEach((index) => makeNop(block.bytecodes[index]));
-            dceInfo.stack.push({ dead: true, deps: [i] });
-          } else {
-            dceInfo.stack.push({ dead: false });
-          }
-          break;
-        }
-        case 51:
-        case 15:
-          if (block.exsucc) {
-            liveInLocals.get(block.exsucc)?.forEach((local) => dceInfo.locals.add(local));
-          }
-        default: {
-          let { push, pop } = getOpInfo(bytecode);
-          while (push-- > 0) {
-            dceInfo.stack.pop();
-          }
-          while (pop-- > 0) {
-            dceInfo.stack.push({ dead: false });
-          }
-        }
-      }
-    }
-    if (changes) {
-      anyChanges = true;
-      block.bytecodes = block.bytecodes.filter(
-        (bc) => bc.op !== 0
-        /* nop */
-      );
-      if ((0, import_chunk_HHQDDCTP.wouldLog)("dce", 3)) {
-        (0, import_chunk_HHQDDCTP.log)(functionBanner(func, context, "local-dce-end")());
-      }
-    }
-  });
-  (0, import_chunk_HHQDDCTP.setBanner)(null);
-  return anyChanges;
-}
-function computeLiveLocals(func) {
-  const liveOutLocals = /* @__PURE__ */ new Map();
-  const liveInLocals = /* @__PURE__ */ new Map();
-  postOrderPropagate(
-    func,
-    (block) => new Set(liveOutLocals.get(block.offset)),
-    (block, bc, locals) => {
-      switch (bc.op) {
-        case 18:
-          locals.add(bc.arg);
-          break;
-        case 19:
-          locals.delete(bc.arg);
-          break;
-        case 51:
-        case 15:
-          if (block.exsucc) {
-            liveInLocals.get(block.exsucc)?.forEach((local) => locals.add(local));
-          }
-          break;
-      }
-    },
-    (block, locals) => {
-      liveInLocals.set(block.offset, locals);
-    },
-    (locals, predBlock, isExPred) => {
-      if (isExPred)
-        return false;
-      const predLocals = liveOutLocals.get(predBlock.offset);
-      if (!predLocals) {
-        liveOutLocals.set(predBlock.offset, new Set(locals));
-        return true;
-      }
-      const size = predLocals.size;
-      locals.forEach((local) => predLocals.add(local));
-      return size !== predLocals.size;
-    }
-  );
-  return { liveInLocals, liveOutLocals };
-}
-var init_dce = (0, import_chunk_HHQDDCTP.__esm)({
-  "src/readprg/dce.ts"() {
-    "use strict";
-    (0, import_chunk_HHQDDCTP.init_util)();
-    init_bytecode();
-    init_cflow();
-    init_opcodes();
-  }
-});
-function interpItemToString(item) {
-  let str = display(item.type);
-  if (item.dup != null)
-    str += ` dup<${item.dup}>`;
-  if (item.equivs) {
-    str += ` equivs: ${Array.from(item.equivs).join(", ")}`;
+function interpItemToString(item) {
+  let str = display(item.type);
+  if (item.equivs) {
+    str += ` equivs: ${Array.from(item.equivs).join(", ")}`;
   }
   return str;
 }
@@ -21961,7 +21571,7 @@ function checkState(state) {
   const checkArray = (items) => items.forEach((item) => {
     item.equivs?.forEach((e) => {
       if (getEquivs(state, e) !== item.equivs) {
-        (0, import_node_assert8.default)(getEquivs(state, e) === item.equivs);
+        (0, import_node_assert7.default)(getEquivs(state, e) === item.equivs);
       }
     });
   });
@@ -22055,10 +21665,6 @@ function mergeElems(fromElem, toElem) {
   if (unionInto(toElem.type, fromElem.type)) {
     changes = true;
   }
-  if (toElem.dup !== fromElem.dup) {
-    changes = true;
-    delete toElem.dup;
-  }
   return changes;
 }
 function mergeInto(from, to) {
@@ -22134,9 +21740,9 @@ function mergeInto(from, to) {
   return changes;
 }
 function findEquivalent(localState, type, value2) {
-  const find = (elems) => {
+  const find = (elems, d) => {
     let alternate = null;
-    for (let i = elems.length; i--; ) {
+    for (let i = elems.length - d; i--; ) {
       const t = elems[i];
       if (t && t.type.type === type) {
         if (t.type.value === value2) {
@@ -22148,310 +21754,1044 @@ function findEquivalent(localState, type, value2) {
     }
     return alternate;
   };
-  const stackIndex = find(localState.stack);
+  const stackIndex = find(localState.stack, 1);
   if (stackIndex != null && stackIndex < localState.stack.length) {
     return ~stackIndex;
   }
-  const localIndex = find(localState.locals);
+  const localIndex = find(localState.locals, 0);
   if (localIndex != null && localIndex < localState.locals.length) {
     return localIndex;
   }
   return stackIndex != null ? ~stackIndex : localIndex;
 }
-function interpFunc(func, context) {
-  const { symbolTable } = context;
-  const equivSets = /* @__PURE__ */ new Map();
-  const selfStores = /* @__PURE__ */ new Set();
-  const liveInState = /* @__PURE__ */ new Map();
-  const replacements = /* @__PURE__ */ new Map();
-  const interpLogging = (0, import_chunk_HHQDDCTP.wouldLog)("interp", 1);
-  if (interpLogging) {
-    if ((0, import_chunk_HHQDDCTP.wouldLog)("interp", 7)) {
-      (0, import_chunk_HHQDDCTP.setBanner)(functionBanner(func, context, "interp"));
-    } else if ((0, import_chunk_HHQDDCTP.wouldLog)("interp", 3)) {
-      (0, import_chunk_HHQDDCTP.setBanner)(
-        () => `+++++++++++++ interp-prepare ${func.name} ++++++++++++++`
-      );
-    }
-  }
-  const xpush = (localState, block, bc, type, value2) => {
+function interpBytecode(bc, localState, context) {
+  const xpush = (type, value2) => {
     const tt = { type };
     if (value2 != null) {
       tt.value = value2;
     }
-    if (bc.size > 2) {
-      const index = findEquivalent(localState, type, value2);
-      let blockReps = replacements.get(block);
-      if (index != null) {
-        if (!blockReps) {
-          blockReps = /* @__PURE__ */ new Map();
-          replacements.set(block, blockReps);
-        }
-        if (index < 0) {
-          const arg = localState.stack.length - ~index % localState.stack.length - 1;
-          blockReps.set(bc, {
-            op: 46,
-            arg,
-            offset: bc.offset,
-            size: 2,
-            invert: localState.stack.length <= ~index
-          });
-        } else {
-          const arg = index % localState.locals.length;
-          blockReps.set(bc, {
-            op: 18,
-            arg,
-            offset: bc.offset,
-            size: 2,
-            invert: localState.locals.length <= index
-          });
-        }
-      } else if (blockReps) {
-        blockReps.delete(bc);
-        if (!blockReps.size) {
-          replacements.delete(block);
-        }
-      }
-    }
     localState.stack.push({
       type: tt
     });
   };
-  rpoPropagate(
-    func,
-    (block) => {
-      if (interpLogging) {
-        (0, import_chunk_HHQDDCTP.logger)(
-          "interp",
-          3,
-          `${offsetToString(block.offset)}: ${block.bytecodes[0]?.lineNum ? lineInfoToString(block.bytecodes[0]?.lineNum, context) : ""}
- ${interpStateToString(liveInState.get(block.offset))}`
-        );
-        (0, import_chunk_HHQDDCTP.logger)("interp", 9, blockToString(block, context));
+  const binary = (op) => {
+    const args = localState.stack.slice(-2);
+    if (args.length !== 2) {
+      args.splice(
+        0,
+        2,
+        { type: {
+          type: 524287
+          /* Any */
+        } },
+        { type: {
+          type: 524287
+          /* Any */
+        } }
+      );
+    }
+    const type = evaluateBinaryTypes(op, args[0].type, args[1].type);
+    if (args[0].equivs) {
+      removeEquiv2(localState, 1 - localState.stack.length);
+    }
+    if (args[1].equivs) {
+      removeEquiv2(localState, 0 - localState.stack.length);
+    }
+    localState.stack.splice(-2, 2, { type });
+  };
+  switch (bc.op) {
+    case 18: {
+      let local = localState.locals[bc.arg];
+      if (local) {
+        local = { ...local };
+        delete local.equivs;
+      } else {
+        local = { type: {
+          type: 524287
+          /* Any */
+        } };
       }
-      return cloneState2(liveInState.get(block.offset));
-    },
-    (block, bc, localState) => {
-      switch (bc.op) {
-        case 18: {
-          let local = localState.locals[bc.arg];
-          if (local) {
-            local = { ...local };
-            delete local.equivs;
+      localState.stack.push(local);
+      addEquiv2(localState, -localState.stack.length, bc.arg);
+      break;
+    }
+    case 46: {
+      const dup = localState.stack.length - bc.arg - 1;
+      let other = localState.stack[dup];
+      if (other) {
+        other = { ...other };
+        delete other.equivs;
+      } else {
+        other = { type: {
+          type: 524287
+          /* Any */
+        } };
+      }
+      localState.stack.push(other);
+      if (dup >= 0) {
+        addEquiv2(localState, -localState.stack.length, ~dup);
+      }
+      break;
+    }
+    case 19: {
+      let curItem = localState.locals[bc.arg];
+      if (!curItem) {
+        curItem = localState.locals[bc.arg] = {
+          type: {
+            type: 524287
+            /* Any */
+          }
+        };
+      }
+      const value2 = localState.stack[localState.stack.length - 1];
+      if (value2.equivs) {
+        if (curItem.equivs?.has(-localState.stack.length)) {
+          removeEquiv2(localState, -localState.stack.length);
+          localState.stack.pop();
+          break;
+        }
+        removeEquiv2(localState, bc.arg);
+        addEquiv2(localState, bc.arg, -localState.stack.length);
+        removeEquiv2(localState, -localState.stack.length);
+      } else if (curItem.equivs) {
+        removeEquiv2(localState, bc.arg);
+      }
+      localState.stack.pop();
+      localState.locals[bc.arg].type = value2.type;
+      break;
+    }
+    case 37:
+      xpush(8, bc.arg);
+      break;
+    case 49:
+      xpush(16, bc.arg);
+      break;
+    case 38:
+      xpush(32, roundToFloat(bc.arg));
+      break;
+    case 50:
+      xpush(64, bc.arg);
+      break;
+    case 52:
+      xpush(128, String.fromCharCode(bc.arg));
+      break;
+    case 43:
+      xpush(
+        bc.arg ? 4 : 2
+        /* False */
+      );
+      break;
+    case 44:
+      xpush(
+        1
+        /* Null */
+      );
+      break;
+    case 39: {
+      const argSym = context.symbolTable.symbolToLabelMap.get(bc.arg);
+      const name = argSym && context.symbolTable.symbols.get(argSym)?.str;
+      const value2 = `${name ?? "symbol"}<${bc.arg}>`;
+      xpush(131072, value2);
+      break;
+    }
+    case 24: {
+      const symbol = context.symbolTable?.symbols.get(bc.arg);
+      xpush(131072, symbol?.str);
+      break;
+    }
+    case 3:
+      binary("+");
+      break;
+    case 4:
+      binary("-");
+      break;
+    case 5:
+      binary("*");
+      break;
+    case 6:
+      binary("/");
+      break;
+    case 9:
+      binary("%");
+      break;
+    case 10:
+      binary("<<");
+      break;
+    case 11:
+      binary(">>");
+      break;
+    case 7:
+      binary("&");
+      break;
+    case 8:
+      binary("|");
+      break;
+    case 12:
+      binary("^");
+      break;
+    case 26:
+      binary("==");
+      break;
+    case 31:
+      binary("!=");
+      break;
+    case 27:
+      binary("<");
+      break;
+    case 28:
+      binary("<=");
+      break;
+    case 29:
+      binary(">");
+      break;
+    case 30:
+      binary(">=");
+      break;
+    default: {
+      const { pop, push } = getOpInfo(bc);
+      for (let i = 0; i < pop; i++) {
+        removeEquiv2(localState, -localState.stack.length);
+        localState.stack.pop();
+      }
+      for (let i = 0; i < push; i++) {
+        localState.stack.push({ type: {
+          type: 524287
+          /* Any */
+        } });
+      }
+      break;
+    }
+  }
+}
+function interpFunc(func, context) {
+  const { symbolTable } = context;
+  const equivSets = /* @__PURE__ */ new Map();
+  const selfStores = /* @__PURE__ */ new Set();
+  const liveInState = /* @__PURE__ */ new Map();
+  const replacements = /* @__PURE__ */ new Map();
+  const interpLogging = (0, import_chunk_HHQDDCTP.wouldLog)("interp", 1);
+  if (interpLogging) {
+    if ((0, import_chunk_HHQDDCTP.wouldLog)("interp", 7)) {
+      (0, import_chunk_HHQDDCTP.setBanner)(functionBanner(func, context, "interp"));
+    } else if ((0, import_chunk_HHQDDCTP.wouldLog)("interp", 3)) {
+      (0, import_chunk_HHQDDCTP.setBanner)(
+        () => `+++++++++++++ interp-prepare ${func.name} ++++++++++++++`
+      );
+    }
+  }
+  rpoPropagate(
+    func,
+    (block) => {
+      if (interpLogging) {
+        (0, import_chunk_HHQDDCTP.logger)(
+          "interp",
+          3,
+          `${offsetToString(block.offset)}: ${block.bytecodes[0]?.lineNum ? lineInfoToString(block.bytecodes[0]?.lineNum, context) : ""}
+ ${interpStateToString(liveInState.get(block.offset))}`
+        );
+        (0, import_chunk_HHQDDCTP.logger)("interp", 9, blockToString(block, context));
+      }
+      return cloneState2(liveInState.get(block.offset));
+    },
+    (block, bc, localState) => {
+      switch (bc.op) {
+        case 19: {
+          selfStores.delete(bc);
+          equivSets.delete(bc);
+          const curItem = localState.locals[bc.arg];
+          const curEquivs = curItem?.equivs;
+          const selfStore = curEquivs?.has(bc.arg) && curEquivs.has(-localState.stack.length);
+          interpBytecode(bc, localState, context);
+          if (!localState.loopBlock) {
+            if (selfStore) {
+              selfStores.add(bc);
+              break;
+            }
+            const postItem = curItem ?? localState.locals[bc.arg];
+            if (postItem.equivs) {
+              equivSets.set(
+                bc,
+                new Set(Array.from(postItem.equivs).filter((e) => e >= 0))
+              );
+            }
+          }
+          break;
+        }
+        case 37:
+        case 49:
+        case 38:
+        case 50:
+        case 52:
+        case 39: {
+          interpBytecode(bc, localState, context);
+          const topType = localState.stack[localState.stack.length - 1].type;
+          (0, import_node_assert7.default)(isExact(topType));
+          const index = localState.loopBlock ? null : findEquivalent(localState, topType.type, topType.value);
+          let blockReps = replacements.get(block);
+          if (index != null) {
+            if (!blockReps) {
+              blockReps = /* @__PURE__ */ new Map();
+              replacements.set(block, blockReps);
+            }
+            if (index < 0) {
+              const arg = localState.stack.length - ~index % localState.stack.length - 2;
+              blockReps.set(bc, {
+                op: 46,
+                arg,
+                offset: bc.offset,
+                size: 2,
+                invert: localState.stack.length <= ~index
+              });
+            } else {
+              const arg = index % localState.locals.length;
+              blockReps.set(bc, {
+                op: 18,
+                arg,
+                offset: bc.offset,
+                size: 2,
+                invert: localState.locals.length <= index
+              });
+            }
+          } else if (blockReps) {
+            blockReps.delete(bc);
+            if (!blockReps.size) {
+              replacements.delete(block);
+            }
+          }
+          break;
+        }
+        case 40:
+        case 41:
+          if (block.taken === block.offset) {
+            const inState = liveInState.get(block.offset);
+            (0, import_node_assert7.default)(inState);
+            if (inState.stack.length !== localState.stack.length - 1) {
+              const condition = localState.stack[localState.stack.length - 1];
+              const isTrue = mustBeTrue(condition.type);
+              const isFalse = mustBeFalse(condition.type);
+              (0, import_node_assert7.default)(isTrue || isFalse);
+              interpBytecode(bc, localState, context);
+              if (isTrue === (bc.op === 40)) {
+                localState.loopBlock = true;
+                inState.loopBlock = true;
+                return 16;
+              }
+              return 4;
+            }
+          }
+          interpBytecode(bc, localState, context);
+          break;
+        default:
+          interpBytecode(bc, localState, context);
+      }
+      return null;
+    },
+    () => {
+    },
+    (from, localState, succBlock, isExSucc) => {
+      if (isExSucc) {
+        const tryEntry = from.try[from.try.length - 1].tryStart;
+        const entryDepth = liveInState.get(tryEntry)?.stack.length ?? 0;
+        localState = cloneState2(localState);
+        while (entryDepth < localState.stack.length) {
+          if (localState.stack[localState.stack.length - 1].equivs) {
+            removeEquiv2(localState, -localState.stack.length);
+          }
+          localState.stack.pop();
+        }
+        localState.stack.push({ type: {
+          type: 524287
+          /* Any */
+        } });
+      }
+      const succState = liveInState.get(succBlock.offset);
+      if (!succState) {
+        liveInState.set(succBlock.offset, cloneState2(localState));
+        return true;
+      }
+      if (!mergeInto(localState, succState))
+        return false;
+      if (interpLogging) {
+        (0, import_chunk_HHQDDCTP.logger)("interp", 3, `Re-Merge to ${offsetToString(succBlock.offset)}`);
+      }
+      return true;
+    }
+  );
+  if (interpLogging) {
+    if ((0, import_chunk_HHQDDCTP.wouldLog)("interp", 5)) {
+      (0, import_chunk_HHQDDCTP.setBanner)(
+        functionBanner(func, context, "interp", (block, footer) => {
+          if (footer)
+            return "";
+          return interpStateToString(liveInState.get(block.offset));
+        })
+      );
+    } else {
+      (0, import_chunk_HHQDDCTP.setBanner)(() => `=============== interp ${func.name} ==============`);
+    }
+    if (equivSets.size) {
+      (0, import_chunk_HHQDDCTP.log)(`====== equivSets =====`);
+      equivSets.forEach(
+        (value2, key) => (0, import_chunk_HHQDDCTP.log)(
+          `L${key.arg} === ${Array.from(value2).sort().join(" ")} ${key.lineNum ? lineInfoToString(key.lineNum, context) : ""}`
+        )
+      );
+    }
+    if (selfStores.size) {
+      (0, import_chunk_HHQDDCTP.log)(`====== selfStores =====`);
+      selfStores.forEach(
+        (value2) => (0, import_chunk_HHQDDCTP.log)(`${bytecodeToString(value2, symbolTable)}`)
+      );
+    }
+    if (replacements.size) {
+      (0, import_chunk_HHQDDCTP.log)(`====== replacements =====`);
+      replacements.forEach(
+        (blockRep) => blockRep.forEach(
+          (rep, bc) => (0, import_chunk_HHQDDCTP.log)(
+            `${bytecodeToString(bc, symbolTable)} => ${rep.invert ? "~" : ""}${bytecodeToString(rep, symbolTable)} ${bc.lineNum ? lineInfoToString(bc.lineNum, context) : ""}`
+          )
+        )
+      );
+    }
+  }
+  selfStores.forEach((bc) => makeArgless(
+    bc,
+    2
+    /* popv */
+  ));
+  replacements.forEach((blockRep, block) => {
+    for (let i = block.bytecodes.length; i--; ) {
+      const orig = block.bytecodes[i];
+      const rep = blockRep.get(orig);
+      if (!rep)
+        continue;
+      orig.op = rep.op;
+      if (rep.arg != null) {
+        orig.arg = rep.arg;
+      } else {
+        delete orig.arg;
+      }
+      orig.size = rep.size;
+      if (rep.invert) {
+        const invv = { ...orig };
+        invv.op = 45;
+        invv.size = 1;
+        invv.offset++;
+        delete invv.arg;
+        block.bytecodes.splice(i + 1, 0, invv);
+      }
+    }
+  });
+  if (interpLogging)
+    (0, import_chunk_HHQDDCTP.setBanner)(null);
+  return { liveInState, equivSets };
+}
+function instForType(type, offset) {
+  if (!hasValue(type))
+    return null;
+  switch (type.type) {
+    case 1:
+      return { op: 44, offset, size: 1 };
+    case 2:
+    case 4:
+      return {
+        op: 43,
+        arg: type.type === 2 ? 0 : 1,
+        offset,
+        size: 1
+      };
+    case 8:
+      return { op: 37, arg: type.value, offset, size: 1 };
+    case 16:
+      return { op: 49, arg: type.value, offset, size: 1 };
+    case 32:
+      return { op: 38, arg: type.value, offset, size: 1 };
+    case 64:
+      return { op: 50, arg: type.value, offset, size: 1 };
+    case 128:
+      return {
+        op: 52,
+        arg: type.value.charCodeAt(0),
+        offset,
+        size: 1
+      };
+    case 131072: {
+      const match = type.value.match(/<(\d+)>$/);
+      (0, import_node_assert7.default)(match);
+      return {
+        op: 37,
+        arg: parseInt(match[1], 10),
+        offset,
+        size: 1
+      };
+    }
+  }
+  return null;
+}
+var init_interp2 = (0, import_chunk_HHQDDCTP.__esm)({
+  "src/readprg/interp.ts"() {
+    "use strict";
+    init_interp_binary();
+    (0, import_chunk_HHQDDCTP.init_logger)();
+    init_interp();
+    init_types();
+    init_union_type();
+    init_bytecode();
+    init_cflow();
+    init_opcodes();
+  }
+});
+function optimizeArrayInit(func, block, index, context, interpState) {
+  (0, import_node_assert8.default)(
+    block.bytecodes[index].op === 20 || block.bytecodes[index].op === 54
+    /* newba */
+  );
+  if (!interpState) {
+    interpState = cloneState2(null);
+  }
+  const putvStarts = [];
+  let i;
+  let initInst = null;
+  let initType = null;
+  let initLocal = null;
+  let usedLocals = 0n;
+  let local = -1;
+  const depth = interpState.stack.length;
+  for (i = index; ++i < block.bytecodes.length - 1; ) {
+    const dup = block.bytecodes[i];
+    if (dup.op !== 46 || dup.arg !== 0) {
+      break;
+    }
+    interpBytecode(dup, interpState, context);
+    const ipush = block.bytecodes[i + 1];
+    interpBytecode(ipush, interpState, context);
+    if (interpState.stack.length !== depth + 2 || interpState.stack[depth + 1].type.type !== 8 || interpState.stack[depth + 1].type.value !== putvStarts.length) {
+      break;
+    }
+    let found = i;
+    let thisInit = null;
+    let thisLocal = null;
+    for (let k = i + 1; ++k < block.bytecodes.length; ) {
+      const bc = block.bytecodes[k];
+      interpBytecode(bc, interpState, context);
+      if (bc.op === 17 && interpState.stack.length === depth) {
+        found = k;
+        break;
+      }
+      if (bc.op === 18) {
+        usedLocals |= 1n << BigInt(bc.arg);
+      }
+      const delta = interpState.stack.length - depth;
+      if (delta === 3) {
+        const t = interpState.stack[interpState.stack.length - 1].type;
+        if (bc.op === 18) {
+          thisLocal = bc;
+        } else {
+          thisLocal = null;
+        }
+        if (hasValue(t) && t.type & (1 | 6 | 120 | 128 | 256 | 131072)) {
+          thisInit = t;
+          continue;
+        }
+        thisInit = null;
+      }
+      if (delta < 0 || bc.op === 46 && bc.arg >= delta - 1) {
+        break;
+      }
+    }
+    if (found === i)
+      break;
+    if (found - i !== 3) {
+      initLocal = initType = false;
+    } else {
+      if (initLocal !== false) {
+        if (thisLocal) {
+          if (initLocal == null) {
+            initLocal = thisLocal;
+          } else if (initLocal.arg !== thisLocal.arg && !interpState.locals[initLocal.arg]?.equivs?.has(thisLocal.arg)) {
+            initLocal = false;
+          }
+        } else {
+          initLocal = false;
+        }
+      }
+      if (initType !== false) {
+        if (thisInit) {
+          if (initType == null) {
+            initType = thisInit;
+          } else if (initType.type !== thisInit.type || initType.value !== thisInit.value) {
+            initType = false;
+          }
+          if (initType) {
+            const bc = block.bytecodes[found - 1];
+            if (bc.op !== 46 && (!initInst || initInst.size > bc.size)) {
+              const { push, pop } = getOpInfo(bc);
+              if (push === 1 && pop === 0) {
+                initInst = bc;
+              }
+            }
+          }
+        } else {
+          initType = false;
+        }
+      }
+    }
+    putvStarts.push(i);
+    i = found;
+  }
+  if (initType && (block.bytecodes[index].op === 20 ? initType.type === 1 : initType.type === 8 && initType.value === 0)) {
+    (0, import_chunk_HHQDDCTP.logger)(
+      "array-init",
+      1,
+      `${func.name}: Removing initialization of default initialized ${putvStarts.length} element array init at block ${offsetToString(
+        block.offset
+      )}, starting at index ${index}, at offset ${offsetToString(
+        block.bytecodes[index].offset
+      )}`
+    );
+    block.bytecodes.splice(index + 1, i - index - 1);
+    return true;
+  }
+  const terminal = block.bytecodes[i];
+  if (terminal?.op === 2) {
+    const convertAputv = (i2) => {
+      const bc = block.bytecodes[i2];
+      const op = bc.op;
+      bc.op = 2;
+      bc.size = 1;
+      delete bc.arg;
+      (0, import_node_assert8.default)(
+        op === 17
+        /* aputv */
+      );
+    };
+    convertAputv(i - 1);
+    for (let i2 = putvStarts.length; i2--; ) {
+      const offset = putvStarts[i2];
+      block.bytecodes.splice(offset, 2);
+      if (i2) {
+        convertAputv(offset - 1);
+      }
+    }
+    (0, import_chunk_HHQDDCTP.logger)(
+      "array-init",
+      1,
+      `${func.name}: Optimizing unused ${putvStarts.length} element array init at block ${offsetToString(
+        block.offset
+      )}, starting at index ${index}, at offset ${offsetToString(
+        block.bytecodes[index].offset
+      )}`
+    );
+    if ((0, import_chunk_HHQDDCTP.wouldLog)("array-init", 5)) {
+      (0, import_chunk_HHQDDCTP.log)(blockToString(block, context));
+    }
+    return true;
+  }
+  const bytecode = (op, arg) => {
+    const bc = { op, arg, size: opcodeSize(op), offset: context.nextOffset++ };
+    if (arg == null)
+      delete bc.arg;
+    return bc;
+  };
+  const tryLocal = (n) => {
+    if (local === -1 && terminal?.op === 19 && !(usedLocals >> BigInt(terminal.arg) & 1n) && putvStarts.length >= n) {
+      local = terminal.arg;
+      block.bytecodes.splice(i++, 1);
+      block.bytecodes.splice(++index, 0, terminal);
+      for (let ix = putvStarts.length; ix--; ) {
+        const dupIx = ++putvStarts[ix];
+        const dup = block.bytecodes[dupIx];
+        (0, import_node_assert8.default)(dup.op === 46 && dup.arg === 0);
+        block.bytecodes[dupIx].op = 18;
+        block.bytecodes[dupIx].arg = local;
+      }
+      return true;
+    }
+    return false;
+  };
+  if (initType) {
+    if (!initInst) {
+      initInst = instForType(initType, block.bytecodes[index + 3].offset);
+    }
+  } else {
+    initInst = null;
+  }
+  if (initLocal && (!initInst || initInst.size > initLocal.size)) {
+    initInst = initLocal;
+  }
+  if (initInst) {
+    if (putvStarts.length < 3)
+      return false;
+    tryLocal(3);
+    (0, import_chunk_HHQDDCTP.logger)(
+      "array-init",
+      1,
+      `${func.name}: Optimizing ${putvStarts.length} element array init with constant initializer ${bytecodeToString(
+        initInst,
+        null
+      )} at block ${offsetToString(
+        block.offset
+      )}, starting at index ${index}, at offset ${offsetToString(
+        block.bytecodes[index].offset
+      )}`
+    );
+    block.bytecodes.splice(index + 5, i - index - 5);
+    block.bytecodes.splice(index + 1, 1);
+    if (local < 0) {
+      block.bytecodes[index + 1].op = 37;
+      block.bytecodes[index + 1].arg = putvStarts.length;
+    } else {
+      if (index >= 2 && block.bytecodes[index - 2].op === 37 && block.bytecodes[index - 2].arg === putvStarts.length) {
+        block.bytecodes.splice(index + 1, 1);
+        block.bytecodes.splice(index - 1, 0, bytecode(46, 0));
+      } else {
+        block.bytecodes[index + 1].op = 37;
+        block.bytecodes[index + 1].arg = putvStarts.length;
+      }
+    }
+    (0, import_chunk_HHQDDCTP.logger)(
+      "array-init",
+      5,
+      `index: ${index}, i: ${i}
+${blockToString(block, context)}`
+    );
+    const loopOffset2 = context.nextOffset;
+    block.bytecodes.splice(
+      index + 2,
+      1,
+      bytecode(37, 1),
+      bytecode(4, void 0),
+      local >= 0 ? bytecode(18, local) : bytecode(46, 1),
+      bytecode(46, 1),
+      initInst
+    );
+    block.bytecodes.splice(
+      index + 8,
+      0,
+      bytecode(46, 0),
+      bytecode(40, loopOffset2),
+      bytecode(2, void 0)
+    );
+    splitBlock(func, block, index + 10);
+    splitBlock(func, block, index + 2);
+    const loop2 = func.blocks.get(loopOffset2);
+    loop2.preds.add(loopOffset2);
+    loop2.taken = loopOffset2;
+    return true;
+  }
+  if (!tryLocal(3) && putvStarts.length < 4)
+    return false;
+  if (local >= 0) {
+    block.bytecodes.splice(i, 0, bytecode(2, void 0));
+  }
+  for (let i2 = putvStarts.length; i2-- > 1; ) {
+    block.bytecodes.splice(putvStarts[i2], 2);
+  }
+  (0, import_chunk_HHQDDCTP.logger)(
+    "array-init",
+    1,
+    `${func.name}: Optimizing ${putvStarts.length} element array init at block ${offsetToString(
+      block.offset
+    )}, starting at index ${index}, at offset ${offsetToString(
+      block.bytecodes[index].offset
+    )}`
+  );
+  let loopOffset;
+  if (local >= 0) {
+    block.bytecodes.splice(index + 1, 2);
+    if (index >= 2 && block.bytecodes[index - 2].op === 37 && block.bytecodes[index - 2].arg === putvStarts.length) {
+      block.bytecodes.splice(index - 1, 0, bytecode(46, 0));
+    } else {
+      block.bytecodes.splice(
+        index + 1,
+        0,
+        bytecode(37, putvStarts.length)
+      );
+    }
+    index--;
+    loopOffset = context.nextOffset;
+    block.bytecodes.splice(
+      index + 3,
+      0,
+      bytecode(18, local),
+      bytecode(46, 1),
+      bytecode(37, 1),
+      bytecode(4, void 0),
+      bytecode(46, 0),
+      bytecode(40, loopOffset)
+    );
+  } else {
+    block.bytecodes[index + 2].op = 37;
+    block.bytecodes[index + 2].arg = putvStarts.length - 1;
+    loopOffset = context.nextOffset;
+    block.bytecodes.splice(
+      index + 3,
+      0,
+      bytecode(46, 1),
+      bytecode(46, 1),
+      bytecode(37, 1),
+      bytecode(4, void 0),
+      bytecode(46, 0),
+      bytecode(40, loopOffset)
+    );
+  }
+  splitBlock(func, block, index + 9);
+  splitBlock(func, block, index + 3);
+  const loop = func.blocks.get(loopOffset);
+  loop.preds.add(loopOffset);
+  loop.taken = loopOffset;
+  return true;
+}
+var init_array_init = (0, import_chunk_HHQDDCTP.__esm)({
+  "src/readprg/array-init.ts"() {
+    "use strict";
+    init_types();
+    (0, import_chunk_HHQDDCTP.init_util)();
+    init_bytecode();
+    init_interp2();
+    init_opcodes();
+  }
+});
+function localDCE(func, context) {
+  if ((0, import_chunk_HHQDDCTP.wouldLog)("dce", 5)) {
+    (0, import_chunk_HHQDDCTP.setBanner)(
+      functionBanner(
+        func,
+        context,
+        "local-dce-start",
+        (block, footer) => footer ? `liveOutLocals: ${Array.from(
+          liveOutLocals.get(block.offset) ?? []
+        ).join(" ")}
+` : ""
+      )
+    );
+  }
+  const { liveInLocals, liveOutLocals } = computeLiveLocals(func);
+  let anyChanges = false;
+  let changes = false;
+  const makeNop = (bc) => {
+    changes = true;
+    makeArgless(
+      bc,
+      0
+      /* nop */
+    );
+  };
+  const makePopv = (bc) => {
+    changes = true;
+    makeArgless(
+      bc,
+      2
+      /* popv */
+    );
+  };
+  func.blocks.forEach((block) => {
+    const reportPopv = (i, item, kill) => {
+      (0, import_chunk_HHQDDCTP.logger)(
+        "dce",
+        2,
+        `${func.name}: Convert ${i}:${bytecodeToString(
+          block.bytecodes[i],
+          context.symbolTable
+        )} to popv for ${item.deps.map(
+          (i2) => `${i2}:${bytecodeToString(
+            block.bytecodes[i2],
+            context.symbolTable
+          )}${kill ? "=>nop" : ""}`
+        ).join(", ")} }`
+      );
+    };
+    const reportNop = (item) => {
+      (0, import_chunk_HHQDDCTP.logger)(
+        "dce",
+        2,
+        `${func.name}: Kill ${item.deps.map((i) => bytecodeToString(block.bytecodes[i], context.symbolTable)).join(", ")}`
+      );
+    };
+    changes = false;
+    const dceInfo = {
+      stack: [],
+      locals: new Set(liveOutLocals.get(block.offset))
+    };
+    for (let i = block.bytecodes.length; i--; ) {
+      const bytecode = block.bytecodes[i];
+      switch (bytecode.op) {
+        case 19: {
+          const liveLocal = dceInfo.locals.has(bytecode.arg);
+          if (!liveLocal) {
+            (0, import_chunk_HHQDDCTP.logger)(
+              "dce",
+              2,
+              `${func.name}: Killing store to unused local ${bytecode.arg} at ${offsetToString(block.offset)}:${i}`
+            );
+            makePopv(bytecode);
+            dceInfo.stack.push({ dead: true, deps: [i] });
+          } else {
+            dceInfo.stack.push({ dead: false });
+          }
+          dceInfo.locals.delete(bytecode.arg);
+          break;
+        }
+        case 2:
+          dceInfo.stack.push({ dead: true, deps: [i] });
+          break;
+        case 46: {
+          const item = dceInfo.stack.pop();
+          if (item?.dead) {
+            item.deps.push(i);
+            reportNop(item);
+            item.deps.forEach((index) => makeNop(block.bytecodes[index]));
+          } else {
+            if (dceInfo.stack.length > bytecode.arg) {
+              dceInfo.stack[dceInfo.stack.length - 1 - bytecode.arg].dead = false;
+            }
+          }
+          break;
+        }
+        case 18:
+        case 44:
+        case 43:
+        case 24:
+        case 37:
+        case 38:
+        case 39:
+        case 52:
+        case 49:
+        case 50: {
+          const item = dceInfo.stack.pop();
+          if (item?.dead) {
+            item.deps.push(i);
+            reportNop(item);
+            item.deps.forEach((index) => makeNop(block.bytecodes[index]));
+          } else if (bytecode.op === 18) {
+            dceInfo.locals.add(bytecode.arg);
+          }
+          break;
+        }
+        case 3:
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+        case 8:
+        case 9:
+        case 10:
+        case 11:
+        case 12:
+        case 26:
+        case 27:
+        case 28:
+        case 29:
+        case 30:
+        case 31:
+        case 34:
+        case 33:
+        case 16:
+        case 13: {
+          const item = dceInfo.stack.pop();
+          if (item?.dead) {
+            reportPopv(i, item, false);
+            makePopv(bytecode);
+            dceInfo.stack.push({ dead: true, deps: item.deps.slice() });
+            dceInfo.stack.push({ dead: true, deps: [i] });
           } else {
-            local = { type: {
-              type: 524287
-              /* Any */
-            } };
+            dceInfo.stack.push({ dead: false });
+            dceInfo.stack.push({ dead: false });
           }
-          localState.stack.push(local);
-          addEquiv2(localState, -localState.stack.length, bc.arg);
           break;
         }
-        case 19: {
-          selfStores.delete(bc);
-          equivSets.delete(bc);
-          let curItem = localState.locals[bc.arg];
-          if (!curItem) {
-            curItem = localState.locals[bc.arg] = {
-              type: {
-                type: 524287
-                /* Any */
-              }
-            };
-          }
-          const { dup: _dup, ...value2 } = localState.stack[localState.stack.length - 1];
-          if (value2.equivs) {
-            if (curItem.equivs?.has(-localState.stack.length)) {
-              selfStores.add(bc);
-              removeEquiv2(localState, -localState.stack.length);
-              localState.stack.pop();
-              break;
-            }
-            removeEquiv2(localState, bc.arg);
-            addEquiv2(localState, bc.arg, -localState.stack.length);
-            removeEquiv2(localState, -localState.stack.length);
-            if (curItem.equivs) {
-              equivSets.set(
-                bc,
-                new Set(Array.from(curItem.equivs).filter((e) => e >= 0))
-              );
-            }
-          } else if (curItem.equivs) {
-            removeEquiv2(localState, bc.arg);
+        case 21:
+        case 32:
+        case 45:
+        case 48:
+        case 20:
+        case 54:
+        case 47: {
+          const item = dceInfo.stack.pop();
+          if (item?.dead) {
+            reportPopv(i, item, true);
+            makePopv(bytecode);
+            item.deps.forEach((index) => makeNop(block.bytecodes[index]));
+            dceInfo.stack.push({ dead: true, deps: [i] });
+          } else {
+            dceInfo.stack.push({ dead: false });
           }
-          localState.stack.pop();
-          localState.locals[bc.arg].type = value2.type;
-          break;
-        }
-        case 37:
-          xpush(localState, block, bc, 8, bc.arg);
-          break;
-        case 49:
-          xpush(localState, block, bc, 16, bc.arg);
-          break;
-        case 38:
-          xpush(localState, block, bc, 32, roundToFloat(bc.arg));
-          break;
-        case 50:
-          xpush(localState, block, bc, 64, bc.arg);
-          break;
-        case 52:
-          xpush(
-            localState,
-            block,
-            bc,
-            128,
-            String.fromCharCode(bc.arg)
-          );
-          break;
-        case 43:
-          xpush(
-            localState,
-            block,
-            bc,
-            bc.arg ? 4 : 2
-            /* False */
-          );
-          break;
-        case 44:
-          xpush(
-            localState,
-            block,
-            bc,
-            1
-            /* Null */
-          );
-          break;
-        case 39: {
-          const argSym = symbolTable?.symbolToLabelMap.get(bc.arg);
-          const value2 = argSym && symbolTable?.symbols.get(argSym)?.str || `symbol<${bc.arg}>`;
-          xpush(localState, block, bc, 131072, value2);
           break;
         }
-        default: {
-          const { pop, push } = getOpInfo(bc);
-          for (let i = 0; i < pop; i++) {
-            removeEquiv2(localState, -localState.stack.length);
-            localState.stack.pop();
+        case 51:
+        case 15:
+          if (block.exsucc) {
+            liveInLocals.get(block.exsucc)?.forEach((local) => dceInfo.locals.add(local));
           }
-          for (let i = 0; i < push; i++) {
-            localState.stack.push({ type: {
-              type: 524287
-              /* Any */
-            } });
+        default: {
+          let { push, pop } = getOpInfo(bytecode);
+          while (push-- > 0) {
+            dceInfo.stack.pop();
           }
-          break;
-        }
-      }
-    },
-    () => {
-    },
-    (from, localState, succBlock, isExSucc) => {
-      if (isExSucc) {
-        const tryEntry = from.try[from.try.length - 1].tryStart;
-        const entryDepth = liveInState.get(tryEntry)?.stack.length ?? 0;
-        localState = cloneState2(localState);
-        while (entryDepth < localState.stack.length) {
-          if (localState.stack[localState.stack.length - 1].equivs) {
-            removeEquiv2(localState, -localState.stack.length);
+          while (pop-- > 0) {
+            dceInfo.stack.push({ dead: false });
           }
-          localState.stack.pop();
         }
-        localState.stack.push({ type: {
-          type: 524287
-          /* Any */
-        } });
-      }
-      const succState = liveInState.get(succBlock.offset);
-      if (!succState) {
-        liveInState.set(succBlock.offset, cloneState2(localState));
-        return true;
-      }
-      if (!mergeInto(localState, succState))
-        return false;
-      if (interpLogging) {
-        (0, import_chunk_HHQDDCTP.logger)("interp", 3, `Re-Merge to ${offsetToString(succBlock.offset)}`);
       }
-      return true;
-    }
-  );
-  if (interpLogging) {
-    if ((0, import_chunk_HHQDDCTP.wouldLog)("interp", 5)) {
-      (0, import_chunk_HHQDDCTP.setBanner)(
-        functionBanner(func, context, "interp", (block, footer) => {
-          if (footer)
-            return "";
-          return interpStateToString(liveInState.get(block.offset));
-        })
-      );
-    } else {
-      (0, import_chunk_HHQDDCTP.setBanner)(() => `=============== interp ${func.name} ==============`);
-    }
-    if (equivSets.size) {
-      (0, import_chunk_HHQDDCTP.log)(`====== equivSets =====`);
-      equivSets.forEach(
-        (value2, key) => (0, import_chunk_HHQDDCTP.log)(
-          `L${key.arg} === ${Array.from(value2).sort().join(" ")} ${key.lineNum ? lineInfoToString(key.lineNum, context) : ""}`
-        )
-      );
-    }
-    if (selfStores.size) {
-      (0, import_chunk_HHQDDCTP.log)(`====== selfStores =====`);
-      selfStores.forEach(
-        (value2) => (0, import_chunk_HHQDDCTP.log)(`${bytecodeToString(value2, symbolTable)}`)
-      );
     }
-    if (replacements.size) {
-      (0, import_chunk_HHQDDCTP.log)(`====== replacements =====`);
-      replacements.forEach(
-        (blockRep) => blockRep.forEach(
-          (rep, bc) => (0, import_chunk_HHQDDCTP.log)(
-            `${bytecodeToString(bc, symbolTable)} => ${rep.invert ? "~" : ""}${bytecodeToString(rep, symbolTable)} ${bc.lineNum ? lineInfoToString(bc.lineNum, context) : ""}`
-          )
-        )
+    if (changes) {
+      anyChanges = true;
+      block.bytecodes = block.bytecodes.filter(
+        (bc) => bc.op !== 0
+        /* nop */
       );
+      if ((0, import_chunk_HHQDDCTP.wouldLog)("dce", 3)) {
+        (0, import_chunk_HHQDDCTP.log)(functionBanner(func, context, "local-dce-end")());
+      }
     }
-  }
-  selfStores.forEach((bc) => makeArgless(
-    bc,
-    2
-    /* popv */
-  ));
-  replacements.forEach((blockRep, block) => {
-    for (let i = block.bytecodes.length; i--; ) {
-      const orig = block.bytecodes[i];
-      const rep = blockRep.get(orig);
-      if (!rep)
-        continue;
-      orig.op = rep.op;
-      if (rep.arg != null) {
-        orig.arg = rep.arg;
-      } else {
-        delete orig.arg;
+  });
+  (0, import_chunk_HHQDDCTP.setBanner)(null);
+  return anyChanges;
+}
+function computeLiveLocals(func) {
+  const liveOutLocals = /* @__PURE__ */ new Map();
+  const liveInLocals = /* @__PURE__ */ new Map();
+  postOrderPropagate(
+    func,
+    (block) => new Set(liveOutLocals.get(block.offset)),
+    (block, bc, locals) => {
+      switch (bc.op) {
+        case 18:
+          locals.add(bc.arg);
+          break;
+        case 19:
+          locals.delete(bc.arg);
+          break;
+        case 51:
+        case 15:
+          if (block.exsucc) {
+            liveInLocals.get(block.exsucc)?.forEach((local) => locals.add(local));
+          }
+          break;
       }
-      orig.size = rep.size;
-      if (rep.invert) {
-        const invv = { ...orig };
-        invv.op = 45;
-        invv.size = 1;
-        invv.offset++;
-        delete invv.arg;
-        block.bytecodes.splice(i + 1, 0, invv);
+    },
+    (block, locals) => {
+      liveInLocals.set(block.offset, locals);
+    },
+    (locals, predBlock, isExPred) => {
+      if (isExPred)
+        return false;
+      const predLocals = liveOutLocals.get(predBlock.offset);
+      if (!predLocals) {
+        liveOutLocals.set(predBlock.offset, new Set(locals));
+        return true;
       }
+      const size = predLocals.size;
+      locals.forEach((local) => predLocals.add(local));
+      return size !== predLocals.size;
     }
-  });
-  if (interpLogging)
-    (0, import_chunk_HHQDDCTP.setBanner)(null);
-  return { liveInState, equivSets };
+  );
+  return { liveInLocals, liveOutLocals };
 }
-var init_interp2 = (0, import_chunk_HHQDDCTP.__esm)({
-  "src/readprg/interp.ts"() {
+var init_dce = (0, import_chunk_HHQDDCTP.__esm)({
+  "src/readprg/dce.ts"() {
     "use strict";
-    (0, import_chunk_HHQDDCTP.init_logger)();
-    init_interp();
-    init_types();
-    init_union_type();
+    (0, import_chunk_HHQDDCTP.init_util)();
     init_bytecode();
     init_cflow();
     init_opcodes();
@@ -22664,21 +23004,44 @@ var init_sharing = (0, import_chunk_HHQDDCTP.__esm)({
 });
 function optimizeFunc(func, context) {
   let changes;
+  let liveInState;
   do {
     cleanCfg2(func, context);
     changes = localDCE(func, context);
     changes = blockSharing(func, context) || changes;
     changes = simpleOpts(func, context) || changes;
-    interpFunc(func, context);
+    ({ liveInState } = interpFunc(func, context));
+    changes = doArrayInits(func, liveInState, context) || changes;
   } while (changes);
+}
+function doArrayInits(func, liveInState, context) {
+  const newAToProcess = /* @__PURE__ */ new Map();
   func.blocks.forEach((block) => {
-    for (let i = block.bytecodes.length; i--; ) {
-      const cur = block.bytecodes[i];
-      if (cur.op === 20) {
-        optimizeArrayInit(func, block, i, false, context);
-      }
+    if (!block.bytecodes.some(
+      (bc) => bc.op === 20 || bc.op === 54
+      /* newba */
+    )) {
+      return;
     }
+    const blockState = cloneState2(liveInState.get(block.offset));
+    const newAStates = /* @__PURE__ */ new Map();
+    block.bytecodes.forEach((bc, index) => {
+      interpBytecode(bc, blockState, context);
+      if (bc.op === 20 || bc.op === 54) {
+        newAStates.set(index, cloneState2(blockState));
+      }
+    });
+    newAToProcess.set(block, newAStates);
   });
+  let changes = false;
+  newAToProcess.forEach(
+    (newAStates, block) => Array.from(newAStates.keys()).reverse().forEach((i) => {
+      if (optimizeArrayInit(func, block, i, context, newAStates.get(i))) {
+        changes = true;
+      }
+    })
+  );
+  return changes;
 }
 function simpleOpts(func, context) {
   const equalsSym = 8388787;
@@ -22686,24 +23049,14 @@ function simpleOpts(func, context) {
   return Array.from(func.blocks.values()).reduce((changes, block) => {
     for (let i = block.bytecodes.length; i--; ) {
       const cur = block.bytecodes[i];
-      if (cur.op === 0) {
+      if (cur.op === 0 || context.config.removeArgc && cur.op === 53) {
         block.bytecodes.splice(i, 1);
         changes = true;
         if (logging3) {
-          (0, import_chunk_HHQDDCTP.log)(`${func.name}: deleting nop`);
-          if (i > 0) {
-            (0, import_chunk_HHQDDCTP.log)(
-              ` - previous bytecode was ${bytecodeToString(
-                block.bytecodes[i - 1],
-                null
-              )}`
-            );
-          }
+          (0, import_chunk_HHQDDCTP.log)(`${func.name}: deleting ${bytecodeToString(cur, null)}`);
         }
       } else if (i && cur.op === 39 && cur.arg === equalsSym) {
         changes = equalSymbolToEq(block, i) || changes;
-      } else if (cur.op === 20) {
-        changes = optimizeArrayInit(func, block, i, true, context) || changes;
       } else if (i && cur.op === 10) {
         const prev = block.bytecodes[i - 1];
         if (prev.op === 37 || prev.op === 49) {
@@ -22840,7 +23193,7 @@ function cleanCfg2(func, context) {
   }
   const deadBlocks = /* @__PURE__ */ new Map();
   func.blocks.forEach((block) => {
-    if (isNopBlock(block)) {
+    if (isNopBlock(block) && block.offset !== func.offset) {
       deadBlocks.set(block.offset, block.next);
     }
   });
@@ -22878,8 +23231,9 @@ function cleanCfg2(func, context) {
       removeBlock(func, offset);
     });
   }
+  const deadCatches = /* @__PURE__ */ new Set();
   func.blocks.forEach((block) => {
-    if (block.next && !block.taken && block.next !== block.offset) {
+    if (block.next && !block.taken && block.next !== block.offset && block.next !== func.offset) {
       const next = func.blocks.get(block.next);
       if (block.try === next.try) {
         if (next.preds.size === 1) {
@@ -22962,6 +23316,7 @@ function cleanCfg2(func, context) {
             )} with handler at ${handler}`
           );
           block.try.splice(i, 1);
+          deadCatches.add(handler);
         }
       }
       if (!block.try.length) {
@@ -22969,6 +23324,29 @@ function cleanCfg2(func, context) {
       }
     }
   });
+  deadCatches.forEach((cb) => {
+    const todo = [cb];
+    for (let i = 0; i < todo.length; i++) {
+      const offset = todo[i];
+      const block = func.blocks.get(offset);
+      if (!block) {
+        todo.splice(i--, 1);
+        continue;
+      }
+      if (block.preds?.size) {
+        continue;
+      }
+      if (block.next != null)
+        todo.push(block.next);
+      if (block.taken != null)
+        todo.push(block.taken);
+      if (block.exsucc != null)
+        todo.push(block.exsucc);
+      removeBlock(func, offset);
+      todo.splice(i, 1);
+      i = -1;
+    }
+  });
   (0, import_chunk_HHQDDCTP.setBanner)(null);
 }
 var init_optimize2 = (0, import_chunk_HHQDDCTP.__esm)({
@@ -28536,7 +28914,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
     const opt_time = await (0, import_chunk_HHQDDCTP.first_modified)(
       Object.values(fnMap).map((v) => v.output)
     );
-    if (source_time < opt_time && 1679602245113 < opt_time) {
+    if (source_time < opt_time && 1680119325581 < opt_time) {
       return { hasTests, diagnostics: prevDiagnostics };
     }
   }
@@ -28568,7 +28946,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
           JSON.stringify({
             hasTests: hasTests2,
             diagnostics,
-            optimizerVersion: "1.1.21",
+            optimizerVersion: "1.1.22",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )
@@ -28806,7 +29184,8 @@ var init_worker_task = (0, import_chunk_HHQDDCTP.__esm)({
           data.xmlBuffer,
           data.xmlOffset,
           data.xmlLength,
-          data.key
+          data.key,
+          data.config
         );
       }
     };
@@ -28951,9 +29330,9 @@ function readPrgWithOffsets(view) {
   }
   return { view, sections };
 }
-async function optimizeProgram(filepath, devKey, output) {
+async function optimizeProgram(filepath, devKey, output, config) {
   if (/\.iq$/i.test(filepath)) {
-    return optimizePackage(filepath, devKey, output);
+    return optimizePackage(filepath, devKey, output, config);
   }
   const removeExt = (filepath2, ext) => path5.join(path5.dirname(filepath2), path5.basename(filepath2, ext));
   if (!output) {
@@ -28967,7 +29346,8 @@ async function optimizeProgram(filepath, devKey, output) {
     filepath,
     view,
     debugXml,
-    key
+    key,
+    config
   );
   const promises = [];
   promises.push(fs7.writeFile(output, buffer));
@@ -28986,7 +29366,7 @@ async function optimizeProgram(filepath, devKey, output) {
   await Promise.all(promises);
   return { signature, output };
 }
-function optimizeProgramBuffer(filepath, view, debugXml, key) {
+function optimizeProgramBuffer(filepath, view, debugXml, key, config) {
   const { sections } = readPrgWithOffsets(view);
   (0, import_chunk_HHQDDCTP.logger)("readprg", 5, sections);
   const symbolTable = new SymbolTable();
@@ -29017,7 +29397,10 @@ function optimizeProgramBuffer(filepath, view, debugXml, key) {
     -1059145026
     /* TEXT */
   ].view, lineTable);
+  if (!config)
+    config = {};
   const context = {
+    config,
     filepath,
     sections,
     bytecodes,
@@ -29041,7 +29424,7 @@ function optimizeProgramBuffer(filepath, view, debugXml, key) {
   buffers.push(Buffer.from(new ArrayBuffer(8)));
   return { signature, buffer: Buffer.concat(buffers) };
 }
-function optimizePackage(filepath, devKey, output) {
+function optimizePackage(filepath, devKey, output, config) {
   if (!devKey) {
     throw new Error(`Can't sign ${filepath} without a developer key`);
   }
@@ -29081,7 +29464,8 @@ function optimizePackage(filepath, devKey, output) {
                 xmlBuffer: xmlBuffer.buffer,
                 xmlOffset: xmlBuffer.byteOffset,
                 xmlLength: xmlBuffer.byteLength,
-                key
+                key,
+                config
               }
             }).then(
               ({
@@ -29232,7 +29616,7 @@ function optimizePackage(filepath, devKey, output) {
     })
   ).finally(() => poolStarted && stopPool());
 }
-function optimizePrgAndDebug(prgName, prgBuffer, prgOffset, prgLength, xmlName, xmlBuffer, xmlOffset, xmlLength, key) {
+function optimizePrgAndDebug(prgName, prgBuffer, prgOffset, prgLength, xmlName, xmlBuffer, xmlOffset, xmlLength, key, config) {
   const xmlString = Buffer.from(xmlBuffer, xmlOffset, xmlLength).toString();
   const debugXml = xml_util_exports.parseXml(xmlString, xmlName);
   if (debugXml.body instanceof Error) {
@@ -29242,7 +29626,8 @@ function optimizePrgAndDebug(prgName, prgBuffer, prgOffset, prgLength, xmlName,
     prgName,
     new DataView(prgBuffer, prgOffset, prgLength),
     debugXml,
-    key
+    key,
+    config
   );
   return Promise.resolve({
     sigBuffer: result.signature?.buffer,