@fluffylabs/anan-as 1.2.0-c2b7f5a → 1.2.0-d2b00f9

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

@@ -740,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;
@@ -783,7 +799,7 @@ var Args = class {
 };
 function twoImm(args, code, offset, end) {
   const low = lowNibble(portable.staticArrayAt(code, offset));
-  const split = minI32(4, low) + 1;
+  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);
@@ -818,7 +834,7 @@ var DECODERS = StaticArray.fromArray([
   (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);
@@ -827,7 +843,7 @@ var DECODERS = StaticArray.fromArray([
   (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);
@@ -894,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;
@@ -923,7 +939,7 @@ var GasCounter = class {
     return false;
   }
 };
-__decorate2([
+__decorate3([
   inline
 ], GasCounter.prototype, "sub", null);
 
@@ -1320,6 +1336,12 @@ var INSTRUCTIONS = StaticArray.fromArray([
 ]);
 
 // 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";
@@ -1334,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;
@@ -1342,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;
@@ -1391,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);
@@ -1431,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;
@@ -1634,7 +1697,7 @@ var Page = class {
     return this.access === Access.Write || this.access === access;
   }
 };
-__decorate3([
+__decorate6([
   inline
 ], Page.prototype, "can", null);
 var RawPage = class {
@@ -1646,7 +1709,7 @@ var RawPage = class {
     return this.page;
   }
 };
-__decorate3([
+__decorate6([
   inline
 ], RawPage.prototype, "data", null);
 var Arena = class {
@@ -1677,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;
@@ -1740,10 +1803,10 @@ var PageCache = class {
     }
   }
 };
-__decorate4([
+__decorate7([
   inline
 ], PageCache.prototype, "lookup", null);
-__decorate4([
+__decorate7([
   inline
 ], PageCache.prototype, "insert", null);
 var MemoryBuilder = class {
@@ -1880,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++) {
@@ -1889,6 +1953,7 @@ var Memory = class {
       this.cache.insert(i, page);
     }
     this.lastAllocatedPage = pageIdx;
+    faultRes4.isFault = false;
     return freeMemoryStart;
   }
   getU8(faultRes4, address) {
@@ -1904,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);
@@ -2084,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);
@@ -2100,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]);
     }
@@ -2119,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) {
@@ -2555,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
@@ -2588,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
@@ -3395,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}`);
@@ -3560,7 +3625,7 @@ var Interpreter = class {
           continue;
         }
         case Outcome.DynamicJump: {
-          const res = dJump2(this.djumpRes, jumpTable, outcome.dJump);
+          const res = dJump(this.djumpRes, jumpTable, outcome.dJump);
           if (res.status === DjumpStatus.HALT) {
             this.status = Status.HALT;
             return false;
@@ -3622,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;
@@ -4351,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;
@@ -4393,7 +4458,7 @@ function immBytes(dataLength, required) {
   if (dataLength < required) {
     return 0;
   }
-  return minI32(4, dataLength - required);
+  return IntMath.minI32(4, dataLength - required);
 }
 export {
   HasMetadata,