@fluffylabs/anan-as 1.2.0-41e43f6 → 1.2.0-5196d29

package/dist/build/js/portable-bundle.js

@@ -28,6 +28,7 @@ var portable = class _portable {
       arr.fill(0);
       return arr;
     };
+    g2.StaticArray.fromArray = (x) => x;
     g2.ASC_TARGET = 0;
     g2.i8 = (value) => {
       const n = typeof value === "bigint" ? Number(value) : value;
@@ -739,12 +740,28 @@ if (typeof globalScope.ASC_TARGET === "undefined") {
 }
 
 // dist/build/js/assembly/math.js
-function minI32(a, b) {
-  return a < b ? a : b;
-}
-function minU32(a, b) {
-  return a < b ? a : b;
-}
+var __decorate2 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var IntMath = class {
+  /** Integer minimum of two i32 values. */
+  static minI32(a, b) {
+    return a < b ? a : b;
+  }
+  /** Unsigned integer minimum of two u32 values. */
+  static minU32(a, b) {
+    return a < b ? a : b;
+  }
+};
+__decorate2([
+  inline
+], IntMath, "minI32", null);
+__decorate2([
+  inline
+], IntMath, "minU32", null);
 
 // dist/build/js/assembly/arguments.js
 var Arguments;
@@ -763,8 +780,8 @@ var Arguments;
   Arguments2[Arguments2["TwoRegTwoImm"] = 11] = "TwoRegTwoImm";
   Arguments2[Arguments2["ThreeReg"] = 12] = "ThreeReg";
 })(Arguments || (Arguments = {}));
-var RELEVANT_ARGS = [0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3];
-var REQUIRED_BYTES = [0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2];
+var RELEVANT_ARGS = StaticArray.fromArray([0, 1, 2, 1, 2, 3, 3, 3, 2, 3, 3, 4, 3]);
+var REQUIRED_BYTES = StaticArray.fromArray([0, 0, 1, 0, 1, 9, 1, 1, 1, 1, 1, 2, 2]);
 var Args = class {
   constructor() {
     this.a = 0;
@@ -781,13 +798,13 @@ var Args = class {
   }
 };
 function twoImm(args, code, offset, end) {
-  const low = lowNibble(portable.arrayAt(code, offset));
-  const split = minI32(4, low) + 1;
+  const low = lowNibble(portable.staticArrayAt(code, offset));
+  const split = IntMath.minI32(4, low) + 1;
   const first = decodeI32(code, offset + 1, offset + split);
   const second = decodeI32(code, offset + split, end);
   return args.fill(first, second, 0, 0);
 }
-var DECODERS = [
+var DECODERS = StaticArray.fromArray([
   // DECODERS[Arguments.Zero] =
   (args, _d, _o, _l) => {
     return args.fill(0, 0, 0, 0);
@@ -817,7 +834,7 @@ var DECODERS = [
   (args, data, o, lim) => {
     const h = higNibble(data[o]);
     const l = lowNibble(data[o]);
-    const split = minI32(4, h) + 1;
+    const split = IntMath.minI32(4, h) + 1;
     const immA = decodeI32(data, o + 1, o + split);
     const immB = decodeI32(data, o + split, lim);
     return args.fill(l, immA, immB, 0);
@@ -826,7 +843,7 @@ var DECODERS = [
   (args, data, o, lim) => {
     const h = higNibble(data[o]);
     const l = lowNibble(data[o]);
-    const split = minI32(4, h) + 1;
+    const split = IntMath.minI32(4, h) + 1;
     const immA = decodeI32(data, o + 1, o + split);
     const offs = decodeI32(data, o + split, lim);
     return args.fill(l, immA, offs, 0);
@@ -861,7 +878,7 @@ var DECODERS = [
     const b = lowNibble(data[o + 1]);
     return args.fill(hig, low, b, 0);
   }
-];
+]);
 function lowNibble(byte) {
   return byte & 15;
 }
@@ -878,7 +895,7 @@ function decodeI32(input, start, end) {
   for (let i = 0; i < len; i++) {
     num |= u32(input[start + i]) << i * 8;
   }
-  const msb = portable.arrayAt(input, start + len - 1) & 128;
+  const msb = portable.staticArrayAt(input, start + len - 1) & 128;
   if (len < 4 && msb > 0) {
     num |= 4294967295 << len * 8;
   }
@@ -893,7 +910,7 @@ function decodeU32(data, offset) {
 }
 
 // dist/build/js/assembly/gas.js
-var __decorate2 = function(decorators, target, key, desc) {
+var __decorate3 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -913,15 +930,16 @@ var GasCounter = class {
     return this.gas;
   }
   sub(g2) {
-    if (g2 > this.gas) {
+    const cost = u64(g2);
+    if (cost > this.gas) {
       this.gas = u64(0);
       return true;
     }
-    this.gas = this.gas - g2;
+    this.gas = this.gas - cost;
     return false;
   }
 };
-__decorate2([
+__decorate3([
   inline
 ], GasCounter.prototype, "sub", null);
 
@@ -930,7 +948,7 @@ var Instruction = class {
   constructor() {
     this.name = "";
     this.kind = Arguments.Zero;
-    this.gas = u64(0);
+    this.gas = u32(0);
     this.isTerminating = false;
   }
 };
@@ -938,13 +956,13 @@ function instruction(name, kind, gas, isTerminating = false) {
   const i = new Instruction();
   i.name = name;
   i.kind = kind;
-  i.gas = u64(gas);
+  i.gas = u32(gas);
   i.isTerminating = isTerminating;
   return i;
 }
 var MISSING_INSTRUCTION = instruction("INVALID", Arguments.Zero, 1, false);
 var SBRK = instruction("SBRK", Arguments.TwoReg, 1);
-var INSTRUCTIONS = [
+var INSTRUCTIONS = StaticArray.fromArray([
   /* 000 */
   instruction("TRAP", Arguments.Zero, 1, true),
   /* 001 */
@@ -1315,9 +1333,15 @@ var INSTRUCTIONS = [
   instruction("MIN", Arguments.ThreeReg, 1),
   /* 230 */
   instruction("MIN_U", Arguments.ThreeReg, 1)
-];
+]);
 
 // dist/build/js/assembly/instructions/outcome.js
+var __decorate4 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var Result;
 (function(Result2) {
   Result2[Result2["PANIC"] = 0] = "PANIC";
@@ -1332,7 +1356,7 @@ var Outcome;
   Outcome2[Outcome2["DynamicJump"] = 2] = "DynamicJump";
   Outcome2[Outcome2["Result"] = 3] = "Result";
 })(Outcome || (Outcome = {}));
-var OutcomeData = class {
+var OutcomeData = class _OutcomeData {
   constructor() {
     this.outcome = Outcome.Ok;
     this.staticJump = 0;
@@ -1340,42 +1364,63 @@ var OutcomeData = class {
     this.result = Result.PANIC;
     this.exitCode = 0;
   }
-};
-function status(r, result) {
-  r.outcome = Outcome.Result;
-  r.result = result;
-  return r;
-}
-function staticJump(r, offset) {
-  r.outcome = Outcome.StaticJump;
-  r.staticJump = offset;
-  return r;
-}
-function dJump(r, address) {
-  r.outcome = Outcome.DynamicJump;
-  r.dJump = address;
-  return r;
-}
-function ok(r) {
-  return r;
-}
-function panic(r) {
-  return status(r, Result.PANIC);
-}
-function hostCall(r, id) {
-  r.outcome = Outcome.Result;
-  r.result = Result.HOST;
-  r.exitCode = id;
-  return r;
-}
-function okOrFault(r, pageFault) {
-  if (pageFault.isFault) {
+  static status(r, result) {
     r.outcome = Outcome.Result;
-    r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
-    r.exitCode = pageFault.fault;
+    r.result = result;
+    return r;
   }
-  return r;
-}
+  static staticJump(r, offset) {
+    r.outcome = Outcome.StaticJump;
+    r.staticJump = offset;
+    return r;
+  }
+  static dJump(r, address) {
+    r.outcome = Outcome.DynamicJump;
+    r.dJump = address;
+    return r;
+  }
+  static ok(r) {
+    return r;
+  }
+  static panic(r) {
+    return _OutcomeData.status(r, Result.PANIC);
+  }
+  static hostCall(r, id) {
+    r.outcome = Outcome.Result;
+    r.result = Result.HOST;
+    r.exitCode = id;
+    return r;
+  }
+  static okOrFault(r, pageFault) {
+    if (pageFault.isFault) {
+      r.outcome = Outcome.Result;
+      r.result = pageFault.isAccess ? Result.FAULT_ACCESS : Result.FAULT;
+      r.exitCode = pageFault.fault;
+    }
+    return r;
+  }
+};
+__decorate4([
+  inline
+], OutcomeData, "status", null);
+__decorate4([
+  inline
+], OutcomeData, "staticJump", null);
+__decorate4([
+  inline
+], OutcomeData, "dJump", null);
+__decorate4([
+  inline
+], OutcomeData, "ok", null);
+__decorate4([
+  inline
+], OutcomeData, "panic", null);
+__decorate4([
+  inline
+], OutcomeData, "hostCall", null);
+__decorate4([
+  inline
+], OutcomeData, "okOrFault", null);
 
 // dist/build/js/assembly/registers.js
 var NO_OF_REGISTERS = 13;
@@ -1389,6 +1434,12 @@ function newRegisters() {
 }
 
 // dist/build/js/assembly/instructions/utils.js
+var __decorate5 = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 function mulUpperUnsigned(a, b) {
   const aHigh = a >> u64(32);
   const aLow = a & u64(4294967295);
@@ -1429,183 +1480,197 @@ function mulUpperSignedUnsigned(a, b) {
   }
   return mulUpperUnsigned(a, b);
 }
-function u8SignExtend(v) {
-  return u64(i64(i32(i16(i8(v)))));
-}
-function u16SignExtend(v) {
-  return u64(i64(i32(i16(v))));
-}
-function u32SignExtend(v) {
-  return u64(i64(i32(v)));
-}
-function reg(v) {
-  return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);
-}
+var Inst = class {
+  static u8SignExtend(v) {
+    return u64(i64(i32(i16(i8(v)))));
+  }
+  static u16SignExtend(v) {
+    return u64(i64(i32(i16(v))));
+  }
+  static u32SignExtend(v) {
+    return u64(i64(i32(v)));
+  }
+  static reg(v) {
+    return v >= u64(NO_OF_REGISTERS) ? NO_OF_REGISTERS - 1 : u32(v);
+  }
+};
+__decorate5([
+  inline
+], Inst, "u8SignExtend", null);
+__decorate5([
+  inline
+], Inst, "u16SignExtend", null);
+__decorate5([
+  inline
+], Inst, "u32SignExtend", null);
+__decorate5([
+  inline
+], Inst, "reg", null);
 
 // dist/build/js/assembly/instructions/bit.js
 var count_set_bits_64 = (r, args, regs) => {
-  regs[reg(args.b)] = portable.popcnt_u64(regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.b)] = portable.popcnt_u64(regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var count_set_bits_32 = (r, args, regs) => {
-  regs[reg(args.b)] = u64(portable.popcnt_u32(u32(regs[reg(args.a)])));
-  return ok(r);
+  regs[Inst.reg(args.b)] = u64(portable.popcnt_u32(u32(regs[Inst.reg(args.a)])));
+  return OutcomeData.ok(r);
 };
 var leading_zero_bits_64 = (r, args, regs) => {
-  regs[reg(args.b)] = portable.clz_u64(regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.b)] = portable.clz_u64(regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var leading_zero_bits_32 = (r, args, regs) => {
-  regs[reg(args.b)] = u64(portable.clz_u32(u32(regs[reg(args.a)])));
-  return ok(r);
+  regs[Inst.reg(args.b)] = u64(portable.clz_u32(u32(regs[Inst.reg(args.a)])));
+  return OutcomeData.ok(r);
 };
 var trailing_zero_bits_64 = (r, args, regs) => {
-  regs[reg(args.b)] = portable.ctz_u64(regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.b)] = portable.ctz_u64(regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var trailing_zero_bits_32 = (r, args, regs) => {
-  regs[reg(args.b)] = u64(portable.ctz_u32(u32(regs[reg(args.a)])));
-  return ok(r);
+  regs[Inst.reg(args.b)] = u64(portable.ctz_u32(u32(regs[Inst.reg(args.a)])));
+  return OutcomeData.ok(r);
 };
 var sign_extend_8 = (r, args, regs) => {
-  regs[reg(args.b)] = u8SignExtend(u8(regs[reg(args.a)]));
-  return ok(r);
+  regs[Inst.reg(args.b)] = Inst.u8SignExtend(u8(regs[Inst.reg(args.a)]));
+  return OutcomeData.ok(r);
 };
 var sign_extend_16 = (r, args, regs) => {
-  regs[reg(args.b)] = u16SignExtend(u16(regs[reg(args.a)]));
-  return ok(r);
+  regs[Inst.reg(args.b)] = Inst.u16SignExtend(u16(regs[Inst.reg(args.a)]));
+  return OutcomeData.ok(r);
 };
 var zero_extend_16 = (r, args, regs) => {
-  regs[reg(args.b)] = u64(u16(regs[reg(args.a)]));
-  return ok(r);
+  regs[Inst.reg(args.b)] = u64(u16(regs[Inst.reg(args.a)]));
+  return OutcomeData.ok(r);
 };
 var reverse_bytes = (r, args, regs) => {
-  regs[reg(args.b)] = portable.bswap_u64(regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.b)] = portable.bswap_u64(regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/branch.js
 var branch_eq_imm = (r, args, registers) => {
-  const b = u64(u32SignExtend(args.b));
-  if (registers[reg(args.a)] === b) {
-    return staticJump(r, args.c);
+  const b = u64(Inst.u32SignExtend(args.b));
+  if (registers[Inst.reg(args.a)] === b) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_ne_imm = (r, args, registers) => {
-  const b = u64(u32SignExtend(args.b));
-  if (registers[reg(args.a)] !== b) {
-    return staticJump(r, args.c);
+  const b = u64(Inst.u32SignExtend(args.b));
+  if (registers[Inst.reg(args.a)] !== b) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_lt_u_imm = (r, args, registers) => {
-  const b = u64(u32SignExtend(args.b));
-  if (registers[reg(args.a)] < b) {
-    return staticJump(r, args.c);
+  const b = u64(Inst.u32SignExtend(args.b));
+  if (registers[Inst.reg(args.a)] < b) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_le_u_imm = (r, args, registers) => {
-  const b = u64(u32SignExtend(args.b));
-  if (registers[reg(args.a)] <= b) {
-    return staticJump(r, args.c);
+  const b = u64(Inst.u32SignExtend(args.b));
+  if (registers[Inst.reg(args.a)] <= b) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_ge_u_imm = (r, args, registers) => {
-  const b = u64(u32SignExtend(args.b));
-  if (registers[reg(args.a)] >= b) {
-    return staticJump(r, args.c);
+  const b = u64(Inst.u32SignExtend(args.b));
+  if (registers[Inst.reg(args.a)] >= b) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_gt_u_imm = (r, args, registers) => {
-  const b = u64(u32SignExtend(args.b));
-  if (registers[reg(args.a)] > b) {
-    return staticJump(r, args.c);
+  const b = u64(Inst.u32SignExtend(args.b));
+  if (registers[Inst.reg(args.a)] > b) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_lt_s_imm = (r, args, registers) => {
-  if (i64(registers[reg(args.a)]) < i64(u32SignExtend(args.b))) {
-    return staticJump(r, args.c);
+  if (i64(registers[Inst.reg(args.a)]) < i64(Inst.u32SignExtend(args.b))) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_le_s_imm = (r, args, registers) => {
-  if (i64(registers[reg(args.a)]) <= i64(u32SignExtend(args.b))) {
-    return staticJump(r, args.c);
+  if (i64(registers[Inst.reg(args.a)]) <= i64(Inst.u32SignExtend(args.b))) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_ge_s_imm = (r, args, registers) => {
-  if (i64(registers[reg(args.a)]) >= i64(u32SignExtend(args.b))) {
-    return staticJump(r, args.c);
+  if (i64(registers[Inst.reg(args.a)]) >= i64(Inst.u32SignExtend(args.b))) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_gt_s_imm = (r, args, registers) => {
-  if (i64(registers[reg(args.a)]) > i64(u32SignExtend(args.b))) {
-    return staticJump(r, args.c);
+  if (i64(registers[Inst.reg(args.a)]) > i64(Inst.u32SignExtend(args.b))) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_eq = (r, args, registers) => {
-  if (registers[reg(args.a)] === registers[reg(args.b)]) {
-    return staticJump(r, args.c);
+  if (registers[Inst.reg(args.a)] === registers[Inst.reg(args.b)]) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_ne = (r, args, registers) => {
-  if (registers[reg(args.a)] !== registers[reg(args.b)]) {
-    return staticJump(r, args.c);
+  if (registers[Inst.reg(args.a)] !== registers[Inst.reg(args.b)]) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_lt_u = (r, args, registers) => {
-  if (registers[reg(args.b)] < registers[reg(args.a)]) {
-    return staticJump(r, args.c);
+  if (registers[Inst.reg(args.b)] < registers[Inst.reg(args.a)]) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_lt_s = (r, args, registers) => {
-  if (i64(registers[reg(args.b)]) < i64(registers[reg(args.a)])) {
-    return staticJump(r, args.c);
+  if (i64(registers[Inst.reg(args.b)]) < i64(registers[Inst.reg(args.a)])) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_ge_u = (r, args, registers) => {
-  if (registers[reg(args.b)] >= registers[reg(args.a)]) {
-    return staticJump(r, args.c);
+  if (registers[Inst.reg(args.b)] >= registers[Inst.reg(args.a)]) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var branch_ge_s = (r, args, registers) => {
-  if (i64(registers[reg(args.b)]) >= i64(registers[reg(args.a)])) {
-    return staticJump(r, args.c);
+  if (i64(registers[Inst.reg(args.b)]) >= i64(registers[Inst.reg(args.a)])) {
+    return OutcomeData.staticJump(r, args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/jump.js
-var jump = (r, args) => staticJump(r, args.a);
+var jump = (r, args) => OutcomeData.staticJump(r, args.a);
 var jump_ind = (r, args, registers) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.b)));
-  return dJump(r, address);
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.b)));
+  return OutcomeData.dJump(r, address);
 };
 var load_imm_jump = (r, args, registers) => {
-  registers[reg(args.a)] = u32SignExtend(args.b);
-  return staticJump(r, args.c);
+  registers[Inst.reg(args.a)] = Inst.u32SignExtend(args.b);
+  return OutcomeData.staticJump(r, args.c);
 };
 var load_imm_jump_ind = (r, args, registers) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.d)));
-  registers[reg(args.b)] = u32SignExtend(args.c);
-  return dJump(r, address);
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.d)));
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c);
+  return OutcomeData.dJump(r, address);
 };
 
 // dist/build/js/assembly/memory-page.js
-var __decorate3 = function(decorators, target, key, desc) {
+var __decorate6 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -1632,7 +1697,7 @@ var Page = class {
     return this.access === Access.Write || this.access === access;
   }
 };
-__decorate3([
+__decorate6([
   inline
 ], Page.prototype, "can", null);
 var RawPage = class {
@@ -1644,7 +1709,7 @@ var RawPage = class {
     return this.page;
   }
 };
-__decorate3([
+__decorate6([
   inline
 ], RawPage.prototype, "data", null);
 var Arena = class {
@@ -1675,7 +1740,7 @@ var Arena = class {
 };
 
 // dist/build/js/assembly/memory.js
-var __decorate4 = function(decorators, target, key, desc) {
+var __decorate7 = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -1738,10 +1803,10 @@ var PageCache = class {
     }
   }
 };
-__decorate4([
+__decorate7([
   inline
 ], PageCache.prototype, "lookup", null);
-__decorate4([
+__decorate7([
   inline
 ], PageCache.prototype, "insert", null);
 var MemoryBuilder = class {
@@ -1878,6 +1943,7 @@ var Memory = class {
     this.sbrkAddress = u32(newSbrk);
     const pageIdx = i32(portable.u64_sub(newSbrk, u64(1)) >> u64(PAGE_SIZE_SHIFT));
     if (pageIdx === this.lastAllocatedPage) {
+      faultRes4.isFault = false;
       return freeMemoryStart;
     }
     for (let i = this.lastAllocatedPage + 1; i <= pageIdx; i++) {
@@ -1887,6 +1953,7 @@ var Memory = class {
       this.cache.insert(i, page);
     }
     this.lastAllocatedPage = pageIdx;
+    faultRes4.isFault = false;
     return freeMemoryStart;
   }
   getU8(faultRes4, address) {
@@ -1902,13 +1969,13 @@ var Memory = class {
     return portable.bswap_u64(this.getBytesReversed(faultRes4, Access.Read, address, 8));
   }
   getI8(faultRes4, address) {
-    return u8SignExtend(u8(this.getU8(faultRes4, address)));
+    return Inst.u8SignExtend(u8(this.getU8(faultRes4, address)));
   }
   getI16(faultRes4, address) {
-    return u16SignExtend(u16(this.getU16(faultRes4, address)));
+    return Inst.u16SignExtend(u16(this.getU16(faultRes4, address)));
   }
   getI32(faultRes4, address) {
-    return u32SignExtend(u32(this.getU32(faultRes4, address)));
+    return Inst.u32SignExtend(u32(this.getU32(faultRes4, address)));
   }
   setU8(faultRes4, address, value) {
     this.setBytes(faultRes4, address, value, 1);
@@ -2082,7 +2149,7 @@ var Memory = class {
       return;
     }
     let bytesLeft = u64(value);
-    const firstPageEnd = minU32(PAGE_SIZE, r.firstPageOffset + bytes);
+    const firstPageEnd = IntMath.minU32(PAGE_SIZE, r.firstPageOffset + bytes);
     for (let i = r.firstPageOffset; i < firstPageEnd; i++) {
       r.firstPageData[i] = u8(bytesLeft);
       bytesLeft >>= u64(8);
@@ -2098,7 +2165,7 @@ var Memory = class {
       return u64(0);
     }
     let r = u64(0);
-    const firstPageEnd = minU32(PAGE_SIZE, this.chunksResult.firstPageOffset + bytes);
+    const firstPageEnd = IntMath.minU32(PAGE_SIZE, this.chunksResult.firstPageOffset + bytes);
     for (let i = this.chunksResult.firstPageOffset; i < firstPageEnd; i++) {
       r = r << u64(8) | u64(this.chunksResult.firstPageData[i]);
     }
@@ -2117,419 +2184,419 @@ function fault(r, address) {
 // dist/build/js/assembly/instructions/load.js
 var faultRes = new MaybePageFault();
 var load_imm_64 = (r, args, registers) => {
-  registers[reg(args.a)] = portable.u64_add(u64(args.b), u64(args.c) << u64(32));
-  return ok(r);
+  registers[Inst.reg(args.a)] = portable.u64_add(u64(args.b), u64(args.c) << u64(32));
+  return OutcomeData.ok(r);
 };
 var load_imm = (r, args, registers) => {
-  registers[reg(args.a)] = u32SignExtend(args.b);
-  return ok(r);
+  registers[Inst.reg(args.a)] = Inst.u32SignExtend(args.b);
+  return OutcomeData.ok(r);
 };
 var load_u8 = (r, args, registers, memory) => {
   const result = memory.getU8(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_i8 = (r, args, registers, memory) => {
   const result = memory.getI8(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_u16 = (r, args, registers, memory) => {
   const result = memory.getU16(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_i16 = (r, args, registers, memory) => {
   const result = memory.getI16(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_u32 = (r, args, registers, memory) => {
   const result = memory.getU32(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_i32 = (r, args, registers, memory) => {
   const result = memory.getI32(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_u64 = (r, args, registers, memory) => {
   const result = memory.getU64(faultRes, args.b);
   if (!faultRes.isFault) {
-    registers[reg(args.a)] = result;
+    registers[Inst.reg(args.a)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_u8 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getU8(faultRes, address);
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_i8 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getI8(faultRes, address);
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_u16 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getU16(faultRes, address);
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_i16 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getI16(faultRes, address);
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_u32 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getU32(faultRes, address);
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_i32 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getI32(faultRes, address);
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 var load_ind_u64 = (r, args, registers, memory) => {
-  const address = u32(portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c)));
+  const address = u32(portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c)));
   const result = memory.getU64(faultRes, u32(address));
   if (!faultRes.isFault) {
-    registers[reg(args.b)] = result;
+    registers[Inst.reg(args.b)] = result;
   }
-  return okOrFault(r, faultRes);
+  return OutcomeData.okOrFault(r, faultRes);
 };
 
 // dist/build/js/assembly/instructions/logic.js
 var and_imm = (r, args, registers) => {
-  registers[reg(args.b)] = registers[reg(args.a)] & u32SignExtend(args.c);
-  return ok(r);
+  registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)] & Inst.u32SignExtend(args.c);
+  return OutcomeData.ok(r);
 };
 var xor_imm = (r, args, registers) => {
-  registers[reg(args.b)] = registers[reg(args.a)] ^ u32SignExtend(args.c);
-  return ok(r);
+  registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)] ^ Inst.u32SignExtend(args.c);
+  return OutcomeData.ok(r);
 };
 var or_imm = (r, args, registers) => {
-  registers[reg(args.b)] = registers[reg(args.a)] | u32SignExtend(args.c);
-  return ok(r);
+  registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)] | Inst.u32SignExtend(args.c);
+  return OutcomeData.ok(r);
 };
 var and = (r, args, registers) => {
-  registers[reg(args.c)] = registers[reg(args.b)] & registers[reg(args.a)];
-  return ok(r);
+  registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] & registers[Inst.reg(args.a)];
+  return OutcomeData.ok(r);
 };
 var xor = (r, args, registers) => {
-  registers[reg(args.c)] = registers[reg(args.b)] ^ registers[reg(args.a)];
-  return ok(r);
+  registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] ^ registers[Inst.reg(args.a)];
+  return OutcomeData.ok(r);
 };
 var or = (r, args, registers) => {
-  registers[reg(args.c)] = registers[reg(args.b)] | registers[reg(args.a)];
-  return ok(r);
+  registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] | registers[Inst.reg(args.a)];
+  return OutcomeData.ok(r);
 };
 var and_inv = (r, args, registers) => {
-  registers[reg(args.c)] = registers[reg(args.b)] & ~registers[reg(args.a)];
-  return ok(r);
+  registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] & ~registers[Inst.reg(args.a)];
+  return OutcomeData.ok(r);
 };
 var or_inv = (r, args, registers) => {
-  registers[reg(args.c)] = u64(registers[reg(args.b)] | ~registers[reg(args.a)]);
-  return ok(r);
+  registers[Inst.reg(args.c)] = u64(registers[Inst.reg(args.b)] | ~registers[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var xnor = (r, args, registers) => {
-  registers[reg(args.c)] = u64(~(registers[reg(args.b)] ^ registers[reg(args.a)]));
-  return ok(r);
+  registers[Inst.reg(args.c)] = u64(~(registers[Inst.reg(args.b)] ^ registers[Inst.reg(args.a)]));
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/math.js
 var add_imm_32 = (r, args, registers) => {
-  const a = registers[reg(args.a)];
-  const c = u32SignExtend(args.c);
-  registers[reg(args.b)] = u32SignExtend(u32(portable.u64_add(a, c)));
-  return ok(r);
+  const a = registers[Inst.reg(args.a)];
+  const c = Inst.u32SignExtend(args.c);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(portable.u64_add(a, c)));
+  return OutcomeData.ok(r);
 };
 var mul_imm_32 = (r, args, registers) => {
-  registers[reg(args.b)] = u32SignExtend(u32(portable.u64_mul(registers[reg(args.a)], u64(args.c))));
-  return ok(r);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(portable.u64_mul(registers[Inst.reg(args.a)], u64(args.c))));
+  return OutcomeData.ok(r);
 };
 var neg_add_imm_32 = (r, args, registers) => {
-  const sum = portable.u64_sub(u64(args.c) | u64(4294967296), registers[reg(args.a)]);
-  registers[reg(args.b)] = u32SignExtend(u32(sum));
-  return ok(r);
+  const sum = portable.u64_sub(u64(args.c) | u64(4294967296), registers[Inst.reg(args.a)]);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(sum));
+  return OutcomeData.ok(r);
 };
 var add_imm = (r, args, registers) => {
-  const sum = portable.u64_add(registers[reg(args.a)], u32SignExtend(args.c));
-  registers[reg(args.b)] = sum;
-  return ok(r);
+  const sum = portable.u64_add(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+  registers[Inst.reg(args.b)] = sum;
+  return OutcomeData.ok(r);
 };
 var mul_imm = (r, args, registers) => {
-  registers[reg(args.b)] = portable.u64_mul(registers[reg(args.a)], u32SignExtend(args.c));
-  return ok(r);
+  registers[Inst.reg(args.b)] = portable.u64_mul(registers[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+  return OutcomeData.ok(r);
 };
 var neg_add_imm = (r, args, registers) => {
-  const sum = portable.u64_sub(u32SignExtend(args.c), registers[reg(args.a)]);
-  registers[reg(args.b)] = sum;
-  return ok(r);
+  const sum = portable.u64_sub(Inst.u32SignExtend(args.c), registers[Inst.reg(args.a)]);
+  registers[Inst.reg(args.b)] = sum;
+  return OutcomeData.ok(r);
 };
 var add_32 = (r, args, registers) => {
-  const a = u32(registers[reg(args.a)]);
-  const b = u32(registers[reg(args.b)]);
-  registers[reg(args.c)] = u32SignExtend(a + b);
-  return ok(r);
+  const a = u32(registers[Inst.reg(args.a)]);
+  const b = u32(registers[Inst.reg(args.b)]);
+  registers[Inst.reg(args.c)] = Inst.u32SignExtend(a + b);
+  return OutcomeData.ok(r);
 };
 var sub_32 = (r, args, registers) => {
-  const a = registers[reg(args.b)];
-  const b = u64(4294967296 - u32(registers[reg(args.a)]));
-  registers[reg(args.c)] = u32SignExtend(u32(portable.u64_add(a, b)));
-  return ok(r);
+  const a = registers[Inst.reg(args.b)];
+  const b = u64(4294967296 - u32(registers[Inst.reg(args.a)]));
+  registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(portable.u64_add(a, b)));
+  return OutcomeData.ok(r);
 };
 var mul_32 = (r, args, registers) => {
-  registers[reg(args.c)] = u32SignExtend(u32(portable.u64_mul(registers[reg(args.a)], registers[reg(args.b)])));
-  return ok(r);
+  registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(portable.u64_mul(registers[Inst.reg(args.a)], registers[Inst.reg(args.b)])));
+  return OutcomeData.ok(r);
 };
 var div_u_32 = (r, args, registers) => {
-  const a = u32(registers[reg(args.a)]);
+  const a = u32(registers[Inst.reg(args.a)]);
   if (a === 0) {
-    registers[reg(args.c)] = u64.MAX_VALUE;
+    registers[Inst.reg(args.c)] = u64.MAX_VALUE;
   } else {
-    const b = u32(registers[reg(args.b)]);
-    registers[reg(args.c)] = u32SignExtend(b / a);
+    const b = u32(registers[Inst.reg(args.b)]);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(b / a);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var div_s_32 = (r, args, registers) => {
-  const b = i64(u32SignExtend(u32(registers[reg(args.b)])));
-  const a = i64(u32SignExtend(u32(registers[reg(args.a)])));
+  const b = i64(Inst.u32SignExtend(u32(registers[Inst.reg(args.b)])));
+  const a = i64(Inst.u32SignExtend(u32(registers[Inst.reg(args.a)])));
   if (a === i64(0)) {
-    registers[reg(args.c)] = u64.MAX_VALUE;
+    registers[Inst.reg(args.c)] = u64.MAX_VALUE;
   } else if (a === i64(-1) && b === i64(i32.MIN_VALUE)) {
-    registers[reg(args.c)] = u64(b);
+    registers[Inst.reg(args.c)] = u64(b);
   } else {
-    registers[reg(args.c)] = u64(b / a);
+    registers[Inst.reg(args.c)] = u64(b / a);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var rem_u_32 = (r, args, registers) => {
-  const a = u32(registers[reg(args.a)]);
-  const b = u32(registers[reg(args.b)]);
+  const a = u32(registers[Inst.reg(args.a)]);
+  const b = u32(registers[Inst.reg(args.b)]);
   if (a === 0) {
-    registers[reg(args.c)] = u32SignExtend(b);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(b);
   } else {
-    registers[reg(args.c)] = u32SignExtend(b % a);
+    registers[Inst.reg(args.c)] = Inst.u32SignExtend(b % a);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var rem_s_32 = (r, args, registers) => {
-  const b = i32(registers[reg(args.b)]);
-  const a = i32(registers[reg(args.a)]);
+  const b = i32(registers[Inst.reg(args.b)]);
+  const a = i32(registers[Inst.reg(args.a)]);
   if (a === 0) {
-    registers[reg(args.c)] = u64(i64(b));
+    registers[Inst.reg(args.c)] = u64(i64(b));
   } else if (a === -1 && b === i32.MIN_VALUE) {
-    registers[reg(args.c)] = u64(0);
+    registers[Inst.reg(args.c)] = u64(0);
   } else {
-    registers[reg(args.c)] = u64(i64(b) % i64(a));
+    registers[Inst.reg(args.c)] = u64(i64(b) % i64(a));
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var add_64 = (r, args, registers) => {
-  const a = registers[reg(args.a)];
-  const b = registers[reg(args.b)];
-  registers[reg(args.c)] = portable.u64_add(a, b);
-  return ok(r);
+  const a = registers[Inst.reg(args.a)];
+  const b = registers[Inst.reg(args.b)];
+  registers[Inst.reg(args.c)] = portable.u64_add(a, b);
+  return OutcomeData.ok(r);
 };
 var sub = (r, args, registers) => {
-  const a = registers[reg(args.a)];
-  const b = registers[reg(args.b)];
-  registers[reg(args.c)] = portable.u64_sub(b, a);
-  return ok(r);
+  const a = registers[Inst.reg(args.a)];
+  const b = registers[Inst.reg(args.b)];
+  registers[Inst.reg(args.c)] = portable.u64_sub(b, a);
+  return OutcomeData.ok(r);
 };
 var mul = (r, args, registers) => {
-  const a = registers[reg(args.a)];
-  const b = registers[reg(args.b)];
-  registers[reg(args.c)] = portable.u64_mul(a, b);
-  return ok(r);
+  const a = registers[Inst.reg(args.a)];
+  const b = registers[Inst.reg(args.b)];
+  registers[Inst.reg(args.c)] = portable.u64_mul(a, b);
+  return OutcomeData.ok(r);
 };
 var div_u = (r, args, registers) => {
-  if (registers[reg(args.a)] === u64(0)) {
-    registers[reg(args.c)] = u64.MAX_VALUE;
+  if (registers[Inst.reg(args.a)] === u64(0)) {
+    registers[Inst.reg(args.c)] = u64.MAX_VALUE;
   } else {
-    registers[reg(args.c)] = registers[reg(args.b)] / registers[reg(args.a)];
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] / registers[Inst.reg(args.a)];
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var div_s = (r, args, registers) => {
-  const b = i64(registers[reg(args.b)]);
-  const a = i64(registers[reg(args.a)]);
+  const b = i64(registers[Inst.reg(args.b)]);
+  const a = i64(registers[Inst.reg(args.a)]);
   if (a === i64(0)) {
-    registers[reg(args.c)] = u64.MAX_VALUE;
+    registers[Inst.reg(args.c)] = u64.MAX_VALUE;
   } else if (a === i64(-1) && b === i64.MIN_VALUE) {
-    registers[reg(args.c)] = u64(b);
+    registers[Inst.reg(args.c)] = u64(b);
   } else {
-    registers[reg(args.c)] = u64(b / a);
+    registers[Inst.reg(args.c)] = u64(b / a);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var rem_u = (r, args, registers) => {
-  if (registers[reg(args.a)] === u64(0)) {
-    registers[reg(args.c)] = registers[reg(args.b)];
+  if (registers[Inst.reg(args.a)] === u64(0)) {
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)];
   } else {
-    registers[reg(args.c)] = registers[reg(args.b)] % registers[reg(args.a)];
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] % registers[Inst.reg(args.a)];
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var rem_s = (r, args, registers) => {
-  const b = i64(registers[reg(args.b)]);
-  const a = i64(registers[reg(args.a)]);
+  const b = i64(registers[Inst.reg(args.b)]);
+  const a = i64(registers[Inst.reg(args.a)]);
   if (a === i64(0)) {
-    registers[reg(args.c)] = u64(b);
+    registers[Inst.reg(args.c)] = u64(b);
   } else if (a === i64(-1) && b === i64.MIN_VALUE) {
-    registers[reg(args.c)] = u64(0);
+    registers[Inst.reg(args.c)] = u64(0);
   } else {
-    registers[reg(args.c)] = u64(b % a);
+    registers[Inst.reg(args.c)] = u64(b % a);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var mul_upper_s_s = (r, args, registers) => {
-  registers[reg(args.c)] = mulUpperSigned(i64(registers[reg(args.b)]), i64(registers[reg(args.a)]));
-  return ok(r);
+  registers[Inst.reg(args.c)] = mulUpperSigned(i64(registers[Inst.reg(args.b)]), i64(registers[Inst.reg(args.a)]));
+  return OutcomeData.ok(r);
 };
 var mul_upper_u_u = (r, args, registers) => {
-  registers[reg(args.c)] = mulUpperUnsigned(registers[reg(args.b)], registers[reg(args.a)]);
-  return ok(r);
+  registers[Inst.reg(args.c)] = mulUpperUnsigned(registers[Inst.reg(args.b)], registers[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var mul_upper_s_u = (r, args, registers) => {
-  registers[reg(args.c)] = mulUpperSignedUnsigned(i64(registers[reg(args.b)]), registers[reg(args.a)]);
-  return ok(r);
+  registers[Inst.reg(args.c)] = mulUpperSignedUnsigned(i64(registers[Inst.reg(args.b)]), registers[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var max = (r, args, registers) => {
-  const a = i64(registers[reg(args.a)]);
-  const b = i64(registers[reg(args.b)]);
-  registers[reg(args.c)] = u64(a < b ? b : a);
-  return ok(r);
+  const a = i64(registers[Inst.reg(args.a)]);
+  const b = i64(registers[Inst.reg(args.b)]);
+  registers[Inst.reg(args.c)] = u64(a < b ? b : a);
+  return OutcomeData.ok(r);
 };
 var max_u = (r, args, registers) => {
-  const a = registers[reg(args.a)];
-  const b = registers[reg(args.b)];
-  registers[reg(args.c)] = a < b ? b : a;
-  return ok(r);
+  const a = registers[Inst.reg(args.a)];
+  const b = registers[Inst.reg(args.b)];
+  registers[Inst.reg(args.c)] = a < b ? b : a;
+  return OutcomeData.ok(r);
 };
 var min = (r, args, registers) => {
-  const a = i64(registers[reg(args.a)]);
-  const b = i64(registers[reg(args.b)]);
-  registers[reg(args.c)] = u64(a > b ? b : a);
-  return ok(r);
+  const a = i64(registers[Inst.reg(args.a)]);
+  const b = i64(registers[Inst.reg(args.b)]);
+  registers[Inst.reg(args.c)] = u64(a > b ? b : a);
+  return OutcomeData.ok(r);
 };
 var min_u = (r, args, registers) => {
-  const a = registers[reg(args.a)];
-  const b = registers[reg(args.b)];
-  registers[reg(args.c)] = a > b ? b : a;
-  return ok(r);
+  const a = registers[Inst.reg(args.a)];
+  const b = registers[Inst.reg(args.b)];
+  registers[Inst.reg(args.c)] = a > b ? b : a;
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/misc.js
 var faultRes2 = new MaybePageFault();
-var INVALID = (r) => panic(r);
-var trap = (r) => panic(r);
-var fallthrough = (r) => ok(r);
-var ecalli = (r, args) => hostCall(r, args.a);
+var INVALID = (r) => OutcomeData.panic(r);
+var trap = (r) => OutcomeData.panic(r);
+var fallthrough = (r) => OutcomeData.ok(r);
+var ecalli = (r, args) => OutcomeData.hostCall(r, args.a);
 var sbrk = (r, args, registers, memory) => {
-  const res = memory.sbrk(faultRes2, u32(registers[reg(args.a)]));
+  const res = memory.sbrk(faultRes2, u32(registers[Inst.reg(args.a)]));
   if (faultRes2.isFault) {
-    return okOrFault(r, faultRes2);
+    return OutcomeData.okOrFault(r, faultRes2);
   }
-  registers[reg(args.b)] = res;
-  return ok(r);
+  registers[Inst.reg(args.b)] = res;
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/mov.js
 var move_reg = (r, args, registers) => {
-  registers[reg(args.b)] = registers[reg(args.a)];
-  return ok(r);
+  registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)];
+  return OutcomeData.ok(r);
 };
 var cmov_iz_imm = (r, args, registers) => {
-  if (registers[reg(args.a)] === u64(0)) {
-    registers[reg(args.b)] = u32SignExtend(args.c);
+  if (registers[Inst.reg(args.a)] === u64(0)) {
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var cmov_nz_imm = (r, args, registers) => {
-  if (registers[reg(args.a)] !== u64(0)) {
-    registers[reg(args.b)] = u32SignExtend(args.c);
+  if (registers[Inst.reg(args.a)] !== u64(0)) {
+    registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c);
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var cmov_iz = (r, args, registers) => {
-  if (registers[reg(args.a)] === u64(0)) {
-    registers[reg(args.c)] = registers[reg(args.b)];
+  if (registers[Inst.reg(args.a)] === u64(0)) {
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)];
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 var cmov_nz = (r, args, registers) => {
-  if (registers[reg(args.a)] !== u64(0)) {
-    registers[reg(args.c)] = registers[reg(args.b)];
+  if (registers[Inst.reg(args.a)] !== u64(0)) {
+    registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)];
   }
-  return ok(r);
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/rot.js
 var rot_r_64_imm = (r, args, regs) => {
-  regs[reg(args.b)] = math.rot_r(regs[reg(args.a)], u32SignExtend(args.c));
-  return ok(r);
+  regs[Inst.reg(args.b)] = math.rot_r(regs[Inst.reg(args.a)], Inst.u32SignExtend(args.c));
+  return OutcomeData.ok(r);
 };
 var rot_r_64_imm_alt = (r, args, regs) => {
-  regs[reg(args.b)] = math.rot_r(u32SignExtend(args.c), regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.b)] = math.rot_r(Inst.u32SignExtend(args.c), regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var rot_r_32_imm = (r, args, regs) => {
-  regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.a)]), u32(args.c)));
-  return ok(r);
+  regs[Inst.reg(args.b)] = Inst.u32SignExtend(math.rot_r_32(u32(regs[Inst.reg(args.a)]), u32(args.c)));
+  return OutcomeData.ok(r);
 };
 var rot_r_32_imm_alt = (r, args, regs) => {
-  regs[reg(args.b)] = u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[reg(args.a)])));
-  return ok(r);
+  regs[Inst.reg(args.b)] = Inst.u32SignExtend(math.rot_r_32(u32(args.c), u32(regs[Inst.reg(args.a)])));
+  return OutcomeData.ok(r);
 };
 var rot_l_64 = (r, args, regs) => {
-  regs[reg(args.c)] = math.rot_l(regs[reg(args.b)], regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.c)] = math.rot_l(regs[Inst.reg(args.b)], regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var rot_l_32 = (r, args, regs) => {
-  regs[reg(args.c)] = u32SignExtend(math.rot_l_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
-  return ok(r);
+  regs[Inst.reg(args.c)] = Inst.u32SignExtend(math.rot_l_32(u32(regs[Inst.reg(args.b)]), u32(regs[Inst.reg(args.a)])));
+  return OutcomeData.ok(r);
 };
 var rot_r_64 = (r, args, regs) => {
-  regs[reg(args.c)] = math.rot_r(regs[reg(args.b)], regs[reg(args.a)]);
-  return ok(r);
+  regs[Inst.reg(args.c)] = math.rot_r(regs[Inst.reg(args.b)], regs[Inst.reg(args.a)]);
+  return OutcomeData.ok(r);
 };
 var rot_r_32 = (r, args, regs) => {
-  regs[reg(args.c)] = u32SignExtend(math.rot_r_32(u32(regs[reg(args.b)]), u32(regs[reg(args.a)])));
-  return ok(r);
+  regs[Inst.reg(args.c)] = Inst.u32SignExtend(math.rot_r_32(u32(regs[Inst.reg(args.b)]), u32(regs[Inst.reg(args.a)])));
+  return OutcomeData.ok(r);
 };
 var math;
 (function(math2) {
@@ -2553,32 +2620,32 @@ var math;
 
 // dist/build/js/assembly/instructions/set.js
 var set_lt_u_imm = (r, args, registers) => {
-  const cond = registers[reg(args.a)] < u64(u32SignExtend(args.c));
-  registers[reg(args.b)] = cond ? u64(1) : u64(0);
-  return ok(r);
+  const cond = registers[Inst.reg(args.a)] < u64(Inst.u32SignExtend(args.c));
+  registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+  return OutcomeData.ok(r);
 };
 var set_lt_s_imm = (r, args, registers) => {
-  const cond = i64(registers[reg(args.a)]) < i64(u32SignExtend(args.c));
-  registers[reg(args.b)] = cond ? u64(1) : u64(0);
-  return ok(r);
+  const cond = i64(registers[Inst.reg(args.a)]) < i64(Inst.u32SignExtend(args.c));
+  registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+  return OutcomeData.ok(r);
 };
 var set_gt_u_imm = (r, args, registers) => {
-  const cond = registers[reg(args.a)] > u64(u32SignExtend(args.c));
-  registers[reg(args.b)] = cond ? u64(1) : u64(0);
-  return ok(r);
+  const cond = registers[Inst.reg(args.a)] > u64(Inst.u32SignExtend(args.c));
+  registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+  return OutcomeData.ok(r);
 };
 var set_gt_s_imm = (r, args, registers) => {
-  const cond = i64(registers[reg(args.a)]) > i64(u32SignExtend(args.c));
-  registers[reg(args.b)] = cond ? u64(1) : u64(0);
-  return ok(r);
+  const cond = i64(registers[Inst.reg(args.a)]) > i64(Inst.u32SignExtend(args.c));
+  registers[Inst.reg(args.b)] = cond ? u64(1) : u64(0);
+  return OutcomeData.ok(r);
 };
 var set_lt_u = (r, args, registers) => {
-  registers[reg(args.c)] = registers[reg(args.b)] < registers[reg(args.a)] ? u64(1) : u64(0);
-  return ok(r);
+  registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] < registers[Inst.reg(args.a)] ? u64(1) : u64(0);
+  return OutcomeData.ok(r);
 };
 var set_lt_s = (r, args, registers) => {
-  registers[reg(args.c)] = i64(registers[reg(args.b)]) < i64(registers[reg(args.a)]) ? u64(1) : u64(0);
-  return ok(r);
+  registers[Inst.reg(args.c)] = i64(registers[Inst.reg(args.b)]) < i64(registers[Inst.reg(args.a)]) ? u64(1) : u64(0);
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/shift.js
@@ -2586,184 +2653,184 @@ var MAX_SHIFT_64 = 64;
 var MAX_SHIFT_32 = 32;
 var shlo_l_imm_32 = (r, args, registers) => {
   const shift = u32(args.c % MAX_SHIFT_32);
-  const value = u32(registers[reg(args.a)]);
-  registers[reg(args.b)] = u32SignExtend(value << shift);
-  return ok(r);
+  const value = u32(registers[Inst.reg(args.a)]);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(value << shift);
+  return OutcomeData.ok(r);
 };
 var shlo_r_imm_32 = (r, args, registers) => {
   const shift = u32(args.c % MAX_SHIFT_32);
-  const value = u32(registers[reg(args.a)]);
-  registers[reg(args.b)] = u32SignExtend(value >>> shift);
-  return ok(r);
+  const value = u32(registers[Inst.reg(args.a)]);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(value >>> shift);
+  return OutcomeData.ok(r);
 };
 var shar_r_imm_32 = (r, args, registers) => {
   const shift = u32(args.c % MAX_SHIFT_32);
-  const value = u32SignExtend(u32(registers[reg(args.a)]));
-  registers[reg(args.b)] = u64(i64(value) >> i64(shift));
-  return ok(r);
+  const value = Inst.u32SignExtend(u32(registers[Inst.reg(args.a)]));
+  registers[Inst.reg(args.b)] = u64(i64(value) >> i64(shift));
+  return OutcomeData.ok(r);
 };
 var shlo_l_imm_alt_32 = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-  registers[reg(args.b)] = u32SignExtend(args.c << shift);
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c << shift);
+  return OutcomeData.ok(r);
 };
 var shlo_r_imm_alt_32 = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-  registers[reg(args.b)] = u32SignExtend(args.c >>> shift);
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(args.c >>> shift);
+  return OutcomeData.ok(r);
 };
 var shar_r_imm_alt_32 = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-  const imm = u32SignExtend(args.c);
-  registers[reg(args.b)] = u32SignExtend(u32(i64(imm) >> i64(shift)));
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+  const imm = Inst.u32SignExtend(args.c);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(i64(imm) >> i64(shift)));
+  return OutcomeData.ok(r);
 };
 var shlo_l_imm = (r, args, registers) => {
   const shift = u32(args.c % MAX_SHIFT_64);
-  registers[reg(args.b)] = u64(registers[reg(args.a)] << u64(shift));
-  return ok(r);
+  registers[Inst.reg(args.b)] = u64(registers[Inst.reg(args.a)] << u64(shift));
+  return OutcomeData.ok(r);
 };
 var shlo_r_imm = (r, args, registers) => {
   const shift = u32(args.c % MAX_SHIFT_64);
-  registers[reg(args.b)] = registers[reg(args.a)] >> u64(shift);
-  return ok(r);
+  registers[Inst.reg(args.b)] = registers[Inst.reg(args.a)] >> u64(shift);
+  return OutcomeData.ok(r);
 };
 var shar_r_imm = (r, args, registers) => {
   const shift = u32(args.c % MAX_SHIFT_64);
-  const value = i64(registers[reg(args.a)]);
-  registers[reg(args.b)] = u64(value >> i64(shift));
-  return ok(r);
+  const value = i64(registers[Inst.reg(args.a)]);
+  registers[Inst.reg(args.b)] = u64(value >> i64(shift));
+  return OutcomeData.ok(r);
 };
 var shlo_l_imm_alt = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-  registers[reg(args.b)] = u64(u32SignExtend(args.c) << i64(shift));
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+  registers[Inst.reg(args.b)] = u64(Inst.u32SignExtend(args.c) << i64(shift));
+  return OutcomeData.ok(r);
 };
 var shlo_r_imm_alt = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-  registers[reg(args.b)] = u64(u32SignExtend(args.c)) >> u64(shift);
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+  registers[Inst.reg(args.b)] = u64(Inst.u32SignExtend(args.c)) >> u64(shift);
+  return OutcomeData.ok(r);
 };
 var shar_r_imm_alt = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-  const value = u32SignExtend(args.c);
-  registers[reg(args.b)] = u32SignExtend(u32(value >> i64(shift)));
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+  const value = Inst.u32SignExtend(args.c);
+  registers[Inst.reg(args.b)] = Inst.u32SignExtend(u32(value >> i64(shift)));
+  return OutcomeData.ok(r);
 };
 var shlo_l_32 = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-  const value = u32(registers[reg(args.b)]);
-  registers[reg(args.c)] = u32SignExtend(value << shift);
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+  const value = u32(registers[Inst.reg(args.b)]);
+  registers[Inst.reg(args.c)] = Inst.u32SignExtend(value << shift);
+  return OutcomeData.ok(r);
 };
 var shlo_r_32 = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-  const value = u32(registers[reg(args.b)]);
-  registers[reg(args.c)] = u32SignExtend(value >>> shift);
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+  const value = u32(registers[Inst.reg(args.b)]);
+  registers[Inst.reg(args.c)] = Inst.u32SignExtend(value >>> shift);
+  return OutcomeData.ok(r);
 };
 var shar_r_32 = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_32));
-  const regValue = u32SignExtend(u32(registers[reg(args.b)]));
-  registers[reg(args.c)] = u32SignExtend(u32(i64(regValue) >> i64(shift)));
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_32));
+  const regValue = Inst.u32SignExtend(u32(registers[Inst.reg(args.b)]));
+  registers[Inst.reg(args.c)] = Inst.u32SignExtend(u32(i64(regValue) >> i64(shift)));
+  return OutcomeData.ok(r);
 };
 var shlo_l = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-  registers[reg(args.c)] = u64(registers[reg(args.b)] << u64(shift));
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+  registers[Inst.reg(args.c)] = u64(registers[Inst.reg(args.b)] << u64(shift));
+  return OutcomeData.ok(r);
 };
 var shlo_r = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-  registers[reg(args.c)] = registers[reg(args.b)] >> u64(shift);
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+  registers[Inst.reg(args.c)] = registers[Inst.reg(args.b)] >> u64(shift);
+  return OutcomeData.ok(r);
 };
 var shar_r = (r, args, registers) => {
-  const shift = u32(registers[reg(args.a)] % u64(MAX_SHIFT_64));
-  registers[reg(args.c)] = u64(i64(registers[reg(args.b)]) >> i64(shift));
-  return ok(r);
+  const shift = u32(registers[Inst.reg(args.a)] % u64(MAX_SHIFT_64));
+  registers[Inst.reg(args.c)] = u64(i64(registers[Inst.reg(args.b)]) >> i64(shift));
+  return OutcomeData.ok(r);
 };
 
 // dist/build/js/assembly/instructions/store.js
 var faultRes3 = new MaybePageFault();
 function effectiveAddress(registers, baseReg, offset) {
-  return u32(portable.u64_add(registers[reg(u64(baseReg))], u32SignExtend(offset)));
+  return u32(portable.u64_add(registers[Inst.reg(u64(baseReg))], Inst.u32SignExtend(offset)));
 }
 var store_imm_u8 = (r, args, _registers, memory) => {
   const address = args.a;
   memory.setU8(faultRes3, address, args.b & 255);
-  return okOrFault(r, faultRes3);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_u16 = (r, args, _registers, memory) => {
   const address = args.a;
   memory.setU16(faultRes3, address, args.b & 65535);
-  return okOrFault(r, faultRes3);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_u32 = (r, args, _registers, memory) => {
   const address = args.a;
   memory.setU32(faultRes3, address, args.b);
-  return okOrFault(r, faultRes3);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_u64 = (r, args, _registers, memory) => {
   const address = args.a;
-  memory.setU64(faultRes3, address, u32SignExtend(args.b));
-  return okOrFault(r, faultRes3);
+  memory.setU64(faultRes3, address, Inst.u32SignExtend(args.b));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_u8 = (r, args, registers, memory) => {
-  memory.setU8(faultRes3, args.b, registers[reg(args.a)] & u64(255));
-  return okOrFault(r, faultRes3);
+  memory.setU8(faultRes3, args.b, registers[Inst.reg(args.a)] & u64(255));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_u16 = (r, args, registers, memory) => {
-  memory.setU16(faultRes3, args.b, registers[reg(args.a)] & u64(65535));
-  return okOrFault(r, faultRes3);
+  memory.setU16(faultRes3, args.b, registers[Inst.reg(args.a)] & u64(65535));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_u32 = (r, args, registers, memory) => {
-  memory.setU32(faultRes3, args.b, u32(registers[reg(args.a)]));
-  return okOrFault(r, faultRes3);
+  memory.setU32(faultRes3, args.b, u32(registers[Inst.reg(args.a)]));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_u64 = (r, args, registers, memory) => {
-  memory.setU64(faultRes3, args.b, registers[reg(args.a)]);
-  return okOrFault(r, faultRes3);
+  memory.setU64(faultRes3, args.b, registers[Inst.reg(args.a)]);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_ind_u8 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.b);
   memory.setU8(faultRes3, address, args.c & 255);
-  return okOrFault(r, faultRes3);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_ind_u16 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.b);
   memory.setU16(faultRes3, address, args.c & 65535);
-  return okOrFault(r, faultRes3);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_ind_u32 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.b);
   memory.setU32(faultRes3, address, args.c);
-  return okOrFault(r, faultRes3);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_imm_ind_u64 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.b);
-  memory.setU64(faultRes3, address, u32SignExtend(args.c));
-  return okOrFault(r, faultRes3);
+  memory.setU64(faultRes3, address, Inst.u32SignExtend(args.c));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_ind_u8 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.c);
-  memory.setU8(faultRes3, address, registers[reg(args.b)] & u64(255));
-  return okOrFault(r, faultRes3);
+  memory.setU8(faultRes3, address, registers[Inst.reg(args.b)] & u64(255));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_ind_u16 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.c);
-  memory.setU16(faultRes3, address, registers[reg(args.b)] & u64(65535));
-  return okOrFault(r, faultRes3);
+  memory.setU16(faultRes3, address, registers[Inst.reg(args.b)] & u64(65535));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_ind_u32 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.c);
-  memory.setU32(faultRes3, address, u32(registers[reg(args.b)]));
-  return okOrFault(r, faultRes3);
+  memory.setU32(faultRes3, address, u32(registers[Inst.reg(args.b)]));
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 var store_ind_u64 = (r, args, registers, memory) => {
   const address = effectiveAddress(registers, args.a, args.c);
-  memory.setU64(faultRes3, address, registers[reg(args.b)]);
-  return okOrFault(r, faultRes3);
+  memory.setU64(faultRes3, address, registers[Inst.reg(args.b)]);
+  return OutcomeData.okOrFault(r, faultRes3);
 };
 
 // dist/build/js/assembly/instructions-exe.js
@@ -3160,13 +3227,13 @@ function liftBytes(data) {
   return p;
 }
 function lowerBytes(data) {
-  const r = new Array(data.length);
+  const r = new StaticArray(data.length);
   for (let i = 0; i < data.length; i++) {
     r[i] = data[i];
   }
   return r;
 }
-function deblob(program) {
+function deblob(program, useBlockGas) {
   const decoder = new Decoder(program);
   const jumpTableLength = decoder.varU32();
   const jumpTableItemLength = decoder.u8();
@@ -3178,7 +3245,8 @@ function deblob(program) {
   const mask = new Mask(rawMask, codeLength);
   const jumpTable = new JumpTable(jumpTableItemLength, rawJumpTable);
   const basicBlocks = new BasicBlocks(rawCode, mask);
-  return new Program(rawCode, mask, jumpTable, basicBlocks);
+  const gasCosts = new GasCosts(rawCode, mask, basicBlocks, useBlockGas);
+  return new Program(rawCode, mask, jumpTable, basicBlocks, gasCosts);
 }
 var Mask = class {
   constructor(packedMask, codeLength) {
@@ -3225,6 +3293,51 @@ var Mask = class {
     return `${v}]`;
   }
 };
+var GasCosts = class {
+  constructor(code, mask, blocks, useBlockGasCost) {
+    const len = code.length;
+    const costs = new StaticArray(len);
+    for (let n = 0; n < len; n += 1) {
+      const isInstructionInMask = mask.isInstruction(n);
+      if (!isInstructionInMask) {
+        costs[n] = code[n];
+        continue;
+      }
+      const skipArgs = mask.skipBytesToNextInstruction(n);
+      const iData = code[n] >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[code[n]];
+      costs[n] = code[n] | iData.gas << 8;
+      n += skipArgs;
+    }
+    if (useBlockGasCost) {
+      let previousStart = 0;
+      let previousSum = 0;
+      for (let n = 0; n < len; n += 1) {
+        const currentGas = costs[n] >> 8;
+        costs[n] = code[n];
+        if (blocks.isStart(n)) {
+          costs[previousStart] = code[previousStart] | previousSum << 8;
+          previousSum = currentGas;
+          previousStart = n;
+        } else {
+          previousSum += currentGas;
+        }
+        n += mask.skipBytesToNextInstruction(n);
+      }
+      costs[previousStart] = code[previousStart] | previousSum << 8;
+    }
+    this.codeAndGas = costs;
+  }
+  toString() {
+    let v = "GasCosts[";
+    for (let i = 0; i < this.codeAndGas.length; i += 1) {
+      const gas = this.codeAndGas[i] >> 8;
+      if (gas !== 0) {
+        v += `${i} -> ${gas}, `;
+      }
+    }
+    return `${v}]`;
+  }
+};
 var BasicBlock;
 (function(BasicBlock2) {
   BasicBlock2[BasicBlock2["NONE"] = 0] = "NONE";
@@ -3302,29 +3415,30 @@ var JumpTable = class {
   }
 };
 var Program = class {
-  constructor(code, mask, jumpTable, basicBlocks) {
+  constructor(code, mask, jumpTable, basicBlocks, gasCosts) {
     this.code = code;
     this.mask = mask;
     this.jumpTable = jumpTable;
     this.basicBlocks = basicBlocks;
+    this.gasCosts = gasCosts;
   }
   toString() {
-    return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks} }`;
+    return `Program { code: ${this.code}, mask: ${this.mask}, jumpTable: ${this.jumpTable}, basicBlocks: ${this.basicBlocks}, gasCosts: ${this.gasCosts} }`;
   }
 };
-var EXTENDED_BUF = new Array(16);
+var EXTENDED_BUF = new StaticArray(16);
 function decodeArguments(args, kind, code, offset, lim) {
   if (code.length < offset + REQUIRED_BYTES[kind]) {
-    const reqBytes = REQUIRED_BYTES[kind];
+    const reqBytes = unchecked(REQUIRED_BYTES[kind]);
     for (let i = 0; i < reqBytes; i++) {
       EXTENDED_BUF[i] = 0;
     }
     for (let i = offset; i < code.length; i++) {
-      EXTENDED_BUF[i - offset] = code[i];
+      EXTENDED_BUF[i - offset] = unchecked(code[i]);
     }
-    return DECODERS[kind](args, EXTENDED_BUF, 0, lim);
+    return unchecked(DECODERS[kind])(args, EXTENDED_BUF, 0, lim);
   }
-  return DECODERS[kind](args, code, offset, offset + lim);
+  return unchecked(DECODERS[kind])(args, code, offset, offset + lim);
 }
 var ResolvedArguments = class {
   constructor() {
@@ -3346,57 +3460,57 @@ function resolveArguments(argsRes, kind, code, offset, lim, registers) {
     case Arguments.Zero:
       return resolved;
     case Arguments.OneImm:
-      resolved.a = u32SignExtend(args.a);
+      resolved.a = Inst.u32SignExtend(args.a);
       return resolved;
     case Arguments.TwoImm:
-      resolved.a = u32SignExtend(args.a);
-      resolved.b = u32SignExtend(args.b);
+      resolved.a = Inst.u32SignExtend(args.a);
+      resolved.b = Inst.u32SignExtend(args.b);
       return resolved;
     case Arguments.OneOff:
-      resolved.a = u32SignExtend(args.a);
+      resolved.a = Inst.u32SignExtend(args.a);
       return resolved;
     case Arguments.OneRegOneImm:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = u32SignExtend(args.b);
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = Inst.u32SignExtend(args.b);
       return resolved;
     case Arguments.OneRegOneExtImm:
-      resolved.a = registers[reg(u64(args.a))];
+      resolved.a = registers[Inst.reg(u64(args.a))];
       resolved.b = portable.u64_add(u64(args.a) << u64(32), u64(args.b));
       return resolved;
     case Arguments.OneRegTwoImm:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = u32SignExtend(args.b);
-      resolved.c = u32SignExtend(args.c);
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = Inst.u32SignExtend(args.b);
+      resolved.c = Inst.u32SignExtend(args.c);
       return resolved;
     case Arguments.OneRegOneImmOneOff:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = u32SignExtend(args.b);
-      resolved.c = u32SignExtend(args.c);
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = Inst.u32SignExtend(args.b);
+      resolved.c = Inst.u32SignExtend(args.c);
       return resolved;
     case Arguments.TwoReg:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = registers[reg(u64(args.b))];
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = registers[Inst.reg(u64(args.b))];
       return resolved;
     case Arguments.TwoRegOneImm:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = registers[reg(u64(args.b))];
-      resolved.c = u32SignExtend(args.c);
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = registers[Inst.reg(u64(args.b))];
+      resolved.c = Inst.u32SignExtend(args.c);
       return resolved;
     case Arguments.TwoRegOneOff:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = registers[reg(u64(args.b))];
-      resolved.c = u32SignExtend(args.c);
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = registers[Inst.reg(u64(args.b))];
+      resolved.c = Inst.u32SignExtend(args.c);
       return resolved;
     case Arguments.TwoRegTwoImm:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = registers[reg(u64(args.b))];
-      resolved.c = u32SignExtend(args.c);
-      resolved.d = u32SignExtend(args.d);
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = registers[Inst.reg(u64(args.b))];
+      resolved.c = Inst.u32SignExtend(args.c);
+      resolved.d = Inst.u32SignExtend(args.d);
       return resolved;
     case Arguments.ThreeReg:
-      resolved.a = registers[reg(u64(args.a))];
-      resolved.b = registers[reg(u64(args.b))];
-      resolved.c = registers[reg(u64(args.c))];
+      resolved.a = registers[Inst.reg(u64(args.a))];
+      resolved.b = registers[Inst.reg(u64(args.b))];
+      resolved.c = registers[Inst.reg(u64(args.c))];
       return resolved;
     default:
       throw new Error(`Unhandled arguments kind: ${kind}`);
@@ -3445,7 +3559,6 @@ var Interpreter = class {
     this.status = Status.OK;
     this.exitCode = 0;
     this.nextPc = 0;
-    this.useSbrkGas = false;
   }
   nextSteps(nSteps2 = 1) {
     if (this.status === Status.HOST) {
@@ -3461,9 +3574,11 @@ var Interpreter = class {
       this.nextPc = -1;
       return true;
     }
-    const program = this.program;
-    const code = program.code;
-    const mask = program.mask;
+    const code = this.program.code;
+    const mask = this.program.mask;
+    const gasCosts = this.program.gasCosts.codeAndGas;
+    const basicBlocks = this.program.basicBlocks;
+    const jumpTable = this.program.jumpTable;
     const argsRes = this.argsRes;
     const outcomeRes = this.outcomeRes;
     for (let i = 0; i < nSteps2; i++) {
@@ -3479,9 +3594,11 @@ var Interpreter = class {
         }
         return false;
       }
-      const instruction2 = unchecked(code[pc]);
+      const codeAndGas = portable.staticArrayAt(gasCosts, pc);
+      const instruction2 = codeAndGas & 255;
+      const gasCost = codeAndGas >> 8;
       const iData = instruction2 < INSTRUCTIONS.length ? unchecked(INSTRUCTIONS[instruction2]) : MISSING_INSTRUCTION;
-      if (this.gas.sub(iData.gas)) {
+      if (gasCost > 0 && this.gas.sub(gasCost)) {
         this.status = Status.OOG;
         return false;
       }
@@ -3491,14 +3608,6 @@ var Interpreter = class {
       }
       const skipBytes2 = mask.skipBytesToNextInstruction(pc);
       const args = decodeArguments(argsRes, iData.kind, code, pc + 1, skipBytes2);
-      if (iData === SBRK && this.useSbrkGas) {
-        const alloc = u64(u32(this.registers[reg(u64(args.a))]));
-        const gas = portable.u64_mul(portable.u64_sub(portable.u64_add(alloc, u64(PAGE_SIZE)), u64(1)) >> u64(PAGE_SIZE_SHIFT), u64(16));
-        if (this.gas.sub(gas)) {
-          this.status = Status.OOG;
-          return false;
-        }
-      }
       const exe = unchecked(RUN[instruction2]);
       const outcome = exe(outcomeRes, args, this.registers, this.memory);
       if (outcome.outcome === Outcome.Ok) {
@@ -3507,7 +3616,7 @@ var Interpreter = class {
       }
       switch (outcome.outcome) {
         case Outcome.StaticJump: {
-          const branchResult = branch(this.branchRes, program.basicBlocks, pc, outcome.staticJump);
+          const branchResult = branch(this.branchRes, basicBlocks, pc, outcome.staticJump);
           if (!branchResult.isOkay) {
             this.status = Status.PANIC;
             return false;
@@ -3516,7 +3625,7 @@ var Interpreter = class {
           continue;
         }
         case Outcome.DynamicJump: {
-          const res = dJump2(this.djumpRes, program.jumpTable, outcome.dJump);
+          const res = dJump(this.djumpRes, jumpTable, outcome.dJump);
           if (res.status === DjumpStatus.HALT) {
             this.status = Status.HALT;
             return false;
@@ -3525,7 +3634,7 @@ var Interpreter = class {
             this.status = Status.PANIC;
             return false;
           }
-          const branchResult = branch(this.branchRes, program.basicBlocks, res.newPc, 0);
+          const branchResult = branch(this.branchRes, basicBlocks, res.newPc, 0);
           if (!branchResult.isOkay) {
             this.status = Status.PANIC;
             return false;
@@ -3578,7 +3687,7 @@ function branch(r, basicBlocks, pc, offset) {
 }
 var EXIT = 4294901760;
 var JUMP_ALIGMENT_FACTOR = 2;
-function dJump2(r, jumpTable, address) {
+function dJump(r, jumpTable, address) {
   if (address === EXIT) {
     r.status = DjumpStatus.HALT;
     return r;
@@ -3619,7 +3728,6 @@ var InitialChunk = class {
 };
 var VmRunOptions = class {
   constructor() {
-    this.useSbrkGas = false;
     this.logs = false;
     this.dumpMemory = false;
   }
@@ -3706,15 +3814,14 @@ function buildMemory(builder, pages, chunks) {
   }
   return builder.build(sbrkIndex);
 }
-function vmInit(input, useSbrkGas = false) {
+function vmInit(input) {
   const int = new Interpreter(input.program, input.registers, input.memory);
-  int.useSbrkGas = useSbrkGas;
   int.nextPc = input.pc;
   int.gas.set(input.gas);
   return int;
 }
 function vmRunOnce(input, options) {
-  const int = vmInit(input, options.useSbrkGas);
+  const int = vmInit(input);
   vmExecute(int, options.logs);
   return vmDestroy(int, options.dumpMemory);
 }
@@ -3830,7 +3937,7 @@ function getOutputChunks(memory) {
 var MAX_ARGS_LEN = 2 ** 24;
 var ARGS_SEGMENT_START = 2 ** 32 - SEGMENT_SIZE - MAX_ARGS_LEN;
 var STACK_SEGMENT_END = ARGS_SEGMENT_START - SEGMENT_SIZE;
-function decodeSpi(data, args, preallocateMemoryPages = 0) {
+function decodeSpi(data, args, preallocateMemoryPages = 0, useBlockGas = false) {
   const argsLength = args.length;
   if (argsLength > MAX_ARGS_LEN) {
     throw new Error(`Arguments length is too big. Got: ${argsLength}, max: ${MAX_ARGS_LEN}`);
@@ -3845,7 +3952,7 @@ function decodeSpi(data, args, preallocateMemoryPages = 0) {
   const codeLength = decoder.u32();
   const code = decoder.bytes(codeLength);
   decoder.finish();
-  const program = deblob(code);
+  const program = deblob(code, useBlockGas);
   const builder = new MemoryBuilder(preallocateMemoryPages);
   const heapStart = 2 * SEGMENT_SIZE + alignToSegmentSize(roLength);
   const heapZerosStart = heapStart + alignToPageSize(rwLength);
@@ -3895,9 +4002,9 @@ var StandardProgram = class {
 
 // dist/build/js/assembly/api-debugger.js
 var interpreter = null;
-function resetJAM(program, pc, initialGas, args, hasMetadata = false) {
+function resetJAM(program, pc, initialGas, args, hasMetadata = false, useBlockGas = false) {
   const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);
-  const p = decodeSpi(code, liftBytes(args), 128);
+  const p = decodeSpi(code, liftBytes(args), 128, useBlockGas);
   const int = new Interpreter(p.program, p.registers, p.memory);
   int.nextPc = pc;
   int.gas.set(initialGas);
@@ -3906,9 +4013,9 @@ function resetJAM(program, pc, initialGas, args, hasMetadata = false) {
   }
   interpreter = int;
 }
-function resetGeneric(program, flatRegisters, initialGas, hasMetadata = false) {
+function resetGeneric(program, flatRegisters, initialGas, hasMetadata = false, useBlockGas = false) {
   const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);
-  const p = deblob(code);
+  const p = deblob(code, useBlockGas);
   const registers = newRegisters();
   fillRegisters(registers, flatRegisters);
   const int = new Interpreter(p, registers);
@@ -3918,9 +4025,9 @@ function resetGeneric(program, flatRegisters, initialGas, hasMetadata = false) {
   }
   interpreter = int;
 }
-function resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata = false) {
+function resetGenericWithMemory(program, flatRegisters, pageMap, chunks, initialGas, hasMetadata = false, useBlockGas = false) {
   const code = hasMetadata ? extractCodeAndMetadata(liftBytes(program)).code : liftBytes(program);
-  const p = deblob(code);
+  const p = deblob(code, useBlockGas);
   const registers = newRegisters();
   fillRegisters(registers, flatRegisters);
   const builder = new MemoryBuilder();
@@ -4094,42 +4201,6 @@ function readChunks(chunks) {
   return res;
 }
 
-// dist/build/js/assembly/gas-costs.js
-var BlockGasCost = class {
-  constructor() {
-    this.pc = 0;
-    this.gas = u64(0);
-  }
-};
-function computeGasCosts(p) {
-  const len = p.code.length;
-  const blocks = /* @__PURE__ */ new Map();
-  let currentBlock = null;
-  for (let i = 0; i < len; i++) {
-    if (!p.mask.isInstruction(i)) {
-      throw new Error("We should iterate only over instructions!");
-    }
-    const instruction2 = p.code[i];
-    const iData = instruction2 >= INSTRUCTIONS.length ? MISSING_INSTRUCTION : INSTRUCTIONS[instruction2];
-    if (p.basicBlocks.isStart(i)) {
-      if (currentBlock !== null) {
-        blocks.set(currentBlock.pc, currentBlock);
-      }
-      currentBlock = new BlockGasCost();
-      currentBlock.pc = i;
-    }
-    if (currentBlock !== null) {
-      currentBlock.gas = portable.u64_add(currentBlock.gas, iData.gas);
-    }
-    const skipBytes2 = p.mask.skipBytesToNextInstruction(i);
-    i += skipBytes2;
-  }
-  if (currentBlock !== null) {
-    blocks.set(currentBlock.pc, currentBlock);
-  }
-  return blocks;
-}
-
 // dist/build/js/assembly/api-utils.js
 var InputKind;
 (function(InputKind2) {
@@ -4141,12 +4212,29 @@ var HasMetadata;
   HasMetadata2[HasMetadata2["Yes"] = 0] = "Yes";
   HasMetadata2[HasMetadata2["No"] = 1] = "No";
 })(HasMetadata || (HasMetadata = {}));
-function getGasCosts(input, kind, withMetadata) {
-  const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0);
-  return portable.asArray(computeGasCosts(program.program).values());
+var BlockGasCost = class {
+  constructor() {
+    this.pc = 0;
+    this.gas = 0;
+  }
+};
+function getBlockGasCosts(input, kind, withMetadata) {
+  const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0, true);
+  const blockCosts = [];
+  const costs = program.program.gasCosts.codeAndGas;
+  for (let n = 0; n < costs.length; n += 1) {
+    const gas = costs[n] >> 8;
+    if (gas !== 0) {
+      const x = new BlockGasCost();
+      x.pc = n;
+      x.gas = costs[n];
+      blockCosts.push(x);
+    }
+  }
+  return blockCosts;
 }
 function disassemble(input, kind, withMetadata) {
-  const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0);
+  const program = prepareProgram(kind, withMetadata, input, [], [], [], [], 0, false);
   let output = "";
   if (withMetadata === HasMetadata.Yes) {
     output = "Metadata: \n";
@@ -4157,7 +4245,7 @@ function disassemble(input, kind, withMetadata) {
   output += getAssembly(program.program);
   return output;
 }
-function prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args, preallocateMemoryPages) {
+function prepareProgram(kind, hasMetadata, program, initialRegisters, initialPageMap, initialMemory, args, preallocateMemoryPages, useBlockGas) {
   let code = liftBytes(program);
   let metadata = new Uint8Array(0);
   if (hasMetadata === HasMetadata.Yes) {
@@ -4166,7 +4254,7 @@ function prepareProgram(kind, hasMetadata, program, initialRegisters, initialPag
     metadata = data.metadata;
   }
   if (kind === InputKind.Generic) {
-    const program2 = deblob(code);
+    const program2 = deblob(code, useBlockGas);
     const builder = new MemoryBuilder(preallocateMemoryPages);
     const memory = buildMemory(builder, initialPageMap, initialMemory);
     const registers = newRegisters();
@@ -4185,22 +4273,21 @@ function prepareProgram(kind, hasMetadata, program, initialRegisters, initialPag
   }
   throw new Error(`Unknown kind: ${kind}`);
 }
-function runProgram(program, initialGas = 0, programCounter = 0, logs = false, useSbrkGas = false, dumpMemory = false) {
+function runProgram(program, initialGas = 0, programCounter = 0, logs = false, dumpMemory = false) {
   const vmInput = new VmInput(program.program, program.memory, program.registers);
   vmInput.gas = i64(initialGas);
   vmInput.pc = programCounter;
   const vmOptions = new VmRunOptions();
   vmOptions.logs = logs;
-  vmOptions.useSbrkGas = useSbrkGas;
   vmOptions.dumpMemory = dumpMemory;
   return vmRunOnce(vmInput, vmOptions);
 }
 var nextPvmId = 0;
 var pvms = /* @__PURE__ */ new Map();
-function pvmStart(program, useSbrkGas = false) {
+function pvmStart(program) {
   const vmInput = new VmInput(program.program, program.memory, program.registers);
   nextPvmId += 1;
-  pvms.set(nextPvmId, vmInit(vmInput, useSbrkGas));
+  pvms.set(nextPvmId, vmInit(vmInput));
   return nextPvmId;
 }
 function pvmDestroy(pvmId) {
@@ -4329,9 +4416,9 @@ function skipBytes(kind, data) {
     case Arguments.TwoReg:
       return 1;
     case Arguments.TwoRegOneImm:
-      return 1 + minI32(4, data.length);
+      return 1 + IntMath.minI32(4, data.length);
     case Arguments.TwoRegOneOff:
-      return 1 + minI32(4, data.length);
+      return 1 + IntMath.minI32(4, data.length);
     case Arguments.TwoRegTwoImm: {
       const low = lowNibble(data[1]);
       const split = low + 1;
@@ -4371,15 +4458,15 @@ function immBytes(dataLength, required) {
   if (dataLength < required) {
     return 0;
   }
-  return minI32(4, dataLength - required);
+  return IntMath.minI32(4, dataLength - required);
 }
 export {
   HasMetadata,
   InputKind,
   disassemble,
   getAssembly,
+  getBlockGasCosts,
   getExitArg,
-  getGasCosts,
   getGasLeft,
   getMemory,
   getPageDump,